Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 211 insertions, 0 deletions

diff --git a/js/src/jit/none/Assembler-none.h b/js/src/jit/none/Assembler-none.h
new file mode 100644
index 0000000000..b69fc462e2
--- /dev/null
+++ b/js/src/jit/none/Assembler-none.h
@@ -0,0 +1,211 @@
+/* -*- 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 <stdint.h>
+
+#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 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;
+
+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 <typename T, typename S>
+  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 */