#define V8_OBJECTS_INL_H_
#include "src/base/atomicops.h"
+#include "src/base/bits.h"
#include "src/contexts.h"
#include "src/conversions-inl.h"
#include "src/elements.h"
#include "src/property.h"
#include "src/prototype.h"
#include "src/transitions-inl.h"
+#include "src/type-feedback-vector-inl.h"
#include "src/v8memory.h"
namespace v8 {
}
-bool Object::IsExternalAsciiString() const {
+bool Object::IsExternalOneByteString() const {
if (!IsString()) return false;
return StringShape(String::cast(this)).IsExternal() &&
String::cast(this)->IsOneByteRepresentation();
Internals::kStringEncodingMask);
-bool StringShape::IsSequentialAscii() {
+bool StringShape::IsSequentialOneByte() {
return full_representation_tag() == (kSeqStringTag | kOneByteStringTag);
}
}
-bool StringShape::IsExternalAscii() {
+bool StringShape::IsExternalOneByte() {
return full_representation_tag() == (kExternalStringTag | kOneByteStringTag);
}
STATIC_ASSERT((kExternalStringTag | kOneByteStringTag) ==
- Internals::kExternalAsciiRepresentationTag);
+ Internals::kExternalOneByteRepresentationTag);
-STATIC_ASSERT(v8::String::ASCII_ENCODING == kOneByteStringTag);
+STATIC_ASSERT(v8::String::ONE_BYTE_ENCODING == kOneByteStringTag);
bool StringShape::IsExternalTwoByte() {
uc32 FlatStringReader::Get(int index) {
DCHECK(0 <= index && index <= length_);
- if (is_ascii_) {
+ if (is_one_byte_) {
return static_cast<const byte*>(start_)[index];
} else {
return static_cast<const uc16*>(start_)[index];
explicit SequentialStringKey(Vector<const Char> string, uint32_t seed)
: string_(string), hash_field_(0), seed_(seed) { }
- virtual uint32_t Hash() V8_OVERRIDE {
+ virtual uint32_t Hash() OVERRIDE {
hash_field_ = StringHasher::HashSequentialString<Char>(string_.start(),
string_.length(),
seed_);
}
- virtual uint32_t HashForObject(Object* other) V8_OVERRIDE {
+ virtual uint32_t HashForObject(Object* other) OVERRIDE {
return String::cast(other)->Hash();
}
OneByteStringKey(Vector<const uint8_t> str, uint32_t seed)
: SequentialStringKey<uint8_t>(str, seed) { }
- virtual bool IsMatch(Object* string) V8_OVERRIDE {
+ virtual bool IsMatch(Object* string) OVERRIDE {
return String::cast(string)->IsOneByteEqualTo(string_);
}
- virtual Handle<Object> AsHandle(Isolate* isolate) V8_OVERRIDE;
+ virtual Handle<Object> AsHandle(Isolate* isolate) OVERRIDE;
};
-template<class Char>
-class SubStringKey : public HashTableKey {
+class SeqOneByteSubStringKey : public HashTableKey {
public:
- SubStringKey(Handle<String> string, int from, int length)
+ SeqOneByteSubStringKey(Handle<SeqOneByteString> string, int from, int length)
: string_(string), from_(from), length_(length) {
- if (string_->IsSlicedString()) {
- string_ = Handle<String>(Unslice(*string_, &from_));
- }
- DCHECK(string_->IsSeqString() || string->IsExternalString());
+ DCHECK(string_->IsSeqOneByteString());
}
- virtual uint32_t Hash() V8_OVERRIDE {
+ virtual uint32_t Hash() OVERRIDE {
DCHECK(length_ >= 0);
DCHECK(from_ + length_ <= string_->length());
- const Char* chars = GetChars() + from_;
+ const uint8_t* chars = string_->GetChars() + from_;
hash_field_ = StringHasher::HashSequentialString(
chars, length_, string_->GetHeap()->HashSeed());
uint32_t result = hash_field_ >> String::kHashShift;
return result;
}
- virtual uint32_t HashForObject(Object* other) V8_OVERRIDE {
+ virtual uint32_t HashForObject(Object* other) OVERRIDE {
return String::cast(other)->Hash();
}
- virtual bool IsMatch(Object* string) V8_OVERRIDE;
- virtual Handle<Object> AsHandle(Isolate* isolate) V8_OVERRIDE;
+ virtual bool IsMatch(Object* string) OVERRIDE;
+ virtual Handle<Object> AsHandle(Isolate* isolate) OVERRIDE;
private:
- const Char* GetChars();
- String* Unslice(String* string, int* offset) {
- while (string->IsSlicedString()) {
- SlicedString* sliced = SlicedString::cast(string);
- *offset += sliced->offset();
- string = sliced->parent();
- }
- return string;
- }
-
- Handle<String> string_;
+ Handle<SeqOneByteString> string_;
int from_;
int length_;
uint32_t hash_field_;
explicit TwoByteStringKey(Vector<const uc16> str, uint32_t seed)
: SequentialStringKey<uc16>(str, seed) { }
- virtual bool IsMatch(Object* string) V8_OVERRIDE {
+ virtual bool IsMatch(Object* string) OVERRIDE {
return String::cast(string)->IsTwoByteEqualTo(string_);
}
- virtual Handle<Object> AsHandle(Isolate* isolate) V8_OVERRIDE;
+ virtual Handle<Object> AsHandle(Isolate* isolate) OVERRIDE;
};
explicit Utf8StringKey(Vector<const char> string, uint32_t seed)
: string_(string), hash_field_(0), seed_(seed) { }
- virtual bool IsMatch(Object* string) V8_OVERRIDE {
+ virtual bool IsMatch(Object* string) OVERRIDE {
return String::cast(string)->IsUtf8EqualTo(string_);
}
- virtual uint32_t Hash() V8_OVERRIDE {
+ virtual uint32_t Hash() OVERRIDE {
if (hash_field_ != 0) return hash_field_ >> String::kHashShift;
hash_field_ = StringHasher::ComputeUtf8Hash(string_, seed_, &chars_);
uint32_t result = hash_field_ >> String::kHashShift;
return result;
}
- virtual uint32_t HashForObject(Object* other) V8_OVERRIDE {
+ virtual uint32_t HashForObject(Object* other) OVERRIDE {
return String::cast(other)->Hash();
}
- virtual Handle<Object> AsHandle(Isolate* isolate) V8_OVERRIDE {
+ virtual Handle<Object> AsHandle(Isolate* isolate) OVERRIDE {
if (hash_field_ == 0) Hash();
return isolate->factory()->NewInternalizedStringFromUtf8(
string_, chars_, hash_field_);
}
+bool Object::IsTypeFeedbackVector() const { return IsFixedArray(); }
+
+
bool Object::IsDeoptimizationInputData() const {
// Must be a fixed array.
if (!IsFixedArray()) return false;
// the entry size.
int length = FixedArray::cast(this)->length();
if (length == 0) return true;
- if (length < DeoptimizationInputData::kFirstDeoptEntryIndex) return false;
- FixedArray* self = FixedArray::cast(const_cast<Object*>(this));
- int deopt_count =
- Smi::cast(self->get(DeoptimizationInputData::kDeoptEntryCountIndex))
- ->value();
- int patch_count =
- Smi::cast(
- self->get(
- DeoptimizationInputData::kReturnAddressPatchEntryCountIndex))
- ->value();
-
- return length == DeoptimizationInputData::LengthFor(deopt_count, patch_count);
+ length -= DeoptimizationInputData::kFirstDeoptEntryIndex;
+ return length >= 0 && length % DeoptimizationInputData::kDeoptEntrySize == 0;
}
TYPE_CHECKER(JSTypedArray, JS_TYPED_ARRAY_TYPE)
TYPE_CHECKER(JSDataView, JS_DATA_VIEW_TYPE)
-TYPE_CHECKER(Float32x4, FLOAT32x4_TYPE)
-TYPE_CHECKER(Float64x2, FLOAT64x2_TYPE)
-TYPE_CHECKER(Int32x4, INT32x4_TYPE)
bool Object::IsJSArrayBufferView() const {
return IsJSDataView() || IsJSTypedArray();
write_double_field(p, offset, value)
#endif // V8_TARGET_ARCH_MIPS
-#define READ_FLOAT32x4_FIELD(p, offset) \
- (*reinterpret_cast<float32x4_value_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_FLOAT32x4_FIELD(p, offset, value) \
- (*reinterpret_cast<float32x4_value_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_FLOAT64x2_FIELD(p, offset) \
- (*reinterpret_cast<float64x2_value_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_FLOAT64x2_FIELD(p, offset, value) \
- (*reinterpret_cast<float64x2_value_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_INT32x4_FIELD(p, offset) \
- (*reinterpret_cast<int32x4_value_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_INT32x4_FIELD(p, offset, value) \
- (*reinterpret_cast<int32x4_value_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_FLOAT_FIELD(p, offset) \
- (*reinterpret_cast<float*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_FLOAT_FIELD(p, offset, value) \
- (*reinterpret_cast<float*>(FIELD_ADDR(p, offset)) = value)
#define READ_INT_FIELD(p, offset) \
(*reinterpret_cast<const int*>(FIELD_ADDR_CONST(p, offset)))
}
-bool HeapObject::MayContainNewSpacePointers() {
+bool HeapObject::MayContainRawValues() {
InstanceType type = map()->instance_type();
if (type <= LAST_NAME_TYPE) {
if (type == SYMBOL_TYPE) {
- return true;
+ return false;
}
DCHECK(type < FIRST_NONSTRING_TYPE);
// There are four string representations: sequential strings, external
// strings, cons strings, and sliced strings.
- // Only the latter two contain non-map-word pointers to heap objects.
- return ((type & kIsIndirectStringMask) == kIsIndirectStringTag);
+ // Only the former two contain raw values and no heap pointers (besides the
+ // map-word).
+ return ((type & kIsIndirectStringMask) != kIsIndirectStringTag);
}
- // The ConstantPoolArray contains heap pointers, but not new space pointers.
- if (type == CONSTANT_POOL_ARRAY_TYPE) return false;
- return (type > LAST_DATA_TYPE);
+ // The ConstantPoolArray contains heap pointers, but also raw values.
+ if (type == CONSTANT_POOL_ARRAY_TYPE) return true;
+ return (type <= LAST_DATA_TYPE);
}
}
-ACCESSORS(Float32x4, value, Object, kValueOffset)
-ACCESSORS(Float64x2, value, Object, kValueOffset)
-ACCESSORS(Int32x4, value, Object, kValueOffset)
-
-
-const char* Float32x4::Name() {
- return "float32x4";
-}
-
-
-int Float32x4::kRuntimeAllocatorId() {
- return Runtime::kAllocateFloat32x4;
-}
-
-
-float Float32x4::getAt(int index) {
- DCHECK(index >= 0 && index < kLanes);
- return get().storage[index];
-}
-
-
-float32x4_value_t Float32x4::get() {
- return FixedFloat32x4Array::cast(value())->get_scalar(0);
-}
-
-
-void Float32x4::set(float32x4_value_t f32x4) {
- FixedFloat32x4Array::cast(value())->set(0, f32x4);
-}
-
-
-const char* Float64x2::Name() {
- return "float64x2";
-}
-
-
-int Float64x2::kRuntimeAllocatorId() {
- return Runtime::kAllocateFloat64x2;
-}
-
-
-double Float64x2::getAt(int index) {
- DCHECK(index >= 0 && index < kLanes);
- return get().storage[index];
-}
-
-float64x2_value_t Float64x2::get() {
- return FixedFloat64x2Array::cast(value())->get_scalar(0);
-}
-
-
-void Float64x2::set(float64x2_value_t f64x2) {
- FixedFloat64x2Array::cast(value())->set(0, f64x2);
-}
-
-
-const char* Int32x4::Name() {
- return "int32x4";
-}
-
-
-int Int32x4::kRuntimeAllocatorId() {
- return Runtime::kAllocateInt32x4;
-}
-
-
-int32_t Int32x4::getAt(int index) {
- DCHECK(index >= 0 && index < kLanes);
- return get().storage[index];;
-}
-
-
-int32x4_value_t Int32x4::get() {
- return FixedInt32x4Array::cast(value())->get_scalar(0);
-}
-
-
-void Int32x4::set(int32x4_value_t i32x4) {
- FixedInt32x4Array::cast(value())->set(0, i32x4);
-}
-
-
ACCESSORS(JSObject, properties, FixedArray, kPropertiesOffset)
return JSTypedArray::kSize;
case JS_DATA_VIEW_TYPE:
return JSDataView::kSize;
- case FLOAT32x4_TYPE:
- return Float32x4::kSize;
- case FLOAT64x2_TYPE:
- return Float64x2::kSize;
- case INT32x4_TYPE:
- return Int32x4::kSize;
case JS_SET_TYPE:
return JSSet::kSize;
case JS_MAP_TYPE:
inline bool FixedDoubleArray::is_the_hole_nan(double value) {
- return BitCast<uint64_t, double>(value) == kHoleNanInt64;
+ return bit_cast<uint64_t, double>(value) == kHoleNanInt64;
}
inline double FixedDoubleArray::hole_nan_as_double() {
- return BitCast<double, uint64_t>(kHoleNanInt64);
+ return bit_cast<double, uint64_t>(kHoleNanInt64);
}
inline double FixedDoubleArray::canonical_not_the_hole_nan_as_double() {
- DCHECK(BitCast<uint64_t>(base::OS::nan_value()) != kHoleNanInt64);
- DCHECK((BitCast<uint64_t>(base::OS::nan_value()) >> 32) != kHoleNanUpper32);
+ DCHECK(bit_cast<uint64_t>(base::OS::nan_value()) != kHoleNanInt64);
+ DCHECK((bit_cast<uint64_t>(base::OS::nan_value()) >> 32) != kHoleNanUpper32);
return base::OS::nan_value();
}
}
-void DescriptorArray::Append(Descriptor* desc,
- const WhitenessWitness& witness) {
- DisallowHeapAllocation no_gc;
- int descriptor_number = number_of_descriptors();
- SetNumberOfDescriptors(descriptor_number + 1);
- Set(descriptor_number, desc, witness);
-
- uint32_t hash = desc->GetKey()->Hash();
-
- int insertion;
-
- for (insertion = descriptor_number; insertion > 0; --insertion) {
- Name* key = GetSortedKey(insertion - 1);
- if (key->Hash() <= hash) break;
- SetSortedKey(insertion, GetSortedKeyIndex(insertion - 1));
- }
-
- SetSortedKey(insertion, descriptor_number);
-}
-
-
void DescriptorArray::Append(Descriptor* desc) {
DisallowHeapAllocation no_gc;
int descriptor_number = number_of_descriptors();
template<typename Derived, typename Shape, typename Key>
int HashTable<Derived, Shape, Key>::ComputeCapacity(int at_least_space_for) {
const int kMinCapacity = 32;
- int capacity = RoundUpToPowerOf2(at_least_space_for * 2);
+ int capacity = base::bits::RoundUpToPowerOfTwo32(at_least_space_for * 2);
if (capacity < kMinCapacity) {
capacity = kMinCapacity; // Guarantee min capacity.
}
CAST_ACCESSOR(DependentCode)
CAST_ACCESSOR(DescriptorArray)
CAST_ACCESSOR(ExternalArray)
-CAST_ACCESSOR(ExternalAsciiString)
+CAST_ACCESSOR(ExternalOneByteString)
CAST_ACCESSOR(ExternalFloat32Array)
-CAST_ACCESSOR(ExternalFloat32x4Array)
CAST_ACCESSOR(ExternalFloat64Array)
-CAST_ACCESSOR(ExternalFloat64x2Array)
CAST_ACCESSOR(ExternalInt16Array)
CAST_ACCESSOR(ExternalInt32Array)
-CAST_ACCESSOR(ExternalInt32x4Array)
CAST_ACCESSOR(ExternalInt8Array)
CAST_ACCESSOR(ExternalString)
CAST_ACCESSOR(ExternalTwoByteString)
CAST_ACCESSOR(FreeSpace)
CAST_ACCESSOR(GlobalObject)
CAST_ACCESSOR(HeapObject)
-CAST_ACCESSOR(Float32x4)
-CAST_ACCESSOR(Float64x2)
-CAST_ACCESSOR(Int32x4)
CAST_ACCESSOR(JSArray)
CAST_ACCESSOR(JSArrayBuffer)
CAST_ACCESSOR(JSArrayBufferView)
ACCESSORS(Symbol, name, Object, kNameOffset)
ACCESSORS(Symbol, flags, Smi, kFlagsOffset)
BOOL_ACCESSORS(Symbol, flags, is_private, kPrivateBit)
+BOOL_ACCESSORS(Symbol, flags, is_own, kOwnBit)
bool String::Equals(String* other) {
case kConsStringTag | kTwoByteStringTag:
return ConsString::cast(this)->ConsStringGet(index);
case kExternalStringTag | kOneByteStringTag:
- return ExternalAsciiString::cast(this)->ExternalAsciiStringGet(index);
+ return ExternalOneByteString::cast(this)->ExternalOneByteStringGet(index);
case kExternalStringTag | kTwoByteStringTag:
return ExternalTwoByteString::cast(this)->ExternalTwoByteStringGet(index);
case kSlicedStringTag | kOneByteStringTag:
case kExternalStringTag | kOneByteStringTag:
visitor->VisitOneByteString(
- ExternalAsciiString::cast(string)->GetChars() + slice_offset,
+ ExternalOneByteString::cast(string)->GetChars() + slice_offset,
length - offset);
return NULL;
}
-const ExternalAsciiString::Resource* ExternalAsciiString::resource() {
+const ExternalOneByteString::Resource* ExternalOneByteString::resource() {
return *reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset));
}
-void ExternalAsciiString::update_data_cache() {
+void ExternalOneByteString::update_data_cache() {
if (is_short()) return;
const char** data_field =
reinterpret_cast<const char**>(FIELD_ADDR(this, kResourceDataOffset));
}
-void ExternalAsciiString::set_resource(
- const ExternalAsciiString::Resource* resource) {
+void ExternalOneByteString::set_resource(
+ const ExternalOneByteString::Resource* resource) {
DCHECK(IsAligned(reinterpret_cast<intptr_t>(resource), kPointerSize));
*reinterpret_cast<const Resource**>(
FIELD_ADDR(this, kResourceOffset)) = resource;
}
-const uint8_t* ExternalAsciiString::GetChars() {
+const uint8_t* ExternalOneByteString::GetChars() {
return reinterpret_cast<const uint8_t*>(resource()->data());
}
-uint16_t ExternalAsciiString::ExternalAsciiStringGet(int index) {
+uint16_t ExternalOneByteString::ExternalOneByteStringGet(int index) {
DCHECK(index >= 0 && index < length());
return GetChars()[index];
}
}
-float32x4_value_t ExternalFloat32x4Array::get_scalar(int index) {
- DCHECK((index >= 0) && (index < this->length()));
- float* ptr = static_cast<float*>(external_pointer());
- float32x4_value_t value;
- value.storage[0] = ptr[index * 4 + 0];
- value.storage[1] = ptr[index * 4 + 1];
- value.storage[2] = ptr[index * 4 + 2];
- value.storage[3] = ptr[index * 4 + 3];
- return value;
-}
-
-
-Handle<Object> ExternalFloat32x4Array::get(Handle<ExternalFloat32x4Array> array,
- int index) {
- float32x4_value_t value = array->get_scalar(index);
- return array->GetIsolate()->factory()->NewFloat32x4(value);
-}
-
-
-void ExternalFloat32x4Array::set(int index, const float32x4_value_t& value) {
- DCHECK((index >= 0) && (index < this->length()));
- float* ptr = static_cast<float*>(external_pointer());
- ptr[index * 4 + 0] = value.storage[0];
- ptr[index * 4 + 1] = value.storage[1];
- ptr[index * 4 + 2] = value.storage[2];
- ptr[index * 4 + 3] = value.storage[3];
-}
-
-
-float64x2_value_t ExternalFloat64x2Array::get_scalar(int index) {
- DCHECK((index >= 0) && (index < this->length()));
- double* ptr = static_cast<double*>(external_pointer());
- float64x2_value_t value;
- value.storage[0] = ptr[index * 2 + 0];
- value.storage[1] = ptr[index * 2 + 1];
- return value;
-}
-
-
-Handle<Object> ExternalFloat64x2Array::get(Handle<ExternalFloat64x2Array> array,
- int index) {
- float64x2_value_t value = array->get_scalar(index);
- return array->GetIsolate()->factory()->NewFloat64x2(value);
-}
-
-
-void ExternalFloat64x2Array::set(int index, const float64x2_value_t& value) {
- DCHECK((index >= 0) && (index < this->length()));
- double* ptr = static_cast<double*>(external_pointer());
- ptr[index * 2 + 0] = value.storage[0];
- ptr[index * 2 + 1] = value.storage[1];
-}
-
-
-int32x4_value_t ExternalInt32x4Array::get_scalar(int index) {
- DCHECK((index >= 0) && (index < this->length()));
- int32_t* ptr = static_cast<int32_t*>(external_pointer());
- int32x4_value_t value;
- value.storage[0] = ptr[index * 4 + 0];
- value.storage[1] = ptr[index * 4 + 1];
- value.storage[2] = ptr[index * 4 + 2];
- value.storage[3] = ptr[index * 4 + 3];
- return value;
-}
-
-
-Handle<Object> ExternalInt32x4Array::get(Handle<ExternalInt32x4Array> array,
- int index) {
- int32x4_value_t value = array->get_scalar(index);
- return array->GetIsolate()->factory()->NewInt32x4(value);
-}
-
-
-void ExternalInt32x4Array::set(int index, const int32x4_value_t& value) {
- DCHECK((index >= 0) && (index < this->length()));
- int32_t* ptr = static_cast<int32_t*>(external_pointer());
- ptr[index * 4 + 0] = value.storage[0];
- ptr[index * 4 + 1] = value.storage[1];
- ptr[index * 4 + 2] = value.storage[2];
- ptr[index * 4 + 3] = value.storage[3];
-}
-
-
double ExternalFloat64Array::get_scalar(int index) {
DCHECK((index >= 0) && (index < this->length()));
double* ptr = static_cast<double*>(external_pointer());
return Traits::ToHandle(array->GetIsolate(), cast_value);
}
-template<> inline
-Handle<Object> FixedTypedArray<Float32x4ArrayTraits>::SetValue(
- Handle<FixedTypedArray<Float32x4ArrayTraits> > array,
- uint32_t index, Handle<Object> value) {
- float32x4_value_t cast_value;
- cast_value.storage[0] = static_cast<float>(base::OS::nan_value());
- cast_value.storage[1] = static_cast<float>(base::OS::nan_value());
- cast_value.storage[2] = static_cast<float>(base::OS::nan_value());
- cast_value.storage[3] = static_cast<float>(base::OS::nan_value());
- if (index < static_cast<uint32_t>(array->length())) {
- if (value->IsFloat32x4()) {
- cast_value = Handle<Float32x4>::cast(value)->get();
- } else {
- // Clamp undefined to NaN (default). All other types have been
- // converted to a number type further up in the call chain.
- DCHECK(value->IsUndefined());
- }
- array->set(index, cast_value);
- }
- return Float32x4ArrayTraits::ToHandle(array->GetIsolate(), cast_value);
-}
-
-
-template<> inline
-Handle<Object> FixedTypedArray<Float64x2ArrayTraits>::SetValue(
- Handle<FixedTypedArray<Float64x2ArrayTraits> > array,
- uint32_t index, Handle<Object> value) {
- float64x2_value_t cast_value;
- cast_value.storage[0] = base::OS::nan_value();
- cast_value.storage[1] = base::OS::nan_value();
- if (index < static_cast<uint32_t>(array->length())) {
- if (value->IsFloat64x2()) {
- cast_value = Handle<Float64x2>::cast(value)->get();
- } else {
- // Clamp undefined to NaN (default). All other types have been
- // converted to a number type further up in the call chain.
- DCHECK(value->IsUndefined());
- }
- array->set(index, cast_value);
- }
- return Float64x2ArrayTraits::ToHandle(array->GetIsolate(), cast_value);
-}
-
-
-template<> inline
-Handle<Object> FixedTypedArray<Int32x4ArrayTraits>::SetValue(
- Handle<FixedTypedArray<Int32x4ArrayTraits> > array,
- uint32_t index, Handle<Object> value) {
- int32x4_value_t cast_value;
- cast_value.storage[0] = 0;
- cast_value.storage[1] = 0;
- cast_value.storage[2] = 0;
- cast_value.storage[3] = 0;
- if (index < static_cast<uint32_t>(array->length())) {
- if (value->IsInt32x4()) {
- cast_value = Handle<Int32x4>::cast(value)->get();
- } else {
- // Clamp undefined to zero (default). All other types have been
- // converted to a number type further up in the call chain.
- DCHECK(value->IsUndefined());
- }
- array->set(index, cast_value);
- }
- return Int32x4ArrayTraits::ToHandle(array->GetIsolate(), cast_value);
-}
-
Handle<Object> Uint8ArrayTraits::ToHandle(Isolate* isolate, uint8_t scalar) {
return handle(Smi::FromInt(scalar), isolate);
}
-Handle<Object> Int32x4ArrayTraits::ToHandle(
- Isolate* isolate, int32x4_value_t scalar) {
- return isolate->factory()->NewInt32x4(scalar);
-}
-
-
-Handle<Object> Float32x4ArrayTraits::ToHandle(
- Isolate* isolate, float32x4_value_t scalar) {
- return isolate->factory()->NewFloat32x4(scalar);
-}
-
-
-Handle<Object> Float64x2ArrayTraits::ToHandle(
- Isolate* isolate, float64x2_value_t scalar) {
- return isolate->factory()->NewFloat64x2(scalar);
-}
-
-
Handle<Object> Float64ArrayTraits::ToHandle(Isolate* isolate, double scalar) {
return isolate->factory()->NewNumber(scalar);
}
if (instance_type == FIXED_ARRAY_TYPE) {
return FixedArray::BodyDescriptor::SizeOf(map, this);
}
- if (instance_type == ASCII_STRING_TYPE ||
- instance_type == ASCII_INTERNALIZED_STRING_TYPE) {
+ if (instance_type == ONE_BYTE_STRING_TYPE ||
+ instance_type == ONE_BYTE_INTERNALIZED_STRING_TYPE) {
return SeqOneByteString::SizeFor(
reinterpret_cast<SeqOneByteString*>(this)->length());
}
void Code::set_profiler_ticks(int ticks) {
- DCHECK_EQ(FUNCTION, kind());
DCHECK(ticks < 256);
- WRITE_BYTE_FIELD(this, kProfilerTicksOffset, ticks);
+ if (kind() == FUNCTION) {
+ WRITE_BYTE_FIELD(this, kProfilerTicksOffset, ticks);
+ }
}
ACCESSORS(SharedFunctionInfo, optimized_code_map, Object,
kOptimizedCodeMapOffset)
ACCESSORS(SharedFunctionInfo, construct_stub, Code, kConstructStubOffset)
-ACCESSORS(SharedFunctionInfo, feedback_vector, FixedArray,
+ACCESSORS(SharedFunctionInfo, feedback_vector, TypeFeedbackVector,
kFeedbackVectorOffset)
ACCESSORS(SharedFunctionInfo, instance_class_name, Object,
kInstanceClassNameOffset)
compiler_hints,
has_duplicate_parameters,
kHasDuplicateParameters)
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, asm_function, kIsAsmFunction)
#if V8_HOST_ARCH_32_BIT
}
+FunctionKind SharedFunctionInfo::kind() {
+ return FunctionKindBits::decode(compiler_hints());
+}
+
+
+void SharedFunctionInfo::set_kind(FunctionKind kind) {
+ DCHECK(IsValidFunctionKind(kind));
+ int hints = compiler_hints();
+ hints = FunctionKindBits::update(hints, kind);
+ set_compiler_hints(hints);
+}
+
+
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, native, kNative)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, inline_builtin,
kInlineBuiltin)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_function, kIsFunction)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, dont_cache, kDontCache)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, dont_flush, kDontFlush)
-BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_generator, kIsGenerator)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_arrow, kIsArrow)
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_generator, kIsGenerator)
+BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, is_concise_method,
+ kIsConciseMethod)
ACCESSORS(CodeCache, default_cache, FixedArray, kDefaultCacheOffset)
ACCESSORS(CodeCache, normal_type_cache, Object, kNormalTypeCacheOffset)
String* src_str = String::cast(src);
if (!StringShape(src_str).IsExternal()) return true;
if (src_str->IsOneByteRepresentation()) {
- return ExternalAsciiString::cast(src)->resource() != NULL;
+ return ExternalOneByteString::cast(src)->resource() != NULL;
} else if (src_str->IsTwoByteRepresentation()) {
return ExternalTwoByteString::cast(src)->resource() != NULL;
}
bool SharedFunctionInfo::is_compiled() {
- return code() !=
- GetIsolate()->builtins()->builtin(Builtins::kCompileUnoptimized);
+ return code() != GetIsolate()->builtins()->builtin(Builtins::kCompileLazy);
}
bool JSFunction::is_compiled() {
- return code() !=
- GetIsolate()->builtins()->builtin(Builtins::kCompileUnoptimized);
+ return code() != GetIsolate()->builtins()->builtin(Builtins::kCompileLazy);
}
}
ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(table, Object, kTableOffset)
-ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(index, Smi, kIndexOffset)
-ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(kind, Smi, kKindOffset)
+ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(index, Object, kIndexOffset)
+ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(kind, Object, kKindOffset)
#undef ORDERED_HASH_TABLE_ITERATOR_ACCESSORS
return String::cast(this)->ComputeAndSetHash();
}
+bool Name::IsOwn() {
+ return this->IsSymbol() && Symbol::cast(this)->is_own();
+}
+
StringHasher::StringHasher(int length, uint32_t seed)
: length_(length),
}
-Handle<Object> TypeFeedbackInfo::UninitializedSentinel(Isolate* isolate) {
- return isolate->factory()->uninitialized_symbol();
-}
-
-
-Handle<Object> TypeFeedbackInfo::MegamorphicSentinel(Isolate* isolate) {
- return isolate->factory()->megamorphic_symbol();
-}
-
-
-Handle<Object> TypeFeedbackInfo::MonomorphicArraySentinel(Isolate* isolate,
- ElementsKind elements_kind) {
- return Handle<Object>(Smi::FromInt(static_cast<int>(elements_kind)), isolate);
-}
-
-
-Object* TypeFeedbackInfo::RawUninitializedSentinel(Heap* heap) {
- return heap->uninitialized_symbol();
-}
-
-
int TypeFeedbackInfo::ic_total_count() {
int current = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
return ICTotalCountField::decode(current);
}
-void ExternalAsciiString::ExternalAsciiStringIterateBody(ObjectVisitor* v) {
- typedef v8::String::ExternalAsciiStringResource Resource;
- v->VisitExternalAsciiString(
+void ExternalOneByteString::ExternalOneByteStringIterateBody(ObjectVisitor* v) {
+ typedef v8::String::ExternalOneByteStringResource Resource;
+ v->VisitExternalOneByteString(
reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
}
-template<typename StaticVisitor>
-void ExternalAsciiString::ExternalAsciiStringIterateBody() {
- typedef v8::String::ExternalAsciiStringResource Resource;
- StaticVisitor::VisitExternalAsciiString(
+template <typename StaticVisitor>
+void ExternalOneByteString::ExternalOneByteStringIterateBody() {
+ typedef v8::String::ExternalOneByteStringResource Resource;
+ StaticVisitor::VisitExternalOneByteString(
reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
}
projects / platform / framework / web / crosswalk.git / blobdiff