JSArrayBuffer::kByteLengthOffset, Representation::Tagged());
}
- static HObjectAccess ForJSArrayBufferFlag() {
+ static HObjectAccess ForJSArrayBufferBitField() {
return HObjectAccess::ForObservableJSObjectOffset(
- JSArrayBuffer::kFlagOffset, Representation::Smi());
+ JSArrayBuffer::kBitFieldOffset, Representation::Integer32());
}
static HObjectAccess ForExternalArrayExternalPointer() {
Add<HLoadNamedField>(checked_object, nullptr,
HObjectAccess::ForJSArrayBufferViewBuffer());
HInstruction* flags = Add<HLoadNamedField>(
- buffer, nullptr, HObjectAccess::ForJSArrayBufferFlag());
+ buffer, nullptr, HObjectAccess::ForJSArrayBufferBitField());
HValue* was_neutered_mask =
- Add<HConstant>(1 << JSArrayBuffer::kWasNeuteredBit);
+ Add<HConstant>(1 << JSArrayBuffer::WasNeutered::kShift);
HValue* was_neutered_test =
AddUncasted<HBitwise>(Token::BIT_AND, flags, was_neutered_mask);
if_has_buffer.Then();
{
HInstruction* flags = Add<HLoadNamedField>(
- buffer, has_buffer, HObjectAccess::ForJSArrayBufferFlag());
+ buffer, has_buffer, HObjectAccess::ForJSArrayBufferBitField());
HValue* was_neutered_mask =
- Add<HConstant>(1 << JSArrayBuffer::kWasNeuteredBit);
+ Add<HConstant>(1 << JSArrayBuffer::WasNeutered::kShift);
HValue* was_neutered_test =
AddUncasted<HBitwise>(Token::BIT_AND, flags, was_neutered_mask);
ACCESSORS(JSArrayBuffer, byte_length, Object, kByteLengthOffset)
-ACCESSORS_TO_SMI(JSArrayBuffer, flag, kFlagOffset)
-bool JSArrayBuffer::is_external() {
- return BooleanBit::get(flag(), kIsExternalBit);
+void JSArrayBuffer::set_bit_field(uint32_t bits) {
+ if (kInt32Size != kPointerSize) {
+ WRITE_UINT32_FIELD(this, kBitFieldOffset + kInt32Size, 0);
+ }
+ WRITE_UINT32_FIELD(this, kBitFieldOffset, bits);
+}
+
+
+uint32_t JSArrayBuffer::bit_field() const {
+ return READ_UINT32_FIELD(this, kBitFieldOffset);
}
+bool JSArrayBuffer::is_external() { return IsExternal::decode(bit_field()); }
+
+
void JSArrayBuffer::set_is_external(bool value) {
- set_flag(BooleanBit::set(flag(), kIsExternalBit, value));
+ set_bit_field(IsExternal::update(bit_field(), value));
}
bool JSArrayBuffer::should_be_freed() {
- return BooleanBit::get(flag(), kShouldBeFreed);
+ return ShouldBeFreed::decode(bit_field());
}
void JSArrayBuffer::set_should_be_freed(bool value) {
- set_flag(BooleanBit::set(flag(), kShouldBeFreed, value));
+ set_bit_field(ShouldBeFreed::update(bit_field(), value));
}
bool JSArrayBuffer::is_neuterable() {
- return BooleanBit::get(flag(), kIsNeuterableBit);
+ return IsNeuterable::decode(bit_field());
}
void JSArrayBuffer::set_is_neuterable(bool value) {
- set_flag(BooleanBit::set(flag(), kIsNeuterableBit, value));
+ set_bit_field(IsNeuterable::update(bit_field(), value));
}
-bool JSArrayBuffer::was_neutered() {
- return BooleanBit::get(flag(), kWasNeuteredBit);
-}
+bool JSArrayBuffer::was_neutered() { return WasNeutered::decode(bit_field()); }
void JSArrayBuffer::set_was_neutered(bool value) {
- set_flag(BooleanBit::set(flag(), kWasNeuteredBit, value));
+ set_bit_field(WasNeutered::update(bit_field(), value));
}
// [byte_length]: length in bytes
DECL_ACCESSORS(byte_length, Object)
- // [flags]
- DECL_ACCESSORS(flag, Smi)
+ inline uint32_t bit_field() const;
+ inline void set_bit_field(uint32_t bits);
inline bool is_external();
inline void set_is_external(bool value);
static const int kBackingStoreOffset = JSObject::kHeaderSize;
static const int kByteLengthOffset = kBackingStoreOffset + kPointerSize;
- static const int kFlagOffset = kByteLengthOffset + kPointerSize;
- static const int kWeakNextOffset = kFlagOffset + kPointerSize;
+ static const int kBitFieldOffset = kByteLengthOffset + kPointerSize;
+ static const int kWeakNextOffset = kBitFieldOffset + kPointerSize;
static const int kSize = kWeakNextOffset + kPointerSize;
static const int kSizeWithInternalFields =
kSize + v8::ArrayBuffer::kInternalFieldCount * kPointerSize;
- // Bit position in a flag
- static const int kIsExternalBit = 0;
- static const int kShouldBeFreed = 1;
- static const int kIsNeuterableBit = 2;
- static const int kWasNeuteredBit = 3;
+ class IsExternal : public BitField<bool, 1, 1> {};
+ class ShouldBeFreed : public BitField<bool, 2, 1> {};
+ class IsNeuterable : public BitField<bool, 3, 1> {};
+ class WasNeutered : public BitField<bool, 4, 1> {};
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBuffer);
array_buffer->SetInternalField(i, Smi::FromInt(0));
}
array_buffer->set_backing_store(data);
- array_buffer->set_flag(Smi::FromInt(0));
+ array_buffer->set_bit_field(0);
array_buffer->set_is_external(is_external);
array_buffer->set_is_neuterable(true);