// Copyright 2011 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef V8_SCOPEINFO_H_ #define V8_SCOPEINFO_H_ #include "src/allocation.h" #include "src/variables.h" #include "src/zone-inl.h" namespace v8 { namespace internal { // Cache for mapping (data, property name) into context slot index. // The cache contains both positive and negative results. // Slot index equals -1 means the property is absent. // Cleared at startup and prior to mark sweep collection. class ContextSlotCache { public: // Lookup context slot index for (data, name). // If absent, kNotFound is returned. int Lookup(Object* data, String* name, VariableMode* mode, InitializationFlag* init_flag, MaybeAssignedFlag* maybe_assigned_flag); // Update an element in the cache. void Update(Handle<Object> data, Handle<String> name, VariableMode mode, InitializationFlag init_flag, MaybeAssignedFlag maybe_assigned_flag, int slot_index); // Clear the cache. void Clear(); static const int kNotFound = -2; private: ContextSlotCache() { for (int i = 0; i < kLength; ++i) { keys_[i].data = NULL; keys_[i].name = NULL; values_[i] = kNotFound; } } inline static int Hash(Object* data, String* name); #ifdef DEBUG void ValidateEntry(Handle<Object> data, Handle<String> name, VariableMode mode, InitializationFlag init_flag, MaybeAssignedFlag maybe_assigned_flag, int slot_index); #endif static const int kLength = 256; struct Key { Object* data; String* name; }; struct Value { Value(VariableMode mode, InitializationFlag init_flag, MaybeAssignedFlag maybe_assigned_flag, int index) { DCHECK(ModeField::is_valid(mode)); DCHECK(InitField::is_valid(init_flag)); DCHECK(MaybeAssignedField::is_valid(maybe_assigned_flag)); DCHECK(IndexField::is_valid(index)); value_ = ModeField::encode(mode) | IndexField::encode(index) | InitField::encode(init_flag) | MaybeAssignedField::encode(maybe_assigned_flag); DCHECK(mode == this->mode()); DCHECK(init_flag == this->initialization_flag()); DCHECK(maybe_assigned_flag == this->maybe_assigned_flag()); DCHECK(index == this->index()); } explicit inline Value(uint32_t value) : value_(value) {} uint32_t raw() { return value_; } VariableMode mode() { return ModeField::decode(value_); } InitializationFlag initialization_flag() { return InitField::decode(value_); } MaybeAssignedFlag maybe_assigned_flag() { return MaybeAssignedField::decode(value_); } int index() { return IndexField::decode(value_); } // Bit fields in value_ (type, shift, size). Must be public so the // constants can be embedded in generated code. class ModeField : public BitField<VariableMode, 0, 4> {}; class InitField : public BitField<InitializationFlag, 4, 1> {}; class MaybeAssignedField : public BitField<MaybeAssignedFlag, 5, 1> {}; class IndexField : public BitField<int, 6, 32 - 6> {}; private: uint32_t value_; }; Key keys_[kLength]; uint32_t values_[kLength]; friend class Isolate; DISALLOW_COPY_AND_ASSIGN(ContextSlotCache); }; //--------------------------------------------------------------------------- // Auxiliary class used for the description of module instances. // Used by Runtime_DeclareModules. class ModuleInfo: public FixedArray { public: static ModuleInfo* cast(Object* description) { return static_cast<ModuleInfo*>(FixedArray::cast(description)); } static Handle<ModuleInfo> Create( Isolate* isolate, Interface* interface, Scope* scope); // Index of module's context in host context. int host_index() { return Smi::cast(get(HOST_OFFSET))->value(); } // Name, mode, and index of the i-th export, respectively. // For value exports, the index is the slot of the value in the module // context, for exported modules it is the slot index of the // referred module's context in the host context. // TODO(rossberg): This format cannot yet handle exports of modules declared // in earlier scripts. String* name(int i) { return String::cast(get(name_offset(i))); } VariableMode mode(int i) { return static_cast<VariableMode>(Smi::cast(get(mode_offset(i)))->value()); } int index(int i) { return Smi::cast(get(index_offset(i)))->value(); } int length() { return (FixedArray::length() - HEADER_SIZE) / ITEM_SIZE; } private: // The internal format is: Index, (Name, VariableMode, Index)* enum { HOST_OFFSET, NAME_OFFSET, MODE_OFFSET, INDEX_OFFSET, HEADER_SIZE = NAME_OFFSET, ITEM_SIZE = INDEX_OFFSET - NAME_OFFSET + 1 }; inline int name_offset(int i) { return NAME_OFFSET + i * ITEM_SIZE; } inline int mode_offset(int i) { return MODE_OFFSET + i * ITEM_SIZE; } inline int index_offset(int i) { return INDEX_OFFSET + i * ITEM_SIZE; } static Handle<ModuleInfo> Allocate(Isolate* isolate, int length) { return Handle<ModuleInfo>::cast( isolate->factory()->NewFixedArray(HEADER_SIZE + ITEM_SIZE * length)); } void set_host_index(int index) { set(HOST_OFFSET, Smi::FromInt(index)); } void set_name(int i, String* name) { set(name_offset(i), name); } void set_mode(int i, VariableMode mode) { set(mode_offset(i), Smi::FromInt(mode)); } void set_index(int i, int index) { set(index_offset(i), Smi::FromInt(index)); } }; } } // namespace v8::internal #endif // V8_SCOPEINFO_H_