src/objects.h - Issue 8404030: Version 3.7.1

Unified Diff: src/objects.h

Issue 8404030: Version 3.7.1 (Closed) Base URL: http://v8.googlecode.com/svn/trunk/

Patch Set: Created 9 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

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:

« no previous file with comments | « src/mksnapshot.cc ('k') | src/objects.cc » ('j') | no next file with comments »