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/MacroAssembler-wasm32.h | 528 ++++++++++++++++++++++++++++++ 1 file changed, 528 insertions(+) create mode 100644 js/src/jit/wasm32/MacroAssembler-wasm32.h (limited to 'js/src/jit/wasm32/MacroAssembler-wasm32.h') 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 */ -- cgit v1.2.3