v8::internal::Interface Class Reference

#include <interface.h>

Inheritance diagram for v8::internal::Interface:

Collaboration diagram for v8::internal::Interface:

Classes
class	Iterator

Public Member Functions
void	Add (const AstRawString *name, Interface *interface, Zone *zone, bool *ok)
void	Unify (Interface *that, Zone *zone, bool *ok)
void	MakeValue (bool *ok)
void	MakeConst (bool *ok)
void	MakeModule (bool *ok)
void	Freeze (bool *ok)
void	Allocate (int index)
bool	IsUnknown ()
bool	IsValue ()
bool	IsConst ()
bool	IsModule ()
bool	IsFrozen ()
bool	IsUnified (Interface *that)
int	Length ()
int	Index ()
Interface *	Lookup (Handle< String > name, Zone *zone)
Iterator	iterator () const
Public Member Functions inherited from v8::internal::ZoneObject
	INLINE (void *operator new(size_t size, Zone *zone))
void	operator delete (void *, size_t)
void	operator delete (void *pointer, Zone *zone)

Static Public Member Functions
static Interface *	NewUnknown (Zone *zone)
static Interface *	NewValue ()
static Interface *	NewConst ()
static Interface *	NewModule (Zone *zone)

Private Types
enum	Flags {   NONE = 0 , VALUE = 1 , CONST = 2 , MODULE = 4 ,   FROZEN = 8 }

Private Member Functions
	Interface (int flags)
Interface *	Chase ()
void	DoAdd (const void *name, uint32_t hash, Interface *interface, Zone *zone, bool *ok)
void	DoUnify (Interface *that, bool *ok, Zone *zone)

Private Attributes
int	flags_
Interface *	forward_
ZoneHashMap *	exports_
int	index_

Detailed Description

Definition at line 35 of file interface.h.

Member Enumeration Documentation

Flags

enum v8::internal::Interface::Flags

private

Enumerator
NONE
VALUE
CONST
MODULE
FROZEN

Definition at line 181 of file interface.h.

             {    // All flags are monotonic
    NONE = 0,
    VALUE = 1,    // This type describes a value
    CONST = 2,    // This type describes a constant
    MODULE = 4,   // This type describes a module
    FROZEN = 8    // This type is fully determined
  };

Constructor & Destructor Documentation

Interface()

v8::internal::Interface::Interface ( int  flags )

inlineexplicitprivate

Definition at line 194 of file interface.h.

    : flags_(flags),
      forward_(NULL),
      exports_(NULL),
      index_(-1) {
#ifdef DEBUG
    if (FLAG_print_interface_details)
      PrintF("# Creating %p\n", static_cast<void*>(this));
#endif
  }

References v8::internal::PrintF().

Referenced by NewModule(), and NewUnknown().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

Add()

void v8::internal::Interface::Add ( const AstRawString *  name, Interface *  interface, Zone *  zone, bool *  ok  )

inline

Definition at line 63 of file interface.h.

                     {
    DoAdd(name, name->hash(), interface, zone, ok);
  }

References DoAdd(), and name.

Referenced by v8::internal::Parser::ParseImportDeclaration(), and v8::internal::Parser::ParseModulePath().

Here is the call graph for this function:

Here is the caller graph for this function:

Allocate()

void v8::internal::Interface::Allocate ( int  index )

inline

Definition at line 97 of file interface.h.

                           {
    DCHECK(IsModule() && IsFrozen() && Chase()->index_ == -1);
    Chase()->index_ = index;
  }

References Chase(), DCHECK, index_, IsFrozen(), and IsModule().

Here is the call graph for this function:

Chase()

Interface* v8::internal::Interface::Chase ( )

inlineprivate

Definition at line 205 of file interface.h.

                     {
    Interface* result = this;
    while (result->forward_ != NULL) result = result->forward_;
    if (result != this) forward_ = result;  // On-the-fly path compression.
    return result;
  }

References forward_, and NULL.

Referenced by Allocate(), DoAdd(), Freeze(), Index(), IsConst(), IsFrozen(), IsModule(), IsUnified(), IsUnknown(), IsValue(), Length(), Lookup(), MakeConst(), MakeModule(), MakeValue(), and Unify().

Here is the caller graph for this function:

DoAdd()

void v8::internal::Interface::DoAdd ( const void *  name, uint32_t  hash, Interface *  interface, Zone *  zone, bool *  ok  )

private

Definition at line 41 of file interface.cc.

                                            {
  MakeModule(ok);
  if (!*ok) return;
 
#ifdef DEBUG
  if (FLAG_print_interface_details) {
    PrintF("%*s# Adding...\n", Nesting::current(), "");
    PrintF("%*sthis = ", Nesting::current(), "");
    this->Print(Nesting::current());
    const AstRawString* symbol = static_cast<const AstRawString*>(name);
    PrintF("%*s%.*s : ", Nesting::current(), "", symbol->length(),
           symbol->raw_data());
    interface->Print(Nesting::current());
  }
#endif
 
  ZoneHashMap** map = &Chase()->exports_;
  ZoneAllocationPolicy allocator(zone);
 
  if (*map == NULL) {
    *map = new(zone->New(sizeof(ZoneHashMap)))
        ZoneHashMap(ZoneHashMap::PointersMatch,
                    ZoneHashMap::kDefaultHashMapCapacity, allocator);
  }
 
  ZoneHashMap::Entry* p =
      (*map)->Lookup(const_cast<void*>(name), hash, !IsFrozen(), allocator);
  if (p == NULL) {
    // This didn't have name but was frozen already, that's an error.
    *ok = false;
  } else if (p->value == NULL) {
    p->value = interface;
  } else {
#ifdef DEBUG
    Nesting nested;
#endif
    static_cast<Interface*>(p->value)->Unify(interface, zone, ok);
  }
 
#ifdef DEBUG
  if (FLAG_print_interface_details) {
    PrintF("%*sthis' = ", Nesting::current(), "");
    this->Print(Nesting::current());
    PrintF("%*s# Added.\n", Nesting::current(), "");
  }
#endif
}

References Chase(), exports_, IsFrozen(), v8::internal::TemplateHashMapImpl< ZoneAllocationPolicy >::kDefaultHashMapCapacity, v8::internal::AstRawString::length(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Lookup(), MakeModule(), map, name, v8::internal::Zone::New(), NULL, v8::internal::TemplateHashMapImpl< ZoneAllocationPolicy >::PointersMatch(), v8::internal::PrintF(), v8::internal::AstRawString::raw_data(), and Unify().

Referenced by Add(), and DoUnify().

Here is the call graph for this function:

Here is the caller graph for this function:

DoUnify()

void v8::internal::Interface::DoUnify ( Interface *  that, bool *  ok, Zone *  zone  )

private

Definition at line 140 of file interface.cc.

                                                             {
  DCHECK(this->forward_ == NULL);
  DCHECK(that->forward_ == NULL);
  DCHECK(!this->IsValue());
  DCHECK(!that->IsValue());
  DCHECK(this->index_ == -1);
  DCHECK(that->index_ == -1);
  DCHECK(*ok);
 
#ifdef DEBUG
    Nesting nested;
#endif
 
  // Try to merge all members from that into this.
  ZoneHashMap* map = that->exports_;
  if (map != NULL) {
    for (ZoneHashMap::Entry* p = map->Start(); p != NULL; p = map->Next(p)) {
      this->DoAdd(p->key, p->hash, static_cast<Interface*>(p->value), zone, ok);
      if (!*ok) return;
    }
  }
 
  // If the new interface is larger than that's, then there were members in
  // 'this' which 'that' didn't have. If 'that' was frozen that is an error.
  int this_size = this->exports_ == NULL ? 0 : this->exports_->occupancy();
  int that_size = map == NULL ? 0 : map->occupancy();
  if (that->IsFrozen() && this_size > that_size) {
    *ok = false;
    return;
  }
 
  // Merge interfaces.
  this->flags_ |= that->flags_;
  that->forward_ = this;
}

References DCHECK, DoAdd(), exports_, flags_, forward_, index_, IsFrozen(), IsValue(), map, NULL, and v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy().

Referenced by Unify().

Here is the call graph for this function:

Here is the caller graph for this function:

Freeze()

void v8::internal::Interface::Freeze ( bool *  ok )

inline

Definition at line 91 of file interface.h.

                        {
    *ok = IsValue() || IsModule();
    if (*ok) Chase()->flags_ |= FROZEN;
  }

References Chase(), flags_, FROZEN, IsModule(), and IsValue().

Here is the call graph for this function:

Index()

int v8::internal::Interface::Index ( )

inline

Definition at line 133 of file interface.h.

              {
    DCHECK(IsModule() && IsFrozen());
    return Chase()->index_;
  }

References Chase(), DCHECK, index_, IsFrozen(), and IsModule().

Referenced by v8::internal::FullCodeGenerator::AllocateModules(), and v8::internal::ModuleInfo::Create().

Here is the call graph for this function:

Here is the caller graph for this function:

IsConst()

bool v8::internal::Interface::IsConst ( )

inline

Definition at line 112 of file interface.h.

{ return Chase()->flags_ & CONST; }

References Chase(), CONST, and flags_.

Referenced by IsUnified(), MakeConst(), and Unify().

Here is the call graph for this function:

Here is the caller graph for this function:

IsFrozen()

bool v8::internal::Interface::IsFrozen ( )

inline

Definition at line 118 of file interface.h.

{ return Chase()->flags_ & FROZEN; }

References Chase(), flags_, and FROZEN.

Referenced by Allocate(), v8::internal::Scope::AllocateModulesRecursively(), DoAdd(), DoUnify(), Index(), Length(), and MakeConst().

Here is the call graph for this function:

Here is the caller graph for this function:

IsModule()

bool v8::internal::Interface::IsModule ( )

inline

Definition at line 115 of file interface.h.

{ return Chase()->flags_ & MODULE; }

References Chase(), flags_, and MODULE.

Referenced by Allocate(), Freeze(), Index(), Length(), Lookup(), MakeConst(), and MakeValue().

Here is the call graph for this function:

Here is the caller graph for this function:

IsUnified()

bool v8::internal::Interface::IsUnified ( Interface *  that )

inline

Definition at line 120 of file interface.h.

                                  {
    return Chase() == that->Chase()
        || (this->IsValue() == that->IsValue() &&
            this->IsConst() == that->IsConst());
  }

References Chase(), IsConst(), and IsValue().

Here is the call graph for this function:

IsUnknown()

bool v8::internal::Interface::IsUnknown ( )

inline

Definition at line 106 of file interface.h.

{ return Chase()->flags_ == NONE; }

References Chase(), flags_, and NONE.

Here is the call graph for this function:

IsValue()

bool v8::internal::Interface::IsValue ( )

inline

Definition at line 109 of file interface.h.

{ return Chase()->flags_ & VALUE; }

References Chase(), flags_, and VALUE.

Referenced by DoUnify(), Freeze(), IsUnified(), MakeModule(), and Unify().

Here is the call graph for this function:

Here is the caller graph for this function:

iterator()

Iterator v8::internal::Interface::iterator ( ) const

inline

Definition at line 170 of file interface.h.

{ return Iterator(this->exports_); }

References exports_.

Referenced by v8::internal::ModuleInfo::Create().

Here is the caller graph for this function:

Length()

int v8::internal::Interface::Length ( )

inline

Definition at line 126 of file interface.h.

               {
    DCHECK(IsModule() && IsFrozen());
    ZoneHashMap* exports = Chase()->exports_;
    return exports ? exports->occupancy() : 0;
  }

References Chase(), DCHECK, exports_, IsFrozen(), IsModule(), and v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy().

Referenced by v8::internal::ModuleInfo::Create().

Here is the call graph for this function:

Here is the caller graph for this function:

Lookup()

Interface * v8::internal::Interface::Lookup	(	Handle< String >	name,
		Zone *	zone
	)

Definition at line 12 of file interface.cc.

                                                            {
  DCHECK(IsModule());
  ZoneHashMap* map = Chase()->exports_;
  if (map == NULL) return NULL;
  ZoneAllocationPolicy allocator(zone);
  ZoneHashMap::Entry* p = map->Lookup(name.location(), name->Hash(), false,
                                      allocator);
  if (p == NULL) return NULL;
  DCHECK(*static_cast<String**>(p->key) == *name);
  DCHECK(p->value != NULL);
  return static_cast<Interface*>(p->value);
}

References Chase(), DCHECK, exports_, IsModule(), map, name, and NULL.

Here is the call graph for this function:

MakeConst()

void v8::internal::Interface::MakeConst ( bool *  ok )

inline

Definition at line 79 of file interface.h.

                           {
    *ok = !IsModule() && (IsConst() || !IsFrozen());
    if (*ok) Chase()->flags_ |= VALUE + CONST;
  }

References Chase(), CONST, flags_, IsConst(), IsFrozen(), IsModule(), and VALUE.

Referenced by Unify().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeModule()

void v8::internal::Interface::MakeModule ( bool *  ok )

inline

Definition at line 85 of file interface.h.

                            {
    *ok = !IsValue();
    if (*ok) Chase()->flags_ |= MODULE;
  }

References Chase(), flags_, IsValue(), and MODULE.

Referenced by DoAdd().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeValue()

void v8::internal::Interface::MakeValue ( bool *  ok )

inline

Definition at line 73 of file interface.h.

                           {
    *ok = !IsModule();
    if (*ok) Chase()->flags_ |= VALUE;
  }

References Chase(), flags_, IsModule(), and VALUE.

Referenced by Unify().

Here is the call graph for this function:

Here is the caller graph for this function:

NewConst()

static Interface* v8::internal::Interface::NewConst ( )

inlinestatic

Definition at line 49 of file interface.h.

                               {
    static Interface value_interface(VALUE + CONST + FROZEN);  // Cached.
    return &value_interface;
  }

References CONST, FROZEN, and VALUE.

Referenced by v8::internal::Parser::ParseEagerFunctionBody(), and v8::internal::Parser::ParseFunctionLiteral().

Here is the caller graph for this function:

NewModule()

static Interface* v8::internal::Interface::NewModule ( Zone *  zone )

inlinestatic

Definition at line 54 of file interface.h.

                                          {
    return new(zone) Interface(MODULE);
  }

References Interface(), and MODULE.

Referenced by v8::internal::Parser::ParseModuleVariable().

Here is the call graph for this function:

Here is the caller graph for this function:

NewUnknown()

static Interface* v8::internal::Interface::NewUnknown ( Zone *  zone )

inlinestatic

Definition at line 40 of file interface.h.

                                           {
    return new(zone) Interface(NONE);
  }

References Interface(), and NONE.

Referenced by v8::internal::ParserTraits::ExpressionFromIdentifier(), v8::internal::Parser::ParseExportDeclaration(), and v8::internal::Parser::ParseImportDeclaration().

Here is the call graph for this function:

Here is the caller graph for this function:

NewValue()

static Interface* v8::internal::Interface::NewValue ( )

inlinestatic

Definition at line 44 of file interface.h.

                               {
    static Interface value_interface(VALUE + FROZEN);  // Cached.
    return &value_interface;
  }

References FROZEN, and VALUE.

Referenced by v8::internal::Parser::DesugarLetBindingsInForStatement(), v8::internal::Parser::ParseClassDeclaration(), v8::internal::Parser::ParseForStatement(), v8::internal::Parser::ParseFunctionDeclaration(), v8::internal::Parser::ParseNativeDeclaration(), and v8::internal::Parser::ParseVariableDeclarations().

Here is the caller graph for this function:

Unify()

void v8::internal::Interface::Unify	(	Interface *	that,
		Zone *	zone,
		bool *	ok
	)

Definition at line 91 of file interface.cc.

                                                           {
  if (this->forward_) return this->Chase()->Unify(that, zone, ok);
  if (that->forward_) return this->Unify(that->Chase(), zone, ok);
  DCHECK(this->forward_ == NULL);
  DCHECK(that->forward_ == NULL);
 
  *ok = true;
  if (this == that) return;
  if (this->IsValue()) {
    that->MakeValue(ok);
    if (*ok && this->IsConst()) that->MakeConst(ok);
    return;
  }
  if (that->IsValue()) {
    this->MakeValue(ok);
    if (*ok && that->IsConst()) this->MakeConst(ok);
    return;
  }
 
#ifdef DEBUG
  if (FLAG_print_interface_details) {
    PrintF("%*s# Unifying...\n", Nesting::current(), "");
    PrintF("%*sthis = ", Nesting::current(), "");
    this->Print(Nesting::current());
    PrintF("%*sthat = ", Nesting::current(), "");
    that->Print(Nesting::current());
  }
#endif
 
  // Merge the smaller interface into the larger, for performance.
  if (this->exports_ != NULL && (that->exports_ == NULL ||
      this->exports_->occupancy() >= that->exports_->occupancy())) {
    this->DoUnify(that, ok, zone);
  } else {
    that->DoUnify(this, ok, zone);
  }
 
#ifdef DEBUG
  if (FLAG_print_interface_details) {
    PrintF("%*sthis' = ", Nesting::current(), "");
    this->Print(Nesting::current());
    PrintF("%*sthat' = ", Nesting::current(), "");
    that->Print(Nesting::current());
    PrintF("%*s# Unified.\n", Nesting::current(), "");
  }
#endif
}

References Chase(), DCHECK, DoUnify(), exports_, forward_, IsConst(), IsValue(), MakeConst(), MakeValue(), NULL, v8::internal::TemplateHashMapImpl< AllocationPolicy >::occupancy(), v8::internal::PrintF(), and Unify().

Referenced by DoAdd(), and Unify().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

exports_

ZoneHashMap* v8::internal::Interface::exports_

private

Definition at line 191 of file interface.h.

Referenced by DoAdd(), DoUnify(), iterator(), Length(), Lookup(), and Unify().

flags_

int v8::internal::Interface::flags_

private

Definition at line 189 of file interface.h.

Referenced by DoUnify(), Freeze(), IsConst(), IsFrozen(), IsModule(), IsUnknown(), IsValue(), MakeConst(), MakeModule(), and MakeValue().

forward_

Interface* v8::internal::Interface::forward_

private

Definition at line 190 of file interface.h.

Referenced by Chase(), DoUnify(), and Unify().

index_

int v8::internal::Interface::index_

private

Definition at line 192 of file interface.h.

Referenced by Allocate(), DoUnify(), and Index().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/interface.h
• /mnt/V8SourceCode/src/interface.cc