#ifndef V8_COMPILER_CODE_ASSEMBLER_H_

#define V8_COMPILER_CODE_ASSEMBLER_H_

#include <initializer_list>

#include <map>

#include <memory>

#include <optional>

#include <sstream>

#include <type_traits>

#include "include/cppgc/source-location.h"

#include "src/base/macros.h"

#include "src/builtins/builtins.h"

#include "src/codegen/atomic-memory-order.h"

#include "src/codegen/callable.h"

#include "src/codegen/handler-table.h"

#include "src/codegen/machine-type.h"

#include "src/codegen/source-position.h"

#include "src/codegen/tnode.h"

#include "src/heap/heap.h"

#include "src/objects/object-type.h"

#include "src/objects/objects.h"

#include "src/runtime/runtime.h"

#include "src/zone/zone-containers.h"

#if V8_ENABLE_WEBASSEMBLY

#include "src/wasm/wasm-builtin-list.h"

#endif

namespace v8 {

namespace internal {

class AsmWasmData;

class AsyncGeneratorRequest;

struct AssemblerOptions;

class BigInt;

class CallInterfaceDescriptor;

class Callable;

class Factory;

class InterpreterData;

class Isolate;

class JSAsyncFunctionObject;

class JSAsyncGeneratorObject;

class JSCollator;

class JSCollection;

class JSDateTimeFormat;

class JSDisplayNames;

class JSDurationFormat;

class JSListFormat;

class JSLocale;

class JSNumberFormat;

class JSPluralRules;

class JSRegExpStringIterator;

class JSRelativeTimeFormat;

class JSSegmentIterator;

class JSSegmenter;

class JSSegments;

class JSV8BreakIterator;

class JSWeakCollection;

class JSFinalizationRegistry;

class JSWeakMap;

class JSWeakRef;

class JSWeakSet;

class OSROptimizedCodeCache;

class ProfileDataFromFile;

class PromiseCapability;

class PromiseFulfillReactionJobTask;

class PromiseReaction;

class PromiseReactionJobTask;

class PromiseRejectReactionJobTask;

class TurbofanCompilationJob;

class Zone;

#define MAKE_FORWARD_DECLARATION(Name) class Name;

TORQUE_DEFINED_CLASS_LIST(MAKE_FORWARD_DECLARATION)

#undef MAKE_FORWARD_DECLARATION

template <typename T>

class Signature;

enum class CheckBounds { kAlways, kDebugOnly };

inline bool NeedsBoundsCheck(CheckBounds check_bounds) {

}

enum class StoreToObjectWriteBarrier { kNone, kMap, kFull };

template <class T>

struct ObjectTypeOf {};

#define OBJECT_TYPE_CASE(Name) \

template <> \

struct ObjectTypeOf<Name> { \

static constexpr ObjectType value = ObjectType::k##Name; \

};

#define OBJECT_TYPE_STRUCT_CASE(NAME, Name, name) \

template <> \

struct ObjectTypeOf<Name> { \

static constexpr ObjectType value = ObjectType::k##Name; \

};

#define OBJECT_TYPE_TEMPLATE_CASE(Name) \

template <class... Args> \

struct ObjectTypeOf<Name<Args...>> { \

static constexpr ObjectType value = ObjectType::k##Name; \

};

#define OBJECT_TYPE_ODDBALL_CASE(Name) \

template <> \

struct ObjectTypeOf<Name> { \

static constexpr ObjectType value = ObjectType::kOddball; \

};

OBJECT_TYPE_CASE(Object)

OBJECT_TYPE_CASE(Smi)

OBJECT_TYPE_CASE(TaggedIndex)

OBJECT_TYPE_CASE(HeapObject)

OBJECT_TYPE_CASE(HeapObjectReference)

OBJECT_TYPE_LIST(OBJECT_TYPE_CASE)

HEAP_OBJECT_ORDINARY_TYPE_LIST(OBJECT_TYPE_CASE)

VIRTUAL_OBJECT_TYPE_LIST(OBJECT_TYPE_CASE)

HEAP_OBJECT_TRUSTED_TYPE_LIST(OBJECT_TYPE_CASE)

STRUCT_LIST(OBJECT_TYPE_STRUCT_CASE)

HEAP_OBJECT_TEMPLATE_TYPE_LIST(OBJECT_TYPE_TEMPLATE_CASE)

OBJECT_TYPE_ODDBALL_CASE(Null)

OBJECT_TYPE_ODDBALL_CASE(Undefined)

OBJECT_TYPE_ODDBALL_CASE(True)

OBJECT_TYPE_ODDBALL_CASE(False)

#undef OBJECT_TYPE_CASE

#undef OBJECT_TYPE_STRUCT_CASE

#undef OBJECT_TYPE_TEMPLATE_CASE

template <class... T>

struct ObjectTypeOf<Union<T...>> {

// For simplicity, don't implement TaggedIndex or HeapObjectReference.

static_assert(!base::has_type_v<TaggedIndex, T...>);

static_assert(!base::has_type_v<HeapObjectReference, T...>);

static constexpr bool kHasSmi = base::has_type_v<Smi, T...>;

static constexpr bool kHasObject = base::has_type_v<Object, T...>;

static constexpr ObjectType value =

(kHasSmi || kHasObject) ? ObjectType::kObject : ObjectType::kHeapObject;

};

#if defined(V8_HOST_ARCH_32_BIT)

#define BINT_IS_SMI

using BInt = Smi;

using AtomicInt64 = PairT<IntPtrT, IntPtrT>;

using AtomicUint64 = PairT<UintPtrT, UintPtrT>;

#elif defined(V8_HOST_ARCH_64_BIT)

#define BINT_IS_INTPTR

using BInt = IntPtrT;

using AtomicInt64 = IntPtrT;

using AtomicUint64 = UintPtrT;

#else

#error Unknown architecture.

#endif

namespace compiler {

class CallDescriptor;

class CodeAssemblerLabel;

class CodeAssemblerVariable;

template <class T>

class TypedCodeAssemblerVariable;

class CodeAssemblerState;

class JSGraph;

class Node;

class RawMachineAssembler;

class RawMachineLabel;

class SourcePositionTable;

using CodeAssemblerVariableList = ZoneVector<CodeAssemblerVariable*>;

using CodeAssemblerCallback = std::function<void()>;

template <class... Types>

class CodeAssemblerParameterizedLabel;

#define PAIR_TYPE(T1, T2) PairT<T1, T2>

#define CODE_ASSEMBLER_COMPARE_BINARY_OP_LIST(V) \

V(Float32Equal, BoolT, Float32T, Float32T) \

V(Float32LessThan, BoolT, Float32T, Float32T) \

V(Float32LessThanOrEqual, BoolT, Float32T, Float32T) \

V(Float32GreaterThan, BoolT, Float32T, Float32T) \

V(Float32GreaterThanOrEqual, BoolT, Float32T, Float32T) \

V(Float64Equal, BoolT, Float64T, Float64T) \

V(Float64NotEqual, BoolT, Float64T, Float64T) \

V(Float64LessThan, BoolT, Float64T, Float64T) \

V(Float64LessThanOrEqual, BoolT, Float64T, Float64T) \

V(Float64GreaterThan, BoolT, Float64T, Float64T) \

V(Float64GreaterThanOrEqual, BoolT, Float64T, Float64T) \

/* Use Word32Equal if you need Int32Equal */ \

V(Int32GreaterThan, BoolT, Word32T, Word32T) \

V(Int32GreaterThanOrEqual, BoolT, Word32T, Word32T) \

V(Int32LessThan, BoolT, Word32T, Word32T) \

V(Int32LessThanOrEqual, BoolT, Word32T, Word32T) \

/* Use WordEqual if you need IntPtrEqual */ \

V(IntPtrLessThan, BoolT, WordT, WordT) \

V(IntPtrLessThanOrEqual, BoolT, WordT, WordT) \

V(IntPtrGreaterThan, BoolT, WordT, WordT) \

V(IntPtrGreaterThanOrEqual, BoolT, WordT, WordT) \

/* Use Word32Equal if you need Uint32Equal */ \

V(Uint32LessThan, BoolT, Word32T, Word32T) \

V(Uint32LessThanOrEqual, BoolT, Word32T, Word32T) \

V(Uint32GreaterThan, BoolT, Word32T, Word32T) \

V(Uint32GreaterThanOrEqual, BoolT, Word32T, Word32T) \

/* Use Word64Equal if you need Uint64Equal */ \

V(Uint64LessThan, BoolT, Word64T, Word64T) \

V(Uint64LessThanOrEqual, BoolT, Word64T, Word64T) \

V(Uint64GreaterThan, BoolT, Word64T, Word64T) \

V(Uint64GreaterThanOrEqual, BoolT, Word64T, Word64T) \

/* Use WordEqual if you need UintPtrEqual */ \

V(UintPtrLessThan, BoolT, WordT, WordT) \

V(UintPtrLessThanOrEqual, BoolT, WordT, WordT) \

V(UintPtrGreaterThan, BoolT, WordT, WordT) \

V(UintPtrGreaterThanOrEqual, BoolT, WordT, WordT)

#define CODE_ASSEMBLER_BINARY_OP_LIST(V) \

CODE_ASSEMBLER_COMPARE_BINARY_OP_LIST(V) \

V(Float32Sub, Float32T, Float32T, Float32T) \

V(Float32Add, Float32T, Float32T, Float32T) \

V(Float32Mul, Float32T, Float32T, Float32T) \

V(Float64Add, Float64T, Float64T, Float64T) \

V(Float64Sub, Float64T, Float64T, Float64T) \

V(Float64Mul, Float64T, Float64T, Float64T) \

V(Float64Div, Float64T, Float64T, Float64T) \

V(Float64Mod, Float64T, Float64T, Float64T) \

V(Float64Atan2, Float64T, Float64T, Float64T) \

V(Float64Pow, Float64T, Float64T, Float64T) \

V(Float64Max, Float64T, Float64T, Float64T) \

V(Float64Min, Float64T, Float64T, Float64T) \

V(Float64InsertLowWord32, Float64T, Float64T, Word32T) \

V(Float64InsertHighWord32, Float64T, Float64T, Word32T) \

V(I8x16Eq, I8x16T, I8x16T, I8x16T) \

V(IntPtrAdd, WordT, WordT, WordT) \

V(IntPtrSub, WordT, WordT, WordT) \

V(IntPtrMul, WordT, WordT, WordT) \

V(IntPtrMulHigh, IntPtrT, IntPtrT, IntPtrT) \

V(UintPtrMulHigh, UintPtrT, UintPtrT, UintPtrT) \

V(IntPtrDiv, IntPtrT, IntPtrT, IntPtrT) \

V(IntPtrMod, IntPtrT, IntPtrT, IntPtrT) \

V(IntPtrAddWithOverflow, PAIR_TYPE(IntPtrT, BoolT), IntPtrT, IntPtrT) \

V(IntPtrSubWithOverflow, PAIR_TYPE(IntPtrT, BoolT), IntPtrT, IntPtrT) \

V(IntPtrMulWithOverflow, PAIR_TYPE(IntPtrT, BoolT), IntPtrT, IntPtrT) \

V(Int32Add, Word32T, Word32T, Word32T) \

V(Int32AddWithOverflow, PAIR_TYPE(Int32T, BoolT), Int32T, Int32T) \

V(Int32Sub, Word32T, Word32T, Word32T) \

V(Int32SubWithOverflow, PAIR_TYPE(Int32T, BoolT), Int32T, Int32T) \

V(Int32Mul, Word32T, Word32T, Word32T) \

V(Int32MulWithOverflow, PAIR_TYPE(Int32T, BoolT), Int32T, Int32T) \

V(Int32Div, Int32T, Int32T, Int32T) \

V(Uint32Div, Uint32T, Uint32T, Uint32T) \

V(Int32Mod, Int32T, Int32T, Int32T) \

V(Uint32Mod, Uint32T, Uint32T, Uint32T) \

V(Int64Add, Word64T, Word64T, Word64T) \

V(Int64Sub, Word64T, Word64T, Word64T) \

V(Int64SubWithOverflow, PAIR_TYPE(Int64T, BoolT), Int64T, Int64T) \

V(Int64Mul, Word64T, Word64T, Word64T) \

V(Int64MulHigh, Int64T, Int64T, Int64T) \

V(Uint64MulHigh, Uint64T, Uint64T, Uint64T) \

V(Int64Div, Int64T, Int64T, Int64T) \

V(Int64Mod, Int64T, Int64T, Int64T) \

V(WordOr, WordT, WordT, WordT) \

V(WordAnd, WordT, WordT, WordT) \

V(WordXor, WordT, WordT, WordT) \

V(WordRor, WordT, WordT, IntegralT) \

V(WordShl, WordT, WordT, IntegralT) \

V(WordShr, WordT, WordT, IntegralT) \

V(WordSar, WordT, WordT, IntegralT) \

V(WordSarShiftOutZeros, WordT, WordT, IntegralT) \

V(Word32Or, Word32T, Word32T, Word32T) \

V(Word32And, Word32T, Word32T, Word32T) \

V(Word32Xor, Word32T, Word32T, Word32T) \

V(Word32Ror, Word32T, Word32T, Word32T) \

V(Word32Shl, Word32T, Word32T, Word32T) \

V(Word32Shr, Word32T, Word32T, Word32T) \

V(Word32Sar, Word32T, Word32T, Word32T) \

V(Word32SarShiftOutZeros, Word32T, Word32T, Word32T) \

V(Word64And, Word64T, Word64T, Word64T) \

V(Word64Or, Word64T, Word64T, Word64T) \

V(Word64Xor, Word64T, Word64T, Word64T) \

V(Word64Shl, Word64T, Word64T, Word64T) \

V(Word64Shr, Word64T, Word64T, Word64T) \

V(Word64Sar, Word64T, Word64T, Word64T)

TNode<Float64T> Float64Add(TNode<Float64T> a, TNode<Float64T> b);

#define CODE_ASSEMBLER_UNARY_OP_LIST(V) \

V(Float32Abs, Float32T, Float32T) \

V(Float64Abs, Float64T, Float64T) \

V(Float64Acos, Float64T, Float64T) \

V(Float64Acosh, Float64T, Float64T) \

V(Float64Asin, Float64T, Float64T) \

V(Float64Asinh, Float64T, Float64T) \

V(Float64Atan, Float64T, Float64T) \

V(Float64Atanh, Float64T, Float64T) \

V(Float64Cos, Float64T, Float64T) \

V(Float64Cosh, Float64T, Float64T) \

V(Float64Exp, Float64T, Float64T) \

V(Float64Expm1, Float64T, Float64T) \

V(Float64Log, Float64T, Float64T) \

V(Float64Log1p, Float64T, Float64T) \

V(Float64Log2, Float64T, Float64T) \

V(Float64Log10, Float64T, Float64T) \

V(Float64Cbrt, Float64T, Float64T) \

V(Float64Neg, Float64T, Float64T) \

V(Float64Sin, Float64T, Float64T) \

V(Float64Sinh, Float64T, Float64T) \

V(Float64Sqrt, Float64T, Float64T) \

V(Float64Tan, Float64T, Float64T) \

V(Float64Tanh, Float64T, Float64T) \

V(Float64ExtractLowWord32, Uint32T, Float64T) \

V(Float64ExtractHighWord32, Uint32T, Float64T) \

V(BitcastTaggedToWord, IntPtrT, Object) \

V(BitcastTaggedToWordForTagAndSmiBits, IntPtrT, AnyTaggedT) \

V(BitcastMaybeObjectToWord, IntPtrT, MaybeObject) \

V(BitcastWordToTagged, Object, WordT) \

V(BitcastWordToTaggedSigned, Smi, WordT) \

V(TruncateFloat64ToFloat32, Float32T, Float64T) \

V(TruncateFloat64ToFloat16RawBits, Float16RawBitsT, Float64T) \

V(TruncateFloat64ToWord32, Uint32T, Float64T) \

V(TruncateInt64ToInt32, Int32T, Int64T) \

V(ChangeFloat32ToFloat64, Float64T, Float32T) \

V(ChangeFloat64ToUint32, Uint32T, Float64T) \

V(ChangeFloat64ToUint64, Uint64T, Float64T) \

V(ChangeFloat64ToInt64, Int64T, Float64T) \

V(ChangeInt32ToFloat64, Float64T, Int32T) \

V(ChangeInt32ToInt64, Int64T, Int32T) \

V(ChangeUint32ToFloat64, Float64T, Word32T) \

V(ChangeUint32ToUint64, Uint64T, Word32T) \

V(ChangeInt64ToFloat64, Float64T, Int64T) \

V(BitcastInt32ToFloat32, Float32T, Word32T) \

V(BitcastFloat32ToInt32, Uint32T, Float32T) \

V(BitcastFloat64ToInt64, Int64T, Float64T) \

V(BitcastInt64ToFloat64, Float64T, Int64T) \

V(RoundFloat64ToInt32, Int32T, Float64T) \

V(RoundInt32ToFloat32, Float32T, Int32T) \

V(Float64SilenceNaN, Float64T, Float64T) \

V(Float64RoundDown, Float64T, Float64T) \

V(Float64RoundUp, Float64T, Float64T) \

V(Float64RoundTiesEven, Float64T, Float64T) \

V(Float64RoundTruncate, Float64T, Float64T) \

V(Word32Clz, Int32T, Word32T) \

V(Word64Clz, Int64T, Word64T) \

V(Word32Ctz, Int32T, Word32T) \

V(Word64Ctz, Int64T, Word64T) \

V(Word32Popcnt, Int32T, Word32T) \

V(Word64Popcnt, Int64T, Word64T) \

V(Word32BitwiseNot, Word32T, Word32T) \

V(WordNot, WordT, WordT) \

V(Word64Not, Word64T, Word64T) \

V(I8x16BitMask, Int32T, I8x16T) \

V(I8x16Splat, I8x16T, Int32T) \

V(Int32AbsWithOverflow, PAIR_TYPE(Int32T, BoolT), Int32T) \

V(Int64AbsWithOverflow, PAIR_TYPE(Int64T, BoolT), Int64T) \

V(IntPtrAbsWithOverflow, PAIR_TYPE(IntPtrT, BoolT), IntPtrT) \

V(Word32BinaryNot, BoolT, Word32T) \

V(StackPointerGreaterThan, BoolT, WordT)

class V8_EXPORT_PRIVATE CodeAssembler {

public:

explicit CodeAssembler(CodeAssemblerState* state) : state_(state) {}

~CodeAssembler();

CodeAssembler(const CodeAssembler&) = delete;

CodeAssembler& operator=(const CodeAssembler&) = delete;

bool Is64() const;

bool Is32() const;

bool IsFloat64RoundUpSupported() const;

bool IsFloat64RoundDownSupported() const;

bool IsFloat64RoundTiesEvenSupported() const;

bool IsFloat64RoundTruncateSupported() const;

bool IsTruncateFloat64ToFloat16RawBitsSupported() const;

bool IsInt32AbsWithOverflowSupported() const;

bool IsInt64AbsWithOverflowSupported() const;

bool IsIntPtrAbsWithOverflowSupported() const;

bool IsWord32PopcntSupported() const;

bool IsWord64PopcntSupported() const;

bool IsWord32CtzSupported() const;

bool IsWord64CtzSupported() const;

// A scheduler to ensure deterministic builtin compilation regardless of

// v8_flags.concurrent_builtin_generation.

//

// Builtin jobs are compiled in three (3) stages: PrepareJob, ExecuteJob, and

// FinalizeJob.

//

// PrepareJob and FinalizeJob may allocate on the heap and must run on the

// main thread. ExecuteJob only allocates in the job's Zone and may run on a

// helper thread. To ensure deterministic builds, there must be a total order

// of all heap allocations across all spaces. In other words, there must be a

// single total order of PrepareJob and FinalizeJob calls.

//

// This order is enforced by batching according to zone size. For each batch,

//

// 1. In ascending order of job->FinalizeOrder(), call PrepareJob for each

// job.

// 2. Call ExecuteJob for each job in the batch in any order, possibly in

// parallel.

// 3. In ascending order of job->FinalizeOrder(), call FinalizeJob for each

// job.

//

// Example use:

//

// BuiltinCompilationScheduler scheduler;

// scheduler.CompileCode(job1);

// scheduler.CompileCode(job2);

// scheduler.AwaitAndFinalizeCurrentBatch();

class BuiltinCompilationScheduler {

};

// Shortened aliases for use in CodeAssembler subclasses.

using Label = CodeAssemblerLabel;

template <class T>

using TVariable = TypedCodeAssemblerVariable<T>;

using VariableList = CodeAssemblerVariableList;

// ===========================================================================

// Base Assembler

// ===========================================================================

template <class PreviousType, bool FromTyped>

class CheckedNode {

};

template <class T>

TNode<T> UncheckedCast(Node* value) {

return TNode<T>::UncheckedCast(value);

}

template <class T, class U>

TNode<T> UncheckedCast(TNode<U> value) {

}

// ReinterpretCast<T>(v) has the power to cast even when the type of v is

// unrelated to T. Use with care.

template <class T>

TNode<T> ReinterpretCast(Node* value) {

return TNode<T>::UncheckedCast(value);

}

CheckedNode<Object, false> Cast(Node* value, const char* location = "") {

return {value, this, location};

}

template <class T>

CheckedNode<T, true> Cast(TNode<T> value, const char* location = "") {

return {value, this, location};

}

#ifdef DEBUG

#define STRINGIFY(x) #x

#define TO_STRING_LITERAL(x) STRINGIFY(x)

#define CAST(x) \

Cast(x, "CAST(" #x ") at " __FILE__ ":" TO_STRING_LITERAL(__LINE__))

#define TORQUE_CAST(...) \

ca_.Cast(__VA_ARGS__, "CAST(" #__VA_ARGS__ ") at " __FILE__ \

":" TO_STRING_LITERAL(__LINE__))

#else

#define CAST(x) Cast(x)

#define TORQUE_CAST(...) ca_.Cast(__VA_ARGS__)

#endif

// Constants.

TNode<Int32T> UniqueInt32Constant(int32_t value);

TNode<Int32T> Int32Constant(int32_t value);

TNode<Int64T> UniqueInt64Constant(int64_t value);

TNode<Int64T> Int64Constant(int64_t value);

TNode<Uint64T> Uint64Constant(uint64_t value) {

return Unsigned(Int64Constant(base::bit_cast<int64_t>(value)));

}

TNode<IntPtrT> IntPtrConstant(intptr_t value);

TNode<IntPtrT> UniqueIntPtrConstant(intptr_t value);

TNode<Uint32T> UniqueUint32Constant(int32_t value) {

return Unsigned(UniqueInt32Constant(base::bit_cast<int32_t>(value)));

}

TNode<Uint32T> Uint32Constant(uint32_t value) {

return Unsigned(Int32Constant(base::bit_cast<int32_t>(value)));

}

TNode<Uint32T> Uint64HighWordConstant(uint64_t value) {

return Uint32Constant(value >> 32);

}

TNode<Uint32T> Uint64HighWordConstantNoLowWord(uint64_t value) {

DCHECK_EQ(0, value & ~uint32_t{0});

return Uint64HighWordConstant(value);

}

TNode<Uint32T> Uint64LowWordConstant(uint64_t value) {

return Uint32Constant(static_cast<uint32_t>(value));

}

TNode<UintPtrT> UintPtrConstant(uintptr_t value) {

return Unsigned(IntPtrConstant(base::bit_cast<intptr_t>(value)));

}

TNode<TaggedIndex> TaggedIndexConstant(intptr_t value);

TNode<RawPtrT> PointerConstant(void* value) {

return ReinterpretCast<RawPtrT>(

IntPtrConstant(reinterpret_cast<intptr_t>(value)));

}

TNode<Number> NumberConstant(double value);

TNode<Smi> SmiConstant(Tagged<Smi> value);

TNode<Smi> SmiConstant(int value);

template <typename E>

TNode<Smi> SmiConstant(E value)

}

void CanonicalizeEmbeddedBuiltinsConstantIfNeeded(Handle<HeapObject> object);

TNode<HeapObject> UntypedHeapConstantNoHole(Handle<HeapObject> object);

TNode<HeapObject> UntypedHeapConstantMaybeHole(Handle<HeapObject> object);

TNode<HeapObject> UntypedHeapConstantHole(Handle<HeapObject> object);

template <class Type>

TNode<Type> HeapConstantNoHole(Handle<Type> object) {

return UncheckedCast<Type>(UntypedHeapConstantNoHole(object));

}

template <class Type>

TNode<Type> HeapConstantMaybeHole(Handle<Type> object) {

return UncheckedCast<Type>(UntypedHeapConstantMaybeHole(object));

}

template <class Type>

TNode<Type> HeapConstantHole(Handle<Type> object) {

return UncheckedCast<Type>(UntypedHeapConstantHole(object));

}

TNode<String> StringConstant(const char* str);

TNode<Boolean> BooleanConstant(bool value);

TNode<ExternalReference> ExternalConstant(ExternalReference address);

TNode<ExternalReference> IsolateField(IsolateFieldId id);

TNode<Float32T> Float32Constant(double value);

TNode<Float64T> Float64Constant(double value);

TNode<BoolT> Int32TrueConstant() {

return ReinterpretCast<BoolT>(Int32Constant(1));

}

TNode<BoolT> Int32FalseConstant() {

return ReinterpretCast<BoolT>(Int32Constant(0));

}

TNode<BoolT> BoolConstant(bool value) {

return value ? Int32TrueConstant() : Int32FalseConstant();

}

TNode<ExternalPointerHandleT> ExternalPointerHandleNullConstant() {

return ReinterpretCast<ExternalPointerHandleT>(Uint32Constant(0));

}

bool IsMapOffsetConstant(Node* node);

bool TryToInt32Constant(TNode<IntegralT> node, int32_t* out_value);

bool TryToInt64Constant(TNode<IntegralT> node, int64_t* out_value);

bool TryToIntPtrConstant(TNode<IntegralT> node, intptr_t* out_value);

bool TryToIntPtrConstant(TNode<Smi> tnode, intptr_t* out_value);

bool TryToSmiConstant(TNode<IntegralT> node, Tagged<Smi>* out_value);

bool TryToSmiConstant(TNode<Smi> node, Tagged<Smi>* out_value);

bool IsUndefinedConstant(TNode<Object> node);

bool IsNullConstant(TNode<Object> node);

TNode<Int32T> Signed(TNode<Word32T> x) { return UncheckedCast<Int32T>(x); }

TNode<Int64T> Signed(TNode<Word64T> x) { return UncheckedCast<Int64T>(x); }

TNode<IntPtrT> Signed(TNode<WordT> x) { return UncheckedCast<IntPtrT>(x); }

TNode<Uint32T> Unsigned(TNode<Word32T> x) {

return UncheckedCast<Uint32T>(x);

}

TNode<Uint64T> Unsigned(TNode<Word64T> x) {

return UncheckedCast<Uint64T>(x);

}

TNode<UintPtrT> Unsigned(TNode<WordT> x) {

return UncheckedCast<UintPtrT>(x);

}

// Support for code with a "dynamic" parameter count.

//

// Code assembled by our code assembler always has a "static" parameter count

// as defined by the call descriptor for the code. This parameter count is

// known at compile time. However, some builtins also have a "dynamic"

// parameter count because they can be installed on different function

// objects with different parameter counts. In that case, the actual

// parameter count is only known at runtime. Examples of such builtins

// include the CompileLazy builtin and the InterpreterEntryTrampoline, or the

// generic JSToWasm and JSToJS wrappers. These builtins then may have to

// obtain the "dynamic" parameter count, for example to correctly remove all

// function arguments (including padding arguments) from the stack.

bool HasDynamicJSParameterCount();

TNode<Uint16T> DynamicJSParameterCount();

void SetDynamicJSParameterCount(TNode<Uint16T> parameter_count);

static constexpr int kTargetParameterIndex = kJSCallClosureParameterIndex;

static_assert(kTargetParameterIndex == -1);

template <class T>

TNode<T> Parameter(int value,

}

template <class T>

TNode<T> UncheckedParameter(int value) {

return UncheckedCast<T>(UntypedParameter(value));

}

Node* UntypedParameter(int value);

TNode<Context> GetJSContextParameter();

void Return(TNode<Object> value);

void Return(TNode<Object> value1, TNode<Object> value2);

void Return(TNode<Object> value1, TNode<Object> value2, TNode<Object> value3);

void Return(TNode<Int32T> value);

void Return(TNode<Uint32T> value);

void Return(TNode<WordT> value);

void Return(TNode<Float32T> value);

void Return(TNode<Float64T> value);

void Return(TNode<WordT> value1, TNode<WordT> value2);

void Return(TNode<Word32T> value1, TNode<Word32T> value2);

void Return(TNode<WordT> value1, TNode<Object> value2);

void Return(TNode<Word32T> value1, TNode<Object> value2);

void PopAndReturn(Node* pop, Node* value);

void PopAndReturn(Node* pop, Node* value1, Node* value2, Node* value3,

Node* value4);

void ReturnIf(TNode<BoolT> condition, TNode<Object> value);

void AbortCSADcheck(Node* message);

void DebugBreak();

void Unreachable();

// Hack for supporting SourceLocation alongside template packs.

struct MessageWithSourceLocation {

};

template <class... Args>

void Comment(MessageWithSourceLocation message, Args&&... args) {

}

void StaticAssert(TNode<BoolT> value,

const char* source = "unknown position");

// The following methods refer to source positions in CSA or Torque code

// compiled during mksnapshot, not JS compiled at runtime.

void SetSourcePosition(const char* file, int line);

void PushSourcePosition();

void PopSourcePosition();

class V8_NODISCARD SourcePositionScope {

public:

explicit SourcePositionScope(CodeAssembler* ca) : ca_(ca) {

ca->PushSourcePosition();

}

~SourcePositionScope() { ca_->PopSourcePosition(); }

private:

CodeAssembler* ca_;

};

const std::vector<FileAndLine>& GetMacroSourcePositionStack() const;

void Bind(Label* label);

#if DEBUG

void Bind(Label* label, AssemblerDebugInfo debug_info);

#endif // DEBUG

void Goto(Label* label);

void GotoIf(TNode<IntegralT> condition, Label* true_label,

GotoHint goto_hint = GotoHint::kNone);

void GotoIfNot(TNode<IntegralT> condition, Label* false_label,

GotoHint goto_hint = GotoHint::kNone);

void Branch(TNode<IntegralT> condition, Label* true_label, Label* false_label,

BranchHint branch_hint = BranchHint::kNone);

template <class T>

TNode<T> Uninitialized() {

return {};

}

template <class... T>

void Bind(CodeAssemblerParameterizedLabel<T...>* label, TNode<T>*... phis) {

Bind(label->plain_label());

label->CreatePhis(phis...);

}

template <class... T, class... Args>

void Branch(TNode<BoolT> condition,

}

template <class... T, class... U>

void Branch(TNode<BoolT> condition,

}

template <class... T, class... Args>

void Goto(CodeAssemblerParameterizedLabel<T...>* label, Args... args) {

label->AddInputs(args...);

Goto(label->plain_label());

}

void Branch(TNode<BoolT> condition, const std::function<void()>& true_body,

const std::function<void()>& false_body);

void Branch(TNode<BoolT> condition, Label* true_label,

const std::function<void()>& false_body);

void Branch(TNode<BoolT> condition, const std::function<void()>& true_body,

Label* false_label);

void Switch(Node* index, Label* default_label, const int32_t* case_values,

Label** case_labels, size_t case_count);

// Access to the frame pointer.

TNode<RawPtrT> LoadFramePointer();

TNode<RawPtrT> LoadParentFramePointer();

TNode<RawPtrT> StackSlotPtr(int size, int alignment);

#if V8_ENABLE_WEBASSEMBLY

// Access to the stack pointer.

TNode<RawPtrT> LoadStackPointer();

void SetStackPointer(TNode<RawPtrT> ptr);

#endif // V8_ENABLE_WEBASSEMBLY

TNode<Object> LoadTaggedFromRootRegister(TNode<IntPtrT> offset);

TNode<RawPtrT> LoadPointerFromRootRegister(TNode<IntPtrT> offset);

TNode<Uint8T> LoadUint8FromRootRegister(TNode<IntPtrT> offset);

// Load raw memory location.

Node* Load(MachineType type, Node* base);

template <class Type>

TNode<Type> Load(MachineType type, TNode<RawPtr<Type>> base) {

}

Node* Load(MachineType type, Node* base, Node* offset);

template <class Type>

TNode<Type> Load(Node* base) {

return UncheckedCast<Type>(Load(MachineTypeOf<Type>::value, base));

}

template <class Type>

TNode<Type> Load(Node* base, TNode<WordT> offset) {

return UncheckedCast<Type>(Load(MachineTypeOf<Type>::value, base, offset));

}

template <class Type>

TNode<Type> AtomicLoad(AtomicMemoryOrder order, TNode<RawPtrT> base,

}

template <class Type>

TNode<Type> AtomicLoad64(AtomicMemoryOrder order, TNode<RawPtrT> base,

TNode<WordT> offset);

// Load uncompressed tagged value from (most likely off JS heap) memory

// location.

TNode<Object> LoadFullTagged(Node* base);

TNode<Object> LoadFullTagged(Node* base, TNode<IntPtrT> offset);

Node* LoadFromObject(MachineType type, TNode<Object> object,

TNode<IntPtrT> offset);

Node* LoadProtectedPointerFromObject(TNode<Object> object,

TNode<IntPtrT> offset);

#ifdef V8_MAP_PACKING

Node* PackMapWord(Node* value);

#endif

// Load a value from the root array.

// If map packing is enabled, LoadRoot for a root map returns the unpacked map

// word (i.e., the map). Use LoadRootMapWord to obtain the packed map word

// instead.

TNode<Object> LoadRoot(RootIndex root_index);

TNode<AnyTaggedT> LoadRootMapWord(RootIndex root_index);

template <typename Type>

TNode<Type> UnalignedLoad(TNode<RawPtrT> base, TNode<IntPtrT> offset) {

MachineType mt = MachineTypeOf<Type>::value;

return UncheckedCast<Type>(UnalignedLoad(mt, base, offset));

}

// Store value to raw memory location.

void Store(Node* base, Node* value);

void Store(Node* base, Node* offset, Node* value);

void StoreEphemeronKey(Node* base, Node* offset, Node* value);

void StoreNoWriteBarrier(MachineRepresentation rep, Node* base, Node* value);

void StoreNoWriteBarrier(MachineRepresentation rep, Node* base, Node* offset,

Node* value);

void UnsafeStoreNoWriteBarrier(MachineRepresentation rep, Node* base,

Node* value);

void UnsafeStoreNoWriteBarrier(MachineRepresentation rep, Node* base,

Node* offset, Node* value);

// Stores uncompressed tagged value to (most likely off JS heap) memory

// location without write barrier.

void StoreFullTaggedNoWriteBarrier(TNode<RawPtrT> base,

TNode<Object> tagged_value);

void StoreFullTaggedNoWriteBarrier(TNode<RawPtrT> base, TNode<IntPtrT> offset,

TNode<Object> tagged_value);

// Optimized memory operations that map to Turbofan simplified nodes.

TNode<HeapObject> OptimizedAllocate(TNode<IntPtrT> size,

AllocationType allocation);

void StoreToObject(MachineRepresentation rep, TNode<Object> object,

TNode<IntPtrT> offset, Node* value,

StoreToObjectWriteBarrier write_barrier);

void OptimizedStoreField(MachineRepresentation rep, TNode<HeapObject> object,

int offset, Node* value);

void OptimizedStoreIndirectPointerField(TNode<HeapObject> object, int offset,

IndirectPointerTag tag, Node* value);

void OptimizedStoreIndirectPointerFieldNoWriteBarrier(

TNode<HeapObject> object, int offset, IndirectPointerTag tag,

Node* value);

void OptimizedStoreFieldAssertNoWriteBarrier(MachineRepresentation rep,

TNode<HeapObject> object,

int offset, Node* value);

void OptimizedStoreFieldUnsafeNoWriteBarrier(MachineRepresentation rep,

TNode<HeapObject> object,

int offset, Node* value);

void OptimizedStoreMap(TNode<HeapObject> object, TNode<Map>);

void AtomicStore(MachineRepresentation rep, AtomicMemoryOrder order,

TNode<RawPtrT> base, TNode<WordT> offset,

TNode<Word32T> value);

// {value_high} is used for 64-bit stores on 32-bit platforms, must be

// nullptr in other cases.

void AtomicStore64(AtomicMemoryOrder order, TNode<RawPtrT> base,

TNode<WordT> offset, TNode<UintPtrT> value,

TNode<UintPtrT> value_high);

TNode<Word32T> AtomicAdd(MachineType type, TNode<RawPtrT> base,

TNode<UintPtrT> offset, TNode<Word32T> value);

template <class Type>

TNode<Type> AtomicAdd64(TNode<RawPtrT> base, TNode<UintPtrT> offset,

TNode<UintPtrT> value, TNode<UintPtrT> value_high);

TNode<Word32T> AtomicSub(MachineType type, TNode<RawPtrT> base,

TNode<UintPtrT> offset, TNode<Word32T> value);

template <class Type>

TNode<Type> AtomicSub64(TNode<RawPtrT> base, TNode<UintPtrT> offset,

TNode<UintPtrT> value, TNode<UintPtrT> value_high);

TNode<Word32T> AtomicAnd(MachineType type, TNode<RawPtrT> base,

TNode<UintPtrT> offset, TNode<Word32T> value);

template <class Type>

TNode<Type> AtomicAnd64(TNode<RawPtrT> base, TNode<UintPtrT> offset,

TNode<UintPtrT> value, TNode<UintPtrT> value_high);

TNode<Word32T> AtomicOr(MachineType type, TNode<RawPtrT> base,

TNode<UintPtrT> offset, TNode<Word32T> value);

template <class Type>

TNode<Type> AtomicOr64(TNode<RawPtrT> base, TNode<UintPtrT> offset,

TNode<UintPtrT> value, TNode<UintPtrT> value_high);

TNode<Word32T> AtomicXor(MachineType type, TNode<RawPtrT> base,

TNode<UintPtrT> offset, TNode<Word32T> value);

template <class Type>

TNode<Type> AtomicXor64(TNode<RawPtrT> base, TNode<UintPtrT> offset,

TNode<UintPtrT> value, TNode<UintPtrT> value_high);

// Exchange value at raw memory location

TNode<Word32T> AtomicExchange(MachineType type, TNode<RawPtrT> base,

TNode<UintPtrT> offset, TNode<Word32T> value);

template <class Type>

TNode<Type> AtomicExchange64(TNode<RawPtrT> base, TNode<UintPtrT> offset,

TNode<UintPtrT> value,

TNode<UintPtrT> value_high);