src/objects.h - Issue 110573004: Merge bleeding_edge 17696:18016.

Unified Diff: src/objects.h

Issue 110573004: Merge bleeding_edge 17696:18016. (Closed) Base URL: https://v8.googlecode.com/svn/branches/experimental/parser

Patch Set: Created 7 years 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 2fc1d2379383f16641883c2344d318b020cd913c..8e2a831126e341ae564a7ad91dcc7e88cfd54d9e 100644

--- a/src/objects.h

+++ b/src/objects.h

@@ -1196,6 +1196,7 @@ class MaybeObject BASE_EMBEDDED {

V(kNonSmiIndex, "Non-smi index") \

V(kNonSmiKeyInArrayLiteral, "Non-smi key in array literal") \

V(kNonSmiValue, "Non-smi value") \

+ V(kNonObject, "Non-object value") \

V(kNotEnoughVirtualRegistersForValues, \

"not enough virtual registers for values") \

V(kNotEnoughSpillSlotsForOsr, \

@@ -1351,10 +1352,6 @@ class Object : public MaybeObject {

inline bool IsExternal();

inline bool IsAccessorInfo();

- // Returns true if this object is an instance of the specified

- // function template.

- inline bool IsInstanceOf(FunctionTemplateInfo* type);

inline bool IsStruct();

#define DECLARE_STRUCT_PREDICATE(NAME, Name, name) inline bool Is##Name();

STRUCT_LIST(DECLARE_STRUCT_PREDICATE)

@@ -1494,6 +1491,7 @@ class Object : public MaybeObject {

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

Object* GetPrototype(Isolate* isolate);

+ Map* GetMarkerMap(Isolate* isolate);

// Returns the permanent hash code associated with this object. May return

// undefined if not yet created.

@@ -2338,24 +2336,10 @@ class JSObject: public JSReceiver {

AccessorPair* GetLocalPropertyAccessorPair(Name* name);

AccessorPair* GetLocalElementAccessorPair(uint32_t index);

- MUST_USE_RESULT MaybeObject* SetFastElement(uint32_t index,

- Object* value,

- StrictModeFlag strict_mode,

- bool check_prototype);

- MUST_USE_RESULT MaybeObject* SetDictionaryElement(

- uint32_t index,

- Object* value,

- PropertyAttributes attributes,

- StrictModeFlag strict_mode,

- bool check_prototype,

- SetPropertyMode set_mode = SET_PROPERTY);

- MUST_USE_RESULT MaybeObject* SetFastDoubleElement(

- uint32_t index,

- Object* value,

- StrictModeFlag strict_mode,

- bool check_prototype = true);

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

+ Handle<Object> value,

+ StrictModeFlag strict_mode,

+ bool check_prototype);

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

uint32_t index,

@@ -2367,15 +2351,6 @@ class JSObject: public JSReceiver {

Handle<JSObject> object,

uint32_t index,

Handle<Object> value,

- PropertyAttributes attr,

- StrictModeFlag strict_mode,

- bool check_prototype = true,

- SetPropertyMode set_mode = SET_PROPERTY);

- // A Failure object is returned if GC is needed.

- MUST_USE_RESULT MaybeObject* SetElement(

- uint32_t index,

- Object* value,

PropertyAttributes attributes,

StrictModeFlag strict_mode,

bool check_prototype = true,

@@ -2392,6 +2367,11 @@ class JSObject: public JSReceiver {

kDontAllowSmiElements

};

+ static Handle<FixedArray> SetFastElementsCapacityAndLength(

+ Handle<JSObject> object,

+ int capacity,

+ int length,

+ SetFastElementsCapacitySmiMode smi_mode);

// Replace the elements' backing store with fast elements of the given

// capacity. Update the length for JSArrays. Returns the new backing

// store.

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

int capacity,

int length,

SetFastElementsCapacitySmiMode smi_mode);

+ static void SetFastDoubleElementsCapacityAndLength(

+ Handle<JSObject> object,

+ int capacity,

+ int length);

MUST_USE_RESULT MaybeObject* SetFastDoubleElementsCapacityAndLength(

int capacity,

int length);

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

ElementsKind to_kind);

MUST_USE_RESULT MaybeObject* TransitionElementsKind(ElementsKind to_kind);

- MUST_USE_RESULT MaybeObject* UpdateAllocationSite(ElementsKind to_kind);

// TODO(mstarzinger): Both public because of ConvertAnsSetLocalProperty().

static void MigrateToMap(Handle<JSObject> object, Handle<Map> new_map);

@@ -2659,6 +2642,10 @@ class JSObject: public JSReceiver {

friend class JSReceiver;

friend class Object;

+ static void UpdateAllocationSite(Handle<JSObject> object,

+ ElementsKind to_kind);

+ MUST_USE_RESULT MaybeObject* UpdateAllocationSite(ElementsKind to_kind);

// Used from Object::GetProperty().

static Handle<Object> GetPropertyWithFailedAccessCheck(

Handle<JSObject> object,

@@ -2686,25 +2673,42 @@ class JSObject: public JSReceiver {

Handle<Object> value,

Handle<JSObject> holder,

StrictModeFlag strict_mode);

- MUST_USE_RESULT MaybeObject* SetElementWithInterceptor(

+ static Handle<Object> SetElementWithInterceptor(

+ Handle<JSObject> object,

uint32_t index,

- Object* value,

+ Handle<Object> value,

PropertyAttributes attributes,

StrictModeFlag strict_mode,

bool check_prototype,

SetPropertyMode set_mode);

- MUST_USE_RESULT MaybeObject* SetElementWithoutInterceptor(

+ static Handle<Object> SetElementWithoutInterceptor(

+ Handle<JSObject> object,

uint32_t index,

- Object* value,

+ Handle<Object> value,

PropertyAttributes attributes,

StrictModeFlag strict_mode,

bool check_prototype,

SetPropertyMode set_mode);

- MUST_USE_RESULT MaybeObject* SetElementWithCallbackSetterInPrototypes(

+ static Handle<Object> SetElementWithCallbackSetterInPrototypes(

+ Handle<JSObject> object,

uint32_t index,

- Object* value,

+ Handle<Object> value,

bool* found,

StrictModeFlag strict_mode);

+ static Handle<Object> SetDictionaryElement(

+ Handle<JSObject> object,

+ uint32_t index,

+ Handle<Object> value,

+ PropertyAttributes attributes,

+ StrictModeFlag 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,

+ bool check_prototype = true);

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

// has a setter, invoke it and set '*done' to true. If it is found and is

@@ -3363,10 +3367,6 @@ class DescriptorArray: public FixedArray {

bool IsEqualTo(DescriptorArray* other);

#endif

- // The maximum number of descriptors we want in a descriptor array (should

- // fit in a page).

- static const int kMaxNumberOfDescriptors = 1024 + 512;

// Returns the fixed array length required to hold number_of_descriptors

// descriptors.

static int LengthFor(int number_of_descriptors) {

@@ -3966,6 +3966,11 @@ class SeededNumberDictionary

// Type specific at put (default NONE attributes is used when adding).

MUST_USE_RESULT MaybeObject* AtNumberPut(uint32_t key, Object* value);

+ MUST_USE_RESULT static Handle<SeededNumberDictionary> AddNumberEntry(

+ Handle<SeededNumberDictionary> dictionary,

+ uint32_t key,

+ Handle<Object> value,

+ PropertyDetails details);

MUST_USE_RESULT MaybeObject* AddNumberEntry(uint32_t key,

Object* value,

PropertyDetails details);

@@ -4590,6 +4595,10 @@ class ExternalByteArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, int8_t value);

+ static Handle<Object> SetValue(Handle<ExternalByteArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4613,6 +4622,10 @@ class ExternalUnsignedByteArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, uint8_t value);

+ static Handle<Object> SetValue(Handle<ExternalUnsignedByteArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4636,6 +4649,10 @@ class ExternalShortArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, int16_t value);

+ static Handle<Object> SetValue(Handle<ExternalShortArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4659,6 +4676,10 @@ class ExternalUnsignedShortArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, uint16_t value);

+ static Handle<Object> SetValue(Handle<ExternalUnsignedShortArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4682,6 +4703,10 @@ class ExternalIntArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, int32_t value);

+ static Handle<Object> SetValue(Handle<ExternalIntArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4705,6 +4730,10 @@ class ExternalUnsignedIntArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, uint32_t value);

+ static Handle<Object> SetValue(Handle<ExternalUnsignedIntArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4728,6 +4757,10 @@ class ExternalFloatArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, float value);

+ static Handle<Object> SetValue(Handle<ExternalFloatArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4751,6 +4784,10 @@ class ExternalDoubleArray: public ExternalArray {

MUST_USE_RESULT inline MaybeObject* get(int index);

inline void set(int index, double value);

+ static Handle<Object> SetValue(Handle<ExternalDoubleArray> array,

+ uint32_t index,

+ Handle<Object> value);

// This accessor applies the correct conversion from Smi, HeapNumber

// and undefined.

MUST_USE_RESULT MaybeObject* SetValue(uint32_t index, Object* value);

@@ -4993,12 +5030,7 @@ class Code: public HeapObject {

// Types of stubs.

enum StubType {

NORMAL,

- FIELD,

- CONSTANT,

- CALLBACKS,

- INTERCEPTOR,

- TRANSITION,

- NONEXISTENT

+ FAST

};

typedef int ExtraICState;

@@ -5022,6 +5054,7 @@ class Code: public HeapObject {

// [relocation_info]: Code relocation information

DECL_ACCESSORS(relocation_info, ByteArray)

void InvalidateRelocation();

+ void InvalidateEmbeddedObjects();

// [handler_table]: Fixed array containing offsets of exception handlers.

DECL_ACCESSORS(handler_table, FixedArray)

@@ -5109,6 +5142,7 @@ class Code: public HeapObject {

// [major_key]: For kind STUB or BINARY_OP_IC, the major key.

inline int major_key();

inline void set_major_key(int value);

+ inline bool has_major_key();

// For kind STUB or ICs, tells whether or not a code object was generated by

// the optimizing compiler (but it may not be an optimized function).

@@ -5198,6 +5232,7 @@ class Code: public HeapObject {

// Find the first map in an IC stub.

Map* FindFirstMap();

void FindAllMaps(MapHandleList* maps);

+ void FindAllTypes(TypeHandleList* types);

void ReplaceFirstMap(Map* replace);

// Find the first handler in an IC stub.

@@ -5253,9 +5288,9 @@ class Code: public HeapObject {

static inline Flags ComputeMonomorphicFlags(

Kind kind,

ExtraICState extra_ic_state = kNoExtraICState,

+ InlineCacheHolderFlag holder = OWN_MAP,

StubType type = NORMAL,

- int argc = -1,

- InlineCacheHolderFlag holder = OWN_MAP);

+ int argc = -1);

static inline InlineCacheState ExtractICStateFromFlags(Flags flags);

static inline StubType ExtractTypeFromFlags(Flags flags);

@@ -5423,7 +5458,7 @@ class Code: public HeapObject {

// Flags layout. BitField<type, shift, size>.

class ICStateField: public BitField<InlineCacheState, 0, 3> {};

- class TypeField: public BitField<StubType, 3, 3> {};

+ class TypeField: public BitField<StubType, 3, 1> {};

class CacheHolderField: public BitField<InlineCacheHolderFlag, 6, 1> {};

class KindField: public BitField<Kind, 7, 4> {};

class IsPregeneratedField: public BitField<bool, 11, 1> {};

@@ -5565,7 +5600,13 @@ class DependentCode: public FixedArray {

// Group of code that depends on global property values in property cells

// not being changed.

kPropertyCellChangedGroup,

- kGroupCount = kPropertyCellChangedGroup + 1

+ // Group of code that depends on tenuring information in AllocationSites

+ // not being changed.

+ kAllocationSiteTenuringChangedGroup,

+ // Group of code that depends on element transition information in

+ // AllocationSites not being changed.

+ kAllocationSiteTransitionChangedGroup,

+ kGroupCount = kAllocationSiteTransitionChangedGroup + 1

};

// Array for holding the index of the first code object of each group.

@@ -5659,17 +5700,20 @@ class Map: public HeapObject {

inline uint32_t bit_field3();

inline void set_bit_field3(uint32_t bits);

- class EnumLengthBits: public BitField<int, 0, 11> {};

- class NumberOfOwnDescriptorsBits: public BitField<int, 11, 11> {};

- class IsShared: public BitField<bool, 22, 1> {};

- class FunctionWithPrototype: public BitField<bool, 23, 1> {};

- class DictionaryMap: public BitField<bool, 24, 1> {};

- class OwnsDescriptors: public BitField<bool, 25, 1> {};

- class IsObserved: public BitField<bool, 26, 1> {};

- class Deprecated: public BitField<bool, 27, 1> {};

- class IsFrozen: public BitField<bool, 28, 1> {};

- class IsUnstable: public BitField<bool, 29, 1> {};

- class IsMigrationTarget: public BitField<bool, 30, 1> {};

+ class EnumLengthBits: public BitField<int,

+ 0, kDescriptorIndexBitCount> {}; // NOLINT

+ class NumberOfOwnDescriptorsBits: public BitField<int,

+ kDescriptorIndexBitCount, kDescriptorIndexBitCount> {}; // NOLINT

+ STATIC_ASSERT(kDescriptorIndexBitCount + kDescriptorIndexBitCount == 20);

+ class IsShared: public BitField<bool, 20, 1> {};

+ class FunctionWithPrototype: public BitField<bool, 21, 1> {};

+ class DictionaryMap: public BitField<bool, 22, 1> {};

+ class OwnsDescriptors: public BitField<bool, 23, 1> {};

+ class HasInstanceCallHandler: public BitField<bool, 24, 1> {};

+ class Deprecated: public BitField<bool, 25, 1> {};

+ class IsFrozen: public BitField<bool, 26, 1> {};

+ class IsUnstable: public BitField<bool, 27, 1> {};

+ class IsMigrationTarget: public BitField<bool, 28, 1> {};

// Tells whether the object in the prototype property will be used

// for instances created from this function. If the prototype

@@ -5728,12 +5772,12 @@ class Map: public HeapObject {

}

// Tells whether the instance has a call-as-function handler.

- inline void set_has_instance_call_handler() {

- set_bit_field(bit_field() | (1 << kHasInstanceCallHandler));

+ inline void set_is_observed() {

+ set_bit_field(bit_field() | (1 << kIsObserved));

}

- inline bool has_instance_call_handler() {

- return ((1 << kHasInstanceCallHandler) & bit_field()) != 0;

+ inline bool is_observed() {

+ return ((1 << kIsObserved) & bit_field()) != 0;

}

inline void set_is_extensible(bool value);

@@ -5742,10 +5786,6 @@ class Map: public HeapObject {

inline void set_elements_kind(ElementsKind elements_kind) {

ASSERT(elements_kind < kElementsKindCount);

ASSERT(kElementsKindCount <= (1 << kElementsKindBitCount));

- ASSERT(!is_observed() ||

- elements_kind == DICTIONARY_ELEMENTS ||

- elements_kind == NON_STRICT_ARGUMENTS_ELEMENTS ||

- IsExternalArrayElementsKind(elements_kind));

set_bit_field2((bit_field2() & ~kElementsKindMask) |

(elements_kind << kElementsKindShift));

ASSERT(this->elements_kind() == elements_kind);

@@ -5988,7 +6028,7 @@ class Map: public HeapObject {

}

void SetEnumLength(int length) {

- if (length != kInvalidEnumCache) {

+ if (length != kInvalidEnumCacheSentinel) {

ASSERT(length >= 0);

ASSERT(length == 0 || instance_descriptors()->HasEnumCache());

ASSERT(length <= NumberOfOwnDescriptors());

@@ -5998,8 +6038,8 @@ class Map: public HeapObject {

inline bool owns_descriptors();

inline void set_owns_descriptors(bool is_shared);

- inline bool is_observed();

- inline void set_is_observed(bool is_observed);

+ inline bool has_instance_call_handler();

+ inline void set_has_instance_call_handler();

inline void freeze();

inline bool is_frozen();

inline void mark_unstable();

@@ -6206,9 +6246,6 @@ class Map: public HeapObject {

static const int kMaxPreAllocatedPropertyFields = 255;

- // Constant for denoting that the enum cache is not yet initialized.

- static const int kInvalidEnumCache = EnumLengthBits::kMax;

// Layout description.

static const int kInstanceSizesOffset = HeapObject::kHeaderSize;

static const int kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize;

@@ -6258,7 +6295,7 @@ class Map: public HeapObject {

static const int kHasNamedInterceptor = 3;

static const int kHasIndexedInterceptor = 4;

static const int kIsUndetectable = 5;

- static const int kHasInstanceCallHandler = 6;

+ static const int kIsObserved = 6;

static const int kIsAccessCheckNeeded = 7;

// Bit positions for bit field 2

@@ -6471,7 +6508,6 @@ class Script: public Struct {

V(Math, exp, MathExp) \

V(Math, sqrt, MathSqrt) \

V(Math, pow, MathPow) \

- V(Math, random, MathRandom) \

V(Math, max, MathMax) \

V(Math, min, MathMin) \

V(Math, imul, MathImul)

@@ -8075,6 +8111,9 @@ class AllocationSite: public Struct {

// walked in a particular order. So [[1, 2], 1, 2] will have one

// nested_site, but [[1, 2], 3, [4]] will have a list of two.

DECL_ACCESSORS(nested_site, Object)

+ DECL_ACCESSORS(memento_found_count, Smi)

+ DECL_ACCESSORS(memento_create_count, Smi)

+ DECL_ACCESSORS(pretenure_decision, Smi)

DECL_ACCESSORS(dependent_code, DependentCode)

DECL_ACCESSORS(weak_next, Object)

@@ -8087,13 +8126,31 @@ class AllocationSite: public Struct {

// This method is expensive, it should only be called for reporting.

bool IsNestedSite();

+ class ElementsKindBits: public BitField<ElementsKind, 0, 15> {};

+ class UnusedBits: public BitField<int, 15, 14> {};

+ class DoNotInlineBit: public BitField<bool, 29, 1> {};

ElementsKind GetElementsKind() {

ASSERT(!SitePointsToLiteral());

- return static_cast<ElementsKind>(Smi::cast(transition_info())->value());

+ int value = Smi::cast(transition_info())->value();

+ return ElementsKindBits::decode(value);

}

void SetElementsKind(ElementsKind kind) {

- set_transition_info(Smi::FromInt(static_cast<int>(kind)));

+ int value = Smi::cast(transition_info())->value();

+ set_transition_info(Smi::FromInt(ElementsKindBits::update(value, kind)),

+ SKIP_WRITE_BARRIER);

+ }

+ bool CanInlineCall() {

+ int value = Smi::cast(transition_info())->value();

+ return DoNotInlineBit::decode(value) == 0;

+ }

+ void SetDoNotInlineCall() {

+ int value = Smi::cast(transition_info())->value();

+ set_transition_info(Smi::FromInt(DoNotInlineBit::update(value, true)),

+ SKIP_WRITE_BARRIER);

}

bool SitePointsToLiteral() {

@@ -8103,6 +8160,16 @@ class AllocationSite: public Struct {

return transition_info()->IsJSArray() || transition_info()->IsJSObject();

}

+ MaybeObject* DigestTransitionFeedback(ElementsKind to_kind);

+ enum Reason {

+ TENURING,

+ TRANSITIONS

+ };

+ void AddDependentCompilationInfo(Reason reason, CompilationInfo* info);

+ void AddDependentCode(Reason reason, Handle<Code> code);

DECLARE_PRINTER(AllocationSite)

DECLARE_VERIFIER(AllocationSite)

@@ -8114,15 +8181,28 @@ class AllocationSite: public Struct {

static const int kTransitionInfoOffset = HeapObject::kHeaderSize;

static const int kNestedSiteOffset = kTransitionInfoOffset + kPointerSize;

- static const int kDependentCodeOffset = kNestedSiteOffset + kPointerSize;

+ static const int kMementoFoundCountOffset = kNestedSiteOffset + kPointerSize;

+ static const int kMementoCreateCountOffset =

+ kMementoFoundCountOffset + kPointerSize;

+ static const int kPretenureDecisionOffset =

+ kMementoCreateCountOffset + kPointerSize;

+ static const int kDependentCodeOffset =

+ kPretenureDecisionOffset + kPointerSize;

static const int kWeakNextOffset = kDependentCodeOffset + kPointerSize;

static const int kSize = kWeakNextOffset + kPointerSize;

+ // During mark compact we need to take special care for the dependent code

+ // field.

+ static const int kPointerFieldsBeginOffset = kTransitionInfoOffset;

+ static const int kPointerFieldsEndOffset = kDependentCodeOffset;

+ // For other visitors, use the fixed body descriptor below.

typedef FixedBodyDescriptor<HeapObject::kHeaderSize,

kDependentCodeOffset + kPointerSize,

kSize> BodyDescriptor;

private:

+ inline DependentCode::DependencyGroup ToDependencyGroup(Reason reason);

DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationSite);

};

@@ -9550,6 +9630,9 @@ class JSArrayBuffer: public JSObject {

inline bool is_external();

inline void set_is_external(bool value);

+ inline bool should_be_freed();

+ inline void set_should_be_freed(bool value);

// [weak_next]: linked list of array buffers.

DECL_ACCESSORS(weak_next, Object)

@@ -9579,6 +9662,7 @@ class JSArrayBuffer: public JSObject {

private:

// Bit position in a flag

static const int kIsExternalBit = 0;

+ static const int kShouldBeFreed = 1;

DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);

};

@@ -9716,6 +9800,10 @@ class JSArray: public JSObject {

// is set to a smi. This matches the set function on FixedArray.

inline void set_length(Smi* length);

+ static void JSArrayUpdateLengthFromIndex(Handle<JSArray> array,

+ uint32_t index,

+ Handle<Object> value);

MUST_USE_RESULT MaybeObject* JSArrayUpdateLengthFromIndex(uint32_t index,

Object* value);

@@ -10190,6 +10278,10 @@ class FunctionTemplateInfo: public TemplateInfo {

static const int kLengthOffset = kFlagOffset + kPointerSize;

static const int kSize = kLengthOffset + kPointerSize;

+ // Returns true if |object| is an instance of this function template.

+ bool IsTemplateFor(Object* object);

+ bool IsTemplateFor(Map* map);

private:

// Bit position in the flag, from least significant bit position.

static const int kHiddenPrototypeBit = 0;

« include/v8-platform.h ('K') | « src/mksnapshot.cc ('k') | src/objects.cc » ('j') | no next file with comments »