TYPE_CHECKER(Oddball, ODDBALL_TYPE)
TYPE_CHECKER(Cell, CELL_TYPE)
TYPE_CHECKER(PropertyCell, PROPERTY_CELL_TYPE)
+TYPE_CHECKER(WeakCell, WEAK_CELL_TYPE)
TYPE_CHECKER(SharedFunctionInfo, SHARED_FUNCTION_INFO_TYPE)
TYPE_CHECKER(JSGeneratorObject, JS_GENERATOR_OBJECT_TYPE)
TYPE_CHECKER(JSModule, JS_MODULE_TYPE)
}
+Handle<Object> Object::GetPrototypeSkipHiddenPrototypes(
+ Isolate* isolate, Handle<Object> receiver) {
+ PrototypeIterator iter(isolate, receiver);
+ while (!iter.IsAtEnd(PrototypeIterator::END_AT_NON_HIDDEN)) {
+ if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) {
+ return PrototypeIterator::GetCurrent(iter);
+ }
+ iter.Advance();
+ }
+ return PrototypeIterator::GetCurrent(iter);
+}
+
+
MaybeHandle<Object> Object::GetPropertyOrElement(Handle<Object> object,
Handle<Name> name) {
uint32_t index;
}
+Object* WeakCell::value() const { return READ_FIELD(this, kValueOffset); }
+
+
+void WeakCell::clear() {
+ DCHECK(GetHeap()->gc_state() == Heap::MARK_COMPACT);
+ WRITE_FIELD(this, kValueOffset, Smi::FromInt(0));
+}
+
+
+void WeakCell::initialize(HeapObject* val) {
+ WRITE_FIELD(this, kValueOffset, val);
+ WRITE_BARRIER(GetHeap(), this, kValueOffset, val);
+}
+
+
+bool WeakCell::cleared() const { return value() == Smi::FromInt(0); }
+
+
+Object* WeakCell::next() const { return READ_FIELD(this, kNextOffset); }
+
+
+void WeakCell::set_next(Object* val, WriteBarrierMode mode) {
+ WRITE_FIELD(this, kNextOffset, val);
+ if (mode == UPDATE_WRITE_BARRIER) {
+ WRITE_BARRIER(GetHeap(), this, kNextOffset, val);
+ }
+}
+
+
int JSObject::GetHeaderSize() {
InstanceType type = map()->instance_type();
// Check for the most common kind of JavaScript object before
}
-Object* FixedArray::get(int index) {
+Object* FixedArray::get(int index) const {
SLOW_DCHECK(index >= 0 && index < this->length());
return READ_FIELD(this, kHeaderSize + index * kPointerSize);
}
// Initialize the extended layout fields.
int extended_header_offset = get_extended_section_header_offset();
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedInt64CountOffset,
- extended.count_of(INT64));
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedCodePtrCountOffset,
- extended.count_of(CODE_PTR));
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedHeapPtrCountOffset,
- extended.count_of(HEAP_PTR));
- WRITE_INT_FIELD(this, extended_header_offset + kExtendedInt32CountOffset,
- extended.count_of(INT32));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedInt64CountOffset,
+ extended.count_of(INT64));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedCodePtrCountOffset,
+ extended.count_of(CODE_PTR));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedHeapPtrCountOffset,
+ extended.count_of(HEAP_PTR));
+ WRITE_INT32_FIELD(this, extended_header_offset + kExtendedInt32CountOffset,
+ extended.count_of(INT32));
}
// Perform a binary search in a fixed array. Low and high are entry indices. If
// there are three entries in this array it should be called with low=0 and
// high=2.
-template<SearchMode search_mode, typename T>
-int BinarySearch(T* array, Name* name, int low, int high, int valid_entries) {
+template <SearchMode search_mode, typename T>
+int BinarySearch(T* array, Name* name, int low, int high, int valid_entries,
+ int* out_insertion_index) {
+ DCHECK(search_mode == ALL_ENTRIES || out_insertion_index == NULL);
uint32_t hash = name->Hash();
int limit = high;
for (; low <= limit; ++low) {
int sort_index = array->GetSortedKeyIndex(low);
Name* entry = array->GetKey(sort_index);
- if (entry->Hash() != hash) break;
+ uint32_t current_hash = entry->Hash();
+ if (current_hash != hash) {
+ if (out_insertion_index != NULL) {
+ *out_insertion_index = sort_index + (current_hash > hash ? 0 : 1);
+ }
+ return T::kNotFound;
+ }
if (entry->Equals(name)) {
if (search_mode == ALL_ENTRIES || sort_index < valid_entries) {
return sort_index;
}
}
+ if (out_insertion_index != NULL) *out_insertion_index = limit + 1;
return T::kNotFound;
}
// Perform a linear search in this fixed array. len is the number of entry
// indices that are valid.
-template<SearchMode search_mode, typename T>
-int LinearSearch(T* array, Name* name, int len, int valid_entries) {
+template <SearchMode search_mode, typename T>
+int LinearSearch(T* array, Name* name, int len, int valid_entries,
+ int* out_insertion_index) {
uint32_t hash = name->Hash();
if (search_mode == ALL_ENTRIES) {
for (int number = 0; number < len; number++) {
int sorted_index = array->GetSortedKeyIndex(number);
Name* entry = array->GetKey(sorted_index);
uint32_t current_hash = entry->Hash();
- if (current_hash > hash) break;
+ if (current_hash > hash) {
+ if (out_insertion_index != NULL) *out_insertion_index = sorted_index;
+ return T::kNotFound;
+ }
if (current_hash == hash && entry->Equals(name)) return sorted_index;
}
+ if (out_insertion_index != NULL) *out_insertion_index = len;
+ return T::kNotFound;
} else {
DCHECK(len >= valid_entries);
+ DCHECK_EQ(NULL, out_insertion_index); // Not supported here.
for (int number = 0; number < valid_entries; number++) {
Name* entry = array->GetKey(number);
uint32_t current_hash = entry->Hash();
if (current_hash == hash && entry->Equals(name)) return number;
}
+ return T::kNotFound;
}
- return T::kNotFound;
}
-template<SearchMode search_mode, typename T>
-int Search(T* array, Name* name, int valid_entries) {
+template <SearchMode search_mode, typename T>
+int Search(T* array, Name* name, int valid_entries, int* out_insertion_index) {
if (search_mode == VALID_ENTRIES) {
SLOW_DCHECK(array->IsSortedNoDuplicates(valid_entries));
} else {
}
int nof = array->number_of_entries();
- if (nof == 0) return T::kNotFound;
+ if (nof == 0) {
+ if (out_insertion_index != NULL) *out_insertion_index = 0;
+ return T::kNotFound;
+ }
// Fast case: do linear search for small arrays.
const int kMaxElementsForLinearSearch = 8;
nof <= kMaxElementsForLinearSearch) ||
(search_mode == VALID_ENTRIES &&
valid_entries <= (kMaxElementsForLinearSearch * 3))) {
- return LinearSearch<search_mode>(array, name, nof, valid_entries);
+ return LinearSearch<search_mode>(array, name, nof, valid_entries,
+ out_insertion_index);
}
// Slow case: perform binary search.
- return BinarySearch<search_mode>(array, name, 0, nof - 1, valid_entries);
+ return BinarySearch<search_mode>(array, name, 0, nof - 1, valid_entries,
+ out_insertion_index);
}
int DescriptorArray::Search(Name* name, int valid_descriptors) {
- return internal::Search<VALID_ENTRIES>(this, name, valid_descriptors);
+ return internal::Search<VALID_ENTRIES>(this, name, valid_descriptors, NULL);
}
CAST_ACCESSOR(Struct)
CAST_ACCESSOR(Symbol)
CAST_ACCESSOR(UnseededNumberDictionary)
+CAST_ACCESSOR(WeakCell)
CAST_ACCESSOR(WeakHashTable)
void Name::set_hash_field(uint32_t value) {
WRITE_UINT32_FIELD(this, kHashFieldOffset, value);
#if V8_HOST_ARCH_64_BIT
- WRITE_UINT32_FIELD(this, kHashFieldOffset + kIntSize, 0);
+#if V8_TARGET_LITTLE_ENDIAN
+ WRITE_UINT32_FIELD(this, kHashFieldSlot + kIntSize, 0);
+#else
+ WRITE_UINT32_FIELD(this, kHashFieldSlot, 0);
+#endif
#endif
}
}
-int ConsStringIteratorOp::OffsetForDepth(int depth) {
- return depth & kDepthMask;
-}
+int ConsStringIterator::OffsetForDepth(int depth) { return depth & kDepthMask; }
-void ConsStringIteratorOp::PushLeft(ConsString* string) {
+void ConsStringIterator::PushLeft(ConsString* string) {
frames_[depth_++ & kDepthMask] = string;
}
-void ConsStringIteratorOp::PushRight(ConsString* string) {
+void ConsStringIterator::PushRight(ConsString* string) {
// Inplace update.
frames_[(depth_-1) & kDepthMask] = string;
}
-void ConsStringIteratorOp::AdjustMaximumDepth() {
+void ConsStringIterator::AdjustMaximumDepth() {
if (depth_ > maximum_depth_) maximum_depth_ = depth_;
}
-void ConsStringIteratorOp::Pop() {
+void ConsStringIterator::Pop() {
DCHECK(depth_ > 0);
DCHECK(depth_ <= maximum_depth_);
depth_--;
}
-StringCharacterStream::StringCharacterStream(String* string,
- ConsStringIteratorOp* op,
- int offset)
- : is_one_byte_(false),
- op_(op) {
+StringCharacterStream::StringCharacterStream(String* string, int offset)
+ : is_one_byte_(false) {
Reset(string, offset);
}
buffer8_ = NULL;
end_ = NULL;
ConsString* cons_string = String::VisitFlat(this, string, offset);
- op_->Reset(cons_string, offset);
+ iter_.Reset(cons_string, offset);
if (cons_string != NULL) {
- string = op_->Next(&offset);
+ string = iter_.Next(&offset);
if (string != NULL) String::VisitFlat(this, string, offset);
}
}
bool StringCharacterStream::HasMore() {
if (buffer8_ != end_) return true;
int offset;
- String* string = op_->Next(&offset);
+ String* string = iter_.Next(&offset);
DCHECK_EQ(offset, 0);
if (string == NULL) return false;
String::VisitFlat(this, string);
template<> inline
uint8_t FixedTypedArray<Uint8ClampedArrayTraits>::from_double(double value) {
- if (value < 0) return 0;
+ // Handle NaNs and less than zero values which clamp to zero.
+ if (!(value > 0)) return 0;
if (value > 0xFF) return 0xFF;
return static_cast<uint8_t>(lrint(value));
}
int Code::builtin_index() {
- DCHECK_EQ(BUILTIN, kind());
return READ_INT32_FIELD(this, kKindSpecificFlags1Offset);
}
void Code::set_builtin_index(int index) {
- DCHECK_EQ(BUILTIN, kind());
WRITE_INT32_FIELD(this, kKindSpecificFlags1Offset, index);
}
bool Map::CanHaveMoreTransitions() {
if (!HasTransitionArray()) return true;
- return FixedArray::SizeFor(transitions()->length() +
- TransitionArray::kTransitionSize)
- <= Page::kMaxRegularHeapObjectSize;
+ return transitions()->number_of_transitions() <
+ TransitionArray::kMaxNumberOfTransitions;
}
ACCESSORS_TO_SMI(Script, line_offset, kLineOffsetOffset)
ACCESSORS_TO_SMI(Script, column_offset, kColumnOffsetOffset)
ACCESSORS(Script, context_data, Object, kContextOffset)
-ACCESSORS(Script, wrapper, Foreign, kWrapperOffset)
+ACCESSORS(Script, wrapper, HeapObject, kWrapperOffset)
ACCESSORS_TO_SMI(Script, type, kTypeOffset)
ACCESSORS(Script, line_ends, Object, kLineEndsOffset)
ACCESSORS(Script, eval_from_shared, Object, kEvalFromSharedOffset)
has_duplicate_parameters,
kHasDuplicateParameters)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, asm_function, kIsAsmFunction)
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, deserialized, kDeserialized)
#if V8_HOST_ARCH_32_BIT
#else
-#define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset) \
- STATIC_ASSERT(holder::offset % kPointerSize == 0); \
- int holder::name() const { \
- int value = READ_INT_FIELD(this, offset); \
- DCHECK(kHeapObjectTag == 1); \
- DCHECK((value & kHeapObjectTag) == 0); \
- return value >> 1; \
- } \
- void holder::set_##name(int value) { \
- DCHECK(kHeapObjectTag == 1); \
- DCHECK((value & 0xC0000000) == 0xC0000000 || \
- (value & 0xC0000000) == 0x0); \
- WRITE_INT_FIELD(this, \
- offset, \
- (value << 1) & ~kHeapObjectTag); \
- }
-
-#define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset) \
- STATIC_ASSERT(holder::offset % kPointerSize == kIntSize); \
+#if V8_TARGET_LITTLE_ENDIAN
+#define PSEUDO_SMI_LO_ALIGN 0
+#define PSEUDO_SMI_HI_ALIGN kIntSize
+#else
+#define PSEUDO_SMI_LO_ALIGN kIntSize
+#define PSEUDO_SMI_HI_ALIGN 0
+#endif
+
+#define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset) \
+ STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_LO_ALIGN); \
+ int holder::name() const { \
+ int value = READ_INT_FIELD(this, offset); \
+ DCHECK(kHeapObjectTag == 1); \
+ DCHECK((value & kHeapObjectTag) == 0); \
+ return value >> 1; \
+ } \
+ void holder::set_##name(int value) { \
+ DCHECK(kHeapObjectTag == 1); \
+ DCHECK((value & 0xC0000000) == 0xC0000000 || (value & 0xC0000000) == 0x0); \
+ WRITE_INT_FIELD(this, offset, (value << 1) & ~kHeapObjectTag); \
+ }
+
+#define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset) \
+ STATIC_ASSERT(holder::offset % kPointerSize == PSEUDO_SMI_HI_ALIGN); \
INT_ACCESSORS(holder, name, offset)
}
+bool JSArrayBuffer::is_neuterable() {
+ return BooleanBit::get(flag(), kIsNeuterableBit);
+}
+
+
+void JSArrayBuffer::set_is_neuterable(bool value) {
+ set_flag(BooleanBit::set(flag(), kIsNeuterableBit, value));
+}
+
+
ACCESSORS(JSArrayBuffer, weak_next, Object, kWeakNextOffset)
ACCESSORS(JSArrayBuffer, weak_first_view, Object, kWeakFirstViewOffset)
// The string was flat.
if (cons_string == NULL) return hasher.GetHashField();
// This is a ConsString, iterate across it.
- ConsStringIteratorOp op(cons_string);
+ ConsStringIterator iter(cons_string);
int offset;
- while (NULL != (string = op.Next(&offset))) {
+ while (NULL != (string = iter.Next(&offset))) {
String::VisitFlat(&hasher, string, offset);
}
return hasher.GetHashField();
DCHECK(SlowEquals(canonical));
DCHECK(canonical->IsInternalizedString());
DCHECK(canonical->HasHashCode());
- WRITE_FIELD(this, kHashFieldOffset, canonical);
+ WRITE_FIELD(this, kHashFieldSlot, canonical);
// Setting the hash field to a tagged value sets the LSB, causing the hash
// code to be interpreted as uninitialized. We use this fact to recognize
// that we have a forwarded string.
String* String::GetForwardedInternalizedString() {
DCHECK(IsInternalizedString());
if (HasHashCode()) return this;
- String* canonical = String::cast(READ_FIELD(this, kHashFieldOffset));
+ String* canonical = String::cast(READ_FIELD(this, kHashFieldSlot));
DCHECK(canonical->IsInternalizedString());
DCHECK(SlowEquals(canonical));
DCHECK(canonical->HasHashCode());
}
-Object* JSReceiver::GetConstructor() {
- return map()->constructor();
-}
-
-
Maybe<bool> JSReceiver::HasProperty(Handle<JSReceiver> object,
Handle<Name> name) {
if (object->IsJSProxy()) {
}
-void NameDictionary::DoGenerateNewEnumerationIndices(
+Handle<FixedArray> NameDictionary::DoGenerateNewEnumerationIndices(
Handle<NameDictionary> dictionary) {
- DerivedDictionary::GenerateNewEnumerationIndices(dictionary);
+ return DerivedDictionary::GenerateNewEnumerationIndices(dictionary);
}
}
+int Map::SlackForArraySize(int old_size, int size_limit) {
+ const int max_slack = size_limit - old_size;
+ CHECK(max_slack >= 0);
+ if (old_size < 4) return Min(max_slack, 1);
+ return Min(max_slack, old_size / 2);
+}
+
+
void JSArray::EnsureSize(Handle<JSArray> array, int required_size) {
DCHECK(array->HasFastSmiOrObjectElements());
Handle<FixedArray> elts = handle(FixedArray::cast(array->elements()));
projects / platform / framework / web / crosswalk.git / blobdiff