Update V8 to r7427: Initial merge by git
As required by WebKit r82507
Change-Id: I7ae83ef3f689356043b4929255b7c1dd31d8c5df
diff --git a/src/objects.h b/src/objects.h
index d7b87c6..96e5cb6 100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -57,8 +57,8 @@
// - JSValue
// - JSMessageObject
// - ByteArray
-// - PixelArray
// - ExternalArray
+// - ExternalPixelArray
// - ExternalByteArray
// - ExternalUnsignedByteArray
// - ExternalShortArray
@@ -135,19 +135,37 @@
PropertyDetails(PropertyAttributes attributes,
PropertyType type,
int index = 0) {
+ ASSERT(type != EXTERNAL_ARRAY_TRANSITION);
ASSERT(TypeField::is_valid(type));
ASSERT(AttributesField::is_valid(attributes));
- ASSERT(IndexField::is_valid(index));
+ ASSERT(StorageField::is_valid(index));
value_ = TypeField::encode(type)
| AttributesField::encode(attributes)
- | IndexField::encode(index);
+ | StorageField::encode(index);
ASSERT(type == this->type());
ASSERT(attributes == this->attributes());
ASSERT(index == this->index());
}
+ PropertyDetails(PropertyAttributes attributes,
+ PropertyType type,
+ ExternalArrayType array_type) {
+ ASSERT(type == EXTERNAL_ARRAY_TRANSITION);
+ ASSERT(TypeField::is_valid(type));
+ ASSERT(AttributesField::is_valid(attributes));
+ ASSERT(StorageField::is_valid(static_cast<int>(array_type)));
+
+ value_ = TypeField::encode(type)
+ | AttributesField::encode(attributes)
+ | StorageField::encode(static_cast<int>(array_type));
+
+ ASSERT(type == this->type());
+ ASSERT(attributes == this->attributes());
+ ASSERT(array_type == this->array_type());
+ }
+
// Conversion for storing details as Object*.
inline PropertyDetails(Smi* smi);
inline Smi* AsSmi();
@@ -157,7 +175,8 @@
bool IsTransition() {
PropertyType t = type();
ASSERT(t != INTERCEPTOR);
- return t == MAP_TRANSITION || t == CONSTANT_TRANSITION;
+ return t == MAP_TRANSITION || t == CONSTANT_TRANSITION ||
+ t == EXTERNAL_ARRAY_TRANSITION;
}
bool IsProperty() {
@@ -166,11 +185,18 @@
PropertyAttributes attributes() { return AttributesField::decode(value_); }
- int index() { return IndexField::decode(value_); }
+ int index() { return StorageField::decode(value_); }
+
+ ExternalArrayType array_type() {
+ ASSERT(type() == EXTERNAL_ARRAY_TRANSITION);
+ return static_cast<ExternalArrayType>(StorageField::decode(value_));
+ }
inline PropertyDetails AsDeleted();
- static bool IsValidIndex(int index) { return IndexField::is_valid(index); }
+ static bool IsValidIndex(int index) {
+ return StorageField::is_valid(index);
+ }
bool IsReadOnly() { return (attributes() & READ_ONLY) != 0; }
bool IsDontDelete() { return (attributes() & DONT_DELETE) != 0; }
@@ -179,10 +205,10 @@
// Bit fields in value_ (type, shift, size). Must be public so the
// constants can be embedded in generated code.
- class TypeField: public BitField<PropertyType, 0, 3> {};
- class AttributesField: public BitField<PropertyAttributes, 3, 3> {};
- class DeletedField: public BitField<uint32_t, 6, 1> {};
- class IndexField: public BitField<uint32_t, 7, 32-7> {};
+ class TypeField: public BitField<PropertyType, 0, 4> {};
+ class AttributesField: public BitField<PropertyAttributes, 4, 3> {};
+ class DeletedField: public BitField<uint32_t, 7, 1> {};
+ class StorageField: public BitField<uint32_t, 8, 32-8> {};
static const int kInitialIndex = 1;
private:
@@ -262,7 +288,6 @@
V(HEAP_NUMBER_TYPE) \
V(PROXY_TYPE) \
V(BYTE_ARRAY_TYPE) \
- V(PIXEL_ARRAY_TYPE) \
/* Note: the order of these external array */ \
/* types is relied upon in */ \
/* Object::IsExternalArray(). */ \
@@ -273,6 +298,7 @@
V(EXTERNAL_INT_ARRAY_TYPE) \
V(EXTERNAL_UNSIGNED_INT_ARRAY_TYPE) \
V(EXTERNAL_FLOAT_ARRAY_TYPE) \
+ V(EXTERNAL_PIXEL_ARRAY_TYPE) \
V(FILLER_TYPE) \
\
V(ACCESSOR_INFO_TYPE) \
@@ -490,14 +516,14 @@
HEAP_NUMBER_TYPE,
PROXY_TYPE,
BYTE_ARRAY_TYPE,
- PIXEL_ARRAY_TYPE,
EXTERNAL_BYTE_ARRAY_TYPE, // FIRST_EXTERNAL_ARRAY_TYPE
EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE,
EXTERNAL_SHORT_ARRAY_TYPE,
EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE,
EXTERNAL_INT_ARRAY_TYPE,
EXTERNAL_UNSIGNED_INT_ARRAY_TYPE,
- EXTERNAL_FLOAT_ARRAY_TYPE, // LAST_EXTERNAL_ARRAY_TYPE
+ EXTERNAL_FLOAT_ARRAY_TYPE,
+ EXTERNAL_PIXEL_ARRAY_TYPE, // LAST_EXTERNAL_ARRAY_TYPE
FILLER_TYPE, // LAST_DATA_TYPE
// Structs.
@@ -544,7 +570,7 @@
LAST_STRING_TYPE = FIRST_NONSTRING_TYPE - 1,
// Boundaries for testing for an external array.
FIRST_EXTERNAL_ARRAY_TYPE = EXTERNAL_BYTE_ARRAY_TYPE,
- LAST_EXTERNAL_ARRAY_TYPE = EXTERNAL_FLOAT_ARRAY_TYPE,
+ LAST_EXTERNAL_ARRAY_TYPE = EXTERNAL_PIXEL_ARRAY_TYPE,
// Boundary for promotion to old data space/old pointer space.
LAST_DATA_TYPE = FILLER_TYPE,
// Boundaries for testing the type is a JavaScript "object". Note that
@@ -557,6 +583,8 @@
FIRST_FUNCTION_CLASS_TYPE = JS_REGEXP_TYPE
};
+static const int kExternalArrayTypeCount = LAST_EXTERNAL_ARRAY_TYPE -
+ FIRST_EXTERNAL_ARRAY_TYPE + 1;
STATIC_CHECK(JS_OBJECT_TYPE == Internals::kJSObjectType);
STATIC_CHECK(FIRST_NONSTRING_TYPE == Internals::kFirstNonstringType);
@@ -655,7 +683,6 @@
V(SeqTwoByteString) \
V(SeqAsciiString) \
\
- V(PixelArray) \
V(ExternalArray) \
V(ExternalByteArray) \
V(ExternalUnsignedByteArray) \
@@ -664,6 +691,7 @@
V(ExternalIntArray) \
V(ExternalUnsignedIntArray) \
V(ExternalFloatArray) \
+ V(ExternalPixelArray) \
V(ByteArray) \
V(JSObject) \
V(JSContextExtensionObject) \
@@ -729,6 +757,7 @@
// Oddball testing.
INLINE(bool IsUndefined());
INLINE(bool IsNull());
+ INLINE(bool IsTheHole()); // Shadows MaybeObject's implementation.
INLINE(bool IsTrue());
INLINE(bool IsFalse());
inline bool IsArgumentsMarker();
@@ -885,7 +914,7 @@
enum Type {
RETRY_AFTER_GC = 0,
EXCEPTION = 1, // Returning this marker tells the real exception
- // is in Top::pending_exception.
+ // is in Isolate::pending_exception.
INTERNAL_ERROR = 2,
OUT_OF_MEMORY_EXCEPTION = 3
};
@@ -1073,6 +1102,14 @@
inline MapWord map_word();
inline void set_map_word(MapWord map_word);
+ // The Heap the object was allocated in. Used also to access Isolate.
+ // This method can not be used during GC, it ASSERTs this.
+ inline Heap* GetHeap();
+ // Convenience method to get current isolate. This method can be
+ // accessed only when its result is the same as
+ // Isolate::Current(), it ASSERTs this. See also comment for GetHeap.
+ inline Isolate* GetIsolate();
+
// Converts an address to a HeapObject pointer.
static inline HeapObject* FromAddress(Address address);
@@ -1297,14 +1334,14 @@
FAST_ELEMENTS,
// All the kinds below are "slow".
DICTIONARY_ELEMENTS,
- PIXEL_ELEMENTS,
EXTERNAL_BYTE_ELEMENTS,
EXTERNAL_UNSIGNED_BYTE_ELEMENTS,
EXTERNAL_SHORT_ELEMENTS,
EXTERNAL_UNSIGNED_SHORT_ELEMENTS,
EXTERNAL_INT_ELEMENTS,
EXTERNAL_UNSIGNED_INT_ELEMENTS,
- EXTERNAL_FLOAT_ELEMENTS
+ EXTERNAL_FLOAT_ELEMENTS,
+ EXTERNAL_PIXEL_ELEMENTS
};
// [properties]: Backing storage for properties.
@@ -1329,15 +1366,14 @@
// few objects and so before writing to any element the array must
// be copied. Use EnsureWritableFastElements in this case.
//
- // In the slow mode elements is either a NumberDictionary or a
- // PixelArray or an ExternalArray.
+ // In the slow mode elements is either a NumberDictionary or an ExternalArray.
DECL_ACCESSORS(elements, HeapObject)
inline void initialize_elements();
MUST_USE_RESULT inline MaybeObject* ResetElements();
inline ElementsKind GetElementsKind();
inline bool HasFastElements();
inline bool HasDictionaryElements();
- inline bool HasPixelElements();
+ inline bool HasExternalPixelElements();
inline bool HasExternalArrayElements();
inline bool HasExternalByteElements();
inline bool HasExternalUnsignedByteElements();
@@ -1588,6 +1624,7 @@
inline int GetHeaderSize();
inline int GetInternalFieldCount();
+ inline int GetInternalFieldOffset(int index);
inline Object* GetInternalField(int index);
inline void SetInternalField(int index, Object* value);
@@ -1682,7 +1719,8 @@
// Add a property to an object.
MUST_USE_RESULT MaybeObject* AddProperty(String* name,
Object* value,
- PropertyAttributes attributes);
+ PropertyAttributes attributes,
+ StrictModeFlag strict_mode);
// Convert the object to use the canonical dictionary
// representation. If the object is expected to have additional properties
@@ -1705,6 +1743,7 @@
inline Object* FastPropertyAtPut(int index, Object* value);
// Access to in object properties.
+ inline int GetInObjectPropertyOffset(int index);
inline Object* InObjectPropertyAt(int index);
inline Object* InObjectPropertyAtPut(int index,
Object* value,
@@ -1891,13 +1930,18 @@
// Setters for frequently used oddballs located in old space.
inline void set_undefined(int index);
+ // TODO(isolates): duplicate.
+ inline void set_undefined(Heap* heap, int index);
inline void set_null(int index);
+ // TODO(isolates): duplicate.
+ inline void set_null(Heap* heap, int index);
inline void set_the_hole(int index);
// Setters with less debug checks for the GC to use.
inline void set_unchecked(int index, Smi* value);
- inline void set_null_unchecked(int index);
- inline void set_unchecked(int index, Object* value, WriteBarrierMode mode);
+ inline void set_null_unchecked(Heap* heap, int index);
+ inline void set_unchecked(Heap* heap, int index, Object* value,
+ WriteBarrierMode mode);
// Gives access to raw memory which stores the array's data.
inline Object** data_start();
@@ -1992,7 +2036,9 @@
// Returns the number of descriptors in the array.
int number_of_descriptors() {
- return IsEmpty() ? 0 : length() - kFirstIndex;
+ ASSERT(length() > kFirstIndex || IsEmpty());
+ int len = length();
+ return len <= kFirstIndex ? 0 : len - kFirstIndex;
}
int NextEnumerationIndex() {
@@ -2284,7 +2330,8 @@
(FixedArray::kMaxLength - kElementsStartOffset) / kEntrySize;
// Find entry for key otherwise return kNotFound.
- int FindEntry(Key key);
+ inline int FindEntry(Key key);
+ int FindEntry(Isolate* isolate, Key key);
protected:
@@ -2356,16 +2403,16 @@
class SymbolTableShape {
public:
- static bool IsMatch(HashTableKey* key, Object* value) {
+ static inline bool IsMatch(HashTableKey* key, Object* value) {
return key->IsMatch(value);
}
- static uint32_t Hash(HashTableKey* key) {
+ static inline uint32_t Hash(HashTableKey* key) {
return key->Hash();
}
- static uint32_t HashForObject(HashTableKey* key, Object* object) {
+ static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
return key->HashForObject(object);
}
- MUST_USE_RESULT static MaybeObject* AsObject(HashTableKey* key) {
+ MUST_USE_RESULT static inline MaybeObject* AsObject(HashTableKey* key) {
return key->AsObject();
}
@@ -2408,18 +2455,18 @@
class MapCacheShape {
public:
- static bool IsMatch(HashTableKey* key, Object* value) {
+ static inline bool IsMatch(HashTableKey* key, Object* value) {
return key->IsMatch(value);
}
- static uint32_t Hash(HashTableKey* key) {
+ static inline uint32_t Hash(HashTableKey* key) {
return key->Hash();
}
- static uint32_t HashForObject(HashTableKey* key, Object* object) {
+ static inline uint32_t HashForObject(HashTableKey* key, Object* object) {
return key->HashForObject(object);
}
- MUST_USE_RESULT static MaybeObject* AsObject(HashTableKey* key) {
+ MUST_USE_RESULT static inline MaybeObject* AsObject(HashTableKey* key) {
return key->AsObject();
}
@@ -2775,59 +2822,6 @@
};
-// A PixelArray represents a fixed-size byte array with special semantics
-// used for implementing the CanvasPixelArray object. Please see the
-// specification at:
-// http://www.whatwg.org/specs/web-apps/current-work/
-// multipage/the-canvas-element.html#canvaspixelarray
-// In particular, write access clamps the value written to 0 or 255 if the
-// value written is outside this range.
-class PixelArray: public HeapObject {
- public:
- // [length]: length of the array.
- inline int length();
- inline void set_length(int value);
-
- // [external_pointer]: The pointer to the external memory area backing this
- // pixel array.
- DECL_ACCESSORS(external_pointer, uint8_t) // Pointer to the data store.
-
- // Setter and getter.
- inline uint8_t get(int index);
- inline void set(int index, uint8_t value);
-
- // This accessor applies the correct conversion from Smi, HeapNumber and
- // undefined and clamps the converted value between 0 and 255.
- Object* SetValue(uint32_t index, Object* value);
-
- // Casting.
- static inline PixelArray* cast(Object* obj);
-
-#ifdef OBJECT_PRINT
- inline void PixelArrayPrint() {
- PixelArrayPrint(stdout);
- }
- void PixelArrayPrint(FILE* out);
-#endif
-#ifdef DEBUG
- void PixelArrayVerify();
-#endif // DEBUG
-
- // Maximal acceptable length for a pixel array.
- static const int kMaxLength = 0x3fffffff;
-
- // PixelArray headers are not quadword aligned.
- static const int kLengthOffset = HeapObject::kHeaderSize;
- static const int kExternalPointerOffset =
- POINTER_SIZE_ALIGN(kLengthOffset + kIntSize);
- static const int kHeaderSize = kExternalPointerOffset + kPointerSize;
- static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);
-
- private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(PixelArray);
-};
-
-
// An ExternalArray represents a fixed-size array of primitive values
// which live outside the JavaScript heap. Its subclasses are used to
// implement the CanvasArray types being defined in the WebGL
@@ -2867,6 +2861,44 @@
};
+// A ExternalPixelArray represents a fixed-size byte array with special
+// semantics used for implementing the CanvasPixelArray object. Please see the
+// specification at:
+
+// http://www.whatwg.org/specs/web-apps/current-work/
+// multipage/the-canvas-element.html#canvaspixelarray
+// In particular, write access clamps the value written to 0 or 255 if the
+// value written is outside this range.
+class ExternalPixelArray: public ExternalArray {
+ public:
+ inline uint8_t* external_pixel_pointer();
+
+ // Setter and getter.
+ inline uint8_t get(int index);
+ inline void set(int index, uint8_t value);
+
+ // This accessor applies the correct conversion from Smi, HeapNumber and
+ // undefined and clamps the converted value between 0 and 255.
+ Object* SetValue(uint32_t index, Object* value);
+
+ // Casting.
+ static inline ExternalPixelArray* cast(Object* obj);
+
+#ifdef OBJECT_PRINT
+ inline void ExternalPixelArrayPrint() {
+ ExternalPixelArrayPrint(stdout);
+ }
+ void ExternalPixelArrayPrint(FILE* out);
+#endif
+#ifdef DEBUG
+ void ExternalPixelArrayVerify();
+#endif // DEBUG
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(ExternalPixelArray);
+};
+
+
class ExternalByteArray: public ExternalArray {
public:
// Setter and getter.
@@ -3201,10 +3233,12 @@
BUILTIN,
LOAD_IC,
KEYED_LOAD_IC,
+ KEYED_EXTERNAL_ARRAY_LOAD_IC,
CALL_IC,
KEYED_CALL_IC,
STORE_IC,
KEYED_STORE_IC,
+ KEYED_EXTERNAL_ARRAY_STORE_IC,
BINARY_OP_IC,
TYPE_RECORDING_BINARY_OP_IC,
COMPARE_IC,
@@ -3279,6 +3313,12 @@
return kind() == TYPE_RECORDING_BINARY_OP_IC;
}
inline bool is_compare_ic_stub() { return kind() == COMPARE_IC; }
+ inline bool is_external_array_load_stub() {
+ return kind() == KEYED_EXTERNAL_ARRAY_LOAD_IC;
+ }
+ inline bool is_external_array_store_stub() {
+ return kind() == KEYED_EXTERNAL_ARRAY_STORE_IC;
+ }
// [major_key]: For kind STUB or BINARY_OP_IC, the major key.
inline int major_key();
@@ -3320,6 +3360,12 @@
inline CheckType check_type();
inline void set_check_type(CheckType value);
+ // [external array type]: For kind KEYED_EXTERNAL_ARRAY_LOAD_IC and
+ // KEYED_EXTERNAL_ARRAY_STORE_IC, identifies the type of external
+ // array that the code stub is specialized for.
+ inline ExternalArrayType external_array_type();
+ inline void set_external_array_type(ExternalArrayType value);
+
// [binary op type]: For all BINARY_OP_IC.
inline byte binary_op_type();
inline void set_binary_op_type(byte value);
@@ -3430,7 +3476,7 @@
inline void CodeIterateBody(ObjectVisitor* v);
template<typename StaticVisitor>
- inline void CodeIterateBody();
+ inline void CodeIterateBody(Heap* heap);
#ifdef OBJECT_PRINT
inline void CodePrint() {
CodePrint(stdout);
@@ -3468,6 +3514,7 @@
static const int kOptimizableOffset = kKindSpecificFlagsOffset;
static const int kStackSlotsOffset = kKindSpecificFlagsOffset;
static const int kCheckTypeOffset = kKindSpecificFlagsOffset;
+ static const int kExternalArrayTypeOffset = kKindSpecificFlagsOffset;
static const int kCompareStateOffset = kStubMajorKeyOffset + 1;
static const int kBinaryOpTypeOffset = kStubMajorKeyOffset + 1;
@@ -3484,18 +3531,18 @@
static const int kFlagsICStateShift = 0;
static const int kFlagsICInLoopShift = 3;
static const int kFlagsTypeShift = 4;
- static const int kFlagsKindShift = 7;
- static const int kFlagsICHolderShift = 11;
- static const int kFlagsExtraICStateShift = 12;
- static const int kFlagsArgumentsCountShift = 14;
+ static const int kFlagsKindShift = 8;
+ static const int kFlagsICHolderShift = 12;
+ static const int kFlagsExtraICStateShift = 13;
+ static const int kFlagsArgumentsCountShift = 15;
static const int kFlagsICStateMask = 0x00000007; // 00000000111
static const int kFlagsICInLoopMask = 0x00000008; // 00000001000
- static const int kFlagsTypeMask = 0x00000070; // 00001110000
- static const int kFlagsKindMask = 0x00000780; // 11110000000
- static const int kFlagsCacheInPrototypeMapMask = 0x00000800;
- static const int kFlagsExtraICStateMask = 0x00003000;
- static const int kFlagsArgumentsCountMask = 0xFFFFC000;
+ static const int kFlagsTypeMask = 0x000000F0; // 00001110000
+ static const int kFlagsKindMask = 0x00000F00; // 11110000000
+ static const int kFlagsCacheInPrototypeMapMask = 0x00001000;
+ static const int kFlagsExtraICStateMask = 0x00006000;
+ static const int kFlagsArgumentsCountMask = 0xFFFF8000;
static const int kFlagsNotUsedInLookup =
(kFlagsICInLoopMask | kFlagsTypeMask | kFlagsCacheInPrototypeMapMask);
@@ -3625,16 +3672,16 @@
}
// Tells whether an instance has pixel array elements.
- inline void set_has_pixel_array_elements(bool value) {
+ inline void set_has_external_array_elements(bool value) {
if (value) {
- set_bit_field2(bit_field2() | (1 << kHasPixelArrayElements));
+ set_bit_field2(bit_field2() | (1 << kHasExternalArrayElements));
} else {
- set_bit_field2(bit_field2() & ~(1 << kHasPixelArrayElements));
+ set_bit_field2(bit_field2() & ~(1 << kHasExternalArrayElements));
}
}
- inline bool has_pixel_array_elements() {
- return ((1 << kHasPixelArrayElements) & bit_field2()) != 0;
+ inline bool has_external_array_elements() {
+ return ((1 << kHasExternalArrayElements) & bit_field2()) != 0;
}
// Tells whether the map is attached to SharedFunctionInfo
@@ -3695,10 +3742,11 @@
// from the descriptors and the fast elements bit cleared.
MUST_USE_RESULT inline MaybeObject* GetSlowElementsMap();
- // Returns this map if it has the pixel array elements bit is set, otherwise
- // returns a copy of the map, with all transitions dropped from the
- // descriptors and the pixel array elements bit set.
- MUST_USE_RESULT inline MaybeObject* GetPixelArrayElementsMap();
+ // Returns a new map with all transitions dropped from the descriptors and the
+ // external array elements bit set.
+ MUST_USE_RESULT MaybeObject* GetExternalArrayElementsMap(
+ ExternalArrayType array_type,
+ bool safe_to_add_transition);
// Returns the property index for name (only valid for FAST MODE).
int PropertyIndexFor(String* name);
@@ -3718,7 +3766,7 @@
// Code cache operations.
// Clears the code cache.
- inline void ClearCodeCache();
+ inline void ClearCodeCache(Heap* heap);
// Update code cache.
MUST_USE_RESULT MaybeObject* UpdateCodeCache(String* name, Code* code);
@@ -3742,7 +3790,7 @@
// Also, restore the original prototype on the targets of these
// transitions, so that we do not process this map again while
// following back pointers.
- void ClearNonLiveTransitions(Object* real_prototype);
+ void ClearNonLiveTransitions(Heap* heap, Object* real_prototype);
// Dispatched behavior.
#ifdef OBJECT_PRINT
@@ -3759,6 +3807,10 @@
inline int visitor_id();
inline void set_visitor_id(int visitor_id);
+ // Returns the isolate/heap this map belongs to.
+ inline Isolate* isolate();
+ inline Heap* heap();
+
typedef void (*TraverseCallback)(Map* map, void* data);
void TraverseTransitionTree(TraverseCallback callback, void* data);
@@ -3818,7 +3870,7 @@
static const int kStringWrapperSafeForDefaultValueOf = 3;
static const int kAttachedToSharedFunctionInfo = 4;
static const int kIsShared = 5;
- static const int kHasPixelArrayElements = 6;
+ static const int kHasExternalArrayElements = 6;
// Layout of the default cache. It holds alternating name and code objects.
static const int kCodeCacheEntrySize = 2;
@@ -5156,6 +5208,11 @@
};
+// Calculates string hash.
+template <typename schar>
+inline uint32_t HashSequentialString(const schar* chars, int length);
+
+
// The characteristics of a string are stored in its map. Retrieving these
// few bits of information is moderately expensive, involving two memory
// loads where the second is dependent on the first. To improve efficiency
@@ -5799,11 +5856,8 @@
// iterating or updating after gc.
class Relocatable BASE_EMBEDDED {
public:
- inline Relocatable() : prev_(top_) { top_ = this; }
- virtual ~Relocatable() {
- ASSERT_EQ(top_, this);
- top_ = prev_;
- }
+ explicit inline Relocatable(Isolate* isolate);
+ inline virtual ~Relocatable();
virtual void IterateInstance(ObjectVisitor* v) { }
virtual void PostGarbageCollection() { }
@@ -5815,7 +5869,7 @@
static void Iterate(ObjectVisitor* v, Relocatable* top);
static char* Iterate(ObjectVisitor* v, char* t);
private:
- static Relocatable* top_;
+ Isolate* isolate_;
Relocatable* prev_;
};
@@ -5825,8 +5879,8 @@
// must be valid as long as the reader is being used.
class FlatStringReader : public Relocatable {
public:
- explicit FlatStringReader(Handle<String> str);
- explicit FlatStringReader(Vector<const char> input);
+ FlatStringReader(Isolate* isolate, Handle<String> str);
+ FlatStringReader(Isolate* isolate, Vector<const char> input);
void PostGarbageCollection();
inline uc32 Get(int index);
int length() { return length_; }
@@ -5889,6 +5943,9 @@
// [to_number]: Cached to_number computed at startup.
DECL_ACCESSORS(to_number, Object)
+ inline byte kind();
+ inline void set_kind(byte kind);
+
// Casting.
static inline Oddball* cast(Object* obj);
@@ -5899,12 +5956,23 @@
// Initialize the fields.
MUST_USE_RESULT MaybeObject* Initialize(const char* to_string,
- Object* to_number);
+ Object* to_number,
+ byte kind);
// Layout description.
static const int kToStringOffset = HeapObject::kHeaderSize;
static const int kToNumberOffset = kToStringOffset + kPointerSize;
- static const int kSize = kToNumberOffset + kPointerSize;
+ static const int kKindOffset = kToNumberOffset + kPointerSize;
+ static const int kSize = kKindOffset + kPointerSize;
+
+ static const byte kFalse = 0;
+ static const byte kTrue = 1;
+ static const byte kNotBooleanMask = ~1;
+ static const byte kTheHole = 2;
+ static const byte kNull = 3;
+ static const byte kArgumentMarker = 4;
+ static const byte kUndefined = 5;
+ static const byte kOther = 6;
typedef FixedBodyDescriptor<kToStringOffset,
kToNumberOffset + kPointerSize,
@@ -6537,6 +6605,9 @@
VisitExternalReferences(p, p + 1);
}
+ // Visits a handle that has an embedder-assigned class ID.
+ virtual void VisitEmbedderReference(Object** p, uint16_t class_id) {}
+
#ifdef DEBUG
// Intended for serialization/deserialization checking: insert, or
// check for the presence of, a tag at this position in the stream.