Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 201 insertions, 0 deletions

diff --git a/js/src/wasm/WasmBCDefs.h b/js/src/wasm/WasmBCDefs.h
new file mode 100644
index 0000000000..d3bd547460
--- /dev/null
+++ b/js/src/wasm/WasmBCDefs.h
@@ -0,0 +1,201 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ *
+ * Copyright 2016 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This is an INTERNAL header for Wasm baseline compiler: common configuration
+// and simple definitions; all include directives.
+
+#ifndef wasm_wasm_baseline_defs_h
+#define wasm_wasm_baseline_defs_h
+
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ScopeExit.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "jit/AtomicOp.h"
+#include "jit/IonTypes.h"
+#include "jit/JitAllocPolicy.h"
+#include "jit/Label.h"
+#include "jit/RegisterAllocator.h"
+#include "jit/Registers.h"
+#include "jit/RegisterSets.h"
+#if defined(JS_CODEGEN_ARM)
+#  include "jit/arm/Assembler-arm.h"
+#endif
+#if defined(JS_CODEGEN_X64) || defined(JS_CODEGEN_X86)
+#  include "jit/x86-shared/Architecture-x86-shared.h"
+#  include "jit/x86-shared/Assembler-x86-shared.h"
+#endif
+#if defined(JS_CODEGEN_MIPS64)
+#  include "jit/mips-shared/Assembler-mips-shared.h"
+#  include "jit/mips64/Assembler-mips64.h"
+#endif
+#if defined(JS_CODEGEN_LOONG64)
+#  include "jit/loong64/Assembler-loong64.h"
+#endif
+#if defined(JS_CODEGEN_RISCV64)
+#  include "jit/riscv64/Assembler-riscv64.h"
+#endif
+#include "js/ScalarType.h"
+#include "util/Memory.h"
+#include "wasm/WasmCodegenTypes.h"
+#include "wasm/WasmDebugFrame.h"
+#include "wasm/WasmGC.h"
+#include "wasm/WasmGcObject.h"
+#include "wasm/WasmGenerator.h"
+#include "wasm/WasmInstance.h"
+#include "wasm/WasmOpIter.h"
+#include "wasm/WasmSignalHandlers.h"
+#include "wasm/WasmStubs.h"
+#include "wasm/WasmValidate.h"
+
+using mozilla::DebugOnly;
+using mozilla::FloorLog2;
+using mozilla::IsPowerOfTwo;
+using mozilla::Maybe;
+using mozilla::Nothing;
+using mozilla::Some;
+
+namespace js {
+namespace wasm {
+
+using HandleNaNSpecially = bool;
+using InvertBranch = bool;
+using IsKnownNotZero = bool;
+using IsUnsigned = bool;
+using IsRemainder = bool;
+using NeedsBoundsCheck = bool;
+using WantResult = bool;
+using ZeroOnOverflow = bool;
+
+class BaseStackFrame;
+
+// Two flags, useABI and restoreRegisterStateAndRealm, control how calls are
+// made.
+//
+// UseABI::Wasm implies that the Instance/Heap/Global registers are nonvolatile,
+// except when RestoreRegisterStateAndRealm::True is also set, when they are
+// volatile.
+//
+// UseABI::Builtin implies that the Instance/Heap/Global registers are volatile.
+// In this case, we require RestoreRegisterStateAndRealm::False.  The calling
+// convention is otherwise like UseABI::Wasm.
+//
+// UseABI::System implies that the Instance/Heap/Global registers are volatile.
+// Additionally, the parameter passing mechanism may be slightly different from
+// the UseABI::Wasm convention.
+//
+// When the Instance/Heap/Global registers are not volatile, the baseline
+// compiler will restore the Instance register from its save slot before the
+// call, since the baseline compiler uses the Instance register for other
+// things.
+//
+// When those registers are volatile, the baseline compiler will reload them
+// after the call (it will restore the Instance register from the save slot and
+// load the other two from the Instance data).
+
+enum class UseABI { Wasm, Builtin, System };
+enum class RestoreRegisterStateAndRealm { False = false, True = true };
+enum class RhsDestOp { True = true };
+
+// Compiler configuration.
+//
+// The following internal configuration #defines are used.  The configuration is
+// partly below in this file, partly in WasmBCRegDefs.h.
+//
+// RABALDR_PIN_INSTANCE
+//   InstanceReg is not allocatable and always holds the current Instance*,
+//   except in known contexts where it could have been clobbered, such as after
+//   certain calls.
+//
+// RABALDR_ZERO_EXTENDS
+//   The canonical representation of a 32-bit value in a 64-bit register is
+//   zero-extended.  For 64-bit platforms only.  See comment block "64-bit GPRs
+//   carrying 32-bit values" in MacroAssembler.h.
+//
+// RABALDR_CHUNKY_STACK
+//   The platform must allocate the CPU stack in chunks and not word-at-a-time
+//   due to SP alignment requirements (ARM64 for now).
+//
+// RABALDR_INT_DIV_I64_CALLOUT
+//   The platform calls out to the runtime to divide i64/u64.
+//
+// RABALDR_I64_TO_FLOAT_CALLOUT
+//   The platform calls out to the runtime for i64 -> fXX conversions.
+//
+// RABALDR_FLOAT_TO_I64_CALLOUT
+//   The platform calls out to the runtime for fXX -> i64 conversions.
+//
+// RABALDR_SCRATCH_<TypeName>
+//   The baseline compiler has its own scratch registers for the given type, it
+//   does not use the MacroAssembler's scratch.  This is really an anachronism -
+//   the baseline compiler should never use the MacroAssembler's scratches.
+//
+// RABALDR_SCRATCH_F32_ALIASES_F64
+//   On a platform where the baseline compiler has its own F32 and F64
+//   scratches, these are the same register.
+
+#ifdef JS_CODEGEN_X64
+#  define RABALDR_ZERO_EXTENDS
+#  define RABALDR_PIN_INSTANCE
+#endif
+
+#ifdef JS_CODEGEN_ARM64
+#  define RABALDR_CHUNKY_STACK
+#  define RABALDR_ZERO_EXTENDS
+#  define RABALDR_PIN_INSTANCE
+#endif
+
+#ifdef JS_CODEGEN_X86
+#  define RABALDR_INT_DIV_I64_CALLOUT
+#endif
+
+#ifdef JS_CODEGEN_ARM
+#  define RABALDR_INT_DIV_I64_CALLOUT
+#  define RABALDR_I64_TO_FLOAT_CALLOUT
+#  define RABALDR_FLOAT_TO_I64_CALLOUT
+#endif
+
+#ifdef JS_CODEGEN_MIPS64
+#  define RABALDR_PIN_INSTANCE
+#endif
+
+#ifdef JS_CODEGEN_LOONG64
+#  define RABALDR_PIN_INSTANCE
+#endif
+
+#ifdef JS_CODEGEN_RISCV64
+#  define RABALDR_PIN_INSTANCE
+#endif
+
+// Max number of pushes onto the value stack for any opcode or emitter that
+// does not push a variable, unbounded amount (anything with multiple
+// results).  This includes also intermediate pushes such as values pushed as
+// parameters for builtin calls.
+//
+// This limit is set quite high on purpose, so as to avoid brittleness.  The
+// true max value is likely no more than four or five.
+
+static constexpr size_t MaxPushesPerOpcode = 10;
+
+}  // namespace wasm
+}  // namespace js
+
+#endif  // wasm_wasm_baseline_defs_h