// Copyright 2011 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/safepoint-table.h" #include "src/codegen/assembler-inl.h" #include "src/codegen/macro-assembler.h" #include "src/deoptimizer/deoptimizer.h" #include "src/diagnostics/disasm.h" #include "src/execution/frames-inl.h" #include "src/utils/ostreams.h" #include "src/wasm/wasm-code-manager.h" namespace v8 { namespace internal { SafepointTable::SafepointTable(Code code) : SafepointTable(code.InstructionStart(), code.SafepointTableAddress(), code.stack_slots(), true) {} SafepointTable::SafepointTable(const wasm::WasmCode* code) : SafepointTable(code->instruction_start(), code->instruction_start() + code->safepoint_table_offset(), code->stack_slots(), false) {} SafepointTable::SafepointTable(Address instruction_start, Address safepoint_table_address, uint32_t stack_slots, bool has_deopt) : instruction_start_(instruction_start), stack_slots_(stack_slots), has_deopt_(has_deopt), safepoint_table_address_(safepoint_table_address), length_(ReadLength(safepoint_table_address)), entry_size_(ReadEntrySize(safepoint_table_address)) {} unsigned SafepointTable::find_return_pc(unsigned pc_offset) { for (unsigned i = 0; i < length(); i++) { if (GetTrampolinePcOffset(i) == static_cast<int>(pc_offset)) { return GetPcOffset(i); } else if (GetPcOffset(i) == pc_offset) { return pc_offset; } } UNREACHABLE(); } SafepointEntry SafepointTable::FindEntry(Address pc) const { unsigned pc_offset = static_cast<unsigned>(pc - instruction_start_); // We use kMaxUInt32 as sentinel value, so check that we don't hit that. DCHECK_NE(kMaxUInt32, pc_offset); unsigned len = length(); CHECK_GT(len, 0); // If pc == kMaxUInt32, then this entry covers all call sites in the function. if (len == 1 && GetPcOffset(0) == kMaxUInt32) return GetEntry(0); for (unsigned i = 0; i < len; i++) { // TODO(kasperl): Replace the linear search with binary search. if (GetPcOffset(i) == pc_offset || (has_deopt_ && GetTrampolinePcOffset(i) == static_cast<int>(pc_offset))) { return GetEntry(i); } } UNREACHABLE(); } void SafepointTable::PrintEntry(unsigned index, std::ostream& os) const { // NOLINT disasm::NameConverter converter; SafepointEntry entry = GetEntry(index); uint8_t* bits = entry.bits(); // Print the stack slot bits. if (entry_size_ > 0) { const int first = 0; int last = entry_size_ - 1; for (int i = first; i < last; i++) PrintBits(os, bits[i], kBitsPerByte); int last_bits = stack_slots_ - ((last - first) * kBitsPerByte); PrintBits(os, bits[last], last_bits); } } void SafepointTable::PrintBits(std::ostream& os, // NOLINT uint8_t byte, int digits) { DCHECK(digits >= 0 && digits <= kBitsPerByte); for (int i = 0; i < digits; i++) { os << (((byte & (1 << i)) == 0) ? "0" : "1"); } } Safepoint SafepointTableBuilder::DefineSafepoint( Assembler* assembler, Safepoint::DeoptMode deopt_mode) { deoptimization_info_.push_back( DeoptimizationInfo(zone_, assembler->pc_offset_for_safepoint())); DeoptimizationInfo& new_info = deoptimization_info_.back(); return Safepoint(new_info.indexes); } unsigned SafepointTableBuilder::GetCodeOffset() const { DCHECK(emitted_); return offset_; } int SafepointTableBuilder::UpdateDeoptimizationInfo(int pc, int trampoline, int start, unsigned deopt_index) { int index = start; for (auto it = deoptimization_info_.Find(start); it != deoptimization_info_.end(); it++, index++) { if (static_cast<int>(it->pc) == pc) { it->trampoline = trampoline; it->deopt_index = deopt_index; return index; } } UNREACHABLE(); } void SafepointTableBuilder::Emit(Assembler* assembler, int bits_per_entry) { RemoveDuplicates(); // Make sure the safepoint table is properly aligned. Pad with nops. assembler->Align(kIntSize); assembler->RecordComment(";;; Safepoint table."); offset_ = assembler->pc_offset(); // Compute the number of bytes per safepoint entry. int bytes_per_entry = RoundUp(bits_per_entry, kBitsPerByte) >> kBitsPerByteLog2; // Emit the table header. STATIC_ASSERT(SafepointTable::kLengthOffset == 0 * kIntSize); STATIC_ASSERT(SafepointTable::kEntrySizeOffset == 1 * kIntSize); STATIC_ASSERT(SafepointTable::kHeaderSize == 2 * kIntSize); int length = static_cast<int>(deoptimization_info_.size()); assembler->dd(length); assembler->dd(bytes_per_entry); // Emit sorted table of pc offsets together with additional info (i.e. the // deoptimization index or arguments count) and trampoline offsets. STATIC_ASSERT(SafepointTable::kPcOffset == 0 * kIntSize); STATIC_ASSERT(SafepointTable::kEncodedInfoOffset == 1 * kIntSize); STATIC_ASSERT(SafepointTable::kTrampolinePcOffset == 2 * kIntSize); STATIC_ASSERT(SafepointTable::kFixedEntrySize == 3 * kIntSize); for (const DeoptimizationInfo& info : deoptimization_info_) { assembler->dd(info.pc); assembler->dd(info.deopt_index); assembler->dd(info.trampoline); } // Emit table of bitmaps. ZoneVector<uint8_t> bits(bytes_per_entry, 0, zone_); for (const DeoptimizationInfo& info : deoptimization_info_) { ZoneChunkList<int>* indexes = info.indexes; std::fill(bits.begin(), bits.end(), 0); // Run through the indexes and build a bitmap. for (int idx : *indexes) { int index = bits_per_entry - 1 - idx; int byte_index = index >> kBitsPerByteLog2; int bit_index = index & (kBitsPerByte - 1); bits[byte_index] |= (1U << bit_index); } // Emit the bitmap for the current entry. for (int k = 0; k < bytes_per_entry; k++) { assembler->db(bits[k]); } } emitted_ = true; } void SafepointTableBuilder::RemoveDuplicates() { // If the table contains more than one entry, and all entries are identical // (except for the pc), replace the whole table by a single entry with pc = // kMaxUInt32. This especially compacts the table for wasm code without tagged // pointers and without deoptimization info. if (deoptimization_info_.size() < 2) return; // Check that all entries (1, size] are identical to entry 0. const DeoptimizationInfo& first_info = deoptimization_info_.front(); for (auto it = deoptimization_info_.Find(1); it != deoptimization_info_.end(); it++) { if (!IsIdenticalExceptForPc(first_info, *it)) return; } // If we get here, all entries were identical. Rewind the list to just one // entry, and set the pc to kMaxUInt32. deoptimization_info_.Rewind(1); deoptimization_info_.front().pc = kMaxUInt32; } bool SafepointTableBuilder::IsIdenticalExceptForPc( const DeoptimizationInfo& info1, const DeoptimizationInfo& info2) const { if (info1.deopt_index != info2.deopt_index) return false; ZoneChunkList<int>* indexes1 = info1.indexes; ZoneChunkList<int>* indexes2 = info2.indexes; if (indexes1->size() != indexes2->size()) return false; if (!std::equal(indexes1->begin(), indexes1->end(), indexes2->begin())) { return false; } return true; } } // namespace internal } // namespace v8