src/objects.h - Issue 196133017: Experimental parser: merge r19949

Unified Diff: src/objects.h

Issue 196133017: Experimental parser: merge r19949 (Closed) Base URL: https://v8.googlecode.com/svn/branches/experimental/parser

Patch Set: Created 6 years, 9 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

Download patch

Index: src/objects.h

diff --git a/src/objects.h b/src/objects.h

index f90662fc6c03e84109486bc83c794ae9ddb2493a..c7725788e803c8b71b5f77cd5de678050530377c 100644

--- a/src/objects.h

+++ b/src/objects.h

@@ -2043,14 +2043,14 @@ class JSReceiver: public HeapObject {

Handle<Name> key,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

StoreFromKeyed store_mode =

MAY_BE_STORE_FROM_KEYED);

static Handle<Object> SetElement(Handle<JSReceiver> object,

uint32_t index,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

// Implementation of [[HasProperty]], ECMA-262 5th edition, section 8.12.6.

static inline bool HasProperty(Handle<JSReceiver> object, Handle<Name> name);

@@ -2076,13 +2076,23 @@ class JSReceiver: public HeapObject {

// function that was used to instantiate the object).

String* constructor_name();

- inline PropertyAttributes GetPropertyAttribute(Name* name);

- PropertyAttributes GetPropertyAttributeWithReceiver(JSReceiver* receiver,

- Name* name);

- PropertyAttributes GetLocalPropertyAttribute(Name* name);

+ static inline PropertyAttributes GetPropertyAttribute(

+ Handle<JSReceiver> object,

+ Handle<Name> name);

+ static PropertyAttributes GetPropertyAttributeWithReceiver(

+ Handle<JSReceiver> object,

+ Handle<JSReceiver> receiver,

+ Handle<Name> name);

+ static PropertyAttributes GetLocalPropertyAttribute(

+ Handle<JSReceiver> object,

+ Handle<Name> name);

- inline PropertyAttributes GetElementAttribute(uint32_t index);

- inline PropertyAttributes GetLocalElementAttribute(uint32_t index);

+ static inline PropertyAttributes GetElementAttribute(

+ Handle<JSReceiver> object,

+ uint32_t index);

+ static inline PropertyAttributes GetLocalElementAttribute(

+ Handle<JSReceiver> object,

+ uint32_t index);

// Return the object's prototype (might be Heap::null_value()).

inline Object* GetPrototype();

@@ -2113,17 +2123,19 @@ class JSReceiver: public HeapObject {

Handle<Object> value);

private:

- PropertyAttributes GetPropertyAttributeForResult(JSReceiver* receiver,

- LookupResult* result,

- Name* name,

- bool continue_search);

+ static PropertyAttributes GetPropertyAttributeForResult(

+ Handle<JSReceiver> object,

+ Handle<JSReceiver> receiver,

+ LookupResult* result,

+ Handle<Name> name,

+ bool continue_search);

static Handle<Object> SetProperty(Handle<JSReceiver> receiver,

LookupResult* result,

Handle<Name> key,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

StoreFromKeyed store_from_keyed);

DISALLOW_IMPLICIT_CONSTRUCTORS(JSReceiver);

@@ -2155,14 +2167,14 @@ class JSObject: public JSReceiver {

// In the fast mode elements is a FixedArray and so each element can

// be quickly accessed. This fact is used in the generated code. The

// elements array can have one of three maps in this mode:

- // fixed_array_map, non_strict_arguments_elements_map or

+ // fixed_array_map, sloppy_arguments_elements_map or

// fixed_cow_array_map (for copy-on-write arrays). In the latter case

// the elements array may be shared by a few objects and so before

// writing to any element the array must be copied. Use

// EnsureWritableFastElements in this case.

// In the slow mode the elements is either a NumberDictionary, an

- // ExternalArray, or a FixedArray parameter map for a (non-strict)

+ // ExternalArray, or a FixedArray parameter map for a (sloppy)

// arguments object.

DECL_ACCESSORS(elements, FixedArrayBase)

inline void initialize_elements();

@@ -2184,7 +2196,7 @@ class JSObject: public JSReceiver {

// Returns true if an object has elements of FAST_HOLEY_*_ELEMENTS

// ElementsKind.

inline bool HasFastHoleyElements();

- inline bool HasNonStrictArgumentsElements();

+ inline bool HasSloppyArgumentsElements();

inline bool HasDictionaryElements();

inline bool HasExternalUint8ClampedElements();

@@ -2236,14 +2248,14 @@ class JSObject: public JSReceiver {

Handle<Name> name,

Handle<Object> value,

Handle<JSObject> holder,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

static Handle<Object> SetPropertyWithInterceptor(

Handle<JSObject> object,

Handle<Name> name,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

static Handle<Object> SetPropertyForResult(

Handle<JSObject> object,

@@ -2251,7 +2263,7 @@ class JSObject: public JSReceiver {

Handle<Name> name,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

StoreFromKeyed store_mode = MAY_BE_STORE_FROM_KEYED);

static Handle<Object> SetLocalPropertyIgnoreAttributes(

@@ -2307,20 +2319,26 @@ class JSObject: public JSReceiver {

InterceptorInfo* GetIndexedInterceptor();

// Used from JSReceiver.

- PropertyAttributes GetPropertyAttributePostInterceptor(JSObject* receiver,

- Name* name,

- bool continue_search);

- PropertyAttributes GetPropertyAttributeWithInterceptor(JSObject* receiver,

- Name* name,

- bool continue_search);

- PropertyAttributes GetPropertyAttributeWithFailedAccessCheck(

- Object* receiver,

+ static PropertyAttributes GetPropertyAttributePostInterceptor(

+ Handle<JSObject> object,

+ Handle<JSObject> receiver,

+ Handle<Name> name,

+ bool continue_search);

+ static PropertyAttributes GetPropertyAttributeWithInterceptor(

+ Handle<JSObject> object,

+ Handle<JSObject> receiver,

+ Handle<Name> name,

+ bool continue_search);

+ static PropertyAttributes GetPropertyAttributeWithFailedAccessCheck(

+ Handle<JSObject> object,

LookupResult* result,

- Name* name,

+ Handle<Name> name,

+ bool continue_search);

+ static PropertyAttributes GetElementAttributeWithReceiver(

+ Handle<JSObject> object,

+ Handle<JSReceiver> receiver,

+ uint32_t index,

bool continue_search);

- PropertyAttributes GetElementAttributeWithReceiver(JSReceiver* receiver,

- uint32_t index,

- bool continue_search);

// Retrieves an AccessorPair property from the given object. Might return

// undefined if the property doesn't exist or is of a different kind.

@@ -2361,10 +2379,6 @@ class JSObject: public JSReceiver {

// been modified since it was created. May give false positives.

bool IsDirty();

- // If the receiver is a JSGlobalProxy this method will return its prototype,

- // otherwise the result is the receiver itself.

- inline Object* BypassGlobalProxy();

// Accessors for hidden properties object.

// Hidden properties are not local properties of the object itself.

@@ -2388,7 +2402,7 @@ class JSObject: public JSReceiver {

static void DeleteHiddenProperty(Handle<JSObject> object,

Handle<Name> key);

// Returns true if the object has a property with the hidden string as name.

- bool HasHiddenProperties();

+ static bool HasHiddenProperties(Handle<JSObject> object);

static void SetIdentityHash(Handle<JSObject> object, Handle<Smi> hash);

@@ -2412,6 +2426,9 @@ class JSObject: public JSReceiver {

uint32_t arg_count,

EnsureElementsMode mode);

+ // Would we convert a fast elements array to dictionary mode given

+ // an access at key?

+ bool WouldConvertToSlowElements(Handle<Object> key);

// Do we want to keep the elements in fast case when increasing the

// capacity?

bool ShouldConvertToSlowElements(int new_capacity);

@@ -2437,13 +2454,13 @@ class JSObject: public JSReceiver {

static Handle<Object> SetFastElement(Handle<JSObject> object, uint32_t index,

Handle<Object> value,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool check_prototype);

static Handle<Object> SetOwnElement(Handle<JSObject> object,

uint32_t index,

Handle<Object> value,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

// Empty handle is returned if the element cannot be set to the given value.

static Handle<Object> SetElement(

@@ -2451,7 +2468,7 @@ class JSObject: public JSReceiver {

uint32_t index,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool check_prototype = true,

SetPropertyMode set_mode = SET_PROPERTY);

@@ -2758,12 +2775,14 @@ class JSObject: public JSReceiver {

Object* structure,

uint32_t index,

Object* holder);

- MUST_USE_RESULT PropertyAttributes GetElementAttributeWithInterceptor(

- JSReceiver* receiver,

+ static PropertyAttributes GetElementAttributeWithInterceptor(

+ Handle<JSObject> object,

+ Handle<JSReceiver> receiver,

uint32_t index,

bool continue_search);

- MUST_USE_RESULT PropertyAttributes GetElementAttributeWithoutInterceptor(

- JSReceiver* receiver,

+ static PropertyAttributes GetElementAttributeWithoutInterceptor(

+ Handle<JSObject> object,

+ Handle<JSReceiver> receiver,

uint32_t index,

bool continue_search);

static Handle<Object> SetElementWithCallback(

@@ -2772,13 +2791,13 @@ class JSObject: public JSReceiver {

uint32_t index,

Handle<Object> value,

Handle<JSObject> holder,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

static Handle<Object> SetElementWithInterceptor(

Handle<JSObject> object,

uint32_t index,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool check_prototype,

SetPropertyMode set_mode);

static Handle<Object> SetElementWithoutInterceptor(

@@ -2786,7 +2805,7 @@ class JSObject: public JSReceiver {

uint32_t index,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool check_prototype,

SetPropertyMode set_mode);

static Handle<Object> SetElementWithCallbackSetterInPrototypes(

@@ -2794,20 +2813,20 @@ class JSObject: public JSReceiver {

uint32_t index,

Handle<Object> value,

bool* found,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

static Handle<Object> SetDictionaryElement(

Handle<JSObject> object,

uint32_t index,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool check_prototype,

SetPropertyMode set_mode = SET_PROPERTY);

static Handle<Object> SetFastDoubleElement(

Handle<JSObject> object,

uint32_t index,

Handle<Object> value,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool check_prototype = true);

// Searches the prototype chain for property 'name'. If it is found and

@@ -2819,14 +2838,14 @@ class JSObject: public JSReceiver {

Handle<Name> name,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool* done);

static Handle<Object> SetPropertyPostInterceptor(

Handle<JSObject> object,

Handle<Name> name,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

static Handle<Object> SetPropertyUsingTransition(

Handle<JSObject> object,

LookupResult* lookup,

@@ -2839,7 +2858,7 @@ class JSObject: public JSReceiver {

Handle<Name> name,

Handle<Object> value,

bool check_prototype,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

// Add a property to an object.

static Handle<Object> AddProperty(

@@ -2847,7 +2866,7 @@ class JSObject: public JSReceiver {

Handle<Name> name,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

StoreFromKeyed store_mode = MAY_BE_STORE_FROM_KEYED,

ExtensibilityCheck extensibility_check = PERFORM_EXTENSIBILITY_CHECK,

ValueType value_type = OPTIMAL_REPRESENTATION,

@@ -2875,15 +2894,6 @@ class JSObject: public JSReceiver {

ValueType value_type,

TransitionFlag flag);

- // Add a property to a fast-case object using a map transition to

- // new_map.

- static void AddFastPropertyUsingMap(Handle<JSObject> object,

- Handle<Map> new_map,

- Handle<Name> name,

- Handle<Object> value,

- int field_index,

- Representation representation);

// Add a property to a slow-case object.

static void AddSlowProperty(Handle<JSObject> object,

Handle<Name> name,

@@ -2920,7 +2930,7 @@ class JSObject: public JSReceiver {

// Gets the current elements capacity and the number of used elements.

void GetElementsCapacityAndUsage(int* capacity, int* used);

- bool CanSetCallback(Name* name);

+ static bool CanSetCallback(Handle<JSObject> object, Handle<Name> name);

static void SetElementCallback(Handle<JSObject> object,

uint32_t index,

Handle<Object> structure,

@@ -3159,29 +3169,35 @@ class FixedDoubleArray: public FixedArrayBase {

// ConstantPoolArray describes a fixed-sized array containing constant pool

// entires.

// The format of the pool is:

-// [0]: Field holding the first index which is a pointer entry

-// [1]: Field holding the first index which is a int32 entry

-// [2] ... [first_ptr_index() - 1]: 64 bit entries

-// [first_ptr_index()] ... [first_int32_index() - 1]: pointer entries

-// [first_int32_index()] ... [length - 1]: 32 bit entries

+// [0]: Field holding the first index which is a raw code target pointer entry

+// [1]: Field holding the first index which is a heap pointer entry

+// [2]: Field holding the first index which is a int32 entry

+// [3] ... [first_code_ptr_index() - 1] : 64 bit entries

+// [first_code_ptr_index()] ... [first_heap_ptr_index() - 1] : code pointers

+// [first_heap_ptr_index()] ... [first_int32_index() - 1] : heap pointers

+// [first_int32_index()] ... [length - 1] : 32 bit entries

class ConstantPoolArray: public FixedArrayBase {

public:

// Getters for the field storing the first index for different type entries.

- inline int first_ptr_index();

+ inline int first_code_ptr_index();

+ inline int first_heap_ptr_index();

inline int first_int64_index();

inline int first_int32_index();

// Getters for counts of different type entries.

- inline int count_of_ptr_entries();

+ inline int count_of_code_ptr_entries();

+ inline int count_of_heap_ptr_entries();

inline int count_of_int64_entries();

inline int count_of_int32_entries();

// Setter and getter for pool elements.

- inline Object* get_ptr_entry(int index);

+ inline Address get_code_ptr_entry(int index);

+ inline Object* get_heap_ptr_entry(int index);

inline int64_t get_int64_entry(int index);

inline int32_t get_int32_entry(int index);

inline double get_int64_entry_as_double(int index);

+ inline void set(int index, Address value);

inline void set(int index, Object* value);

inline void set(int index, int64_t value);

inline void set(int index, double value);

@@ -3189,7 +3205,8 @@ class ConstantPoolArray: public FixedArrayBase {

// Set up initial state.

inline void SetEntryCounts(int number_of_int64_entries,

- int number_of_ptr_entries,

+ int number_of_code_ptr_entries,

+ int number_of_heap_ptr_entries,

int number_of_int32_entries);

// Copy operations

@@ -3197,10 +3214,12 @@ class ConstantPoolArray: public FixedArrayBase {

// Garbage collection support.

inline static int SizeFor(int number_of_int64_entries,

- int number_of_ptr_entries,

+ int number_of_code_ptr_entries,

+ int number_of_heap_ptr_entries,

int number_of_int32_entries) {

return RoundUp(OffsetAt(number_of_int64_entries,

- number_of_ptr_entries,

+ number_of_code_ptr_entries,

+ number_of_heap_ptr_entries,

number_of_int32_entries),

kPointerSize);

}

@@ -3209,22 +3228,33 @@ class ConstantPoolArray: public FixedArrayBase {

inline int OffsetOfElementAt(int index) {

ASSERT(index < length());

if (index >= first_int32_index()) {

- return OffsetAt(count_of_int64_entries(), count_of_ptr_entries(),

- index - first_int32_index());

- } else if (index >= first_ptr_index()) {

- return OffsetAt(count_of_int64_entries(), index - first_ptr_index(), 0);

+ return OffsetAt(count_of_int64_entries(), count_of_code_ptr_entries(),

+ count_of_heap_ptr_entries(), index - first_int32_index());

+ } else if (index >= first_heap_ptr_index()) {

+ return OffsetAt(count_of_int64_entries(), count_of_code_ptr_entries(),

+ index - first_heap_ptr_index(), 0);

+ } else if (index >= first_code_ptr_index()) {

+ return OffsetAt(count_of_int64_entries(), index - first_code_ptr_index(),

+ 0, 0);

} else {

- return OffsetAt(index, 0, 0);

+ return OffsetAt(index, 0, 0, 0);

}

// Casting.

static inline ConstantPoolArray* cast(Object* obj);

+ // Garbage collection support.

+ Object** RawFieldOfElementAt(int index) {

+ return HeapObject::RawField(this, OffsetOfElementAt(index));

+ }

// Layout description.

- static const int kFirstPointerIndexOffset = FixedArray::kHeaderSize;

+ static const int kFirstCodePointerIndexOffset = FixedArray::kHeaderSize;

+ static const int kFirstHeapPointerIndexOffset =

+ kFirstCodePointerIndexOffset + kPointerSize;

static const int kFirstInt32IndexOffset =

- kFirstPointerIndexOffset + kPointerSize;

+ kFirstHeapPointerIndexOffset + kPointerSize;

static const int kFirstOffset = kFirstInt32IndexOffset + kPointerSize;

// Dispatched behavior.

@@ -3234,15 +3264,18 @@ class ConstantPoolArray: public FixedArrayBase {

DECLARE_VERIFIER(ConstantPoolArray)

private:

- inline void set_first_ptr_index(int value);

+ inline void set_first_code_ptr_index(int value);

+ inline void set_first_heap_ptr_index(int value);

inline void set_first_int32_index(int value);

inline static int OffsetAt(int number_of_int64_entries,

- int number_of_ptr_entries,

+ int number_of_code_ptr_entries,

+ int number_of_heap_ptr_entries,

int number_of_int32_entries) {

return kFirstOffset

+ (number_of_int64_entries * kInt64Size)

- + (number_of_ptr_entries * kPointerSize)

+ + (number_of_code_ptr_entries * kPointerSize)

+ + (number_of_heap_ptr_entries * kPointerSize)

+ (number_of_int32_entries * kInt32Size);

}

@@ -4003,7 +4036,7 @@ class NameDictionary: public Dictionary<NameDictionaryShape, Name*> {

}

// Copies enumerable keys to preallocated fixed array.

- FixedArray* CopyEnumKeysTo(FixedArray* storage);

+ void CopyEnumKeysTo(FixedArray* storage);

static void DoGenerateNewEnumerationIndices(

Handle<NameDictionary> dictionary);

@@ -4317,13 +4350,11 @@ class ScopeInfo : public FixedArray {

// Does this scope call eval?

bool CallsEval();

- // Return the language mode of this scope.

- LanguageMode language_mode();

+ // Return the strict mode of this scope.

+ StrictMode strict_mode();

- // Does this scope make a non-strict eval call?

- bool CallsNonStrictEval() {

- return CallsEval() && (language_mode() == CLASSIC_MODE);

- }

+ // Does this scope make a sloppy eval call?

+ bool CallsSloppyEval() { return CallsEval() && strict_mode() == SLOPPY; }

// Return the total number of locals allocated on the stack and in the

// context. This includes the parameters that are allocated in the context.

@@ -4497,9 +4528,9 @@ class ScopeInfo : public FixedArray {

// Properties of scopes.

class ScopeTypeField: public BitField<ScopeType, 0, 3> {};

class CallsEvalField: public BitField<bool, 3, 1> {};

- class LanguageModeField: public BitField<LanguageMode, 4, 2> {};

- class FunctionVariableField: public BitField<FunctionVariableInfo, 6, 2> {};

- class FunctionVariableMode: public BitField<VariableMode, 8, 3> {};

+ class StrictModeField: public BitField<StrictMode, 4, 1> {};

+ class FunctionVariableField: public BitField<FunctionVariableInfo, 5, 2> {};

+ class FunctionVariableMode: public BitField<VariableMode, 7, 3> {};

// BitFields representing the encoded information for context locals in the

// ContextLocalInfoEntries part.

@@ -5466,8 +5497,6 @@ class Code: public HeapObject {

void ClearInlineCaches();

void ClearInlineCaches(Kind kind);

- void ClearTypeFeedbackInfo(Heap* heap);

BailoutId TranslatePcOffsetToAstId(uint32_t pc_offset);

uint32_t TranslateAstIdToPcOffset(BailoutId ast_id);

@@ -5912,8 +5941,8 @@ class Map: public HeapObject {

return IsFastElementsKind(elements_kind());

}

- inline bool has_non_strict_arguments_elements() {

- return elements_kind() == NON_STRICT_ARGUMENTS_ELEMENTS;

+ inline bool has_sloppy_arguments_elements() {

+ return elements_kind() == SLOPPY_ARGUMENTS_ELEMENTS;

}

inline bool has_external_array_elements() {

@@ -5930,7 +5959,7 @@ class Map: public HeapObject {

inline bool has_slow_elements_kind() {

return elements_kind() == DICTIONARY_ELEMENTS

- || elements_kind() == NON_STRICT_ARGUMENTS_ELEMENTS;

+ || elements_kind() == SLOPPY_ARGUMENTS_ELEMENTS;

}

static bool IsValidElementsTransition(ElementsKind from_kind,

@@ -6514,9 +6543,6 @@ class Script: public Struct {

// extracted.

DECL_ACCESSORS(column_offset, Smi)

- // [data]: additional data associated with this script.

- DECL_ACCESSORS(data, Object)

// [context_data]: context data for the context this script was compiled in.

DECL_ACCESSORS(context_data, Object)

@@ -6570,8 +6596,7 @@ class Script: public Struct {

static const int kNameOffset = kSourceOffset + kPointerSize;

static const int kLineOffsetOffset = kNameOffset + kPointerSize;

static const int kColumnOffsetOffset = kLineOffsetOffset + kPointerSize;

- static const int kDataOffset = kColumnOffsetOffset + kPointerSize;

- static const int kContextOffset = kDataOffset + kPointerSize;

+ static const int kContextOffset = kColumnOffsetOffset + kPointerSize;

static const int kWrapperOffset = kContextOffset + kPointerSize;

static const int kTypeOffset = kWrapperOffset + kPointerSize;

static const int kLineEndsOffset = kTypeOffset + kPointerSize;

@@ -6667,6 +6692,8 @@ class SharedFunctionInfo: public HeapObject {

// Removed a specific optimized code object from the optimized code map.

void EvictFromOptimizedCodeMap(Code* optimized_code, const char* reason);

+ void ClearTypeFeedbackInfo(Heap* heap);

// Trims the optimized code map after entries have been removed.

void TrimOptimizedCodeMap(int shrink_by);

@@ -6689,13 +6716,6 @@ class SharedFunctionInfo: public HeapObject {

static const int kLiteralsOffset = 2;

static const int kOsrAstIdOffset = 3;

static const int kEntryLength = 4;

- static const int kFirstContextSlot = FixedArray::kHeaderSize +

- (kEntriesStart + kContextOffset) * kPointerSize;

- static const int kFirstCodeSlot = FixedArray::kHeaderSize +

- (kEntriesStart + kCachedCodeOffset) * kPointerSize;

- static const int kFirstOsrAstIdSlot = FixedArray::kHeaderSize +

- (kEntriesStart + kOsrAstIdOffset) * kPointerSize;

- static const int kSecondEntryIndex = kEntryLength + kEntriesStart;

static const int kInitialLength = kEntriesStart + kEntryLength;

// [scope_info]: Scope info.

@@ -6782,6 +6802,12 @@ class SharedFunctionInfo: public HeapObject {

inline int construction_count();

inline void set_construction_count(int value);

+ // [feedback_vector] - accumulates ast node feedback from full-codegen and

+ // (increasingly) from crankshafted code where sufficient feedback isn't

+ // available. Currently the field is duplicated in

+ // TypeFeedbackInfo::feedback_vector, but the allocation is done here.

+ DECL_ACCESSORS(feedback_vector, FixedArray)

// [initial_map]: initial map of the first function called as a constructor.

// Saved for the duration of the tracking phase.

// This is a weak link (GC resets it to undefined_value if no other live

@@ -6914,20 +6940,9 @@ class SharedFunctionInfo: public HeapObject {

// spending time attempting to optimize it again.

DECL_BOOLEAN_ACCESSORS(optimization_disabled)

- // Indicates the language mode of the function's code as defined by the

- // current harmony drafts for the next ES language standard. Possible

- // values are:

- // 1. CLASSIC_MODE - Unrestricted syntax and semantics, same as in ES5.

- // 2. STRICT_MODE - Restricted syntax and semantics, same as in ES5.

- // 3. EXTENDED_MODE - Only available under the harmony flag, not part of ES5.

- inline LanguageMode language_mode();

- inline void set_language_mode(LanguageMode language_mode);

- // Indicates whether the language mode of this function is CLASSIC_MODE.

- inline bool is_classic_mode();

- // Indicates whether the language mode of this function is EXTENDED_MODE.

- inline bool is_extended_mode();

+ // Indicates the language mode.

+ inline StrictMode strict_mode();

+ inline void set_strict_mode(StrictMode strict_mode);

// False if the function definitely does not allocate an arguments object.

DECL_BOOLEAN_ACCESSORS(uses_arguments)

@@ -7073,8 +7088,10 @@ class SharedFunctionInfo: public HeapObject {

static const int kScriptOffset = kFunctionDataOffset + kPointerSize;

static const int kDebugInfoOffset = kScriptOffset + kPointerSize;

static const int kInferredNameOffset = kDebugInfoOffset + kPointerSize;

- static const int kInitialMapOffset =

+ static const int kFeedbackVectorOffset =

kInferredNameOffset + kPointerSize;

+ static const int kInitialMapOffset =

+ kFeedbackVectorOffset + kPointerSize;

// ast_node_count is a Smi field. It could be grouped with another Smi field

// into a PSEUDO_SMI_ACCESSORS pair (on x64), if one becomes available.

static const int kAstNodeCountOffset =

@@ -7176,7 +7193,6 @@ class SharedFunctionInfo: public HeapObject {

kLiveObjectsMayExist,

kOptimizationDisabled,

kStrictModeFunction,

- kExtendedModeFunction,

kUsesArguments,

kHasDuplicateParameters,

kNative,

@@ -7221,26 +7237,18 @@ class SharedFunctionInfo: public HeapObject {

static const int kStrictModeBitWithinByte =

(kStrictModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;

- static const int kExtendedModeBitWithinByte =

- (kExtendedModeFunction + kCompilerHintsSmiTagSize) % kBitsPerByte;

static const int kNativeBitWithinByte =

(kNative + kCompilerHintsSmiTagSize) % kBitsPerByte;

#if __BYTE_ORDER == __LITTLE_ENDIAN

static const int kStrictModeByteOffset = kCompilerHintsOffset +

(kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;

- static const int kExtendedModeByteOffset = kCompilerHintsOffset +

- (kExtendedModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte;

static const int kNativeByteOffset = kCompilerHintsOffset +

(kNative + kCompilerHintsSmiTagSize) / kBitsPerByte;

#elif __BYTE_ORDER == __BIG_ENDIAN

static const int kStrictModeByteOffset = kCompilerHintsOffset +

(kCompilerHintsSize - 1) -

((kStrictModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);

- static const int kExtendedModeByteOffset = kCompilerHintsOffset +

- (kCompilerHintsSize - 1) -

- ((kExtendedModeFunction + kCompilerHintsSmiTagSize) / kBitsPerByte);

static const int kNativeByteOffset = kCompilerHintsOffset +

(kCompilerHintsSize - 1) -

((kNative + kCompilerHintsSmiTagSize) / kBitsPerByte);

@@ -7991,7 +7999,7 @@ class CompilationCacheTable: public HashTable<CompilationCacheShape,

Object* Lookup(String* src, Context* context);

Object* LookupEval(String* src,

Context* context,

- LanguageMode language_mode,

+ StrictMode strict_mode,

int scope_position);

Object* LookupRegExp(String* source, JSRegExp::Flags flags);

MUST_USE_RESULT MaybeObject* Put(String* src,

@@ -8169,8 +8177,6 @@ class TypeFeedbackInfo: public Struct {

inline void set_inlined_type_change_checksum(int checksum);

inline bool matches_inlined_type_change_checksum(int checksum);

- DECL_ACCESSORS(feedback_vector, FixedArray)

static inline TypeFeedbackInfo* cast(Object* obj);

// Dispatched behavior.

@@ -8179,10 +8185,9 @@ class TypeFeedbackInfo: public Struct {

static const int kStorage1Offset = HeapObject::kHeaderSize;

static const int kStorage2Offset = kStorage1Offset + kPointerSize;

- static const int kFeedbackVectorOffset =

- kStorage2Offset + kPointerSize;

- static const int kSize = kFeedbackVectorOffset + kPointerSize;

+ static const int kSize = kStorage2Offset + kPointerSize;

+ // TODO(mvstanton): move these sentinel declarations to shared function info.

// The object that indicates an uninitialized cache.

static inline Handle<Object> UninitializedSentinel(Isolate* isolate);

@@ -8198,9 +8203,6 @@ class TypeFeedbackInfo: public Struct {

// garbage collection (e.g., for patching the cache).

static inline Object* RawUninitializedSentinel(Heap* heap);

- static const int kForInFastCaseMarker = 0;

- static const int kForInSlowCaseMarker = 1;

private:

static const int kTypeChangeChecksumBits = 7;

@@ -8434,8 +8436,8 @@ class AllocationMemento: public Struct {

};

-// Representation of a slow alias as part of a non-strict arguments objects.

-// For fast aliases (if HasNonStrictArgumentsElements()):

+// Representation of a slow alias as part of a sloppy arguments objects.

+// For fast aliases (if HasSloppyArgumentsElements()):

// - the parameter map contains an index into the context

// - all attributes of the element have default values

// For slow aliases (if HasDictionaryArgumentsElements()):

@@ -9613,14 +9615,16 @@ class JSProxy: public JSReceiver {

Handle<Name> name,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode,

+ StrictMode strict_mode,

bool* done);

- MUST_USE_RESULT PropertyAttributes GetPropertyAttributeWithHandler(

- JSReceiver* receiver,

- Name* name);

- MUST_USE_RESULT PropertyAttributes GetElementAttributeWithHandler(

- JSReceiver* receiver,

+ static PropertyAttributes GetPropertyAttributeWithHandler(

+ Handle<JSProxy> proxy,

+ Handle<JSReceiver> receiver,

+ Handle<Name> name);

+ static PropertyAttributes GetElementAttributeWithHandler(

+ Handle<JSProxy> proxy,

+ Handle<JSReceiver> receiver,

uint32_t index);

// Turn the proxy into an (empty) JSObject.

@@ -9664,12 +9668,12 @@ class JSProxy: public JSReceiver {

Handle<Name> name,

Handle<Object> value,

PropertyAttributes attributes,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

static Handle<Object> SetElementWithHandler(Handle<JSProxy> proxy,

Handle<JSReceiver> receiver,

uint32_t index,

Handle<Object> value,

- StrictModeFlag strict_mode);

+ StrictMode strict_mode);

static bool HasPropertyWithHandler(Handle<JSProxy> proxy, Handle<Name> name);

static bool HasElementWithHandler(Handle<JSProxy> proxy, uint32_t index);

« no previous file with comments | « src/object-observe.js ('k') | src/objects.cc » ('j') | no next file with comments »