blob: 934cc2a19febd4d9cc7de3ee016e0717224b255a [file]
// Copyright 2022 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "src/codegen/maglev-safepoint-table.h"
#include <iomanip>
#include "src/codegen/macro-assembler.h"
#include "src/objects/code-inl.h"
namespace v8 {
namespace internal {
MaglevSafepointTable::MaglevSafepointTable(Isolate* isolate, Address pc,
Tagged<Code> code)
: MaglevSafepointTable(code->InstructionStart(isolate, pc),
code->safepoint_table_address()) {
DCHECK(code->is_maglevved());
}
MaglevSafepointTable::MaglevSafepointTable(Isolate* isolate, Address pc,
Tagged<GcSafeCode> code)
: MaglevSafepointTable(code->InstructionStart(isolate, pc),
code->safepoint_table_address()) {
DCHECK(code->is_maglevved());
}
MaglevSafepointTable::MaglevSafepointTable(Address instruction_start,
Address safepoint_table_address)
: instruction_start_(instruction_start),
safepoint_table_address_(safepoint_table_address),
length_(base::Memory<int>(safepoint_table_address + kLengthOffset)),
entry_configuration_(base::Memory<uint32_t>(safepoint_table_address +
kEntryConfigurationOffset)),
num_tagged_slots_(base::Memory<uint32_t>(safepoint_table_address +
kNumTaggedSlotsOffset)),
num_untagged_slots_(base::Memory<uint32_t>(safepoint_table_address +
kNumUntaggedSlotsOffset)) {}
int MaglevSafepointTable::find_return_pc(int pc_offset) {
for (int i = 0; i < length(); i++) {
MaglevSafepointEntry entry = GetEntry(i);
if (entry.trampoline_pc() == pc_offset || entry.pc() == pc_offset) {
return entry.pc();
}
}
UNREACHABLE();
}
MaglevSafepointEntry MaglevSafepointTable::FindEntry(Address pc) const {
int pc_offset = static_cast<int>(pc - instruction_start_);
// Check if the PC is pointing at a trampoline.
if (has_deopt_data()) {
for (int i = 0; i < length_; ++i) {
MaglevSafepointEntry entry = GetEntry(i);
int trampoline_pc = GetEntry(i).trampoline_pc();
if (trampoline_pc != -1 && trampoline_pc == pc_offset) return entry;
if (trampoline_pc > pc_offset) break;
}
}
// Try to find an exact pc match.
for (int i = 0; i < length_; ++i) {
MaglevSafepointEntry entry = GetEntry(i);
if (entry.pc() == pc_offset) {
return entry;
}
}
// Return a default entry which has no deopt data and no pushed registers.
// This allows us to elide emitting entries for trivial calls.
int deopt_index = MaglevSafepointEntry::kNoDeoptIndex;
int trampoline_pc = MaglevSafepointEntry::kNoTrampolinePC;
uint8_t num_extra_spill_slots = 0;
int tagged_register_indexes = 0;
return MaglevSafepointEntry(pc_offset, deopt_index, num_tagged_slots_,
num_untagged_slots_, num_extra_spill_slots,
tagged_register_indexes, trampoline_pc);
}
// static
MaglevSafepointEntry MaglevSafepointTable::FindEntry(Isolate* isolate,
Tagged<GcSafeCode> code,
Address pc) {
MaglevSafepointTable table(isolate, pc, code);
return table.FindEntry(pc);
}
void MaglevSafepointTable::Print(std::ostream& os) const {
os << "Safepoints (entries = " << length_ << ", byte size = " << byte_size()
<< ", tagged slots = " << num_tagged_slots_
<< ", untagged slots = " << num_untagged_slots_ << ")\n";
for (int index = 0; index < length_; index++) {
MaglevSafepointEntry entry = GetEntry(index);
os << reinterpret_cast<const void*>(instruction_start_ + entry.pc()) << " "
<< std::setw(6) << std::hex << entry.pc() << std::dec;
os << " num extra spill slots: "
<< static_cast<int>(entry.num_extra_spill_slots());
if (entry.tagged_register_indexes() != 0) {
os << " registers: ";
uint32_t register_bits = entry.tagged_register_indexes();
int bits = 32 - base::bits::CountLeadingZeros32(register_bits);
for (int j = bits - 1; j >= 0; --j) {
os << ((register_bits >> j) & 1);
}
}
if (entry.has_deoptimization_index()) {
os << " deopt " << std::setw(6) << entry.deoptimization_index()
<< " trampoline: " << std::setw(6) << std::hex
<< entry.trampoline_pc();
}
os << "\n";
}
}
MaglevSafepointTableBuilder::Safepoint
MaglevSafepointTableBuilder::DefineSafepoint(Assembler* assembler) {
entries_.push_back(EntryBuilder(assembler->pc_offset_for_safepoint()));
return MaglevSafepointTableBuilder::Safepoint(&entries_.back());
}
int MaglevSafepointTableBuilder::UpdateDeoptimizationInfo(int pc,
int trampoline,
int start,
int deopt_index) {
DCHECK_NE(MaglevSafepointEntry::kNoTrampolinePC, trampoline);
DCHECK_NE(MaglevSafepointEntry::kNoDeoptIndex, deopt_index);
auto it = entries_.Find(start);
DCHECK(std::any_of(it, entries_.end(),
[pc](auto& entry) { return entry.pc == pc; }));
int index = start;
while (it->pc != pc) ++it, ++index;
it->trampoline = trampoline;
it->deopt_index = deopt_index;
return index;
}
void MaglevSafepointTableBuilder::Emit(Assembler* assembler) {
#ifdef DEBUG
int last_pc = -1;
int last_trampoline = -1;
for (const EntryBuilder& entry : entries_) {
// Entries are ordered by PC.
DCHECK_LT(last_pc, entry.pc);
last_pc = entry.pc;
// Trampoline PCs are increasing, and larger than regular PCs.
if (entry.trampoline != MaglevSafepointEntry::kNoTrampolinePC) {
DCHECK_LT(last_trampoline, entry.trampoline);
DCHECK_LT(entries_.back().pc, entry.trampoline);
last_trampoline = entry.trampoline;
}
// An entry either has trampoline and deopt index, or none of the two.
DCHECK_EQ(entry.trampoline == MaglevSafepointEntry::kNoTrampolinePC,
entry.deopt_index == MaglevSafepointEntry::kNoDeoptIndex);
}
#endif // DEBUG
#if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
// We cannot emit a const pool within the safepoint table.
Assembler::BlockConstPoolScope block_const_pool(assembler);
#endif
// Make sure the safepoint table is properly aligned. Pad with nops.
assembler->Align(InstructionStream::kMetadataAlignment);
assembler->RecordComment(";;; Maglev safepoint table.");
set_safepoint_table_offset(assembler->pc_offset());
// Compute the required sizes of the fields.
int used_register_indexes = 0;
static_assert(MaglevSafepointEntry::kNoTrampolinePC == -1);
int max_pc = MaglevSafepointEntry::kNoTrampolinePC;
static_assert(MaglevSafepointEntry::kNoDeoptIndex == -1);
int max_deopt_index = MaglevSafepointEntry::kNoDeoptIndex;
for (const EntryBuilder& entry : entries_) {
used_register_indexes |= entry.tagged_register_indexes;
max_pc = std::max(max_pc, std::max(entry.pc, entry.trampoline));
max_deopt_index = std::max(max_deopt_index, entry.deopt_index);
}
// Derive the bytes and bools for the entry configuration from the values.
auto value_to_bytes = [](int value) {
DCHECK_LE(0, value);
if (value == 0) return 0;
if (value <= 0xff) return 1;
if (value <= 0xffff) return 2;
if (value <= 0xffffff) return 3;
return 4;
};
bool has_deopt_data = max_deopt_index != -1;
int register_indexes_size = value_to_bytes(used_register_indexes);
// Add 1 so all values (including kNoDeoptIndex and kNoTrampolinePC) are
// non-negative.
static_assert(MaglevSafepointEntry::kNoDeoptIndex == -1);
static_assert(MaglevSafepointEntry::kNoTrampolinePC == -1);
int pc_size = value_to_bytes(max_pc + 1);
int deopt_index_size = value_to_bytes(max_deopt_index + 1);
// Add a CHECK to ensure we never overflow the space in the bitfield, even for
// huge functions which might not be covered by tests.
CHECK(MaglevSafepointTable::RegisterIndexesSizeField::is_valid(
register_indexes_size));
CHECK(MaglevSafepointTable::PcSizeField::is_valid(pc_size));
CHECK(MaglevSafepointTable::DeoptIndexSizeField::is_valid(deopt_index_size));
uint32_t entry_configuration =
MaglevSafepointTable::HasDeoptDataField::encode(has_deopt_data) |
MaglevSafepointTable::RegisterIndexesSizeField::encode(
register_indexes_size) |
MaglevSafepointTable::PcSizeField::encode(pc_size) |
MaglevSafepointTable::DeoptIndexSizeField::encode(deopt_index_size);
// Emit the table header.
static_assert(MaglevSafepointTable::kLengthOffset == 0 * kIntSize);
static_assert(MaglevSafepointTable::kEntryConfigurationOffset ==
1 * kIntSize);
static_assert(MaglevSafepointTable::kNumTaggedSlotsOffset == 2 * kIntSize);
static_assert(MaglevSafepointTable::kNumUntaggedSlotsOffset == 3 * kIntSize);
static_assert(MaglevSafepointTable::kHeaderSize == 4 * kIntSize);
int length = static_cast<int>(entries_.size());
assembler->dd(length);
assembler->dd(entry_configuration);
assembler->dd(num_tagged_slots_);
assembler->dd(num_untagged_slots_);
auto emit_bytes = [assembler](int value, int bytes) {
DCHECK_LE(0, value);
for (; bytes > 0; --bytes, value >>= 8) assembler->db(value);
DCHECK_EQ(0, value);
};
// Emit entries, sorted by pc offsets.
for (const EntryBuilder& entry : entries_) {
emit_bytes(entry.pc, pc_size);
if (has_deopt_data) {
// Add 1 so all values (including kNoDeoptIndex and kNoTrampolinePC) are
// non-negative.
static_assert(MaglevSafepointEntry::kNoDeoptIndex == -1);
static_assert(MaglevSafepointEntry::kNoTrampolinePC == -1);
emit_bytes(entry.deopt_index + 1, deopt_index_size);
emit_bytes(entry.trampoline + 1, pc_size);
}
assembler->db(entry.num_extra_spill_slots);
emit_bytes(entry.tagged_register_indexes, register_indexes_size);
}
}
} // namespace internal
} // namespace v8