From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- js/src/jit/none/Architecture-none.h | 171 ++++++++++ js/src/jit/none/Assembler-none.h | 220 +++++++++++++ js/src/jit/none/CodeGenerator-none.h | 78 +++++ js/src/jit/none/LIR-none.h | 111 +++++++ js/src/jit/none/Lowering-none.h | 130 ++++++++ js/src/jit/none/MacroAssembler-none.h | 479 +++++++++++++++++++++++++++++ js/src/jit/none/MoveEmitter-none.h | 32 ++ js/src/jit/none/SharedICHelpers-none-inl.h | 31 ++ js/src/jit/none/SharedICHelpers-none.h | 32 ++ js/src/jit/none/SharedICRegisters-none.h | 32 ++ js/src/jit/none/Trampoline-none.cpp | 43 +++ 11 files changed, 1359 insertions(+) create mode 100644 js/src/jit/none/Architecture-none.h create mode 100644 js/src/jit/none/Assembler-none.h create mode 100644 js/src/jit/none/CodeGenerator-none.h create mode 100644 js/src/jit/none/LIR-none.h create mode 100644 js/src/jit/none/Lowering-none.h create mode 100644 js/src/jit/none/MacroAssembler-none.h create mode 100644 js/src/jit/none/MoveEmitter-none.h create mode 100644 js/src/jit/none/SharedICHelpers-none-inl.h create mode 100644 js/src/jit/none/SharedICHelpers-none.h create mode 100644 js/src/jit/none/SharedICRegisters-none.h create mode 100644 js/src/jit/none/Trampoline-none.cpp (limited to 'js/src/jit/none') diff --git a/js/src/jit/none/Architecture-none.h b/js/src/jit/none/Architecture-none.h new file mode 100644 index 0000000000..2433234fbf --- /dev/null +++ b/js/src/jit/none/Architecture-none.h @@ -0,0 +1,171 @@ +/* -*- 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_none_Architecture_none_h +#define jit_none_Architecture_none_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 { +namespace 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 { + r0 = 0, + 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 = invalid_reg; + static const Encoding Invalid = invalid_reg; + static const uint32_t Total = 1; + 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 jit +} // namespace js + +#endif /* jit_none_Architecture_none_h */ diff --git a/js/src/jit/none/Assembler-none.h b/js/src/jit/none/Assembler-none.h new file mode 100644 index 0000000000..4c16334703 --- /dev/null +++ b/js/src/jit/none/Assembler-none.h @@ -0,0 +1,220 @@ +/* -*- 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_none_Assembler_none_h +#define jit_none_Assembler_none_h + +#include "mozilla/Assertions.h" + +#include + +#include "jit/none/Architecture-none.h" +#include "jit/Registers.h" +#include "jit/RegisterSets.h" +#include "jit/shared/Assembler-shared.h" + +namespace js { +namespace jit { + +class MacroAssembler; + +static constexpr Register StackPointer{Registers::invalid_reg}; +static constexpr Register FramePointer{Registers::invalid_reg}; +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(InvalidReg, InvalidReg); +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 Register WasmTailCallInstanceScratchReg{ + Registers::invalid_reg}; +static constexpr Register WasmTailCallRAScratchReg{Registers::invalid_reg}; +static constexpr Register WasmTailCallFPScratchReg{Registers::invalid_reg}; + +static constexpr uint32_t ABIStackAlignment = 4; +static constexpr uint32_t CodeAlignment = 16; +#ifdef ENABLE_PORTABLE_BASELINE_INTERP +static constexpr uint32_t JitStackAlignment = sizeof(void*); +static constexpr uint32_t JitStackValueAlignment = 1; +#else +static constexpr uint32_t JitStackAlignment = 8; +static constexpr uint32_t JitStackValueAlignment = + JitStackAlignment / sizeof(Value); +#endif + +static const Scale ScalePointer = TimesOne; + +class Assembler : public AssemblerShared { + 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() { MOZ_CRASH(); } + ABIArg next(MIRType) { MOZ_CRASH(); } + ABIArg& current() { MOZ_CRASH(); } + uint32_t stackBytesConsumedSoFar() const { MOZ_CRASH(); } + void increaseStackOffset(uint32_t) { MOZ_CRASH(); } +}; + +} // namespace jit +} // namespace js + +#endif /* jit_none_Assembler_none_h */ diff --git a/js/src/jit/none/CodeGenerator-none.h b/js/src/jit/none/CodeGenerator-none.h new file mode 100644 index 0000000000..6efd71555e --- /dev/null +++ b/js/src/jit/none/CodeGenerator-none.h @@ -0,0 +1,78 @@ +/* -*- 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_none_CodeGenerator_none_h +#define jit_none_CodeGenerator_none_h + +#include "jit/shared/CodeGenerator-shared.h" + +namespace js { +namespace jit { + +class CodeGeneratorNone : public CodeGeneratorShared { + protected: + CodeGeneratorNone(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 CodeGeneratorNone CodeGeneratorSpecific; + +} // namespace jit +} // namespace js + +#endif /* jit_none_CodeGenerator_none_h */ diff --git a/js/src/jit/none/LIR-none.h b/js/src/jit/none/LIR-none.h new file mode 100644 index 0000000000..c04578630e --- /dev/null +++ b/js/src/jit/none/LIR-none.h @@ -0,0 +1,111 @@ +/* -*- 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_none_LIR_none_h +#define jit_none_LIR_none_h + +namespace js { +namespace 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 jit +} // namespace js + +#endif /* jit_none_LIR_none_h */ diff --git a/js/src/jit/none/Lowering-none.h b/js/src/jit/none/Lowering-none.h new file mode 100644 index 0000000000..ad804b970b --- /dev/null +++ b/js/src/jit/none/Lowering-none.h @@ -0,0 +1,130 @@ +/* -*- 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_none_Lowering_none_h +#define jit_none_Lowering_none_h + +#include "jit/shared/Lowering-shared.h" + +namespace js { +namespace jit { + +class LIRGeneratorNone : public LIRGeneratorShared { + protected: + LIRGeneratorNone(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 LIRGeneratorNone LIRGeneratorSpecific; + +} // namespace jit +} // namespace js + +#endif /* jit_none_Lowering_none_h */ diff --git a/js/src/jit/none/MacroAssembler-none.h b/js/src/jit/none/MacroAssembler-none.h new file mode 100644 index 0000000000..fb9e757631 --- /dev/null +++ b/js/src/jit/none/MacroAssembler-none.h @@ -0,0 +1,479 @@ +/* -*- 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_none_MacroAssembler_none_h +#define jit_none_MacroAssembler_none_h + +#include + +#include "jit/MoveResolver.h" +#include "jit/none/Assembler-none.h" +#include "wasm/WasmCodegenTypes.h" +#include "wasm/WasmTypeDecls.h" + +using js::wasm::FaultingCodeOffsetPair; + +namespace js { +namespace 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 MacroAssemblerNone : public Assembler { + public: + MacroAssemblerNone() { MOZ_CRASH(); } + + MoveResolver moveResolver_; + + size_t size() const { MOZ_CRASH(); } + 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 false; } + static bool SupportsUnalignedAccesses() { return false; } + static bool SupportsFastUnalignedFPAccesses() { return false; } + + void executableCopy(void*, bool = true) { MOZ_CRASH(); } + 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(); } + + template + void bind(T) { + MOZ_CRASH(); + } + template + void j(Condition, T) { + MOZ_CRASH(); + } + template + void jump(T) { + MOZ_CRASH(); + } + void writeCodePointer(CodeLabel* label) { MOZ_CRASH(); } + void haltingAlign(size_t) { MOZ_CRASH(); } + void nopAlign(size_t) { MOZ_CRASH(); } + void checkStackAlignment() { MOZ_CRASH(); } + uint32_t currentOffset() { MOZ_CRASH(); } + + void nop() { MOZ_CRASH(); } + void breakpoint() { MOZ_CRASH(); } + void abiret() { MOZ_CRASH(); } + void ret() { MOZ_CRASH(); } + + CodeOffset toggledJump(Label*) { MOZ_CRASH(); } + CodeOffset toggledCall(JitCode*, bool) { MOZ_CRASH(); } + static size_t ToggledCallSize(uint8_t*) { MOZ_CRASH(); } + + void finish() { MOZ_CRASH(); } + + 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(); + } + template + void pushValue(T, S) { + MOZ_CRASH(); + } + void popValue(ValueOperand) { MOZ_CRASH(); } + void tagValue(JSValueType, Register, ValueOperand) { MOZ_CRASH(); } + void retn(Imm32 n) { MOZ_CRASH(); } + template + void push(const T&) { + MOZ_CRASH(); + } + template + void Push(T) { + MOZ_CRASH(); + } + template + void pop(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(); + } + void cmp8Set(Condition, Address, Imm32, Register) { MOZ_CRASH(); } + void cmp16Set(Condition, Address, Imm32, Register) { MOZ_CRASH(); } + template + void cmp32Set(Condition, T, S, Register) { + MOZ_CRASH(); + } + void cmp64Set(Condition, Address, Imm64, Register) { MOZ_CRASH(); } + + template + void mov(T, Register) { + MOZ_CRASH(); + } + template + void movePtr(T, Register) { + 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 + FaultingCodeOffset loadPtr(T, Register) { + MOZ_CRASH(); + } + template + FaultingCodeOffset load32(T, Register) { + MOZ_CRASH(); + } + template + void load32Unaligned(T, Register) { + MOZ_CRASH(); + } + template + FaultingCodeOffset loadFloat32(T, FloatRegister) { + MOZ_CRASH(); + } + template + FaultingCodeOffset loadDouble(T, FloatRegister) { + MOZ_CRASH(); + } + template + void loadPrivate(T, Register) { + MOZ_CRASH(); + } + template + FaultingCodeOffset load8SignExtend(T, Register) { + MOZ_CRASH(); + } + template + FaultingCodeOffset load8ZeroExtend(T, Register) { + MOZ_CRASH(); + } + template + FaultingCodeOffset load16SignExtend(T, Register) { + MOZ_CRASH(); + } + template + void load16UnalignedSignExtend(T, Register) { + MOZ_CRASH(); + } + template + FaultingCodeOffset load16ZeroExtend(T, Register) { + MOZ_CRASH(); + } + template + void load16UnalignedZeroExtend(T, Register) { + MOZ_CRASH(); + } +#ifdef JS_64BIT + template + FaultingCodeOffset load64(T, Register64) { + MOZ_CRASH(); + } +#else + template + FaultingCodeOffsetPair load64(T, Register64) { + MOZ_CRASH(); + } +#endif + template + void load64Unaligned(T, Register64) { + MOZ_CRASH(); + } + + template + FaultingCodeOffset storePtr(const T&, S) { + MOZ_CRASH(); + } + template + FaultingCodeOffset store32(T, S) { + MOZ_CRASH(); + } + template + void store32Unaligned(T, S) { + MOZ_CRASH(); + } + template + void storeFloat32(T, S) { + MOZ_CRASH(); + } + template + void storeDouble(T, S) { + MOZ_CRASH(); + } + template + FaultingCodeOffset store8(T, S) { + MOZ_CRASH(); + } + template + FaultingCodeOffset store16(T, S) { + MOZ_CRASH(); + } + template + void store16Unaligned(T, S) { + MOZ_CRASH(); + } +#ifdef JS_64BIT + template + FaultingCodeOffset store64(T, S) { + MOZ_CRASH(); + } +#else + template + FaultingCodeOffsetPair store64(T, S) { + MOZ_CRASH(); + } +#endif + 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(); + } + 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&, Register, JSValueType) { MOZ_CRASH(); } + template + void unboxGCThingForGCBarrier(const T&, Register) { + MOZ_CRASH(); + } + + template + void unboxWasmAnyRefGCThingForGCBarrier(const T&, Register) { + MOZ_CRASH(); + } + + void getWasmAnyRefGCThingChunk(Register, 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 storeUnboxedValue(const ConstantOrRegister&, MIRType, T) { + 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(Address) { MOZ_CRASH(); } + + Register getStackPointer() const { MOZ_CRASH(); } + + // Instrumentation for entering and leaving the profiler. + void profilerEnterFrame(Register, Register) { MOZ_CRASH(); } + void profilerExitFrame() { MOZ_CRASH(); } + +#ifdef JS_NUNBOX32 + Address ToType(Address) { MOZ_CRASH(); } +#endif +}; + +typedef MacroAssemblerNone MacroAssemblerSpecific; + +static inline bool GetTempRegForIntArg(uint32_t, uint32_t, Register*) { + MOZ_CRASH(); +} + +} // namespace jit +} // namespace js + +#endif /* jit_none_MacroAssembler_none_h */ diff --git a/js/src/jit/none/MoveEmitter-none.h b/js/src/jit/none/MoveEmitter-none.h new file mode 100644 index 0000000000..39e60bfaee --- /dev/null +++ b/js/src/jit/none/MoveEmitter-none.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_none_MoveEmitter_none_h +#define jit_none_MoveEmitter_none_h + +#include "mozilla/Assertions.h" + +namespace js { +namespace jit { + +class MacroAssemblerNone; +class MoveResolver; +struct Register; + +class MoveEmitterNone { + public: + explicit MoveEmitterNone(MacroAssemblerNone&) { MOZ_CRASH(); } + void emit(const MoveResolver&) { MOZ_CRASH(); } + void finish() { MOZ_CRASH(); } + void setScratchRegister(Register) { MOZ_CRASH(); } +}; + +typedef MoveEmitterNone MoveEmitter; + +} // namespace jit +} // namespace js + +#endif /* jit_none_MoveEmitter_none_h */ diff --git a/js/src/jit/none/SharedICHelpers-none-inl.h b/js/src/jit/none/SharedICHelpers-none-inl.h new file mode 100644 index 0000000000..2d63956ba7 --- /dev/null +++ b/js/src/jit/none/SharedICHelpers-none-inl.h @@ -0,0 +1,31 @@ +/* -*- 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_none_SharedICHelpers_none_inl_h +#define jit_none_SharedICHelpers_none_inl_h + +#include "jit/SharedICHelpers.h" + +namespace js { +namespace 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(); } + +inline void EmitBaselineEnterStubFrame(MacroAssembler&, Register) { + MOZ_CRASH(); +} + +} // namespace jit +} // namespace js + +#endif /* jit_none_SharedICHelpers_none_inl_h */ diff --git a/js/src/jit/none/SharedICHelpers-none.h b/js/src/jit/none/SharedICHelpers-none.h new file mode 100644 index 0000000000..8c2b4ee396 --- /dev/null +++ b/js/src/jit/none/SharedICHelpers-none.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_none_SharedICHelpers_none_h +#define jit_none_SharedICHelpers_none_h + +namespace js { +namespace 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 jit +} // namespace js + +#endif /* jit_none_SharedICHelpers_none_h */ diff --git a/js/src/jit/none/SharedICRegisters-none.h b/js/src/jit/none/SharedICRegisters-none.h new file mode 100644 index 0000000000..170e5058a9 --- /dev/null +++ b/js/src/jit/none/SharedICRegisters-none.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_none_SharedICRegisters_none_h +#define jit_none_SharedICRegisters_none_h + +#include "jit/none/MacroAssembler-none.h" +#include "jit/Registers.h" +#include "jit/RegisterSets.h" + +namespace js { +namespace jit { + +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 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 jit +} // namespace js + +#endif /* jit_none_SharedICRegisters_none_h */ diff --git a/js/src/jit/none/Trampoline-none.cpp b/js/src/jit/none/Trampoline-none.cpp new file mode 100644 index 0000000000..33265a2341 --- /dev/null +++ b/js/src/jit/none/Trampoline-none.cpp @@ -0,0 +1,43 @@ +/* -*- 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; + +// This file includes stubs for generating the JIT trampolines when there is no +// JIT backend, and also includes implementations for assorted random things +// which can't be implemented in headers. + +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(); +} +void JitRuntime::generateBailoutTailStub(MacroAssembler&, Label*) { + MOZ_CRASH(); +} + +bool JitRuntime::generateVMWrapper(JSContext*, MacroAssembler&, VMFunctionId, + const VMFunctionData&, DynFn, uint32_t*) { + MOZ_CRASH(); +} -- cgit v1.2.3