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/wasm/WasmBCDefs.h | 201 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 js/src/wasm/WasmBCDefs.h (limited to 'js/src/wasm/WasmBCDefs.h') 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 +#include + +#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_ +// 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 -- cgit v1.2.3