AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[Turboprop] Support HeapObject immediate deopt args.

Browse Source 
Adds support for emitting data with a reloc info to enable support
for HeapObjects for immediate deopt args, required by dynamic check maps.

In order to do this, a new DATA_EMBEDDED_OBJECT relocinfo type is added.
This represents a raw object inserted into the instruction stream. For
x64/ia32 it is treated the same as FULL_EMBEDDED_OBJECT, but on
Arm/Arm64 this behaves differently since it points directly to the
embedded object pointer rather than to an instruction that loads it.

BUG=v8:10582

Change-Id: I384e88af032b832742447482ae7af5c599097ec1
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2595295
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Reviewed-by: Sathya Gunasekaran  <gsathya@chromium.org>
Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#71926}
This commit is contained in:
Ross McIlroy 2021-01-05 17:57:11 +00:00 committed by Commit Bot
parent 2f72efd67c
commit bbb1b3457b
21 changed files with 146 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/codegen/arm/assembler-arm-inl.h
View File

@ -94,7 +94,11 @@ Address RelocInfo::constant_pool_entry_address() {
int RelocInfo::target_address_size() { return kPointerSize; }
HeapObject RelocInfo::target_object() {
DCHECK(IsCodeTarget(rmode_) || rmode_ == FULL_EMBEDDED_OBJECT);
DCHECK(IsCodeTarget(rmode_) || IsFullEmbeddedObject(rmode_) ||
IsDataEmbeddedObject(rmode_));
if (IsDataEmbeddedObject(rmode_)) {
return HeapObject::cast(Object(ReadUnalignedValue<Address>(pc_)));
}
return HeapObject::cast(
Object(Assembler::target_address_at(pc_, constant_pool_)));
}
@ -104,9 +108,11 @@ HeapObject RelocInfo::target_object_no_host(Isolate* isolate) {
}
Handle<HeapObject> RelocInfo::target_object_handle(Assembler* origin) {
if (IsCodeTarget(rmode_) || rmode_ == FULL_EMBEDDED_OBJECT) {
if (IsCodeTarget(rmode_) || IsFullEmbeddedObject(rmode_)) {
return Handle<HeapObject>(reinterpret_cast<Address*>(
Assembler::target_address_at(pc_, constant_pool_)));
} else if (IsDataEmbeddedObject(rmode_)) {
return Handle<HeapObject>::cast(ReadUnalignedValue<Handle<Object>>(pc_));
}
DCHECK(IsRelativeCodeTarget(rmode_));
return origin->relative_code_target_object_handle_at(pc_);
@ -115,9 +121,15 @@ Handle<HeapObject> RelocInfo::target_object_handle(Assembler* origin) {
void RelocInfo::set_target_object(Heap* heap, HeapObject target,
WriteBarrierMode write_barrier_mode,
ICacheFlushMode icache_flush_mode) {
DCHECK(IsCodeTarget(rmode_) || rmode_ == FULL_EMBEDDED_OBJECT);
Assembler::set_target_address_at(pc_, constant_pool_, target.ptr(),
icache_flush_mode);
DCHECK(IsCodeTarget(rmode_) || IsFullEmbeddedObject(rmode_) ||
IsDataEmbeddedObject(rmode_));
if (IsDataEmbeddedObject(rmode_)) {
WriteUnalignedValue(pc_, target.ptr());
// No need to flush icache since no instructions were changed.
} else {
Assembler::set_target_address_at(pc_, constant_pool_, target.ptr(),
icache_flush_mode);
}
if (write_barrier_mode == UPDATE_WRITE_BARRIER && !host().is_null() &&
!FLAG_disable_write_barriers) {
WriteBarrierForCode(host(), this, target);

12
src/codegen/arm/assembler-arm.cc
View File

@ -5117,20 +5117,28 @@ void Assembler::db(uint8_t data) {
pc_ += sizeof(uint8_t);
}
void Assembler::dd(uint32_t data) {
void Assembler::dd(uint32_t data, RelocInfo::Mode rmode) {
// dd is used to write raw data. The constant pool should be emitted or
// blocked before using dd.
DCHECK(is_const_pool_blocked() || pending_32_bit_constants_.empty());
CheckBuffer();
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
base::WriteUnalignedValue(reinterpret_cast<Address>(pc_), data);
pc_ += sizeof(uint32_t);
}
void Assembler::dq(uint64_t value) {
void Assembler::dq(uint64_t value, RelocInfo::Mode rmode) {
// dq is used to write raw data. The constant pool should be emitted or
// blocked before using dq.
DCHECK(is_const_pool_blocked() || pending_32_bit_constants_.empty());
CheckBuffer();
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
base::WriteUnalignedValue(reinterpret_cast<Address>(pc_), value);
pc_ += sizeof(uint64_t);
}

8
src/codegen/arm/assembler-arm.h
View File

@ -1083,9 +1083,11 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
// called before any use of db/dd/dq/dp to ensure that constant pools
// are not emitted as part of the tables generated.
void db(uint8_t data);
void dd(uint32_t data);
void dq(uint64_t data);
void dp(uintptr_t data) { dd(data); }
void dd(uint32_t data, RelocInfo::Mode rmode = RelocInfo::NONE);
void dq(uint64_t data, RelocInfo::Mode rmode = RelocInfo::NONE);
void dp(uintptr_t data, RelocInfo::Mode rmode = RelocInfo::NONE) {
dd(data, rmode);
}
// Read/patch instructions
Instr instr_at(int pos) {

13
src/codegen/arm64/assembler-arm64-inl.h
View File

@ -659,7 +659,9 @@ Address RelocInfo::constant_pool_entry_address() {
HeapObject RelocInfo::target_object() {
DCHECK(IsCodeTarget(rmode_) || IsEmbeddedObjectMode(rmode_));
if (IsCompressedEmbeddedObject(rmode_)) {
if (IsDataEmbeddedObject(rmode_)) {
return HeapObject::cast(Object(ReadUnalignedValue<Address>(pc_)));
} else if (IsCompressedEmbeddedObject(rmode_)) {
CHECK(!host_.is_null());
return HeapObject::cast(Object(DecompressTaggedAny(
host_.address(),
@ -681,7 +683,9 @@ HeapObject RelocInfo::target_object_no_host(Isolate* isolate) {
}
Handle<HeapObject> RelocInfo::target_object_handle(Assembler* origin) {
if (IsEmbeddedObjectMode(rmode_)) {
if (IsDataEmbeddedObject(rmode_)) {
return Handle<HeapObject>::cast(ReadUnalignedValue<Handle<Object>>(pc_));
} else if (IsEmbeddedObjectMode(rmode_)) {
return origin->target_object_handle_at(pc_);
} else {
DCHECK(IsCodeTarget(rmode_));
@ -693,7 +697,10 @@ void RelocInfo::set_target_object(Heap* heap, HeapObject target,
WriteBarrierMode write_barrier_mode,
ICacheFlushMode icache_flush_mode) {
DCHECK(IsCodeTarget(rmode_) || IsEmbeddedObjectMode(rmode_));
if (IsCompressedEmbeddedObject(rmode_)) {
if (IsDataEmbeddedObject(rmode_)) {
WriteUnalignedValue(pc_, target.ptr());
// No need to flush icache since no instructions were changed.
} else if (IsCompressedEmbeddedObject(rmode_)) {
Assembler::set_target_compressed_address_at(
pc_, constant_pool_, CompressTagged(target.ptr()), icache_flush_mode);
} else {

2
src/codegen/arm64/assembler-arm64.cc
View File

@ -4339,6 +4339,7 @@ void Assembler::GrowBuffer() {
void Assembler::RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data,
ConstantPoolMode constant_pool_mode) {
if ((rmode == RelocInfo::INTERNAL_REFERENCE) ||
(rmode == RelocInfo::DATA_EMBEDDED_OBJECT) ||
(rmode == RelocInfo::CONST_POOL) || (rmode == RelocInfo::VENEER_POOL) ||
(rmode == RelocInfo::DEOPT_SCRIPT_OFFSET) ||
(rmode == RelocInfo::DEOPT_INLINING_ID) ||
@ -4347,6 +4348,7 @@ void Assembler::RecordRelocInfo(RelocInfo::Mode rmode, intptr_t data,
DCHECK(RelocInfo::IsDeoptReason(rmode) || RelocInfo::IsDeoptId(rmode) ||
RelocInfo::IsDeoptPosition(rmode) ||
RelocInfo::IsInternalReference(rmode) ||
RelocInfo::IsDataEmbeddedObject(rmode) ||
RelocInfo::IsConstPool(rmode) || RelocInfo::IsVeneerPool(rmode));
// These modes do not need an entry in the constant pool.
} else if (constant_pool_mode == NEEDS_POOL_ENTRY) {

27
src/codegen/arm64/assembler-arm64.h
View File

@ -2066,10 +2066,31 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
void debug(const char* message, uint32_t code, Instr params = BREAK);
// Required by V8.
void dd(uint32_t data) { dc32(data); }
void db(uint8_t data) { dc8(data); }
void dq(uint64_t data) { dc64(data); }
void dp(uintptr_t data) { dc64(data); }
void dd(uint32_t data, RelocInfo::Mode rmode = RelocInfo::NONE) {
BlockPoolsScope no_pool_scope(this);
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
dc32(data);
}
void dq(uint64_t data, RelocInfo::Mode rmode = RelocInfo::NONE) {
BlockPoolsScope no_pool_scope(this);
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
dc64(data);
}
void dp(uintptr_t data, RelocInfo::Mode rmode = RelocInfo::NONE) {
BlockPoolsScope no_pool_scope(this);
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
dc64(data);
}
// Code generation helpers --------------------------------------------------

9
src/codegen/ia32/assembler-ia32-inl.h
View File

@ -83,7 +83,8 @@ Address RelocInfo::constant_pool_entry_address() { UNREACHABLE(); }
int RelocInfo::target_address_size() { return Assembler::kSpecialTargetSize; }
HeapObject RelocInfo::target_object() {
DCHECK(IsCodeTarget(rmode_) || rmode_ == FULL_EMBEDDED_OBJECT);
DCHECK(IsCodeTarget(rmode_) || IsFullEmbeddedObject(rmode_) ||
IsDataEmbeddedObject(rmode_));
return HeapObject::cast(Object(ReadUnalignedValue<Address>(pc_)));
}
@ -92,14 +93,16 @@ HeapObject RelocInfo::target_object_no_host(Isolate* isolate) {
}
Handle<HeapObject> RelocInfo::target_object_handle(Assembler* origin) {
DCHECK(IsCodeTarget(rmode_) || rmode_ == FULL_EMBEDDED_OBJECT);
DCHECK(IsCodeTarget(rmode_) || IsFullEmbeddedObject(rmode_) ||
IsDataEmbeddedObject(rmode_));
return Handle<HeapObject>::cast(ReadUnalignedValue<Handle<Object>>(pc_));
}
void RelocInfo::set_target_object(Heap* heap, HeapObject target,
WriteBarrierMode write_barrier_mode,
ICacheFlushMode icache_flush_mode) {
DCHECK(IsCodeTarget(rmode_) || rmode_ == FULL_EMBEDDED_OBJECT);
DCHECK(IsCodeTarget(rmode_) || IsFullEmbeddedObject(rmode_) ||
IsDataEmbeddedObject(rmode_));
WriteUnalignedValue(pc_, target.ptr());
if (icache_flush_mode != SKIP_ICACHE_FLUSH) {
FlushInstructionCache(pc_, sizeof(Address));

12
src/codegen/ia32/assembler-ia32.cc
View File

@ -3393,13 +3393,21 @@ void Assembler::db(uint8_t data) {
EMIT(data);
}
void Assembler::dd(uint32_t data) {
void Assembler::dd(uint32_t data, RelocInfo::Mode rmode) {
EnsureSpace ensure_space(this);
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
emit(data);
}
void Assembler::dq(uint64_t data) {
void Assembler::dq(uint64_t data, RelocInfo::Mode rmode) {
EnsureSpace ensure_space(this);
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
emit_q(data);
}

8
src/codegen/ia32/assembler-ia32.h
View File

@ -1756,9 +1756,11 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
// Writes a single byte or word of data in the code stream. Used for
// inline tables, e.g., jump-tables.
void db(uint8_t data);
void dd(uint32_t data);
void dq(uint64_t data);
void dp(uintptr_t data) { dd(data); }
void dd(uint32_t data, RelocInfo::Mode rmode = RelocInfo::NONE);
void dq(uint64_t data, RelocInfo::Mode rmode = RelocInfo::NONE);
void dp(uintptr_t data, RelocInfo::Mode rmode = RelocInfo::NONE) {
dd(data, rmode);
}
void dd(Label* label);
// Check if there is less than kGap bytes available in the buffer.

3
src/codegen/reloc-info.cc
View File

@ -410,6 +410,8 @@ const char* RelocInfo::RelocModeName(RelocInfo::Mode rmode) {
return "compressed embedded object";
case FULL_EMBEDDED_OBJECT:
return "full embedded object";
case DATA_EMBEDDED_OBJECT:
return "data embedded object";
case CODE_TARGET:
return "code target";
case RELATIVE_CODE_TARGET:
@ -496,6 +498,7 @@ void RelocInfo::Verify(Isolate* isolate) {
switch (rmode_) {
case COMPRESSED_EMBEDDED_OBJECT:
case FULL_EMBEDDED_OBJECT:
case DATA_EMBEDDED_OBJECT:
Object::VerifyPointer(isolate, target_object());
break;
case CODE_TARGET:

12
src/codegen/reloc-info.h
View File

@ -59,7 +59,8 @@ class RelocInfo {
CODE_TARGET,
RELATIVE_CODE_TARGET, // LAST_CODE_TARGET_MODE
COMPRESSED_EMBEDDED_OBJECT,
FULL_EMBEDDED_OBJECT, // LAST_GCED_ENUM
FULL_EMBEDDED_OBJECT,
DATA_EMBEDDED_OBJECT, // LAST_GCED_ENUM
WASM_CALL, // FIRST_SHAREABLE_RELOC_MODE
WASM_STUB_CALL,
@ -96,7 +97,7 @@ class RelocInfo {
FIRST_REAL_RELOC_MODE = CODE_TARGET,
LAST_REAL_RELOC_MODE = VENEER_POOL,
FIRST_EMBEDDED_OBJECT_RELOC_MODE = COMPRESSED_EMBEDDED_OBJECT,
LAST_EMBEDDED_OBJECT_RELOC_MODE = FULL_EMBEDDED_OBJECT,
LAST_EMBEDDED_OBJECT_RELOC_MODE = DATA_EMBEDDED_OBJECT,
LAST_GCED_ENUM = LAST_EMBEDDED_OBJECT_RELOC_MODE,
FIRST_SHAREABLE_RELOC_MODE = WASM_CALL,
};
@ -140,6 +141,9 @@ class RelocInfo {
static constexpr bool IsCompressedEmbeddedObject(Mode mode) {
return COMPRESS_POINTERS_BOOL && mode == COMPRESSED_EMBEDDED_OBJECT;
}
static constexpr bool IsDataEmbeddedObject(Mode mode) {
return mode == DATA_EMBEDDED_OBJECT;
}
static constexpr bool IsEmbeddedObjectMode(Mode mode) {
return base::IsInRange(mode, FIRST_EMBEDDED_OBJECT_RELOC_MODE,
LAST_EMBEDDED_OBJECT_RELOC_MODE);
@ -337,7 +341,8 @@ class RelocInfo {
static int EmbeddedObjectModeMask() {
return ModeMask(RelocInfo::FULL_EMBEDDED_OBJECT) |
ModeMask(RelocInfo::COMPRESSED_EMBEDDED_OBJECT);
ModeMask(RelocInfo::COMPRESSED_EMBEDDED_OBJECT) |
ModeMask(RelocInfo::DATA_EMBEDDED_OBJECT);
}
// In addition to modes covered by the apply mask (which is applied at GC
@ -347,6 +352,7 @@ class RelocInfo {
return ModeMask(RelocInfo::CODE_TARGET) |
ModeMask(RelocInfo::COMPRESSED_EMBEDDED_OBJECT) |
ModeMask(RelocInfo::FULL_EMBEDDED_OBJECT) |
ModeMask(RelocInfo::DATA_EMBEDDED_OBJECT) |
ModeMask(RelocInfo::RUNTIME_ENTRY) |
ModeMask(RelocInfo::RELATIVE_CODE_TARGET) | kApplyMask;
}

4
src/codegen/x64/assembler-x64-inl.h
View File

@ -320,6 +320,7 @@ HeapObject RelocInfo::target_object() {
host_.ptr(), ReadUnalignedValue<Tagged_t>(pc_)));
return HeapObject::cast(o);
}
DCHECK(IsFullEmbeddedObject(rmode_) || IsDataEmbeddedObject(rmode_));
return HeapObject::cast(Object(ReadUnalignedValue<Address>(pc_)));
}
@ -331,6 +332,7 @@ HeapObject RelocInfo::target_object_no_host(Isolate* isolate) {
Object obj(DecompressTaggedPointer(isolate, compressed));
return HeapObject::cast(obj);
}
DCHECK(IsFullEmbeddedObject(rmode_) || IsDataEmbeddedObject(rmode_));
return HeapObject::cast(Object(ReadUnalignedValue<Address>(pc_)));
}
@ -342,6 +344,7 @@ Handle<HeapObject> RelocInfo::target_object_handle(Assembler* origin) {
if (IsCompressedEmbeddedObject(rmode_)) {
return origin->compressed_embedded_object_handle_at(pc_);
}
DCHECK(IsFullEmbeddedObject(rmode_) || IsDataEmbeddedObject(rmode_));
return Handle<HeapObject>::cast(ReadUnalignedValue<Handle<Object>>(pc_));
}
}
@ -379,6 +382,7 @@ void RelocInfo::set_target_object(Heap* heap, HeapObject target,
Tagged_t tagged = CompressTagged(target.ptr());
WriteUnalignedValue(pc_, tagged);
} else {
DCHECK(IsFullEmbeddedObject(rmode_) || IsDataEmbeddedObject(rmode_));
WriteUnalignedValue(pc_, target.ptr());
}
if (icache_flush_mode != SKIP_ICACHE_FLUSH) {

12
src/codegen/x64/assembler-x64.cc
View File

@ -4231,13 +4231,21 @@ void Assembler::db(uint8_t data) {
emit(data);
}
void Assembler::dd(uint32_t data) {
void Assembler::dd(uint32_t data, RelocInfo::Mode rmode) {
EnsureSpace ensure_space(this);
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
emitl(data);
}
void Assembler::dq(uint64_t data) {
void Assembler::dq(uint64_t data, RelocInfo::Mode rmode) {
EnsureSpace ensure_space(this);
if (!RelocInfo::IsNone(rmode)) {
DCHECK(RelocInfo::IsDataEmbeddedObject(rmode));
RecordRelocInfo(rmode);
}
emitq(data);
}

8
src/codegen/x64/assembler-x64.h
View File

@ -1844,9 +1844,11 @@ class V8_EXPORT_PRIVATE Assembler : public AssemblerBase {
// Writes a single word of data in the code stream.
// Used for inline tables, e.g., jump-tables.
void db(uint8_t data);
void dd(uint32_t data);
void dq(uint64_t data);
void dp(uintptr_t data) { dq(data); }
void dd(uint32_t data, RelocInfo::Mode rmode = RelocInfo::NONE);
void dq(uint64_t data, RelocInfo::Mode rmode = RelocInfo::NONE);
void dp(uintptr_t data, RelocInfo::Mode rmode = RelocInfo::NONE) {
dq(data, rmode);
}
void dq(Label* label);
// Patch entries for partial constant pool.

24
src/compiler/backend/code-generator.cc
View File

@ -166,32 +166,38 @@ void CodeGenerator::AssembleDeoptImmediateArgs(
for (int i = 0; i < kImmediateArgCount; i++) {
ImmediateOperand* op = immediate_args->at(i);
Constant constant = instructions()->GetImmediate(op);
uintptr_t value;
DCHECK_EQ(tasm()->SizeOfCodeGeneratedSince(deopt_exit),
expected_offsets[i] + Deoptimizer::kNonLazyDeoptExitSize);
USE(expected_offsets);
switch (constant.type()) {
case Constant::kInt32:
value = constant.ToInt32();
tasm()->dp(constant.ToInt32());
break;
#ifdef V8_TARGET_ARCH_64_BIT
case Constant::kInt64:
value = constant.ToInt64();
tasm()->dp(constant.ToInt64());
break;
#endif
case Constant::kFloat64: {
int smi;
CHECK(DoubleToSmiInteger(constant.ToFloat64().value(), &smi));
value = Smi::FromInt(smi).ptr();
tasm()->dp(Smi::FromInt(smi).ptr());
break;
}
case Constant::kCompressedHeapObject:
case Constant::kHeapObject:
// Emit as a DATA_EMBEDDED_OBJECT to specify that this is a raw full
// pointer that is fixed size.
tasm()->dp(constant.ToHeapObject().address(),
RelocInfo::DATA_EMBEDDED_OBJECT);
break;
default:
// Currently only Smis and Ints are supported, but other immediate
// constants can be added when required.
UNREACHABLE();
}
DCHECK_EQ(tasm()->SizeOfCodeGeneratedSince(deopt_exit),
expected_offsets[i] + Deoptimizer::kNonLazyDeoptExitSize);
USE(expected_offsets);
tasm()->dp(value);
}
DCHECK_EQ(tasm()->SizeOfCodeGeneratedSince(deopt_exit),

1
src/heap/heap.cc
View File

@ -4179,6 +4179,7 @@ class SlotVerifyingVisitor : public ObjectVisitor {
CHECK(
InTypedSet(FULL_EMBEDDED_OBJECT_SLOT, rinfo->pc()) ||
InTypedSet(COMPRESSED_EMBEDDED_OBJECT_SLOT, rinfo->pc()) ||
InTypedSet(DATA_EMBEDDED_OBJECT_SLOT, rinfo->pc()) ||
(rinfo->IsInConstantPool() &&
InTypedSet(COMPRESSED_OBJECT_SLOT,
rinfo->constant_pool_entry_address())) ||

4
src/heap/remembered-set-inl.h
View File

@ -32,6 +32,10 @@ SlotCallbackResult UpdateTypedSlotHelper::UpdateTypedSlot(Heap* heap,
RelocInfo rinfo(addr, RelocInfo::FULL_EMBEDDED_OBJECT, 0, Code());
return UpdateEmbeddedPointer(heap, &rinfo, callback);
}
case DATA_EMBEDDED_OBJECT_SLOT: {
RelocInfo rinfo(addr, RelocInfo::DATA_EMBEDDED_OBJECT, 0, Code());
return UpdateEmbeddedPointer(heap, &rinfo, callback);
}
case COMPRESSED_OBJECT_SLOT: {
HeapObject old_target = HeapObject::cast(Object(
DecompressTaggedAny(heap->isolate(), base::Memory<Tagged_t>(addr))));

2
src/heap/remembered-set.h
View File

@ -396,6 +396,8 @@ inline SlotType SlotTypeForRelocInfoMode(RelocInfo::Mode rmode) {
return FULL_EMBEDDED_OBJECT_SLOT;
} else if (RelocInfo::IsCompressedEmbeddedObject(rmode)) {
return COMPRESSED_EMBEDDED_OBJECT_SLOT;
} else if (RelocInfo::IsDataEmbeddedObject(rmode)) {
return DATA_EMBEDDED_OBJECT_SLOT;
}
UNREACHABLE();
}

1
src/heap/slot-set.h
View File

@ -605,6 +605,7 @@ STATIC_ASSERT(std::is_standard_layout<SlotSet::Bucket>::value);
enum SlotType {
FULL_EMBEDDED_OBJECT_SLOT,
COMPRESSED_EMBEDDED_OBJECT_SLOT,
DATA_EMBEDDED_OBJECT_SLOT,
FULL_OBJECT_SLOT,
COMPRESSED_OBJECT_SLOT,
CODE_TARGET_SLOT,

2
src/objects/code.cc
View File

@ -250,6 +250,7 @@ bool Code::IsIsolateIndependent(Isolate* isolate) {
RelocInfo::ModeMask(RelocInfo::RELATIVE_CODE_TARGET) |
RelocInfo::ModeMask(RelocInfo::COMPRESSED_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::FULL_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::DATA_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) |
RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) |
@ -305,6 +306,7 @@ bool Code::IsNativeContextIndependent(Isolate* isolate) {
RelocInfo::ModeMask(RelocInfo::RELATIVE_CODE_TARGET) |
RelocInfo::ModeMask(RelocInfo::COMPRESSED_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::FULL_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::DATA_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::WASM_CALL) |
RelocInfo::ModeMask(RelocInfo::WASM_STUB_CALL)));

1
src/objects/objects-body-descriptors-inl.h
View File

@ -627,6 +627,7 @@ class Code::BodyDescriptor final : public BodyDescriptorBase {
RelocInfo::ModeMask(RelocInfo::RELATIVE_CODE_TARGET) |
RelocInfo::ModeMask(RelocInfo::FULL_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::COMPRESSED_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::DATA_EMBEDDED_OBJECT) |
RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) |
RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) |