#ifndef V8_CODEGEN_ASSEMBLER_H_

#define V8_CODEGEN_ASSEMBLER_H_

#include <algorithm>

#include <forward_list>

#include <map>

#include <memory>

#include <ostream>

#include <type_traits>

#include <unordered_map>

#include <variant>

#include "src/base/macros.h"

#include "src/base/memory.h"

#include "src/codegen/code-comments.h"

#include "src/codegen/cpu-features.h"

#include "src/codegen/external-reference.h"

#include "src/codegen/label.h"

#include "src/codegen/reglist.h"

#include "src/codegen/reloc-info.h"

#include "src/common/globals.h"

#include "src/deoptimizer/deoptimize-reason.h"

#include "src/flags/flags.h"

#include "src/handles/handles.h"

#include "src/objects/objects.h"

#include "src/sandbox/indirect-pointer-tag.h"

#include "src/utils/ostreams.h"

namespace v8 {

class ApiFunction;

namespace internal {

using base::Memory;

using base::ReadUnalignedValue;

using base::WriteUnalignedValue;

class EmbeddedData;

class OffHeapInstructionStream;

class Isolate;

class SCTableReference;

class SourcePosition;

class StatsCounter;

class Label;

struct JumpOptimizationInfo {

};

class HeapNumberRequest {

};

enum class CodeObjectRequired { kNo, kYes };

enum class BuiltinCallJumpMode {

};

struct V8_EXPORT_PRIVATE AssemblerOptions {

// Recording reloc info for external references and off-heap targets is

// needed whenever code is serialized, e.g. into the snapshot or as a Wasm

// module. This flag allows this reloc info to be disabled for code that

// will not survive process destruction.

bool record_reloc_info_for_serialization = true;

// Enables root-relative access to arbitrary untagged addresses (usually

// external references). Only valid if code will not survive the process.

bool enable_root_relative_access = false;

// Enables specific assembler sequences only used for the simulator.

bool enable_simulator_code = USE_SIMULATOR_BOOL;

// Enables use of isolate-independent constants, indirected through the

// root array.

// (macro assembler feature).

bool isolate_independent_code = false;

// Defines how builtin calls and tail calls should be generated.

BuiltinCallJumpMode builtin_call_jump_mode = BuiltinCallJumpMode::kAbsolute;

// Mksnapshot ensures that the code range is small enough to guarantee that

// PC-relative call/jump instructions can be used for builtin to builtin

// calls/tail calls. The embedded builtins blob generator also ensures that.

// However, there are serializer tests, where we force isolate creation at

// runtime and at this point, Code space isn't restricted to a size s.t.

// PC-relative calls may be used. So, we fall back to an indirect mode.

// TODO(v8:11527): remove once kForMksnapshot is removed.

bool use_pc_relative_calls_and_jumps_for_mksnapshot = false;

// On some platforms, all code is created within a certain address range in

// the process, and the base of this code range is configured here.

Address code_range_base = 0;

// Enables the collection of information useful for the generation of unwind

// info. This is useful in some platform (Win64) where the unwind info depends

// on a function prologue/epilogue.

bool collect_win64_unwind_info = false;

// Whether to emit code comments.

bool emit_code_comments = v8_flags.code_comments;

bool is_wasm = false;

static AssemblerOptions Default(Isolate* isolate);

};

using MaybeAssemblerZone = std::variant<Zone*, AccountingAllocator*>;

class AssemblerBuffer {

};

class SlotDescriptor {

};

V8_EXPORT_PRIVATE

std::unique_ptr<AssemblerBuffer> ExternalAssemblerBuffer(void* buffer,

int size);

V8_EXPORT_PRIVATE

std::unique_ptr<AssemblerBuffer> NewAssemblerBuffer(int size);

class V8_EXPORT_PRIVATE AssemblerBase : public Malloced {

public:

AssemblerBase(const AssemblerOptions& options,

std::unique_ptr<AssemblerBuffer>);

virtual ~AssemblerBase();

const AssemblerOptions& options() const { return options_; }

bool predictable_code_size() const { return predictable_code_size_; }

void set_predictable_code_size(bool value) { predictable_code_size_ = value; }

uint64_t enabled_cpu_features() const { return enabled_cpu_features_; }

void set_enabled_cpu_features(uint64_t features) {

enabled_cpu_features_ = features;

}

// Features are usually enabled by CpuFeatureScope, which also asserts that

// the features are supported before they are enabled.

// IMPORTANT: IsEnabled() should only be used by DCHECKs. For real feature

// detection, use IsSupported().

bool IsEnabled(CpuFeature f) {

return (enabled_cpu_features_ & (static_cast<uint64_t>(1) << f)) != 0;

}

void EnableCpuFeature(CpuFeature f) {

enabled_cpu_features_ |= (static_cast<uint64_t>(1) << f);

}

bool is_constant_pool_available() const {

}

JumpOptimizationInfo* jump_optimization_info() {

return jump_optimization_info_;

}

void set_jump_optimization_info(JumpOptimizationInfo* jump_opt) {

jump_optimization_info_ = jump_opt;

}

void FinalizeJumpOptimizationInfo() {}

// Overwrite a host NaN with a quiet target NaN. Used by mksnapshot for

// cross-snapshotting.

static void QuietNaN(Tagged<HeapObject> nan) {}

int pc_offset() const { return static_cast<int>(pc_ - buffer_start_); }

int pc_offset_for_safepoint() {

}

uint8_t* buffer_start() const { return buffer_->start(); }

int buffer_size() const { return buffer_->size(); }

int instruction_size() const { return pc_offset(); }

std::unique_ptr<AssemblerBuffer> ReleaseBuffer() {

}

// This function is called when code generation is aborted, so that

// the assembler could clean up internal data structures.

virtual void AbortedCodeGeneration() {}

// Debugging

void Print(Isolate* isolate);

// Record an inline code comment that can be used by a disassembler.

// Use --code-comments to enable.

V8_INLINE void RecordComment(

}

V8_INLINE void RecordComment(

}

#ifdef V8_CODE_COMMENTS

class CodeComment {

};

#else // V8_CODE_COMMENTS

class CodeComment {

V8_NODISCARD CodeComment(Assembler*, const std::string&) {}

};

#endif

// The minimum buffer size. Should be at least two times the platform-specific

// {Assembler::kGap}.

static constexpr int kMinimalBufferSize = 128;

// The default buffer size used if we do not know the final size of the

// generated code.

static constexpr int kDefaultBufferSize = 4 * KB;

protected:

// Add 'target' to the {code_targets_} vector, if necessary, and return the

// offset at which it is stored.

int AddCodeTarget(IndirectHandle<Code> target);

IndirectHandle<Code> GetCodeTarget(intptr_t code_target_index) const;

// Add 'object' to the {embedded_objects_} vector and return the index at

// which it is stored.

using EmbeddedObjectIndex = size_t;

EmbeddedObjectIndex AddEmbeddedObject(IndirectHandle<HeapObject> object);

IndirectHandle<HeapObject> GetEmbeddedObject(EmbeddedObjectIndex index) const;

// The buffer into which code and relocation info are generated.

std::unique_ptr<AssemblerBuffer> buffer_;

// Cached from {buffer_->start()}, for faster access.

uint8_t* buffer_start_;

std::forward_list<HeapNumberRequest> heap_number_requests_;

// The program counter, which points into the buffer above and moves forward.

// TODO(jkummerow): This should probably have type {Address}.

uint8_t* pc_;

void set_constant_pool_available(bool available) {

}

// {RequestHeapNumber} records the need for a future heap number allocation,

// code stub generation or string allocation. After code assembly, each

// platform's {Assembler::AllocateAndInstallRequestedHeapNumbers} will

// allocate these objects and place them where they are expected (determined

// by the pc offset associated with each request).

void RequestHeapNumber(HeapNumberRequest request);

bool ShouldRecordRelocInfo(RelocInfo::Mode rmode) const {

}

CodeCommentsWriter code_comments_writer_;

private:

// Before we copy code into the code space, we sometimes cannot encode

// call/jump code targets as we normally would, as the difference between the

// instruction's location in the temporary buffer and the call target is not

// guaranteed to fit in the instruction's offset field. We keep track of the

// code handles we encounter in calls in this vector, and encode the index of

// the code handle in the vector instead.

std::vector<IndirectHandle<Code>> code_targets_;

// If an assembler needs a small number to refer to a heap object handle

// (for example, because there are only 32bit available on a 64bit arch), the

// assembler adds the object into this vector using AddEmbeddedObject, and

// may then refer to the heap object using the handle's index in this vector.

std::vector<IndirectHandle<HeapObject>> embedded_objects_;

// Embedded objects are deduplicated based on handle location. This is a

// compromise that is almost as effective as deduplication based on actual

// heap object addresses maintains GC safety.

std::unordered_map<IndirectHandle<HeapObject>, EmbeddedObjectIndex,

IndirectHandle<HeapObject>::hash,

IndirectHandle<HeapObject>::equal_to>

embedded_objects_map_;

const AssemblerOptions options_;

uint64_t enabled_cpu_features_;

bool predictable_code_size_;

// Indicates whether the constant pool can be accessed, which is only possible

// if the pp register points to the current code object's constant pool.

bool constant_pool_available_;

JumpOptimizationInfo* jump_optimization_info_;

#ifdef V8_CODE_COMMENTS

int comment_depth_ = 0;

#endif

// Constant pool.

friend class FrameAndConstantPoolScope;

friend class ConstantPoolUnavailableScope;

};

class V8_EXPORT_PRIVATE V8_NODISCARD CpuFeatureScope {

public:

enum CheckPolicy {

kCheckSupported,

kDontCheckSupported,

};

#ifdef DEBUG

CpuFeatureScope(AssemblerBase* assembler, CpuFeature f,

CheckPolicy check = kCheckSupported);

~CpuFeatureScope();

private:

AssemblerBase* assembler_;

uint64_t old_enabled_;

#else

CpuFeatureScope(AssemblerBase* assembler, CpuFeature f,

CheckPolicy check = kCheckSupported) {}

~CpuFeatureScope() {

// Define a destructor to avoid unused variable warnings.

}

#endif

};

#ifdef V8_CODE_COMMENTS

#if V8_SUPPORTS_SOURCE_LOCATION

#define ASM_CODE_COMMENT(asm) ASM_CODE_COMMENT_STRING(asm, "")

#else

#define ASM_CODE_COMMENT(asm) ASM_CODE_COMMENT_STRING(asm, __func__)

#endif

#define ASM_CODE_COMMENT_STRING(asm, comment) \

AssemblerBase::CodeComment UNIQUE_IDENTIFIER(asm_code_comment)(asm, comment)

#else

#define ASM_CODE_COMMENT(asm)

#define ASM_CODE_COMMENT_STRING(asm, ...)

#endif

#ifdef V8_ENABLE_DEBUG_CODE

#define NOOP_UNLESS_DEBUG_CODE

#else

#define NOOP_UNLESS_DEBUG_CODE \

{ static_assert(v8_flags.debug_code.value() == false); } \

/* Dummy static_assert to swallow the semicolon after this macro */ \

static_assert(true)

#endif

} // namespace internal

} // namespace v8

#endif // V8_CODEGEN_ASSEMBLER_H_