reloc-info.cc | Explore in Territory

// Copyright 2018 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/reloc-info.h"

#include "src/base/vlq.h"
#include "src/codegen/assembler-inl.h"
#include "src/codegen/code-reference.h"
#include "src/codegen/external-reference-encoder.h"
#include "src/codegen/reloc-info-inl.h"
#include "src/deoptimizer/deoptimize-reason.h"
#include "src/deoptimizer/deoptimizer.h"
#include "src/heap/heap-write-barrier-inl.h"
#include "src/objects/code-inl.h"
#include "src/snapshot/embedded/embedded-data-inl.h"

namespace v8 {
namespace internal {

usingnamespacedetail;

uint32_t RelocInfoWriter::WriteLongPCJump(uint32_t pc_delta) { … }

void RelocInfoWriter::WriteShortTaggedPC(uint32_t pc_delta, int tag) { … }

void RelocInfoWriter::WriteShortData(intptr_t data_delta) { … }

void RelocInfoWriter::WriteMode(RelocInfo::Mode rmode) { … }

void RelocInfoWriter::WriteModeAndPC(uint32_t pc_delta, RelocInfo::Mode rmode) { … }

void RelocInfoWriter::WriteIntData(int number) { … }

void RelocInfoWriter::Write(const RelocInfo* rinfo) { … }

template <typename RelocInfoT>
void RelocIteratorBase<RelocInfoT>::AdvanceReadInt() { … }

template <typename RelocInfoT>
void RelocIteratorBase<RelocInfoT>::AdvanceReadLongPCJump() { … }

template <typename RelocInfoT>
inline void RelocIteratorBase<RelocInfoT>::ReadShortData() { … }

template <typename RelocInfoT>
void RelocIteratorBase<RelocInfoT>::next() { … }

RelocIterator::RelocIterator(Tagged<Code> code, int mode_mask)
    : … { … }

RelocIterator::RelocIterator(Tagged<InstructionStream> istream, int mode_mask)
    : … { … }

RelocIterator::RelocIterator(const CodeReference code_reference)
    : … { … }

RelocIterator::RelocIterator(EmbeddedData* embedded_data, Tagged<Code> code,
                             int mode_mask)
    : … { … }

RelocIterator::RelocIterator(base::Vector<uint8_t> instructions,
                             base::Vector<const uint8_t> reloc_info,
                             Address const_pool, int mode_mask)
    : … { … }

RelocIterator::RelocIterator(Address pc, Address constant_pool,
                             const uint8_t* pos, const uint8_t* end,
                             int mode_mask)
    : … { … }

WritableRelocIterator::WritableRelocIterator(
    WritableJitAllocation& jit_allocation, Tagged<InstructionStream> istream,
    Address constant_pool, int mode_mask)
    : … { … }

WritableRelocIterator::WritableRelocIterator(
    WritableJitAllocation& jit_allocation, base::Vector<uint8_t> instructions,
    base::Vector<const uint8_t> reloc_info, Address constant_pool,
    int mode_mask)
    : … { … }

// -----------------------------------------------------------------------------
// Implementation of RelocInfo

// static
bool RelocInfo::OffHeapTargetIsCodedSpecially() { … }

Address RelocInfo::wasm_call_address() const { … }

void WritableRelocInfo::set_wasm_call_address(Address address) { … }

Address RelocInfo::wasm_stub_call_address() const { … }

void WritableRelocInfo::set_wasm_stub_call_address(Address address) { … }

uint32_t RelocInfo::wasm_canonical_sig_id() const { … }

void WritableRelocInfo::set_wasm_canonical_sig_id(uint32_t canonical_sig_id) { … }

void WritableRelocInfo::set_target_address(Address target,
                                           ICacheFlushMode icache_flush_mode) { … }

void WritableRelocInfo::set_target_address(Tagged<InstructionStream> host,
                                           Address target,
                                           WriteBarrierMode write_barrier_mode,
                                           ICacheFlushMode icache_flush_mode) { … }

void RelocInfo::set_off_heap_target_address(Address target,
                                            ICacheFlushMode icache_flush_mode) { … }

bool RelocInfo::HasTargetAddressAddress() const { … }

#ifdef ENABLE_DISASSEMBLER
const char* RelocInfo::RelocModeName(RelocInfo::Mode rmode) { … }

void RelocInfo::Print(Isolate* isolate, std::ostream& os) { … }
#endif  // ENABLE_DISASSEMBLER

#ifdef VERIFY_HEAP
void RelocInfo::Verify(Isolate* isolate) { … }
#endif  // VERIFY_HEAP

template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
    RelocIteratorBase<RelocInfo>;
template class EXPORT_TEMPLATE_DEFINE(V8_EXPORT_PRIVATE)
    RelocIteratorBase<WritableRelocInfo>;

}  // namespace internal
}  // namespace v8
chromium/v8/src/codegen/reloc-info.cc
