From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- js/src/jit/wasm32/Architecture-wasm32.h | 174 ++++ js/src/jit/wasm32/Assembler-wasm32.h | 229 +++++ js/src/jit/wasm32/CodeGenerator-wasm32.cpp | 254 +++++ js/src/jit/wasm32/CodeGenerator-wasm32.h | 76 ++ js/src/jit/wasm32/LIR-wasm32.h | 109 +++ js/src/jit/wasm32/Lowering-wasm32.h | 128 +++ js/src/jit/wasm32/MacroAssembler-wasm32-inl.h | 1176 ++++++++++++++++++++++++ js/src/jit/wasm32/MacroAssembler-wasm32.cpp | 502 ++++++++++ js/src/jit/wasm32/MacroAssembler-wasm32.h | 528 +++++++++++ js/src/jit/wasm32/MoveEmitter-wasm32.h | 30 + js/src/jit/wasm32/SharedICHelpers-wasm32-inl.h | 32 + js/src/jit/wasm32/SharedICHelpers-wasm32.h | 30 + js/src/jit/wasm32/SharedICRegisters-wasm32.h | 36 + js/src/jit/wasm32/Trampoline-wasm32.cpp | 46 + 14 files changed, 3350 insertions(+) create mode 100644 js/src/jit/wasm32/Architecture-wasm32.h create mode 100644 js/src/jit/wasm32/Assembler-wasm32.h create mode 100644 js/src/jit/wasm32/CodeGenerator-wasm32.cpp create mode 100644 js/src/jit/wasm32/CodeGenerator-wasm32.h create mode 100644 js/src/jit/wasm32/LIR-wasm32.h create mode 100644 js/src/jit/wasm32/Lowering-wasm32.h create mode 100644 js/src/jit/wasm32/MacroAssembler-wasm32-inl.h create mode 100644 js/src/jit/wasm32/MacroAssembler-wasm32.cpp create mode 100644 js/src/jit/wasm32/MacroAssembler-wasm32.h create mode 100644 js/src/jit/wasm32/MoveEmitter-wasm32.h create mode 100644 js/src/jit/wasm32/SharedICHelpers-wasm32-inl.h create mode 100644 js/src/jit/wasm32/SharedICHelpers-wasm32.h create mode 100644 js/src/jit/wasm32/SharedICRegisters-wasm32.h create mode 100644 js/src/jit/wasm32/Trampoline-wasm32.cpp (limited to 'js/src/jit/wasm32') diff --git a/js/src/jit/wasm32/Architecture-wasm32.h b/js/src/jit/wasm32/Architecture-wasm32.h new file mode 100644 index 0000000000..d7726eaa5f --- /dev/null +++ b/js/src/jit/wasm32/Architecture-wasm32.h @@ -0,0 +1,174 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_Architecture_wasm32_h +#define jit_wasm32_Architecture_wasm32_h + +// JitSpewer.h is included through MacroAssembler implementations for other +// platforms, so include it here to avoid inadvertent build bustage. +#include "jit/JitSpewer.h" + +#include "jit/shared/Architecture-shared.h" + +namespace js::jit { + +static const uint32_t SimdMemoryAlignment = + 4; // Make it 4 to avoid a bunch of div-by-zero warnings +static const uint32_t WasmStackAlignment = 8; +static const uint32_t WasmTrapInstructionLength = 0; + +// See comments in wasm::GenerateFunctionPrologue. +static constexpr uint32_t WasmCheckedCallEntryOffset = 0u; + +class Registers { + public: + enum RegisterID { + sp = 0, // corresponds to global __stack_pointer which is mapped into + // global[0] + fp = 1, + r2 = 2, + r3 = 3, + invalid_reg, + invalid_reg2, // To avoid silly static_assert failures. + }; + typedef uint8_t Code; + typedef RegisterID Encoding; + union RegisterContent { + uintptr_t r; + }; + + typedef uint8_t SetType; + + static uint32_t SetSize(SetType) { MOZ_CRASH(); } + static uint32_t FirstBit(SetType) { MOZ_CRASH(); } + static uint32_t LastBit(SetType) { MOZ_CRASH(); } + static const char* GetName(Code) { MOZ_CRASH(); } + static Code FromName(const char*) { MOZ_CRASH(); } + + static const Encoding StackPointer = RegisterID::sp; + static const Encoding FramePointer = RegisterID::fp; + static const Encoding Invalid = invalid_reg; + static const uint32_t Total = 5; + static const uint32_t TotalPhys = 0; + static const uint32_t Allocatable = 0; + static const SetType AllMask = 0; + static const SetType ArgRegMask = 0; + static const SetType VolatileMask = 0; + static const SetType NonVolatileMask = 0; + static const SetType NonAllocatableMask = 0; + static const SetType AllocatableMask = 0; + static const SetType JSCallMask = 0; + static const SetType CallMask = 0; +}; + +typedef uint8_t PackedRegisterMask; + +class FloatRegisters { + public: + enum FPRegisterID { f0 = 0, invalid_reg }; + typedef FPRegisterID Code; + typedef FPRegisterID Encoding; + union RegisterContent { + float s; + double d; + }; + + typedef uint32_t SetType; + + static const char* GetName(Code) { MOZ_CRASH(); } + static Code FromName(const char*) { MOZ_CRASH(); } + + static const Code Invalid = invalid_reg; + static const uint32_t Total = 0; + static const uint32_t TotalPhys = 0; + static const uint32_t Allocatable = 0; + static const SetType AllMask = 0; + static const SetType AllDoubleMask = 0; + static const SetType AllSingleMask = 0; + static const SetType VolatileMask = 0; + static const SetType NonVolatileMask = 0; + static const SetType NonAllocatableMask = 0; + static const SetType AllocatableMask = 0; +}; + +template +class TypedRegisterSet; + +struct FloatRegister { + typedef FloatRegisters Codes; + typedef Codes::Code Code; + typedef Codes::Encoding Encoding; + typedef Codes::SetType SetType; + + Code _; + + static uint32_t FirstBit(SetType) { MOZ_CRASH(); } + static uint32_t LastBit(SetType) { MOZ_CRASH(); } + static FloatRegister FromCode(uint32_t) { MOZ_CRASH(); } + bool isSingle() const { MOZ_CRASH(); } + bool isDouble() const { MOZ_CRASH(); } + bool isSimd128() const { MOZ_CRASH(); } + bool isInvalid() const { MOZ_CRASH(); } + FloatRegister asSingle() const { MOZ_CRASH(); } + FloatRegister asDouble() const { MOZ_CRASH(); } + FloatRegister asSimd128() const { MOZ_CRASH(); } + Code code() const { MOZ_CRASH(); } + Encoding encoding() const { MOZ_CRASH(); } + const char* name() const { MOZ_CRASH(); } + bool volatile_() const { MOZ_CRASH(); } + bool operator!=(FloatRegister) const { MOZ_CRASH(); } + bool operator==(FloatRegister) const { MOZ_CRASH(); } + bool aliases(FloatRegister) const { MOZ_CRASH(); } + uint32_t numAliased() const { MOZ_CRASH(); } + FloatRegister aliased(uint32_t) { MOZ_CRASH(); } + bool equiv(FloatRegister) const { MOZ_CRASH(); } + uint32_t size() const { MOZ_CRASH(); } + uint32_t numAlignedAliased() const { MOZ_CRASH(); } + FloatRegister alignedAliased(uint32_t) { MOZ_CRASH(); } + SetType alignedOrDominatedAliasedSet() const { MOZ_CRASH(); } + + static constexpr RegTypeName DefaultType = RegTypeName::Float64; + + template + static SetType LiveAsIndexableSet(SetType s) { + return SetType(0); + } + + template + static SetType AllocatableAsIndexableSet(SetType s) { + static_assert(Name != RegTypeName::Any, "Allocatable set are not iterable"); + return SetType(0); + } + + template + static T ReduceSetForPush(T) { + MOZ_CRASH(); + } + uint32_t getRegisterDumpOffsetInBytes() { MOZ_CRASH(); } + static uint32_t SetSize(SetType x) { MOZ_CRASH(); } + static Code FromName(const char* name) { MOZ_CRASH(); } + + // This is used in static initializers, so produce a bogus value instead of + // crashing. + static uint32_t GetPushSizeInBytes(const TypedRegisterSet&) { + return 0; + } +}; + +inline bool hasUnaliasedDouble() { MOZ_CRASH(); } +inline bool hasMultiAlias() { MOZ_CRASH(); } + +static const uint32_t ShadowStackSpace = 0; +static const uint32_t JumpImmediateRange = INT32_MAX; + +#ifdef JS_NUNBOX32 +static const int32_t NUNBOX32_TYPE_OFFSET = 4; +static const int32_t NUNBOX32_PAYLOAD_OFFSET = 0; +#endif + +} // namespace js::jit + +#endif /* jit_wasm32_Architecture_wasm32_h */ diff --git a/js/src/jit/wasm32/Assembler-wasm32.h b/js/src/jit/wasm32/Assembler-wasm32.h new file mode 100644 index 0000000000..d3816a3ea6 --- /dev/null +++ b/js/src/jit/wasm32/Assembler-wasm32.h @@ -0,0 +1,229 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_Assembler_wasm32_h +#define jit_wasm32_Assembler_wasm32_h + +#include "mozilla/Assertions.h" + +#include + +#include "jit/Registers.h" +#include "jit/RegisterSets.h" +#include "jit/shared/Assembler-shared.h" +#include "jit/wasm32/Architecture-wasm32.h" +#include "js/Value.h" + +namespace js::jit { + +struct ImmTag : public Imm32 { + explicit ImmTag(JSValueTag mask) : Imm32(int32_t(mask)) {} +}; + +struct ImmType : public ImmTag { + explicit ImmType(JSValueType type) : ImmTag(JSVAL_TYPE_TO_TAG(type)) {} +}; + +class MacroAssembler; + +static constexpr Register StackPointer{Registers::StackPointer}; +static constexpr Register FramePointer{Registers::FramePointer}; + +static constexpr Register ReturnReg{Registers::invalid_reg2}; +static constexpr FloatRegister ReturnFloat32Reg = {FloatRegisters::invalid_reg}; +static constexpr FloatRegister ReturnDoubleReg = {FloatRegisters::invalid_reg}; +static constexpr FloatRegister ReturnSimd128Reg = {FloatRegisters::invalid_reg}; +static constexpr FloatRegister ScratchSimd128Reg = { + FloatRegisters::invalid_reg}; +static constexpr FloatRegister InvalidFloatReg = {FloatRegisters::invalid_reg}; + +struct ScratchFloat32Scope : FloatRegister { + explicit ScratchFloat32Scope(MacroAssembler& masm) {} +}; + +struct ScratchDoubleScope : FloatRegister { + explicit ScratchDoubleScope(MacroAssembler& masm) {} +}; + +static constexpr Register OsrFrameReg{Registers::invalid_reg}; +static constexpr Register PreBarrierReg{Registers::invalid_reg}; +static constexpr Register InterpreterPCReg{Registers::invalid_reg}; +static constexpr Register CallTempReg0{Registers::invalid_reg}; +static constexpr Register CallTempReg1{Registers::invalid_reg}; +static constexpr Register CallTempReg2{Registers::invalid_reg}; +static constexpr Register CallTempReg3{Registers::invalid_reg}; +static constexpr Register CallTempReg4{Registers::invalid_reg}; +static constexpr Register CallTempReg5{Registers::invalid_reg}; +static constexpr Register InvalidReg{Registers::invalid_reg}; +static constexpr Register CallTempNonArgRegs[] = {InvalidReg, InvalidReg}; +static const uint32_t NumCallTempNonArgRegs = std::size(CallTempNonArgRegs); + +static constexpr Register IntArgReg0{Registers::invalid_reg}; +static constexpr Register IntArgReg1{Registers::invalid_reg}; +static constexpr Register IntArgReg2{Registers::invalid_reg}; +static constexpr Register IntArgReg3{Registers::invalid_reg}; +static constexpr Register HeapReg{Registers::invalid_reg}; + +static constexpr Register RegExpMatcherRegExpReg{Registers::invalid_reg}; +static constexpr Register RegExpMatcherStringReg{Registers::invalid_reg}; +static constexpr Register RegExpMatcherLastIndexReg{Registers::invalid_reg}; + +static constexpr Register RegExpExecTestRegExpReg{Registers::invalid_reg}; +static constexpr Register RegExpExecTestStringReg{Registers::invalid_reg}; + +static constexpr Register RegExpSearcherRegExpReg{Registers::invalid_reg}; +static constexpr Register RegExpSearcherStringReg{Registers::invalid_reg}; +static constexpr Register RegExpSearcherLastIndexReg{Registers::invalid_reg}; + +// Uses |invalid_reg2| to avoid static_assert failures. +static constexpr Register JSReturnReg_Type{Registers::invalid_reg2}; +static constexpr Register JSReturnReg_Data{Registers::invalid_reg2}; +static constexpr Register JSReturnReg{Registers::invalid_reg2}; + +#if defined(JS_NUNBOX32) +static constexpr ValueOperand JSReturnOperand(Register{Registers::r2}, + Register{Registers::r3}); +static constexpr Register64 ReturnReg64(InvalidReg, InvalidReg); +#elif defined(JS_PUNBOX64) +static constexpr ValueOperand JSReturnOperand(InvalidReg); +static constexpr Register64 ReturnReg64(InvalidReg); +#else +# error "Bad architecture" +#endif + +static constexpr Register ABINonArgReg0{Registers::invalid_reg}; +static constexpr Register ABINonArgReg1{Registers::invalid_reg}; +static constexpr Register ABINonArgReg2{Registers::invalid_reg}; +static constexpr Register ABINonArgReg3{Registers::invalid_reg}; +static constexpr Register ABINonArgReturnReg0{Registers::invalid_reg}; +static constexpr Register ABINonArgReturnReg1{Registers::invalid_reg}; +static constexpr Register ABINonVolatileReg{Registers::invalid_reg}; +static constexpr Register ABINonArgReturnVolatileReg{Registers::invalid_reg}; + +static constexpr FloatRegister ABINonArgDoubleReg = { + FloatRegisters::invalid_reg}; + +static constexpr Register WasmTableCallScratchReg0{Registers::invalid_reg}; +static constexpr Register WasmTableCallScratchReg1{Registers::invalid_reg}; +static constexpr Register WasmTableCallSigReg{Registers::invalid_reg}; +static constexpr Register WasmTableCallIndexReg{Registers::invalid_reg}; +static constexpr Register InstanceReg{Registers::invalid_reg}; +static constexpr Register WasmJitEntryReturnScratch{Registers::invalid_reg}; +static constexpr Register WasmCallRefCallScratchReg0{Registers::invalid_reg}; +static constexpr Register WasmCallRefCallScratchReg1{Registers::invalid_reg}; +static constexpr Register WasmCallRefReg{Registers::invalid_reg}; + +static constexpr uint32_t ABIStackAlignment = 4; +static constexpr uint32_t CodeAlignment = 16; +static constexpr uint32_t JitStackAlignment = 8; +static constexpr uint32_t JitStackValueAlignment = + JitStackAlignment / sizeof(Value); + +static const Scale ScalePointer = TimesOne; + +static constexpr uint32_t Int32SizeLog2 = 2; + +struct MemoryArgument { + uint32_t align; + uint32_t offset; +}; + +class AssemblerWasm32 : public AssemblerShared {}; + +class Assembler : public AssemblerWasm32 { + public: + enum Condition { + Equal, + NotEqual, + Above, + AboveOrEqual, + Below, + BelowOrEqual, + GreaterThan, + GreaterThanOrEqual, + LessThan, + LessThanOrEqual, + Overflow, + CarrySet, + CarryClear, + Signed, + NotSigned, + Zero, + NonZero, + Always, + }; + + enum DoubleCondition { + DoubleOrdered, + DoubleEqual, + DoubleNotEqual, + DoubleGreaterThan, + DoubleGreaterThanOrEqual, + DoubleLessThan, + DoubleLessThanOrEqual, + DoubleUnordered, + DoubleEqualOrUnordered, + DoubleNotEqualOrUnordered, + DoubleGreaterThanOrUnordered, + DoubleGreaterThanOrEqualOrUnordered, + DoubleLessThanOrUnordered, + DoubleLessThanOrEqualOrUnordered + }; + + static Condition InvertCondition(Condition) { MOZ_CRASH(); } + + static DoubleCondition InvertCondition(DoubleCondition) { MOZ_CRASH(); } + + template + static void PatchDataWithValueCheck(CodeLocationLabel, T, S) { + MOZ_CRASH(); + } + static void PatchWrite_Imm32(CodeLocationLabel, Imm32) { MOZ_CRASH(); } + + static void PatchWrite_NearCall(CodeLocationLabel, CodeLocationLabel) { + MOZ_CRASH(); + } + static uint32_t PatchWrite_NearCallSize() { MOZ_CRASH(); } + + static void ToggleToJmp(CodeLocationLabel) { MOZ_CRASH(); } + static void ToggleToCmp(CodeLocationLabel) { MOZ_CRASH(); } + static void ToggleCall(CodeLocationLabel, bool) { MOZ_CRASH(); } + + static void Bind(uint8_t*, const CodeLabel&) { MOZ_CRASH(); } + + static uintptr_t GetPointer(uint8_t*) { MOZ_CRASH(); } + + static bool HasRoundInstruction(RoundingMode) { return false; } + + void verifyHeapAccessDisassembly(uint32_t begin, uint32_t end, + const Disassembler::HeapAccess& heapAccess) { + MOZ_CRASH(); + } + + void setUnlimitedBuffer() { MOZ_CRASH(); } +}; + +class Operand { + public: + explicit Operand(const Address&) { MOZ_CRASH(); } + explicit Operand(const Register) { MOZ_CRASH(); } + explicit Operand(const FloatRegister) { MOZ_CRASH(); } + explicit Operand(Register, Imm32) { MOZ_CRASH(); } + explicit Operand(Register, int32_t) { MOZ_CRASH(); } +}; + +class ABIArgGenerator { + public: + ABIArgGenerator() = default; + ABIArg next(MIRType) { MOZ_CRASH(); } + ABIArg& current() { MOZ_CRASH(); } + uint32_t stackBytesConsumedSoFar() const { MOZ_CRASH(); } + void increaseStackOffset(uint32_t) { MOZ_CRASH(); } +}; + +} // namespace js::jit + +#endif /* jit_wasm32_Assembler_wasm32_h */ diff --git a/js/src/jit/wasm32/CodeGenerator-wasm32.cpp b/js/src/jit/wasm32/CodeGenerator-wasm32.cpp new file mode 100644 index 0000000000..5535eed21d --- /dev/null +++ b/js/src/jit/wasm32/CodeGenerator-wasm32.cpp @@ -0,0 +1,254 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "jit/wasm32/CodeGenerator-wasm32.h" + +#include "jit/CodeGenerator.h" + +using namespace js::jit; + +void CodeGenerator::visitDouble(LDouble*) { MOZ_CRASH(); } +void CodeGenerator::visitFloat32(LFloat32* ins) { MOZ_CRASH(); } +void CodeGenerator::visitValue(LValue* value) { MOZ_CRASH(); } +void CodeGenerator::visitWasmReinterpret(LWasmReinterpret* lir) { MOZ_CRASH(); } +void CodeGenerator::visitWasmReinterpretFromI64(LWasmReinterpretFromI64* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmReinterpretToI64(LWasmReinterpretToI64* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitRotateI64(LRotateI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitTestIAndBranch(LTestIAndBranch* test) { MOZ_CRASH(); } +void CodeGenerator::visitTestI64AndBranch(LTestI64AndBranch* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitTestDAndBranch(LTestDAndBranch* test) { MOZ_CRASH(); } +void CodeGenerator::visitTestFAndBranch(LTestFAndBranch* test) { MOZ_CRASH(); } +void CodeGenerator::visitCompare(LCompare* comp) { MOZ_CRASH(); } +void CodeGenerator::visitCompareI64(LCompareI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitCompareI64AndBranch(LCompareI64AndBranch* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitCompareAndBranch(LCompareAndBranch* comp) { + MOZ_CRASH(); +} +void CodeGenerator::visitCompareD(LCompareD* comp) { MOZ_CRASH(); } +void CodeGenerator::visitCompareF(LCompareF* comp) { MOZ_CRASH(); } +void CodeGenerator::visitCompareDAndBranch(LCompareDAndBranch* comp) { + MOZ_CRASH(); +} +void CodeGenerator::visitCompareFAndBranch(LCompareFAndBranch* comp) { + MOZ_CRASH(); +} +void CodeGenerator::visitBitAndAndBranch(LBitAndAndBranch* lir) { MOZ_CRASH(); } +void CodeGenerator::visitNotI(LNotI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitNotI64(LNotI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitNotD(LNotD* ins) { MOZ_CRASH(); } +void CodeGenerator::visitNotF(LNotF* ins) { MOZ_CRASH(); } +void CodeGenerator::visitBitNotI(LBitNotI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitBitNotI64(LBitNotI64* ins) { MOZ_CRASH(); } +void CodeGenerator::visitBitOpI(LBitOpI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitBitOpI64(LBitOpI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitShiftI(LShiftI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitShiftI64(LShiftI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitSignExtendInt64(LSignExtendInt64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitUrshD(LUrshD* ins) { MOZ_CRASH(); } +void CodeGenerator::visitMinMaxD(LMinMaxD* ins) { MOZ_CRASH(); } +void CodeGenerator::visitMinMaxF(LMinMaxF* ins) { MOZ_CRASH(); } +void CodeGenerator::visitNegI(LNegI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitNegI64(LNegI64* ins) { MOZ_CRASH(); } +void CodeGenerator::visitNegD(LNegD* ins) { MOZ_CRASH(); } +void CodeGenerator::visitNegF(LNegF* ins) { MOZ_CRASH(); } +void CodeGenerator::visitCopySignD(LCopySignD* ins) { MOZ_CRASH(); } +void CodeGenerator::visitCopySignF(LCopySignF* ins) { MOZ_CRASH(); } +void CodeGenerator::visitClzI(LClzI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitClzI64(LClzI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitCtzI(LCtzI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitCtzI64(LCtzI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitPopcntI(LPopcntI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitPopcntI64(LPopcntI64* ins) { MOZ_CRASH(); } +void CodeGenerator::visitAddI(LAddI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitAddI64(LAddI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitSubI(LSubI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitSubI64(LSubI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitMulI64(LMulI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitMathD(LMathD* math) { MOZ_CRASH(); } +void CodeGenerator::visitMathF(LMathF* math) { MOZ_CRASH(); } +void CodeGenerator::visitTruncateDToInt32(LTruncateDToInt32* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmBuiltinTruncateDToInt32( + LWasmBuiltinTruncateDToInt32* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitTruncateFToInt32(LTruncateFToInt32* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmBuiltinTruncateFToInt32( + LWasmBuiltinTruncateFToInt32* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmTruncateToInt32(LWasmTruncateToInt32* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitWrapInt64ToInt32(LWrapInt64ToInt32* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitExtendInt32ToInt64(LExtendInt32ToInt64* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitPowHalfD(LPowHalfD* ins) { MOZ_CRASH(); } +void CodeGenerator::visitCompareExchangeTypedArrayElement( + LCompareExchangeTypedArrayElement* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitAtomicExchangeTypedArrayElement( + LAtomicExchangeTypedArrayElement* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitAtomicTypedArrayElementBinop64( + LAtomicTypedArrayElementBinop64* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitAtomicTypedArrayElementBinopForEffect64( + LAtomicTypedArrayElementBinopForEffect64* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitAtomicLoad64(LAtomicLoad64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitAtomicStore64(LAtomicStore64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitCompareExchangeTypedArrayElement64( + LCompareExchangeTypedArrayElement64* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitAtomicExchangeTypedArrayElement64( + LAtomicExchangeTypedArrayElement64* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitEffectiveAddress(LEffectiveAddress* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitNearbyInt(LNearbyInt*) { MOZ_CRASH(); } +void CodeGenerator::visitNearbyIntF(LNearbyIntF*) { MOZ_CRASH(); } +void CodeGenerator::visitWasmSelectI64(LWasmSelectI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitWasmCompareAndSelect(LWasmCompareAndSelect* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmAddOffset(LWasmAddOffset* lir) { MOZ_CRASH(); } +void CodeGenerator::visitWasmAddOffset64(LWasmAddOffset64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitWasmExtendU32Index(LWasmExtendU32Index* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmWrapU32Index(LWasmWrapU32Index* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitAtomicTypedArrayElementBinop( + LAtomicTypedArrayElementBinop* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitAtomicTypedArrayElementBinopForEffect( + LAtomicTypedArrayElementBinopForEffect* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmSelect(LWasmSelect* ins) { MOZ_CRASH(); } +void CodeGenerator::visitWasmHeapBase(LWasmHeapBase* ins) { MOZ_CRASH(); } +void CodeGenerator::visitWasmLoad(LWasmLoad* lir) { MOZ_CRASH(); } +void CodeGenerator::visitWasmLoadI64(LWasmLoadI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitWasmStore(LWasmStore* lir) { MOZ_CRASH(); } +void CodeGenerator::visitWasmStoreI64(LWasmStoreI64* lir) { MOZ_CRASH(); } +void CodeGenerator::visitAsmJSLoadHeap(LAsmJSLoadHeap* ins) { MOZ_CRASH(); } +void CodeGenerator::visitAsmJSStoreHeap(LAsmJSStoreHeap* ins) { MOZ_CRASH(); } +void CodeGenerator::visitWasmCompareExchangeHeap( + LWasmCompareExchangeHeap* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmAtomicExchangeHeap(LWasmAtomicExchangeHeap* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmAtomicBinopHeap(LWasmAtomicBinopHeap* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmAtomicBinopHeapForEffect( + LWasmAtomicBinopHeapForEffect* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmStackArg(LWasmStackArg* ins) { MOZ_CRASH(); } +void CodeGenerator::visitWasmStackArgI64(LWasmStackArgI64* ins) { MOZ_CRASH(); } +void CodeGenerator::visitMemoryBarrier(LMemoryBarrier* ins) { MOZ_CRASH(); } +void CodeGenerator::visitSimd128(LSimd128* ins) { MOZ_CRASH(); } +void CodeGenerator::visitWasmTernarySimd128(LWasmTernarySimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmBinarySimd128(LWasmBinarySimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmBinarySimd128WithConstant( + LWasmBinarySimd128WithConstant* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmVariableShiftSimd128( + LWasmVariableShiftSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmConstantShiftSimd128( + LWasmConstantShiftSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmSignReplicationSimd128( + LWasmSignReplicationSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmShuffleSimd128(LWasmShuffleSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmPermuteSimd128(LWasmPermuteSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmReplaceLaneSimd128(LWasmReplaceLaneSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmReplaceInt64LaneSimd128( + LWasmReplaceInt64LaneSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmScalarToSimd128(LWasmScalarToSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmInt64ToSimd128(LWasmInt64ToSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmUnarySimd128(LWasmUnarySimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmReduceSimd128(LWasmReduceSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmReduceAndBranchSimd128( + LWasmReduceAndBranchSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmReduceSimd128ToInt64( + LWasmReduceSimd128ToInt64* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmLoadLaneSimd128(LWasmLoadLaneSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmStoreLaneSimd128(LWasmStoreLaneSimd128* ins) { + MOZ_CRASH(); +} +void CodeGenerator::visitUnbox(LUnbox* unbox) { MOZ_CRASH(); } +void CodeGenerator::visitWasmUint32ToDouble(LWasmUint32ToDouble* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitWasmUint32ToFloat32(LWasmUint32ToFloat32* lir) { + MOZ_CRASH(); +} +void CodeGenerator::visitDivI(LDivI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitModI(LModI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitDivPowTwoI(LDivPowTwoI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitModPowTwoI(LModPowTwoI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitMulI(LMulI* ins) { MOZ_CRASH(); } +void CodeGenerator::visitBox(LBox* box) { MOZ_CRASH(); } diff --git a/js/src/jit/wasm32/CodeGenerator-wasm32.h b/js/src/jit/wasm32/CodeGenerator-wasm32.h new file mode 100644 index 0000000000..26d4adf982 --- /dev/null +++ b/js/src/jit/wasm32/CodeGenerator-wasm32.h @@ -0,0 +1,76 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_CodeGenerator_wasm32_h +#define jit_wasm32_CodeGenerator_wasm32_h + +#include "jit/shared/CodeGenerator-shared.h" + +namespace js::jit { + +class CodeGeneratorWasm32 : public CodeGeneratorShared { + protected: + CodeGeneratorWasm32(MIRGenerator* gen, LIRGraph* graph, MacroAssembler* masm) + : CodeGeneratorShared(gen, graph, masm) { + MOZ_CRASH(); + } + + MoveOperand toMoveOperand(LAllocation) const { MOZ_CRASH(); } + template + void bailoutCmp32(Assembler::Condition, T1, T2, LSnapshot*) { + MOZ_CRASH(); + } + template + void bailoutTest32(Assembler::Condition, T1, T2, LSnapshot*) { + MOZ_CRASH(); + } + template + void bailoutCmpPtr(Assembler::Condition, T1, T2, LSnapshot*) { + MOZ_CRASH(); + } + void bailoutTestPtr(Assembler::Condition, Register, Register, LSnapshot*) { + MOZ_CRASH(); + } + void bailoutIfFalseBool(Register, LSnapshot*) { MOZ_CRASH(); } + void bailoutFrom(Label*, LSnapshot*) { MOZ_CRASH(); } + void bailout(LSnapshot*) { MOZ_CRASH(); } + void bailoutIf(Assembler::Condition, LSnapshot*) { MOZ_CRASH(); } + bool generateOutOfLineCode() { MOZ_CRASH(); } + void testNullEmitBranch(Assembler::Condition, ValueOperand, MBasicBlock*, + MBasicBlock*) { + MOZ_CRASH(); + } + void testUndefinedEmitBranch(Assembler::Condition, ValueOperand, MBasicBlock*, + MBasicBlock*) { + MOZ_CRASH(); + } + void testObjectEmitBranch(Assembler::Condition, ValueOperand, MBasicBlock*, + MBasicBlock*) { + MOZ_CRASH(); + } + void testZeroEmitBranch(Assembler::Condition, Register, MBasicBlock*, + MBasicBlock*) { + MOZ_CRASH(); + } + void emitTableSwitchDispatch(MTableSwitch*, Register, Register) { + MOZ_CRASH(); + } + void emitBigIntDiv(LBigIntDiv*, Register, Register, Register, Label*) { + MOZ_CRASH(); + } + void emitBigIntMod(LBigIntMod*, Register, Register, Register, Label*) { + MOZ_CRASH(); + } + ValueOperand ToValue(LInstruction*, size_t) { MOZ_CRASH(); } + ValueOperand ToTempValue(LInstruction*, size_t) { MOZ_CRASH(); } + void generateInvalidateEpilogue() { MOZ_CRASH(); } +}; + +typedef CodeGeneratorWasm32 CodeGeneratorSpecific; + +} // namespace js::jit + +#endif /* jit_wasm32_CodeGenerator_wasm32_h */ diff --git a/js/src/jit/wasm32/LIR-wasm32.h b/js/src/jit/wasm32/LIR-wasm32.h new file mode 100644 index 0000000000..8943d89143 --- /dev/null +++ b/js/src/jit/wasm32/LIR-wasm32.h @@ -0,0 +1,109 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_LIR_wasm32_h +#define jit_wasm32_LIR_wasm32_h + +namespace js::jit { + +class LUnboxFloatingPoint : public LInstruction { + public: + LIR_HEADER(UnboxFloatingPoint) + static const size_t Input = 0; + + MUnbox* mir() const { MOZ_CRASH(); } + + const LDefinition* output() const { MOZ_CRASH(); } + MIRType type() const { MOZ_CRASH(); } +}; + +class LTableSwitch : public LInstruction { + public: + LIR_HEADER(TableSwitch) + MTableSwitch* mir() { MOZ_CRASH(); } + + const LAllocation* index() { MOZ_CRASH(); } + const LDefinition* tempInt() { MOZ_CRASH(); } + const LDefinition* tempPointer() { MOZ_CRASH(); } +}; + +class LTableSwitchV : public LInstruction { + public: + LIR_HEADER(TableSwitchV) + MTableSwitch* mir() { MOZ_CRASH(); } + + const LDefinition* tempInt() { MOZ_CRASH(); } + const LDefinition* tempFloat() { MOZ_CRASH(); } + const LDefinition* tempPointer() { MOZ_CRASH(); } + + static const size_t InputValue = 0; +}; + +class LWasmUint32ToFloat32 : public LInstructionHelper<1, 1, 0> { + public: + explicit LWasmUint32ToFloat32(const LAllocation&) + : LInstructionHelper(Opcode::Invalid) { + MOZ_CRASH(); + } +}; + +class LUnbox : public LInstructionHelper<1, 2, 0> { + public: + MUnbox* mir() const { MOZ_CRASH(); } + const LAllocation* payload() { MOZ_CRASH(); } + const LAllocation* type() { MOZ_CRASH(); } + const char* extraName() const { MOZ_CRASH(); } +}; +class LDivI : public LBinaryMath<1> { + public: + LDivI(const LAllocation&, const LAllocation&, const LDefinition&) + : LBinaryMath(Opcode::Invalid) { + MOZ_CRASH(); + } + MDiv* mir() const { MOZ_CRASH(); } +}; +class LDivPowTwoI : public LInstructionHelper<1, 1, 0> { + public: + LDivPowTwoI(const LAllocation&, int32_t) + : LInstructionHelper(Opcode::Invalid) { + MOZ_CRASH(); + } + const LAllocation* numerator() { MOZ_CRASH(); } + int32_t shift() { MOZ_CRASH(); } + MDiv* mir() const { MOZ_CRASH(); } +}; +class LModI : public LBinaryMath<1> { + public: + LModI(const LAllocation&, const LAllocation&, const LDefinition&) + : LBinaryMath(Opcode::Invalid) { + MOZ_CRASH(); + } + + const LDefinition* callTemp() { MOZ_CRASH(); } + MMod* mir() const { MOZ_CRASH(); } +}; +class LWasmUint32ToDouble : public LInstructionHelper<1, 1, 0> { + public: + explicit LWasmUint32ToDouble(const LAllocation&) + : LInstructionHelper(Opcode::Invalid) { + MOZ_CRASH(); + } +}; +class LModPowTwoI : public LInstructionHelper<1, 1, 0> { + public: + int32_t shift() { MOZ_CRASH(); } + LModPowTwoI(const LAllocation& lhs, int32_t shift) + : LInstructionHelper(Opcode::Invalid) { + MOZ_CRASH(); + } + MMod* mir() const { MOZ_CRASH(); } +}; + +class LMulI : public LInstruction {}; + +} // namespace js::jit + +#endif /* jit_wasm32_LIR_wasm32_h */ diff --git a/js/src/jit/wasm32/Lowering-wasm32.h b/js/src/jit/wasm32/Lowering-wasm32.h new file mode 100644 index 0000000000..3a0aab364a --- /dev/null +++ b/js/src/jit/wasm32/Lowering-wasm32.h @@ -0,0 +1,128 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_Lowering_wasm32_h +#define jit_wasm32_Lowering_wasm32_h + +#include "jit/shared/Lowering-shared.h" + +namespace js::jit { + +class LIRGeneratorWasm32 : public LIRGeneratorShared { + protected: + LIRGeneratorWasm32(MIRGenerator* gen, MIRGraph& graph, LIRGraph& lirGraph) + : LIRGeneratorShared(gen, graph, lirGraph) { + MOZ_CRASH(); + } + + LBoxAllocation useBoxFixed(MDefinition*, Register, Register, + bool useAtStart = false) { + MOZ_CRASH(); + } + + LAllocation useByteOpRegister(MDefinition*) { MOZ_CRASH(); } + LAllocation useByteOpRegisterAtStart(MDefinition*) { MOZ_CRASH(); } + LAllocation useByteOpRegisterOrNonDoubleConstant(MDefinition*) { + MOZ_CRASH(); + } + LDefinition tempByteOpRegister() { MOZ_CRASH(); } + LDefinition tempToUnbox() { MOZ_CRASH(); } + bool needTempForPostBarrier() { MOZ_CRASH(); } + void lowerUntypedPhiInput(MPhi*, uint32_t, LBlock*, size_t) { MOZ_CRASH(); } + void lowerInt64PhiInput(MPhi*, uint32_t, LBlock*, size_t) { MOZ_CRASH(); } + void defineInt64Phi(MPhi*, size_t) { MOZ_CRASH(); } + void lowerForShift(LInstructionHelper<1, 2, 0>*, MDefinition*, MDefinition*, + MDefinition*) { + MOZ_CRASH(); + } + void lowerUrshD(MUrsh*) { MOZ_CRASH(); } + void lowerPowOfTwoI(MPow*) { MOZ_CRASH(); } + template + void lowerForALU(T, MDefinition*, MDefinition*, MDefinition* v = nullptr) { + MOZ_CRASH(); + } + template + void lowerForFPU(T, MDefinition*, MDefinition*, MDefinition* v = nullptr) { + MOZ_CRASH(); + } + template + void lowerForALUInt64(T, MDefinition*, MDefinition*, + MDefinition* v = nullptr) { + MOZ_CRASH(); + } + void lowerForMulInt64(LMulI64*, MMul*, MDefinition*, + MDefinition* v = nullptr) { + MOZ_CRASH(); + } + template + void lowerForShiftInt64(T, MDefinition*, MDefinition*, + MDefinition* v = nullptr) { + MOZ_CRASH(); + } + void lowerForBitAndAndBranch(LBitAndAndBranch*, MInstruction*, MDefinition*, + MDefinition*) { + MOZ_CRASH(); + } + void lowerForCompareI64AndBranch(MTest*, MCompare*, JSOp, MDefinition*, + MDefinition*, MBasicBlock*, MBasicBlock*) { + MOZ_CRASH(); + } + + void lowerConstantDouble(double, MInstruction*) { MOZ_CRASH(); } + void lowerConstantFloat32(float, MInstruction*) { MOZ_CRASH(); } + void lowerTruncateDToInt32(MTruncateToInt32*) { MOZ_CRASH(); } + void lowerTruncateFToInt32(MTruncateToInt32*) { MOZ_CRASH(); } + void lowerBuiltinInt64ToFloatingPoint(MBuiltinInt64ToFloatingPoint* ins) { + MOZ_CRASH(); + } + void lowerWasmBuiltinTruncateToInt64(MWasmBuiltinTruncateToInt64* ins) { + MOZ_CRASH(); + } + void lowerWasmBuiltinTruncateToInt32(MWasmBuiltinTruncateToInt32* ins) { + MOZ_CRASH(); + } + void lowerDivI(MDiv*) { MOZ_CRASH(); } + void lowerModI(MMod*) { MOZ_CRASH(); } + void lowerDivI64(MDiv*) { MOZ_CRASH(); } + void lowerWasmBuiltinDivI64(MWasmBuiltinDivI64* div) { MOZ_CRASH(); } + void lowerModI64(MMod*) { MOZ_CRASH(); } + void lowerWasmBuiltinModI64(MWasmBuiltinModI64* mod) { MOZ_CRASH(); } + void lowerNegI(MInstruction*, MDefinition*) { MOZ_CRASH(); } + void lowerNegI64(MInstruction*, MDefinition*) { MOZ_CRASH(); } + void lowerMulI(MMul*, MDefinition*, MDefinition*) { MOZ_CRASH(); } + void lowerUDiv(MDiv*) { MOZ_CRASH(); } + void lowerUMod(MMod*) { MOZ_CRASH(); } + void lowerWasmSelectI(MWasmSelect* select) { MOZ_CRASH(); } + void lowerWasmSelectI64(MWasmSelect* select) { MOZ_CRASH(); } + void lowerWasmCompareAndSelect(MWasmSelect* ins, MDefinition* lhs, + MDefinition* rhs, MCompare::CompareType compTy, + JSOp jsop) { + MOZ_CRASH(); + } + bool canSpecializeWasmCompareAndSelect(MCompare::CompareType compTy, + MIRType insTy) { + MOZ_CRASH(); + } + + void lowerBigIntLsh(MBigIntLsh*) { MOZ_CRASH(); } + void lowerBigIntRsh(MBigIntRsh*) { MOZ_CRASH(); } + void lowerBigIntDiv(MBigIntDiv*) { MOZ_CRASH(); } + void lowerBigIntMod(MBigIntMod*) { MOZ_CRASH(); } + + void lowerAtomicLoad64(MLoadUnboxedScalar*) { MOZ_CRASH(); } + void lowerAtomicStore64(MStoreUnboxedScalar*) { MOZ_CRASH(); } + + LTableSwitch* newLTableSwitch(LAllocation, LDefinition, MTableSwitch*) { + MOZ_CRASH(); + } + LTableSwitchV* newLTableSwitchV(MTableSwitch*) { MOZ_CRASH(); } +}; + +typedef LIRGeneratorWasm32 LIRGeneratorSpecific; + +} // namespace js::jit + +#endif /* jit_wasm32_Lowering_wasm32_h */ diff --git a/js/src/jit/wasm32/MacroAssembler-wasm32-inl.h b/js/src/jit/wasm32/MacroAssembler-wasm32-inl.h new file mode 100644 index 0000000000..eca2a07a65 --- /dev/null +++ b/js/src/jit/wasm32/MacroAssembler-wasm32-inl.h @@ -0,0 +1,1176 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_MacroAssembler_wasm32_inl_h +#define jit_wasm32_MacroAssembler_wasm32_inl_h + +#include "jit/wasm32/MacroAssembler-wasm32.h" + +namespace js::jit { + +//{{{ check_macroassembler_style + +void MacroAssembler::move64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::move64(Register64 src, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::moveDoubleToGPR64(FloatRegister src, Register64 dest) { + MOZ_CRASH(); +} + +void MacroAssembler::moveGPR64ToDouble(Register64 src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::move64To32(Register64 src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::move32To64ZeroExtend(Register src, Register64 dest) { + MOZ_CRASH(); +} + +void MacroAssembler::move8To64SignExtend(Register src, Register64 dest) { + MOZ_CRASH(); +} + +void MacroAssembler::move16To64SignExtend(Register src, Register64 dest) { + MOZ_CRASH(); +} + +void MacroAssembler::move32To64SignExtend(Register src, Register64 dest) { + MOZ_CRASH(); +} + +void MacroAssembler::move32SignExtendToPtr(Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::move32ZeroExtendToPtr(Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::load32SignExtendToPtr(const Address& src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::notPtr(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::andPtr(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::andPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::and64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::or64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::xor64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::orPtr(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::orPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::and64(Register64 src, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::or64(Register64 src, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::xor64(Register64 src, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::xorPtr(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::xorPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::byteSwap64(Register64 reg) { MOZ_CRASH(); } + +void MacroAssembler::addPtr(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::addPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::addPtr(ImmWord imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::add64(Register64 src, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::add64(Imm32 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::add64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } + +CodeOffset MacroAssembler::sub32FromStackPtrWithPatch(Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::patchSub32FromStackPtr(CodeOffset offset, Imm32 imm) { + MOZ_CRASH(); +} + +void MacroAssembler::subPtr(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::subPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::sub64(Register64 src, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::sub64(Imm64 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::mulPtr(Register rhs, Register srcDest) { MOZ_CRASH(); } + +void MacroAssembler::mul64(Imm64 imm, const Register64& dest) { MOZ_CRASH(); } + +void MacroAssembler::mul64(const Register64& src, const Register64& dest, + const Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::mulBy3(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::inc64(AbsoluteAddress dest) { MOZ_CRASH(); } + +void MacroAssembler::neg64(Register64 reg) { MOZ_CRASH(); } + +void MacroAssembler::negPtr(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::lshiftPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::rshiftPtr(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::rshiftPtrArithmetic(Imm32 imm, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::lshift64(Imm32 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::rshift64(Imm32 imm, Register64 dest) { MOZ_CRASH(); } + +void MacroAssembler::rshift64Arithmetic(Imm32 imm, Register64 dest) { + MOZ_CRASH(); +} + +void MacroAssembler::lshiftPtr(Register shift, Register srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::rshiftPtr(Register shift, Register srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::lshift64(Register shift, Register64 srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::rshift64(Register shift, Register64 srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::rshift64Arithmetic(Register shift, Register64 srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::clz64(Register64 src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::ctz64(Register64 src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::popcnt64(Register64 src, Register64 dest, Register temp) { + MOZ_CRASH(); +} + +template +void MacroAssembler::cmpPtrSet(Condition cond, T1 lhs, T2 rhs, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::branchToComputedAddress(const BaseIndex& address) { + MOZ_CRASH(); +} + +void MacroAssembler::move8SignExtend(Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::move16SignExtend(Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::loadAbiReturnAddress(Register dest) { MOZ_CRASH(); } + +void MacroAssembler::not32(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::and32(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::and32(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::and32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } + +void MacroAssembler::and32(const Address& src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::or32(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::or32(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::or32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } + +void MacroAssembler::xor32(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::xor32(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::xor32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } + +void MacroAssembler::xor32(const Address& src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::byteSwap16SignExtend(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::byteSwap16ZeroExtend(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::byteSwap32(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::add32(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::add32(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::add32(Imm32 imm, const Address& dest) { MOZ_CRASH(); } + +void MacroAssembler::addFloat32(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::addDouble(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::sub32(const Address& src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::sub32(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::sub32(Imm32 imm, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::subFloat32(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::subDouble(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::mul32(Register rhs, Register srcDest) { MOZ_CRASH(); } + +void MacroAssembler::mul32(Imm32 imm, Register srcDest) { MOZ_CRASH(); } + +void MacroAssembler::mulHighUnsigned32(Imm32 imm, Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::mulFloat32(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::mulDouble(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::divFloat32(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::divDouble(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::neg32(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::negateFloat(FloatRegister reg) { MOZ_CRASH(); } + +void MacroAssembler::negateDouble(FloatRegister reg) { MOZ_CRASH(); } + +void MacroAssembler::abs32(Register src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::absFloat32(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::absDouble(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::sqrtDouble(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::lshift32(Imm32 shift, Register srcDest) { MOZ_CRASH(); } + +void MacroAssembler::rshift32(Imm32 shift, Register srcDest) { MOZ_CRASH(); } + +void MacroAssembler::rshift32Arithmetic(Imm32 shift, Register srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::rshift32Arithmetic(Register shift, Register srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::lshift32(Register shift, Register srcDest) { MOZ_CRASH(); } + +void MacroAssembler::rshift32(Register shift, Register srcDest) { MOZ_CRASH(); } + +void MacroAssembler::memoryBarrier(MemoryBarrierBits barrier) { MOZ_CRASH(); } + +void MacroAssembler::clampIntToUint8(Register reg) { MOZ_CRASH(); } + +template +void MacroAssembler::branchTest32(Condition cond, Register lhs, Register rhs, + L label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchTest32(Condition cond, Register lhs, Imm32 rhs, + L label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTest32(Condition cond, const Address& lhs, Imm32 rhh, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTest32(Condition cond, const AbsoluteAddress& lhs, + Imm32 rhs, Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchTestPtr(Condition cond, Register lhs, Register rhs, + L label) { + MOZ_CRASH(); +} +void MacroAssembler::branchTestPtr(Condition cond, Register lhs, Imm32 rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestPtr(Condition cond, const Address& lhs, + Imm32 rhs, Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchTest64(Condition cond, Register64 lhs, + Register64 rhs, Register temp, L label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestUndefined(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestInt32(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestDouble(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestNumber(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBoolean(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestString(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestSymbol(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBigInt(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestNull(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestObject(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestPrimitive(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestMagic(Condition cond, Register tag, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestUndefined(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestUndefined(Condition cond, + const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestInt32(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestInt32(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestInt32(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestDouble(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestDouble(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBoolean(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBoolean(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestString(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestString(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestSymbol(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestSymbol(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBigInt(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBigInt(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestNull(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestNull(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestNull(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestObject(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestObject(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestObject(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestGCThing(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestGCThing(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestGCThing(Condition cond, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestMagic(Condition cond, const Address& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestMagic(Condition cond, const BaseIndex& address, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestMagic(Condition cond, const Address& valaddr, + JSWhyMagic why, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestValue(Condition cond, const BaseIndex& lhs, + const ValueOperand& rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestDoubleTruthy(bool truthy, FloatRegister reg, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBooleanTruthy(bool truthy, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestStringTruthy(bool truthy, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBigIntTruthy(bool truthy, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::fallibleUnboxPtr(const ValueOperand& src, Register dest, + JSValueType type, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::fallibleUnboxPtr(const Address& src, Register dest, + JSValueType type, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::fallibleUnboxPtr(const BaseIndex& src, Register dest, + JSValueType type, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::cmpPtrMovePtr(Condition cond, Register lhs, Register rhs, + Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::cmpPtrMovePtr(Condition cond, Register lhs, + const Address& rhs, Register src, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::branch32(Condition cond, const BaseIndex& lhs, Imm32 rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch32(Condition cond, const AbsoluteAddress& lhs, + Imm32 rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch32(Condition cond, const Address& lhs, Register rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch32(Condition cond, const Address& lhs, Imm32 rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch32(Condition cond, const AbsoluteAddress& lhs, + Register rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch8(Condition cond, const Address& lhs, Imm32 rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch8(Condition cond, const BaseIndex& lhs, Register rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch16(Condition cond, const Address& lhs, Imm32 rhs, + Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branch32(Condition cond, Register lhs, Register rhs, + L label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branch32(Condition cond, Register lhs, Imm32 rhs, + L label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch32(Condition cond, wasm::SymbolicAddress lhs, + Imm32 rhs, Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchPtr(Condition cond, Register lhs, Register rhs, + L label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, Register lhs, Imm32 rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, Register lhs, ImmPtr rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, Register lhs, ImmGCPtr rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, Register lhs, ImmWord rhs, + Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchPtr(Condition cond, const Address& lhs, Register rhs, + L label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, const Address& lhs, ImmPtr rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, const Address& lhs, ImmGCPtr rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, const Address& lhs, ImmWord rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, const BaseIndex& lhs, + ImmWord rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, const BaseIndex& lhs, + Register rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, const AbsoluteAddress& lhs, + Register rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, const AbsoluteAddress& lhs, + ImmWord rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPtr(Condition cond, wasm::SymbolicAddress lhs, + Register rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchFloat(DoubleCondition cond, FloatRegister lhs, + FloatRegister rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchDouble(DoubleCondition cond, FloatRegister lhs, + FloatRegister rhs, Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchAdd32(Condition cond, T src, Register dest, + Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchSub32(Condition cond, T src, Register dest, + Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchMul32(Condition cond, T src, Register dest, + Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchRshift32(Condition cond, T src, Register dest, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchNeg32(Condition cond, Register reg, Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchAddPtr(Condition cond, T src, Register dest, + Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchSubPtr(Condition cond, T src, Register dest, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchMulPtr(Condition cond, Register src, Register dest, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::decBranchPtr(Condition cond, Register lhs, Imm32 rhs, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::spectreZeroRegister(Condition cond, Register scratch, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::spectreMovePtr(Condition cond, Register src, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::storeUncanonicalizedDouble(FloatRegister src, + const Address& dest) { + MOZ_CRASH(); +} + +void MacroAssembler::storeUncanonicalizedDouble(FloatRegister src, + const BaseIndex& dest) { + MOZ_CRASH(); +} + +void MacroAssembler::storeUncanonicalizedFloat32(FloatRegister src, + const Address& dest) { + MOZ_CRASH(); +} + +void MacroAssembler::storeUncanonicalizedFloat32(FloatRegister src, + const BaseIndex& dest) { + MOZ_CRASH(); +} + +void MacroAssembler::addPtr(Imm32 imm, const Address& dest) { MOZ_CRASH(); } + +void MacroAssembler::addPtr(const Address& src, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::subPtr(Register src, const Address& dest) { MOZ_CRASH(); } + +void MacroAssembler::subPtr(const Address& addr, Register dest) { MOZ_CRASH(); } + +void MacroAssembler::branchTruncateFloat32MaybeModUint32(FloatRegister src, + Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTruncateDoubleMaybeModUint32(FloatRegister src, + Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::test32MovePtr(Condition cond, const Address& addr, + Imm32 mask, Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::cmp32MovePtr(Condition cond, Register lhs, Imm32 rhs, + Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::test32LoadPtr(Condition cond, const Address& addr, + Imm32 mask, const Address& src, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::spectreBoundsCheck32(Register index, Register length, + Register maybeScratch, + Label* failure) { + MOZ_CRASH(); +} + +void MacroAssembler::spectreBoundsCheck32(Register index, const Address& length, + Register maybeScratch, + Label* failure) { + MOZ_CRASH(); +} + +void MacroAssembler::spectreBoundsCheckPtr(Register index, Register length, + Register maybeScratch, + Label* failure) { + MOZ_CRASH(); +} + +void MacroAssembler::spectreBoundsCheckPtr(Register index, + const Address& length, + Register maybeScratch, + Label* failure) { + MOZ_CRASH(); +} + +void MacroAssembler::cmp32LoadPtr(Condition cond, const Address& lhs, Imm32 rhs, + const Address& src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTruncateFloat32ToInt32(FloatRegister src, + Register dest, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTruncateDoubleToInt32(FloatRegister src, + Register dest, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::mulDoublePtr(ImmPtr imm, Register temp, + FloatRegister dest) { + MOZ_CRASH(); +} + +template +void MacroAssembler::cmp32Set(Condition cond, T1 lhs, T2 rhs, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::cmp64Set(Condition cond, Address lhs, Imm64 rhs, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestDouble(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestInt32Truthy(bool truthy, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestNumber(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestSymbol(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBigInt(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestBoolean(Condition cond, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchTestMagic(Condition cond, const ValueOperand& value, + L label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestString(Condition cond, const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::cmp32Move32(Condition cond, Register lhs, Register rhs, + Register src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::cmp32Move32(Condition cond, Register lhs, + const Address& rhs, Register src, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestUndefined(Condition cond, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchAdd64(Condition cond, Imm64 imm, Register64 dest, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::quotient32(Register rhs, Register srcDest, + bool isUnsigned) { + MOZ_CRASH(); +} + +void MacroAssembler::remainder32(Register rhs, Register srcDest, + bool isUnsigned) { + MOZ_CRASH(); +} + +void MacroAssembler::branch64(Condition cond, Register64 lhs, Imm64 val, + Label* success, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::branch64(Condition cond, Register64 lhs, Register64 rhs, + Label* success, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::branch64(Condition cond, const Address& lhs, Imm64 val, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch64(Condition cond, const Address& lhs, + Register64 rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branch64(Condition cond, const Address& lhs, + const Address& rhs, Register scratch, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::minFloat32(FloatRegister other, FloatRegister srcDest, + bool handleNaN) { + MOZ_CRASH(); +} + +void MacroAssembler::minDouble(FloatRegister other, FloatRegister srcDest, + bool handleNaN) { + MOZ_CRASH(); +} + +void MacroAssembler::maxFloat32(FloatRegister other, FloatRegister srcDest, + bool handleNaN) { + MOZ_CRASH(); +} + +void MacroAssembler::maxDouble(FloatRegister other, FloatRegister srcDest, + bool handleNaN) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateLeft(Imm32 count, Register input, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateLeft(Register count, Register input, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateLeft64(Imm32 count, Register64 input, + Register64 dest, Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateLeft64(Register count, Register64 input, + Register64 dest, Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateRight(Imm32 count, Register input, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateRight(Register count, Register input, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateRight64(Imm32 count, Register64 input, + Register64 dest, Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::rotateRight64(Register count, Register64 input, + Register64 dest, Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::flexibleLshift32(Register shift, Register srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::flexibleRshift32(Register shift, Register srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::flexibleRshift32Arithmetic(Register shift, + Register srcDest) { + MOZ_CRASH(); +} + +void MacroAssembler::branchPrivatePtr(Condition cond, const Address& lhs, + Register rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::clz32(Register src, Register dest, bool knownNotZero) { + MOZ_CRASH(); +} + +void MacroAssembler::ctz32(Register src, Register dest, bool knownNotZero) { + MOZ_CRASH(); +} + +void MacroAssembler::popcnt32(Register src, Register dest, Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::moveFloat32ToGPR(FloatRegister src, Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::moveGPRToFloat32(Register src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestPrimitive(Condition cond, + const ValueOperand& value, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::sqrtFloat32(FloatRegister src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::cmp16Set(Condition cond, Address lhs, Imm32 rhs, + Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::cmp8Set(Condition cond, Address lhs, Imm32 rhs, + Register dest) { + MOZ_CRASH(); +} + +template +void MacroAssembler::testNumberSet(Condition cond, const T& src, + Register dest) { + MOZ_CRASH(); +} + +template +void MacroAssembler::testBooleanSet(Condition cond, const T& src, + Register dest) { + MOZ_CRASH(); +} + +template +void MacroAssembler::testStringSet(Condition cond, const T& src, + Register dest) { + MOZ_CRASH(); +} + +template +void MacroAssembler::testSymbolSet(Condition cond, const T& src, + Register dest) { + MOZ_CRASH(); +} + +template +void MacroAssembler::testBigIntSet(Condition cond, const T& src, + Register dest) { + MOZ_CRASH(); +} + +template +void MacroAssembler::branchTestGCThingImpl(Condition cond, const T& t, + Label* label) { + MOZ_CRASH(); +} + +//}}} check_macroassembler_style + +} // namespace js::jit + +#endif /* jit_wasm32_MacroAssembler_wasm32_inl_h */ diff --git a/js/src/jit/wasm32/MacroAssembler-wasm32.cpp b/js/src/jit/wasm32/MacroAssembler-wasm32.cpp new file mode 100644 index 0000000000..fe82793499 --- /dev/null +++ b/js/src/jit/wasm32/MacroAssembler-wasm32.cpp @@ -0,0 +1,502 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "jit/wasm32/MacroAssembler-wasm32.h" + +namespace js::jit { + +void MacroAssembler::subFromStackPtr(Imm32 imm32) { MOZ_CRASH(); } + +//{{{ check_macroassembler_style + +void MacroAssembler::PushBoxed(FloatRegister reg) { MOZ_CRASH(); } + +void MacroAssembler::branchPtrInNurseryChunk(Condition cond, Register ptr, + Register temp, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::pushReturnAddress() { MOZ_CRASH(); } + +void MacroAssembler::popReturnAddress() { MOZ_CRASH(); } + +CodeOffset MacroAssembler::moveNearAddressWithPatch(Register dest) { + MOZ_CRASH(); +} + +void MacroAssembler::patchNearAddressMove(CodeLocationLabel loc, + CodeLocationLabel target) { + MOZ_CRASH(); +} + +size_t MacroAssembler::PushRegsInMaskSizeInBytes(LiveRegisterSet set) { + MOZ_CRASH(); + return 0; +} + +void MacroAssembler::PushRegsInMask(LiveRegisterSet set) { MOZ_CRASH(); } + +void MacroAssembler::PopRegsInMaskIgnore(LiveRegisterSet set, + LiveRegisterSet ignore) { + MOZ_CRASH(); +} + +void MacroAssembler::PopStackPtr() { MOZ_CRASH(); } + +void MacroAssembler::flexibleDivMod32(Register rhs, Register srcDest, + Register remOutput, bool isUnsigned, + const LiveRegisterSet& volatileLiveRegs) { + MOZ_CRASH(); +} + +void MacroAssembler::flexibleRemainder32( + Register rhs, Register srcDest, bool isUnsigned, + const LiveRegisterSet& volatileLiveRegs) { + MOZ_CRASH(); +} + +void MacroAssembler::storeRegsInMask(LiveRegisterSet set, Address dest, + Register scratch) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmBoundsCheck32(Condition cond, Register index, + Register boundsCheckLimit, Label* ok) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmBoundsCheck32(Condition cond, Register index, + Address boundsCheckLimit, Label* ok) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmBoundsCheck64(Condition cond, Register64 index, + Register64 boundsCheckLimit, Label* ok) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmBoundsCheck64(Condition cond, Register64 index, + Address boundsCheckLimit, Label* ok) { + MOZ_CRASH(); +} + +void MacroAssembler::oolWasmTruncateCheckF32ToI32(FloatRegister input, + Register output, + TruncFlags flags, + wasm::BytecodeOffset off, + Label* rejoin) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmTruncateDoubleToInt64( + FloatRegister input, Register64 output, bool isSaturating, Label* oolEntry, + Label* oolRejoin, FloatRegister tempDouble) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmTruncateDoubleToUInt64( + FloatRegister input, Register64 output, bool isSaturating, Label* oolEntry, + Label* oolRejoin, FloatRegister tempDouble) { + MOZ_CRASH(); +} + +void MacroAssembler::oolWasmTruncateCheckF64ToI64(FloatRegister input, + Register64 output, + TruncFlags flags, + wasm::BytecodeOffset off, + Label* rejoin) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmTruncateFloat32ToInt64( + FloatRegister input, Register64 output, bool isSaturating, Label* oolEntry, + Label* oolRejoin, FloatRegister tempDouble) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmTruncateFloat32ToUInt64( + FloatRegister input, Register64 output, bool isSaturating, Label* oolEntry, + Label* oolRejoin, FloatRegister tempDouble) { + MOZ_CRASH(); +} + +void MacroAssembler::oolWasmTruncateCheckF32ToI64(FloatRegister input, + Register64 output, + TruncFlags flags, + wasm::BytecodeOffset off, + Label* rejoin) { + MOZ_CRASH(); +} + +void MacroAssembler::oolWasmTruncateCheckF64ToI32(FloatRegister input, + Register output, + TruncFlags flags, + wasm::BytecodeOffset off, + Label* rejoin) { + MOZ_CRASH(); +} + +void MacroAssembler::convertUInt64ToFloat32(Register64 src, FloatRegister dest, + Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::convertInt64ToFloat32(Register64 src, FloatRegister dest) { + MOZ_CRASH(); +} + +bool MacroAssembler::convertUInt64ToDoubleNeedsTemp() { MOZ_CRASH(); } + +void MacroAssembler::convertUInt64ToDouble(Register64 src, FloatRegister dest, + Register temp) { + MOZ_CRASH(); +} + +void MacroAssembler::convertInt64ToDouble(Register64 src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::convertIntPtrToDouble(Register src, FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmAtomicLoad64(const wasm::MemoryAccessDesc& access, + const Address& mem, Register64 temp, + Register64 output) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmAtomicLoad64(const wasm::MemoryAccessDesc& access, + const BaseIndex& mem, Register64 temp, + Register64 output) { + MOZ_CRASH(); +} + +void MacroAssembler::patchNopToCall(uint8_t* call, uint8_t* target) { + MOZ_CRASH(); +} + +void MacroAssembler::patchCallToNop(uint8_t* call) { MOZ_CRASH(); } + +void MacroAssembler::patchCall(uint32_t callerOffset, uint32_t calleeOffset) { + MOZ_CRASH(); +} + +CodeOffset MacroAssembler::farJumpWithPatch() { + MOZ_CRASH(); + return CodeOffset(0); +} + +void MacroAssembler::patchFarJump(CodeOffset farJump, uint32_t targetOffset) { + MOZ_CRASH(); +} + +CodeOffset MacroAssembler::call(Register reg) { + MOZ_CRASH(); + return CodeOffset(0); +} + +CodeOffset MacroAssembler::call(Label* label) { + MOZ_CRASH(); + return CodeOffset(0); +} + +CodeOffset MacroAssembler::call(wasm::SymbolicAddress imm) { + MOZ_CRASH(); + return CodeOffset(0); +} + +CodeOffset MacroAssembler::callWithPatch() { + MOZ_CRASH(); + return CodeOffset(0); +} + +CodeOffset MacroAssembler::nopPatchableToCall() { + MOZ_CRASH(); + return CodeOffset(0); +} + +CodeOffset MacroAssembler::wasmTrapInstruction() { + MOZ_CRASH(); + return CodeOffset(0); +} + +template void MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, + MIRType valueType, + const Address& dest); + +template void MacroAssembler::storeUnboxedValue( + const ConstantOrRegister& value, MIRType valueType, + const BaseObjectElementIndex& dest); + +template +void MacroAssembler::storeUnboxedValue(const ConstantOrRegister& value, + MIRType valueType, const T& dest) { + MOZ_CRASH(); +} + +uint32_t MacroAssembler::pushFakeReturnAddress(Register scratch) { + MOZ_CRASH(); +} + +void MacroAssembler::Pop(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::Pop(FloatRegister t) { MOZ_CRASH(); } + +void MacroAssembler::Pop(const ValueOperand& val) { MOZ_CRASH(); } + +void MacroAssembler::Push(Register reg) { MOZ_CRASH(); } + +void MacroAssembler::Push(const Imm32 imm) { MOZ_CRASH(); } + +void MacroAssembler::Push(const ImmWord imm) { MOZ_CRASH(); } + +void MacroAssembler::Push(const ImmPtr imm) { MOZ_CRASH(); } + +void MacroAssembler::Push(const ImmGCPtr ptr) { MOZ_CRASH(); } + +void MacroAssembler::Push(FloatRegister reg) { MOZ_CRASH(); } + +void MacroAssembler::wasmTruncateFloat32ToInt32(FloatRegister input, + Register output, + bool isSaturating, + Label* oolEntry) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmTruncateFloat32ToUInt32(FloatRegister input, + Register output, + bool isSaturating, + Label* oolEntry) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmTruncateDoubleToUInt32(FloatRegister input, + Register output, + bool isSaturating, + Label* oolEntry) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmTruncateDoubleToInt32(FloatRegister input, + Register output, + bool isSaturating, + Label* oolEntry) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmAtomicExchange64(const wasm::MemoryAccessDesc& access, + const Address& mem, Register64 value, + Register64 output) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmAtomicExchange64(const wasm::MemoryAccessDesc& access, + const BaseIndex& mem, + Register64 value, Register64 output) { + MOZ_CRASH(); +} + +void MacroAssembler::speculationBarrier() { MOZ_CRASH(); } + +void MacroAssembler::shiftIndex32AndAdd(Register indexTemp32, int shift, + Register pointer) { + MOZ_CRASH(); +} + +void MacroAssembler::setupUnalignedABICall(Register scratch) { MOZ_CRASH(); } + +void MacroAssembler::enterFakeExitFrameForWasm(Register cxreg, Register scratch, + ExitFrameType type) { + MOZ_CRASH(); +} + +void MacroAssembler::floorFloat32ToInt32(FloatRegister src, Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::floorDoubleToInt32(FloatRegister src, Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::ceilFloat32ToInt32(FloatRegister src, Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::ceilDoubleToInt32(FloatRegister src, Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::roundFloat32ToInt32(FloatRegister src, Register dest, + FloatRegister temp, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::roundDoubleToInt32(FloatRegister src, Register dest, + FloatRegister temp, Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::truncFloat32ToInt32(FloatRegister src, Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::truncDoubleToInt32(FloatRegister src, Register dest, + Label* fail) { + MOZ_CRASH(); +} + +void MacroAssembler::nearbyIntDouble(RoundingMode mode, FloatRegister src, + FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::nearbyIntFloat32(RoundingMode mode, FloatRegister src, + FloatRegister dest) { + MOZ_CRASH(); +} + +void MacroAssembler::copySignDouble(FloatRegister lhs, FloatRegister rhs, + FloatRegister output) { + MOZ_CRASH(); +} + +void MacroAssembler::branchTestValue(Condition cond, const ValueOperand& lhs, + const Value& rhs, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchValueIsNurseryCell(Condition cond, + const Address& address, + Register temp, Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::branchValueIsNurseryCell(Condition cond, + ValueOperand value, Register temp, + Label* label) { + MOZ_CRASH(); +} + +void MacroAssembler::callWithABINoProfiler(Register fun, MoveOp::Type result) { + MOZ_CRASH(); +} + +void MacroAssembler::callWithABINoProfiler(const Address& fun, + MoveOp::Type result) { + MOZ_CRASH(); +} + +void MacroAssembler::call(const Address& addr) { MOZ_CRASH(); } + +void MacroAssembler::call(ImmWord imm) { MOZ_CRASH(); } + +void MacroAssembler::call(ImmPtr imm) { MOZ_CRASH(); } + +void MacroAssembler::call(JitCode* c) { MOZ_CRASH(); } + +void MacroAssembler::callWithABIPost(uint32_t stackAdjust, MoveOp::Type result, + bool callFromWasm) { + MOZ_CRASH(); +} + +void MacroAssembler::callWithABIPre(uint32_t* stackAdjust, bool callFromWasm) { + MOZ_CRASH(); +} + +void MacroAssembler::comment(const char* msg) { MOZ_CRASH(); } + +void MacroAssembler::flush() { MOZ_CRASH(); } + +void MacroAssembler::loadStoreBuffer(Register ptr, Register buffer) { + MOZ_CRASH(); +} + +void MacroAssembler::moveValue(const TypedOrValueRegister& src, + const ValueOperand& dest) { + MOZ_CRASH(); +} + +void MacroAssembler::moveValue(const ValueOperand& src, + const ValueOperand& dest) { + MOZ_CRASH(); +} + +void MacroAssembler::moveValue(const Value& src, const ValueOperand& dest) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmCompareExchange64(const wasm::MemoryAccessDesc& access, + const Address& mem, + Register64 expected, + Register64 replacement, + Register64 output) { + MOZ_CRASH(); +} + +void MacroAssembler::wasmCompareExchange64(const wasm::MemoryAccessDesc& access, + const BaseIndex& mem, + Register64 expected, + Register64 replacement, + Register64 output) { + MOZ_CRASH(); +} + +//}}} check_macroassembler_style + +void MacroAssemblerWasm32::executableCopy(void* buffer) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::jump(Label* label) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::writeCodePointer(CodeLabel* label) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::haltingAlign(size_t) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::nopAlign(size_t) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::checkStackAlignment() { MOZ_CRASH(); } + +uint32_t MacroAssemblerWasm32::currentOffset() { + MOZ_CRASH(); + return 0; +} + +void MacroAssemblerWasm32::nop() { MOZ_CRASH(); } + +void MacroAssemblerWasm32::breakpoint() { MOZ_CRASH(); } + +void MacroAssemblerWasm32::abiret() { MOZ_CRASH(); } + +void MacroAssemblerWasm32::ret() { MOZ_CRASH(); } + +CodeOffset MacroAssemblerWasm32::toggledJump(Label*) { MOZ_CRASH(); } + +CodeOffset MacroAssemblerWasm32::toggledCall(JitCode*, bool) { MOZ_CRASH(); } + +size_t MacroAssemblerWasm32::ToggledCallSize(uint8_t*) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::finish() { MOZ_CRASH(); } + +void MacroAssemblerWasm32::pushValue(ValueOperand val) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::popValue(ValueOperand) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::tagValue(JSValueType, Register, ValueOperand) { + MOZ_CRASH(); +} + +void MacroAssemblerWasm32::retn(Imm32 n) { MOZ_CRASH(); } + +void MacroAssemblerWasm32::push(Register reg) { MOZ_CRASH(); } + +Address MacroAssemblerWasm32::ToType(const Address& address) { MOZ_CRASH(); } + +} // namespace js::jit diff --git a/js/src/jit/wasm32/MacroAssembler-wasm32.h b/js/src/jit/wasm32/MacroAssembler-wasm32.h new file mode 100644 index 0000000000..e876cfff1e --- /dev/null +++ b/js/src/jit/wasm32/MacroAssembler-wasm32.h @@ -0,0 +1,528 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_MacroAssembler_wasm32_h +#define jit_wasm32_MacroAssembler_wasm32_h + +#include "jit/wasm32/Assembler-wasm32.h" + +namespace js::jit { + +class CompactBufferReader; + +class ScratchTagScope { + public: + ScratchTagScope(MacroAssembler&, const ValueOperand) {} + operator Register() { MOZ_CRASH(); } + void release() { MOZ_CRASH(); } + void reacquire() { MOZ_CRASH(); } +}; + +class ScratchTagScopeRelease { + public: + explicit ScratchTagScopeRelease(ScratchTagScope*) {} +}; + +class MacroAssemblerWasm32 : public Assembler { + public: + size_t size() const { return bytesNeeded(); } + + size_t bytesNeeded() const { MOZ_CRASH(); } + + size_t jumpRelocationTableBytes() const { MOZ_CRASH(); } + + size_t dataRelocationTableBytes() const { MOZ_CRASH(); } + + size_t preBarrierTableBytes() const { MOZ_CRASH(); } + + size_t numCodeLabels() const { MOZ_CRASH(); } + CodeLabel codeLabel(size_t) { MOZ_CRASH(); } + + bool reserve(size_t size) { MOZ_CRASH(); } + bool appendRawCode(const uint8_t* code, size_t numBytes) { MOZ_CRASH(); } + bool swapBuffer(wasm::Bytes& bytes) { MOZ_CRASH(); } + + void assertNoGCThings() const { MOZ_CRASH(); } + + static void TraceJumpRelocations(JSTracer*, JitCode*, CompactBufferReader&) { + MOZ_CRASH(); + } + static void TraceDataRelocations(JSTracer*, JitCode*, CompactBufferReader&) { + MOZ_CRASH(); + } + + static bool SupportsFloatingPoint() { return true; } + static bool SupportsUnalignedAccesses() { return false; } + static bool SupportsFastUnalignedFPAccesses() { return false; } + + void executableCopy(void* buffer); + + void copyJumpRelocationTable(uint8_t*) { MOZ_CRASH(); } + + void copyDataRelocationTable(uint8_t*) { MOZ_CRASH(); } + + void copyPreBarrierTable(uint8_t*) { MOZ_CRASH(); } + + void processCodeLabels(uint8_t*) { MOZ_CRASH(); } + + void flushBuffer() { MOZ_CRASH(); } + + void bind(Label* label) { MOZ_CRASH(); } + + void bind(CodeLabel* label) { MOZ_CRASH(); } + + template + void j(Condition, T) { + MOZ_CRASH(); + } + + void jump(Label* label); + + void jump(JitCode* code) { MOZ_CRASH(); } + + void jump(Register reg) { MOZ_CRASH(); } + + void jump(const Address& address) { MOZ_CRASH(); } + + void jump(ImmPtr ptr) { MOZ_CRASH(); } + + void jump(TrampolinePtr code) { MOZ_CRASH(); } + + void writeCodePointer(CodeLabel* label); + + void haltingAlign(size_t); + + void nopAlign(size_t); + void checkStackAlignment(); + + uint32_t currentOffset(); + + void nop(); + + void breakpoint(); + + void abiret(); + void ret(); + + CodeOffset toggledJump(Label*); + CodeOffset toggledCall(JitCode*, bool); + static size_t ToggledCallSize(uint8_t*); + + void finish(); + + template + void moveValue(T, S) { + MOZ_CRASH(); + } + + template + void moveValue(T, S, U) { + MOZ_CRASH(); + } + + template + void storeValue(const T&, const S&) { + MOZ_CRASH(); + } + + template + void storeValue(T, S, U) { + MOZ_CRASH(); + } + + template + void storePrivateValue(const T&, const S&) { + MOZ_CRASH(); + } + + template + void loadValue(T, S) { + MOZ_CRASH(); + } + + template + void loadUnalignedValue(T, S) { + MOZ_CRASH(); + } + + template + void pushValue(const T&) { + MOZ_CRASH(); + } + + void pushValue(ValueOperand val); + + template + void pushValue(T, S) { + MOZ_CRASH(); + } + + void popValue(ValueOperand); + void tagValue(JSValueType, Register, ValueOperand); + void retn(Imm32 n); + + template + void push(const T&) { + MOZ_CRASH(); + } + + void push(Register reg); + + template + void Push(T) { + MOZ_CRASH(); + } + + template + void pop(T) { + MOZ_CRASH(); + } + + template + CodeOffset pushWithPatch(T) { + MOZ_CRASH(); + } + + void testNullSet(Condition, ValueOperand, Register) { MOZ_CRASH(); } + void testObjectSet(Condition, ValueOperand, Register) { MOZ_CRASH(); } + void testUndefinedSet(Condition, ValueOperand, Register) { MOZ_CRASH(); } + + template + void cmpPtrSet(Condition, T, S, Register) { + MOZ_CRASH(); + } + + template + void mov(T, Register) { + MOZ_CRASH(); + } + + template + void movePtr(T, Register) { + MOZ_CRASH(); + } + + void movePtr(Register src, Register dst) { MOZ_CRASH(); } + + template + void move32(const T&, Register) { + MOZ_CRASH(); + } + + template + void movq(T, S) { + MOZ_CRASH(); + } + + template + void moveFloat32(T, S) { + MOZ_CRASH(); + } + + template + void moveDouble(T, S) { + MOZ_CRASH(); + } + + template + void move64(T, S) { + MOZ_CRASH(); + } + + template + CodeOffset movWithPatch(T, Register) { + MOZ_CRASH(); + } + + template + void loadPtr(T, Register) { + MOZ_CRASH(); + } + + void loadPtr(const Address& address, Register dest) { MOZ_CRASH(); } + + template + void load32(T, Register) { + MOZ_CRASH(); + } + + template + void load32Unaligned(T, Register) { + MOZ_CRASH(); + } + + template + void loadFloat32(T, FloatRegister) { + MOZ_CRASH(); + } + + template + void loadDouble(T, FloatRegister) { + MOZ_CRASH(); + } + + template + void loadPrivate(T, Register) { + MOZ_CRASH(); + } + + template + void load8SignExtend(T, Register) { + MOZ_CRASH(); + } + + template + void load8ZeroExtend(T, Register) { + MOZ_CRASH(); + } + + template + void load16SignExtend(T, Register) { + MOZ_CRASH(); + } + + template + void load16UnalignedSignExtend(T, Register) { + MOZ_CRASH(); + } + + template + void load16ZeroExtend(T, Register) { + MOZ_CRASH(); + } + + template + void load16UnalignedZeroExtend(T, Register) { + MOZ_CRASH(); + } + + template + void load64(T, Register64) { + MOZ_CRASH(); + } + + template + void load64Unaligned(T, Register64) { + MOZ_CRASH(); + } + + template + void storePtr(const T&, S) { + MOZ_CRASH(); + } + + void storePtr(Register src, const Address& address) { MOZ_CRASH(); } + void storePtr(ImmPtr src, const Address& address) { MOZ_CRASH(); } + + template + void store32(T, S) { + MOZ_CRASH(); + } + + void store32(Imm32 src, const Address& address) { MOZ_CRASH(); } + + template + void store32Unaligned(T, S) { + MOZ_CRASH(); + } + + template + void storeFloat32(T, S) { + MOZ_CRASH(); + } + + template + void storeDouble(T, S) { + MOZ_CRASH(); + } + + template + void store8(T, S) { + MOZ_CRASH(); + } + + template + void store16(T, S) { + MOZ_CRASH(); + } + + template + void store16Unaligned(T, S) { + MOZ_CRASH(); + } + + template + void store64(T, S) { + MOZ_CRASH(); + } + + template + void store64Unaligned(T, S) { + MOZ_CRASH(); + } + + template + void computeEffectiveAddress(T, Register) { + MOZ_CRASH(); + } + + void splitTagForTest(ValueOperand, ScratchTagScope&) { MOZ_CRASH(); } + + void boxDouble(FloatRegister, ValueOperand, FloatRegister) { MOZ_CRASH(); } + void boxNonDouble(JSValueType, Register, ValueOperand) { MOZ_CRASH(); } + + template + void boxDouble(FloatRegister src, const T& dest) { + MOZ_CRASH(); + } + + template + void unboxInt32(T, Register) { + MOZ_CRASH(); + } + + template + void unboxBoolean(T, Register) { + MOZ_CRASH(); + } + + template + void unboxString(T, Register) { + MOZ_CRASH(); + } + + template + void unboxSymbol(T, Register) { + MOZ_CRASH(); + } + + template + void unboxBigInt(T, Register) { + MOZ_CRASH(); + } + + template + void unboxObject(T, Register) { + MOZ_CRASH(); + } + + void unboxObject(const Address& src, Register dest) { + unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT); + } + + template + void unboxDouble(T, FloatRegister) { + MOZ_CRASH(); + } + + void unboxValue(const ValueOperand&, AnyRegister, JSValueType) { + MOZ_CRASH(); + } + + void unboxNonDouble(const ValueOperand&, Register, JSValueType) { + MOZ_CRASH(); + } + + void unboxNonDouble(const Address& address, Register dest, JSValueType type) { + MOZ_CRASH(); + } + + template + void unboxGCThingForGCBarrier(const T&, Register) { + MOZ_CRASH(); + } + + template + void unboxObjectOrNull(const T& src, Register dest) { + MOZ_CRASH(); + } + + void notBoolean(ValueOperand) { MOZ_CRASH(); } + [[nodiscard]] Register extractObject(Address, Register) { MOZ_CRASH(); } + [[nodiscard]] Register extractObject(ValueOperand, Register) { MOZ_CRASH(); } + [[nodiscard]] Register extractSymbol(ValueOperand, Register) { MOZ_CRASH(); } + [[nodiscard]] Register extractInt32(ValueOperand, Register) { MOZ_CRASH(); } + [[nodiscard]] Register extractBoolean(ValueOperand, Register) { MOZ_CRASH(); } + + template + [[nodiscard]] Register extractTag(T, Register) { + MOZ_CRASH(); + } + + void convertFloat32ToInt32(FloatRegister, Register, Label*, bool v = true) { + MOZ_CRASH(); + } + void convertDoubleToInt32(FloatRegister, Register, Label*, bool v = true) { + MOZ_CRASH(); + } + void convertDoubleToPtr(FloatRegister, Register, Label*, bool v = true) { + MOZ_CRASH(); + } + void convertBoolToInt32(Register, Register) { MOZ_CRASH(); } + void convertDoubleToFloat32(FloatRegister, FloatRegister) { MOZ_CRASH(); } + void convertInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); } + + template + void convertInt32ToDouble(T, FloatRegister) { + MOZ_CRASH(); + } + + void convertFloat32ToDouble(FloatRegister, FloatRegister) { MOZ_CRASH(); } + + void boolValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); } + void boolValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); } + void int32ValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); } + void int32ValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); } + + void loadConstantDouble(double, FloatRegister) { MOZ_CRASH(); } + void loadConstantFloat32(float, FloatRegister) { MOZ_CRASH(); } + Condition testInt32Truthy(bool, ValueOperand) { MOZ_CRASH(); } + Condition testStringTruthy(bool, ValueOperand) { MOZ_CRASH(); } + Condition testBigIntTruthy(bool, ValueOperand) { MOZ_CRASH(); } + + template + void loadUnboxedValue(T, MIRType, AnyRegister) { + MOZ_CRASH(); + } + + template + void storeUnboxedPayload(ValueOperand value, T, size_t, JSValueType) { + MOZ_CRASH(); + } + + void convertUInt32ToDouble(Register, FloatRegister) { MOZ_CRASH(); } + void convertUInt32ToFloat32(Register, FloatRegister) { MOZ_CRASH(); } + void incrementInt32Value(Address) { MOZ_CRASH(); } + void ensureDouble(ValueOperand, FloatRegister, Label*) { MOZ_CRASH(); } + void handleFailureWithHandlerTail(Label*, Label*) { MOZ_CRASH(); } + + void buildFakeExitFrame(Register, uint32_t*) { MOZ_CRASH(); } + bool buildOOLFakeExitFrame(void*) { MOZ_CRASH(); } + + void setPrinter(Sprinter*) { MOZ_CRASH(); } + Operand ToPayload(Operand base) { MOZ_CRASH(); } + Address ToPayload(const Address& base) const { return base; } + + Register getStackPointer() const { return StackPointer; } + + // Instrumentation for entering and leaving the profiler. + void profilerEnterFrame(Register, Register) { MOZ_CRASH(); } + void profilerExitFrame() { MOZ_CRASH(); } + +#ifdef JS_NUNBOX32 + Address ToType(const Address& address); +#endif +}; + +typedef MacroAssemblerWasm32 MacroAssemblerSpecific; + +static inline bool GetTempRegForIntArg(uint32_t, uint32_t, Register*) { + MOZ_CRASH(); +} + +} // namespace js::jit + +#endif /* jit_wasm32_MacroAssembler_wasm32_h */ diff --git a/js/src/jit/wasm32/MoveEmitter-wasm32.h b/js/src/jit/wasm32/MoveEmitter-wasm32.h new file mode 100644 index 0000000000..01fc494dfd --- /dev/null +++ b/js/src/jit/wasm32/MoveEmitter-wasm32.h @@ -0,0 +1,30 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_MoveEmitter_wasm32_h +#define jit_wasm32_MoveEmitter_wasm32_h + +#include "mozilla/Assertions.h" + +namespace js::jit { + +class MacroAssemblerWasm32; +class MoveResolver; +struct Register; + +class MoveEmitterWasm32 { + public: + explicit MoveEmitterWasm32(MacroAssemblerWasm32&) { MOZ_CRASH(); } + void emit(const MoveResolver&) { MOZ_CRASH(); } + void finish() { MOZ_CRASH(); } + void setScratchRegister(Register) { MOZ_CRASH(); } +}; + +typedef MoveEmitterWasm32 MoveEmitter; + +} // namespace js::jit + +#endif /* jit_wasm32_MoveEmitter_wasm32_h */ diff --git a/js/src/jit/wasm32/SharedICHelpers-wasm32-inl.h b/js/src/jit/wasm32/SharedICHelpers-wasm32-inl.h new file mode 100644 index 0000000000..d4629dc93f --- /dev/null +++ b/js/src/jit/wasm32/SharedICHelpers-wasm32-inl.h @@ -0,0 +1,32 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_SharedICHelpers_wasm32_inl_h +#define jit_wasm32_SharedICHelpers_wasm32_inl_h + +#include "jit/SharedICHelpers.h" + +namespace js::jit { + +inline void EmitBaselineTailCallVM(TrampolinePtr, MacroAssembler&, uint32_t) { + MOZ_CRASH(); +} +inline void EmitBaselineCreateStubFrameDescriptor(MacroAssembler&, Register, + uint32_t) { + MOZ_CRASH(); +} +inline void EmitBaselineCallVM(TrampolinePtr, MacroAssembler&) { MOZ_CRASH(); } + +static const uint32_t STUB_FRAME_SIZE = 0; +static const uint32_t STUB_FRAME_SAVED_STUB_OFFSET = 0; + +inline void EmitBaselineEnterStubFrame(MacroAssembler&, Register) { + MOZ_CRASH(); +} + +} // namespace js::jit + +#endif /* jit_wasm32_SharedICHelpers_wasm32_inl_h */ diff --git a/js/src/jit/wasm32/SharedICHelpers-wasm32.h b/js/src/jit/wasm32/SharedICHelpers-wasm32.h new file mode 100644 index 0000000000..f45b085838 --- /dev/null +++ b/js/src/jit/wasm32/SharedICHelpers-wasm32.h @@ -0,0 +1,30 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_SharedICHelpers_wasm32_h +#define jit_wasm32_SharedICHelpers_wasm32_h + +namespace js::jit { + +static const size_t ICStackValueOffset = 0; + +inline void EmitRestoreTailCallReg(MacroAssembler&) { MOZ_CRASH(); } +inline void EmitRepushTailCallReg(MacroAssembler&) { MOZ_CRASH(); } +inline void EmitCallIC(MacroAssembler&, CodeOffset*) { MOZ_CRASH(); } +inline void EmitReturnFromIC(MacroAssembler&) { MOZ_CRASH(); } +inline void EmitBaselineLeaveStubFrame(MacroAssembler&, bool v = false) { + MOZ_CRASH(); +} +inline void EmitStubGuardFailure(MacroAssembler&) { MOZ_CRASH(); } + +template +inline void EmitPreBarrier(MacroAssembler&, T, MIRType) { + MOZ_CRASH(); +} + +} // namespace js::jit + +#endif /* jit_wasm32_SharedICHelpers_wasm32_h */ diff --git a/js/src/jit/wasm32/SharedICRegisters-wasm32.h b/js/src/jit/wasm32/SharedICRegisters-wasm32.h new file mode 100644 index 0000000000..23e43b2239 --- /dev/null +++ b/js/src/jit/wasm32/SharedICRegisters-wasm32.h @@ -0,0 +1,36 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef jit_wasm32_SharedICRegisters_wasm32_h +#define jit_wasm32_SharedICRegisters_wasm32_h + +#include "jit/Registers.h" +#include "jit/RegisterSets.h" +#include "jit/wasm32/MacroAssembler-wasm32.h" + +namespace js::jit { + +static constexpr Register BaselineStackReg = StackPointer; +static constexpr Register BaselineFrameReg = FramePointer; + +static constexpr ValueOperand R0 = JSReturnOperand; +static constexpr ValueOperand R1 = JSReturnOperand; +static constexpr ValueOperand R2 = JSReturnOperand; + +static constexpr Register ICTailCallReg{Registers::invalid_reg}; +static constexpr Register ICStubReg{Registers::invalid_reg}; + +static constexpr Register ExtractTemp0{Registers::invalid_reg}; +static constexpr Register ExtractTemp1{Registers::invalid_reg}; + +static constexpr FloatRegister FloatReg0 = {FloatRegisters::invalid_reg}; +static constexpr FloatRegister FloatReg1 = {FloatRegisters::invalid_reg}; +static constexpr FloatRegister FloatReg2 = {FloatRegisters::invalid_reg}; +static constexpr FloatRegister FloatReg3 = {FloatRegisters::invalid_reg}; + +} // namespace js::jit + +#endif /* jit_wasm32_SharedICRegisters_wasm32_h */ diff --git a/js/src/jit/wasm32/Trampoline-wasm32.cpp b/js/src/jit/wasm32/Trampoline-wasm32.cpp new file mode 100644 index 0000000000..7c4c4db348 --- /dev/null +++ b/js/src/jit/wasm32/Trampoline-wasm32.cpp @@ -0,0 +1,46 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "jit/Bailouts.h" +#include "jit/BaselineIC.h" +#include "jit/JitRuntime.h" +#include "vm/Realm.h" + +using namespace js; +using namespace js::jit; + +void JitRuntime::generateEnterJIT(JSContext*, MacroAssembler&) { MOZ_CRASH(); } + +// static +mozilla::Maybe<::JS::ProfilingFrameIterator::RegisterState> +JitRuntime::getCppEntryRegisters(JitFrameLayout* frameStackAddress) { + return mozilla::Nothing{}; +} + +void JitRuntime::generateInvalidator(MacroAssembler&, Label*) { MOZ_CRASH(); } + +void JitRuntime::generateArgumentsRectifier(MacroAssembler&, + ArgumentsRectifierKind kind) { + MOZ_CRASH(); +} + +void JitRuntime::generateBailoutHandler(MacroAssembler&, Label*) { + MOZ_CRASH(); +} + +uint32_t JitRuntime::generatePreBarrier(JSContext*, MacroAssembler&, MIRType) { + MOZ_CRASH(); + return 0; +} + +void JitRuntime::generateBailoutTailStub(MacroAssembler&, Label*) { + MOZ_CRASH(); +} + +bool JitRuntime::generateVMWrapper(JSContext*, MacroAssembler&, + const VMFunctionData&, DynFn, uint32_t*) { + MOZ_CRASH(); +} -- cgit v1.2.3