Index: src/objects.h |
=================================================================== |
--- src/objects.h (revision 9808) |
+++ src/objects.h (working copy) |
@@ -40,6 +40,7 @@ |
#endif |
#include "v8checks.h" |
+ |
// |
// Most object types in the V8 JavaScript are described in this file. |
// |
@@ -52,6 +53,8 @@ |
// - JSReceiver (suitable for property access) |
// - JSObject |
// - JSArray |
+// - JSSet |
+// - JSMap |
// - JSWeakMap |
// - JSRegExp |
// - JSFunction |
@@ -173,6 +176,8 @@ |
static const int kElementsKindCount = |
LAST_ELEMENTS_KIND - FIRST_ELEMENTS_KIND + 1; |
+void PrintElementsKind(FILE* out, ElementsKind kind); |
+ |
// PropertyDetails captures type and attributes for a property. |
// They are used both in property dictionaries and instance descriptors. |
class PropertyDetails BASE_EMBEDDED { |
@@ -628,6 +633,8 @@ |
JS_BUILTINS_OBJECT_TYPE, |
JS_GLOBAL_PROXY_TYPE, |
JS_ARRAY_TYPE, |
+ JS_SET_TYPE, |
+ JS_MAP_TYPE, |
JS_WEAK_MAP_TYPE, |
JS_REGEXP_TYPE, |
@@ -820,6 +827,8 @@ |
V(JSArray) \ |
V(JSProxy) \ |
V(JSFunctionProxy) \ |
+ V(JSSet) \ |
+ V(JSMap) \ |
V(JSWeakMap) \ |
V(JSRegExp) \ |
V(HashTable) \ |
@@ -857,6 +866,8 @@ |
HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL) |
#undef IS_TYPE_FUNCTION_DECL |
+ inline bool IsFixedArrayBase(); |
+ |
// Returns true if this object is an instance of the specified |
// function template. |
inline bool IsInstanceOf(FunctionTemplateInfo* type); |
@@ -912,13 +923,22 @@ |
Object* receiver, |
String* key, |
PropertyAttributes* attributes); |
+ |
+ static Handle<Object> GetProperty(Handle<Object> object, |
+ Handle<Object> receiver, |
+ LookupResult* result, |
+ Handle<String> key, |
+ PropertyAttributes* attributes); |
+ |
MUST_USE_RESULT MaybeObject* GetProperty(Object* receiver, |
LookupResult* result, |
String* key, |
PropertyAttributes* attributes); |
+ |
MUST_USE_RESULT MaybeObject* GetPropertyWithDefinedGetter(Object* receiver, |
JSReceiver* getter); |
+ static Handle<Object> GetElement(Handle<Object> object, uint32_t index); |
inline MaybeObject* GetElement(uint32_t index); |
// For use when we know that no exception can be thrown. |
inline Object* GetElementNoExceptionThrown(uint32_t index); |
@@ -927,6 +947,16 @@ |
// Return the object's prototype (might be Heap::null_value()). |
Object* GetPrototype(); |
+ // Returns the permanent hash code associated with this object depending on |
+ // the actual object type. Might return a failure in case no hash was |
+ // created yet or GC was caused by creation. |
+ MUST_USE_RESULT MaybeObject* GetHash(CreationFlag flag); |
+ |
+ // Checks whether this object has the same value as the given one. This |
+ // function is implemented according to ES5, section 9.12 and can be used |
+ // to implement the Harmony "egal" function. |
+ bool SameValue(Object* other); |
+ |
// Tries to convert an object to an array index. Returns true and sets |
// the output parameter if it succeeds. |
inline bool ToArrayIndex(uint32_t* index); |
@@ -1351,6 +1381,9 @@ |
StrictModeFlag strict_mode, |
bool check_prototype); |
+ // Tests for the fast common case for property enumeration. |
+ bool IsSimpleEnum(); |
+ |
// Returns the class name ([[Class]] property in the specification). |
String* class_name(); |
@@ -1376,7 +1409,7 @@ |
bool skip_hidden_prototypes); |
// Retrieves a permanent object identity hash code. The undefined value might |
- // be returned in case no has been created yet and OMIT_CREATION was used. |
+ // be returned in case no hash was created yet and OMIT_CREATION was used. |
inline MUST_USE_RESULT MaybeObject* GetIdentityHash(CreationFlag flag); |
// Lookup a property. If found, the result is valid and has |
@@ -1603,9 +1636,6 @@ |
MUST_USE_RESULT MaybeObject* DeleteProperty(String* name, DeleteMode mode); |
MUST_USE_RESULT MaybeObject* DeleteElement(uint32_t index, DeleteMode mode); |
- // Tests for the fast common case for property enumeration. |
- bool IsSimpleEnum(); |
- |
inline void ValidateSmiOnlyElements(); |
// Makes sure that this object can contain non-smi Object as elements. |
@@ -1786,9 +1816,13 @@ |
// Returns a new map with all transitions dropped from the object's current |
// map and the ElementsKind set. |
+ static Handle<Map> GetElementsTransitionMap(Handle<JSObject> object, |
+ ElementsKind to_kind); |
MUST_USE_RESULT MaybeObject* GetElementsTransitionMap( |
ElementsKind elements_kind); |
+ MUST_USE_RESULT MaybeObject* TransitionElementsKind(ElementsKind to_kind); |
+ |
// Converts a descriptor of any other type to a real field, |
// backed by the properties array. Descriptors of visible |
// types, such as CONSTANT_FUNCTION, keep their enumeration order. |
@@ -1835,6 +1869,10 @@ |
// dictionary. Returns the backing after conversion. |
MUST_USE_RESULT MaybeObject* NormalizeElements(); |
+ static void UpdateMapCodeCache(Handle<JSObject> object, |
+ Handle<String> name, |
+ Handle<Code> code); |
+ |
MUST_USE_RESULT MaybeObject* UpdateMapCodeCache(String* name, Code* code); |
// Transform slow named properties to fast variants. |
@@ -1896,6 +1934,10 @@ |
void PrintElements(FILE* out); |
#endif |
+ void PrintElementsTransition( |
+ FILE* file, ElementsKind from_kind, FixedArrayBase* from_elements, |
+ ElementsKind to_kind, FixedArrayBase* to_elements); |
+ |
#ifdef DEBUG |
// Structure for collecting spill information about JSObjects. |
class SpillInformation { |
@@ -2162,7 +2204,9 @@ |
protected: |
// Set operation on FixedArray without using write barriers. Can |
// only be used for storing old space objects or smis. |
- static inline void fast_set(FixedArray* array, int index, Object* value); |
+ static inline void NoWriteBarrierSet(FixedArray* array, |
+ int index, |
+ Object* value); |
private: |
DISALLOW_IMPLICIT_CONSTRUCTORS(FixedArray); |
@@ -2185,6 +2229,9 @@ |
// Checking for the hole. |
inline bool is_the_hole(int index); |
+ // Copy operations |
+ MUST_USE_RESULT inline MaybeObject* Copy(); |
+ |
// Garbage collection support. |
inline static int SizeFor(int length) { |
return kHeaderSize + length * kDoubleSize; |
@@ -2224,6 +2271,9 @@ |
}; |
+class IncrementalMarking; |
+ |
+ |
// DescriptorArrays are fixed arrays used to hold instance descriptors. |
// The format of the these objects is: |
// TODO(1399): It should be possible to make room for bit_field3 in the map |
@@ -2265,7 +2315,7 @@ |
// Set next enumeration index and flush any enum cache. |
void SetNextEnumerationIndex(int value) { |
if (!IsEmpty()) { |
- fast_set(this, kEnumerationIndexIndex, Smi::FromInt(value)); |
+ set(kEnumerationIndexIndex, Smi::FromInt(value)); |
} |
} |
bool HasEnumCache() { |
@@ -2302,13 +2352,27 @@ |
inline bool IsNullDescriptor(int descriptor_number); |
inline bool IsDontEnum(int descriptor_number); |
+ class WhitenessWitness { |
+ public: |
+ inline explicit WhitenessWitness(DescriptorArray* array); |
+ inline ~WhitenessWitness(); |
+ |
+ private: |
+ IncrementalMarking* marking_; |
+ }; |
+ |
// Accessor for complete descriptor. |
inline void Get(int descriptor_number, Descriptor* desc); |
- inline void Set(int descriptor_number, Descriptor* desc); |
+ inline void Set(int descriptor_number, |
+ Descriptor* desc, |
+ const WhitenessWitness&); |
// Transfer complete descriptor from another descriptor array to |
// this one. |
- inline void CopyFrom(int index, DescriptorArray* src, int src_index); |
+ inline void CopyFrom(int index, |
+ DescriptorArray* src, |
+ int src_index, |
+ const WhitenessWitness&); |
// Copy the descriptor array, insert a new descriptor and optionally |
// remove map transitions. If the descriptor is already present, it is |
@@ -2325,11 +2389,11 @@ |
// Sort the instance descriptors by the hash codes of their keys. |
// Does not check for duplicates. |
- void SortUnchecked(); |
+ void SortUnchecked(const WhitenessWitness&); |
// Sort the instance descriptors by the hash codes of their keys. |
// Checks the result for duplicates. |
- void Sort(); |
+ void Sort(const WhitenessWitness&); |
// Search the instance descriptors for given name. |
inline int Search(String* name); |
@@ -2422,10 +2486,12 @@ |
NULL_DESCRIPTOR; |
} |
// Swap operation on FixedArray without using write barriers. |
- static inline void fast_swap(FixedArray* array, int first, int second); |
+ static inline void NoWriteBarrierSwap(FixedArray* array, |
+ int first, |
+ int second); |
// Swap descriptor first and second. |
- inline void Swap(int first, int second); |
+ inline void NoWriteBarrierSwapDescriptors(int first, int second); |
FixedArray* GetContentArray() { |
return FixedArray::cast(get(kContentArrayIndex)); |
@@ -2567,12 +2633,12 @@ |
// Update the number of elements in the hash table. |
void SetNumberOfElements(int nof) { |
- fast_set(this, kNumberOfElementsIndex, Smi::FromInt(nof)); |
+ set(kNumberOfElementsIndex, Smi::FromInt(nof)); |
} |
// Update the number of deleted elements in the hash table. |
void SetNumberOfDeletedElements(int nod) { |
- fast_set(this, kNumberOfDeletedElementsIndex, Smi::FromInt(nod)); |
+ set(kNumberOfDeletedElementsIndex, Smi::FromInt(nod)); |
} |
// Sets the capacity of the hash table. |
@@ -2582,7 +2648,7 @@ |
// and non-zero. |
ASSERT(capacity > 0); |
ASSERT(capacity <= kMaxCapacity); |
- fast_set(this, kCapacityIndex, Smi::FromInt(capacity)); |
+ set(kCapacityIndex, Smi::FromInt(capacity)); |
} |
@@ -2790,7 +2856,7 @@ |
// Accessors for next enumeration index. |
void SetNextEnumerationIndex(int index) { |
- this->fast_set(this, kNextEnumerationIndexIndex, Smi::FromInt(index)); |
+ this->set(kNextEnumerationIndexIndex, Smi::FromInt(index)); |
} |
int NextEnumerationIndex() { |
@@ -2931,20 +2997,41 @@ |
}; |
+template <int entrysize> |
class ObjectHashTableShape { |
public: |
- static inline bool IsMatch(JSReceiver* key, Object* other); |
- static inline uint32_t Hash(JSReceiver* key); |
- static inline uint32_t HashForObject(JSReceiver* key, Object* object); |
- MUST_USE_RESULT static inline MaybeObject* AsObject(JSReceiver* key); |
+ static inline bool IsMatch(Object* key, Object* other); |
+ static inline uint32_t Hash(Object* key); |
+ static inline uint32_t HashForObject(Object* key, Object* object); |
+ MUST_USE_RESULT static inline MaybeObject* AsObject(Object* key); |
static const int kPrefixSize = 0; |
- static const int kEntrySize = 2; |
+ static const int kEntrySize = entrysize; |
}; |
-// ObjectHashTable maps keys that are JavaScript objects to object values by |
+// ObjectHashSet holds keys that are arbitrary objects by using the identity |
+// hash of the key for hashing purposes. |
+class ObjectHashSet: public HashTable<ObjectHashTableShape<1>, Object*> { |
+ public: |
+ static inline ObjectHashSet* cast(Object* obj) { |
+ ASSERT(obj->IsHashTable()); |
+ return reinterpret_cast<ObjectHashSet*>(obj); |
+ } |
+ |
+ // Looks up whether the given key is part of this hash set. |
+ bool Contains(Object* key); |
+ |
+ // Adds the given key to this hash set. |
+ MUST_USE_RESULT MaybeObject* Add(Object* key); |
+ |
+ // Removes the given key from this hash set. |
+ MUST_USE_RESULT MaybeObject* Remove(Object* key); |
+}; |
+ |
+ |
+// ObjectHashTable maps keys that are arbitrary objects to object values by |
// using the identity hash of the key for hashing purposes. |
-class ObjectHashTable: public HashTable<ObjectHashTableShape, JSReceiver*> { |
+class ObjectHashTable: public HashTable<ObjectHashTableShape<2>, Object*> { |
public: |
static inline ObjectHashTable* cast(Object* obj) { |
ASSERT(obj->IsHashTable()); |
@@ -2953,16 +3040,16 @@ |
// Looks up the value associated with the given key. The undefined value is |
// returned in case the key is not present. |
- Object* Lookup(JSReceiver* key); |
+ Object* Lookup(Object* key); |
// Adds (or overwrites) the value associated with the given key. Mapping a |
// key to the undefined value causes removal of the whole entry. |
- MUST_USE_RESULT MaybeObject* Put(JSReceiver* key, Object* value); |
+ MUST_USE_RESULT MaybeObject* Put(Object* key, Object* value); |
private: |
friend class MarkCompactCollector; |
- void AddEntry(int entry, JSReceiver* key, Object* value); |
+ void AddEntry(int entry, Object* key, Object* value); |
void RemoveEntry(int entry, Heap* heap); |
inline void RemoveEntry(int entry); |
@@ -3020,6 +3107,9 @@ |
return reinterpret_cast<SerializedScopeInfo*>(object); |
} |
+ // Return the type of this scope. |
+ ScopeType Type(); |
+ |
// Does this scope call eval? |
bool CallsEval(); |
@@ -3035,6 +3125,9 @@ |
// Return if this has context slots besides MIN_CONTEXT_SLOTS; |
bool HasHeapAllocatedLocals(); |
+ // Return if contexts are allocated for this scope. |
+ bool HasContext(); |
+ |
// Lookup support for serialized scope info. Returns the |
// the stack slot index for a given slot name if the slot is |
// present; otherwise returns a value < 0. The name must be a symbol |
@@ -3057,7 +3150,7 @@ |
// function context slot index if the function name is present (named |
// function expressions, only), otherwise returns a value < 0. The name |
// must be a symbol (canonicalized). |
- int FunctionContextSlotIndex(String* name); |
+ int FunctionContextSlotIndex(String* name, VariableMode* mode); |
static Handle<SerializedScopeInfo> Create(Scope* scope); |
@@ -3746,6 +3839,11 @@ |
inline bool has_debug_break_slots(); |
inline void set_has_debug_break_slots(bool value); |
+ // [compiled_with_optimizing]: For FUNCTION kind, tells if it has |
+ // been compiled with IsOptimizing set to true. |
+ inline bool is_compiled_optimizable(); |
+ inline void set_compiled_optimizable(bool value); |
+ |
// [allow_osr_at_loop_nesting_level]: For FUNCTION kind, tells for |
// how long the function has been marked for OSR and therefore which |
// level of loop nesting we are willing to do on-stack replacement |
@@ -3941,6 +4039,7 @@ |
class FullCodeFlagsHasDeoptimizationSupportField: |
public BitField<bool, 0, 1> {}; // NOLINT |
class FullCodeFlagsHasDebugBreakSlotsField: public BitField<bool, 1, 1> {}; |
+ class FullCodeFlagsIsCompiledOptimizable: public BitField<bool, 2, 1> {}; |
static const int kBinaryOpReturnTypeOffset = kBinaryOpTypeOffset + 1; |
@@ -4122,6 +4221,9 @@ |
return elements_kind() == DICTIONARY_ELEMENTS; |
} |
+ static bool IsValidElementsTransition(ElementsKind from_kind, |
+ ElementsKind to_kind); |
+ |
// Tells whether the map is attached to SharedFunctionInfo |
// (for inobject slack tracking). |
inline void set_attached_to_shared_function_info(bool value); |
@@ -4230,6 +4332,9 @@ |
inline void ClearCodeCache(Heap* heap); |
// Update code cache. |
+ static void UpdateCodeCache(Handle<Map> map, |
+ Handle<String> name, |
+ Handle<Code> code); |
MUST_USE_RESULT MaybeObject* UpdateCodeCache(String* name, Code* code); |
// Returns the found code or undefined if absent. |
@@ -4288,6 +4393,13 @@ |
MaybeObject* AddElementsTransition(ElementsKind elements_kind, |
Map* transitioned_map); |
+ // Returns the transitioned map for this map with the most generic |
+ // elements_kind that's found in |candidates|, or null handle if no match is |
+ // found at all. |
+ Handle<Map> FindTransitionedMap(MapHandleList* candidates); |
+ Map* FindTransitionedMap(MapList* candidates); |
+ |
+ |
// Dispatched behavior. |
#ifdef OBJECT_PRINT |
inline void MapPrint() { |
@@ -4796,8 +4908,12 @@ |
DECL_BOOLEAN_ACCESSORS(optimization_disabled) |
// Indicates whether the function is a strict mode function. |
- DECL_BOOLEAN_ACCESSORS(strict_mode) |
+ inline bool strict_mode(); |
+ // Indicates the mode of the function. |
+ inline StrictModeFlag strict_mode_flag(); |
+ inline void set_strict_mode_flag(StrictModeFlag strict_mode_flag); |
+ |
// False if the function definitely does not allocate an arguments object. |
DECL_BOOLEAN_ACCESSORS(uses_arguments) |
@@ -4888,6 +5004,13 @@ |
void SharedFunctionInfoVerify(); |
#endif |
+ // Helpers to compile the shared code. Returns true on success, false on |
+ // failure (e.g., stack overflow during compilation). |
+ static bool EnsureCompiled(Handle<SharedFunctionInfo> shared, |
+ ClearExceptionFlag flag); |
+ static bool CompileLazy(Handle<SharedFunctionInfo> shared, |
+ ClearExceptionFlag flag); |
+ |
// Casting. |
static inline SharedFunctionInfo* cast(Object* obj); |
@@ -5038,7 +5161,7 @@ |
public: |
// Constants for optimizing codegen for strict mode function and |
// native tests. |
- // Allows to use byte-widgh instructions. |
+ // Allows to use byte-width instructions. |
static const int kStrictModeBitWithinByte = |
(kStrictModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte; |
@@ -5109,6 +5232,14 @@ |
// recompiled the next time it is executed. |
void MarkForLazyRecompilation(); |
+ // Helpers to compile this function. Returns true on success, false on |
+ // failure (e.g., stack overflow during compilation). |
+ static bool CompileLazy(Handle<JSFunction> function, |
+ ClearExceptionFlag flag); |
+ static bool CompileOptimized(Handle<JSFunction> function, |
+ int osr_ast_id, |
+ ClearExceptionFlag flag); |
+ |
// Tells whether or not the function is already marked for lazy |
// recompilation. |
inline bool IsMarkedForLazyRecompilation(); |
@@ -5116,7 +5247,8 @@ |
// Check whether or not this function is inlineable. |
bool IsInlineable(); |
- // [literals]: Fixed array holding the materialized literals. |
+ // [literals_or_bindings]: Fixed array holding either |
+ // the materialized literals or the bindings of a bound function. |
// |
// If the function contains object, regexp or array literals, the |
// literals array prefix contains the object, regexp, and array |
@@ -5125,8 +5257,18 @@ |
// or array functions. Performing a dynamic lookup, we might end up |
// using the functions from a new context that we should not have |
// access to. |
- DECL_ACCESSORS(literals, FixedArray) |
+ // |
+ // On bound functions, the array is a (copy-on-write) fixed-array containing |
+ // the function that was bound, bound this-value and any bound |
+ // arguments. Bound functions never contain literals. |
+ DECL_ACCESSORS(literals_or_bindings, FixedArray) |
+ inline FixedArray* literals(); |
+ inline void set_literals(FixedArray* literals); |
+ |
+ inline FixedArray* function_bindings(); |
+ inline void set_function_bindings(FixedArray* bindings); |
+ |
// The initial map for an object created by this constructor. |
inline Map* initial_map(); |
inline void set_initial_map(Map* value); |
@@ -5213,6 +5355,11 @@ |
static const int kLiteralsPrefixSize = 1; |
static const int kLiteralGlobalContextIndex = 0; |
+ // Layout of the bound-function binding array. |
+ static const int kBoundFunctionIndex = 0; |
+ static const int kBoundThisIndex = 1; |
+ static const int kBoundArgumentsStartIndex = 2; |
+ |
private: |
DISALLOW_IMPLICIT_CONSTRUCTORS(JSFunction); |
}; |
@@ -5285,6 +5432,11 @@ |
} |
// Ensure that the global object has a cell for the given property name. |
+ static Handle<JSGlobalPropertyCell> EnsurePropertyCell( |
+ Handle<GlobalObject> global, |
+ Handle<String> name); |
+ // TODO(kmillikin): This function can be eliminated once the stub cache is |
+ // full handlified (and the static helper can be written directly). |
MUST_USE_RESULT MaybeObject* EnsurePropertyCell(String* name); |
// Casting. |
@@ -5757,11 +5909,18 @@ |
public: |
DECL_ACCESSORS(cache, Object) |
- MUST_USE_RESULT MaybeObject* Update(MapList* maps, |
+ static void Update(Handle<PolymorphicCodeCache> cache, |
+ MapHandleList* maps, |
+ Code::Flags flags, |
+ Handle<Code> code); |
+ |
+ MUST_USE_RESULT MaybeObject* Update(MapHandleList* maps, |
Code::Flags flags, |
Code* code); |
- Object* Lookup(MapList* maps, Code::Flags flags); |
+ // Returns an undefined value if the entry is not found. |
+ Handle<Object> Lookup(MapHandleList* maps, Code::Flags flags); |
+ |
static inline PolymorphicCodeCache* cast(Object* obj); |
#ifdef OBJECT_PRINT |
@@ -5785,9 +5944,12 @@ |
class PolymorphicCodeCacheHashTable |
: public HashTable<CodeCacheHashTableShape, HashTableKey*> { |
public: |
- Object* Lookup(MapList* maps, int code_kind); |
- MUST_USE_RESULT MaybeObject* Put(MapList* maps, int code_kind, Code* code); |
+ Object* Lookup(MapHandleList* maps, int code_kind); |
+ MUST_USE_RESULT MaybeObject* Put(MapHandleList* maps, |
+ int code_kind, |
+ Code* code); |
+ |
static inline PolymorphicCodeCacheHashTable* cast(Object* obj); |
static const int kInitialSize = 64; |
@@ -6057,7 +6219,8 @@ |
RobustnessFlag robustness_flag = FAST_STRING_TRAVERSAL, |
int* length_output = 0); |
- int Utf8Length(); |
+ inline int Utf8Length() { return Utf8Length(this, 0, length()); } |
+ static int Utf8Length(String* input, int from, int to); |
// Return a 16 bit Unicode representation of the string. |
// The string should be nearly flat, otherwise the performance of |
@@ -6917,6 +7080,60 @@ |
}; |
+// The JSSet describes EcmaScript Harmony maps |
+class JSSet: public JSObject { |
+ public: |
+ // [set]: the backing hash set containing keys. |
+ DECL_ACCESSORS(table, Object) |
+ |
+ // Casting. |
+ static inline JSSet* cast(Object* obj); |
+ |
+#ifdef OBJECT_PRINT |
+ inline void JSSetPrint() { |
+ JSSetPrint(stdout); |
+ } |
+ void JSSetPrint(FILE* out); |
+#endif |
+#ifdef DEBUG |
+ void JSSetVerify(); |
+#endif |
+ |
+ static const int kTableOffset = JSObject::kHeaderSize; |
+ static const int kSize = kTableOffset + kPointerSize; |
+ |
+ private: |
+ DISALLOW_IMPLICIT_CONSTRUCTORS(JSSet); |
+}; |
+ |
+ |
+// The JSMap describes EcmaScript Harmony maps |
+class JSMap: public JSObject { |
+ public: |
+ // [table]: the backing hash table mapping keys to values. |
+ DECL_ACCESSORS(table, Object) |
+ |
+ // Casting. |
+ static inline JSMap* cast(Object* obj); |
+ |
+#ifdef OBJECT_PRINT |
+ inline void JSMapPrint() { |
+ JSMapPrint(stdout); |
+ } |
+ void JSMapPrint(FILE* out); |
+#endif |
+#ifdef DEBUG |
+ void JSMapVerify(); |
+#endif |
+ |
+ static const int kTableOffset = JSObject::kHeaderSize; |
+ static const int kSize = kTableOffset + kPointerSize; |
+ |
+ private: |
+ DISALLOW_IMPLICIT_CONSTRUCTORS(JSMap); |
+}; |
+ |
+ |
// The JSWeakMap describes EcmaScript Harmony weak maps |
class JSWeakMap: public JSObject { |
public: |