mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 18:54:02 +01:00
538b137e0b
This to protect against non-sensical instruction sequences being assembled, which would either cause asserts/crashes further down, or a Wasm module being output that doesn't validate. Unlike a validator, this type checker is able to give type-errors as part of the parsing process, which makes the assembler much friendlier to be used by humans writing manual input. Because the MC system is single pass (instructions aren't even stored in MC format, they are directly output) the type checker has to be single pass as well, which means that from now on .globaltype and .functype decls must come before their use. An extra pass is added to Codegen to collect information for this purpose, since AsmPrinter is normally single pass / streaming as well, and would otherwise generate this information on the fly. A `-no-type-check` flag was added to llvm-mc (and any other tools that take asm input) that surpresses type errors, as a quick escape hatch for tests that were not intended to be type correct. This is a first version of the type checker that ignores control flow, i.e. it checks that types are correct along the linear path, but not the branch path. This will still catch most errors. Branch checking could be added in the future. Differential Revision: https://reviews.llvm.org/D104945
437 lines
18 KiB
TableGen
437 lines
18 KiB
TableGen
// WebAssemblyInstrInfo.td-Describe the WebAssembly Instructions-*- tablegen -*-
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// WebAssembly Instruction definitions.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly Instruction Predicate Definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def IsPIC : Predicate<"TM.isPositionIndependent()">;
|
|
def IsNotPIC : Predicate<"!TM.isPositionIndependent()">;
|
|
|
|
def HasAddr32 : Predicate<"!Subtarget->hasAddr64()">;
|
|
|
|
def HasAddr64 : Predicate<"Subtarget->hasAddr64()">;
|
|
|
|
def HasSIMD128 :
|
|
Predicate<"Subtarget->hasSIMD128()">,
|
|
AssemblerPredicate<(all_of FeatureSIMD128), "simd128">;
|
|
|
|
def HasAtomics :
|
|
Predicate<"Subtarget->hasAtomics()">,
|
|
AssemblerPredicate<(all_of FeatureAtomics), "atomics">;
|
|
|
|
def HasMultivalue :
|
|
Predicate<"Subtarget->hasMultivalue()">,
|
|
AssemblerPredicate<(all_of FeatureMultivalue), "multivalue">;
|
|
|
|
def HasNontrappingFPToInt :
|
|
Predicate<"Subtarget->hasNontrappingFPToInt()">,
|
|
AssemblerPredicate<(all_of FeatureNontrappingFPToInt), "nontrapping-fptoint">;
|
|
|
|
def NotHasNontrappingFPToInt :
|
|
Predicate<"!Subtarget->hasNontrappingFPToInt()">,
|
|
AssemblerPredicate<(all_of (not FeatureNontrappingFPToInt)), "nontrapping-fptoint">;
|
|
|
|
def HasSignExt :
|
|
Predicate<"Subtarget->hasSignExt()">,
|
|
AssemblerPredicate<(all_of FeatureSignExt), "sign-ext">;
|
|
|
|
def HasTailCall :
|
|
Predicate<"Subtarget->hasTailCall()">,
|
|
AssemblerPredicate<(all_of FeatureTailCall), "tail-call">;
|
|
|
|
def HasExceptionHandling :
|
|
Predicate<"Subtarget->hasExceptionHandling()">,
|
|
AssemblerPredicate<(all_of FeatureExceptionHandling), "exception-handling">;
|
|
|
|
def HasBulkMemory :
|
|
Predicate<"Subtarget->hasBulkMemory()">,
|
|
AssemblerPredicate<(all_of FeatureBulkMemory), "bulk-memory">;
|
|
|
|
def HasReferenceTypes :
|
|
Predicate<"Subtarget->hasReferenceTypes()">,
|
|
AssemblerPredicate<(all_of FeatureReferenceTypes), "reference-types">;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly-specific DAG Node Types.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def SDT_WebAssemblyCallSeqStart : SDCallSeqStart<[SDTCisVT<0, iPTR>,
|
|
SDTCisVT<1, iPTR>]>;
|
|
def SDT_WebAssemblyCallSeqEnd :
|
|
SDCallSeqEnd<[SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>;
|
|
def SDT_WebAssemblyBrTable : SDTypeProfile<0, -1, [SDTCisPtrTy<0>]>;
|
|
def SDT_WebAssemblyArgument : SDTypeProfile<1, 1, [SDTCisVT<1, i32>]>;
|
|
def SDT_WebAssemblyLocalGet : SDTypeProfile<1, 1, [SDTCisVT<1, i32>]>;
|
|
def SDT_WebAssemblyLocalSet : SDTypeProfile<0, 2, [SDTCisVT<0, i32>]>;
|
|
def SDT_WebAssemblyReturn : SDTypeProfile<0, -1, []>;
|
|
def SDT_WebAssemblyWrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
|
|
SDTCisPtrTy<0>]>;
|
|
def SDT_WebAssemblyWrapperPIC : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>,
|
|
SDTCisPtrTy<0>]>;
|
|
def SDT_WebAssemblyThrow : SDTypeProfile<0, -1, []>;
|
|
def SDT_WebAssemblyCatch : SDTypeProfile<1, 1, [SDTCisPtrTy<0>]>;
|
|
def SDT_WebAssemblyGlobalGet : SDTypeProfile<1, 1, [SDTCisPtrTy<1>]>;
|
|
def SDT_WebAssemblyGlobalSet : SDTypeProfile<0, 2, [SDTCisPtrTy<1>]>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly-specific DAG Nodes.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
def WebAssemblycallseq_start :
|
|
SDNode<"ISD::CALLSEQ_START", SDT_WebAssemblyCallSeqStart,
|
|
[SDNPHasChain, SDNPOutGlue]>;
|
|
def WebAssemblycallseq_end :
|
|
SDNode<"ISD::CALLSEQ_END", SDT_WebAssemblyCallSeqEnd,
|
|
[SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
|
|
def WebAssemblybr_table : SDNode<"WebAssemblyISD::BR_TABLE",
|
|
SDT_WebAssemblyBrTable,
|
|
[SDNPHasChain, SDNPVariadic]>;
|
|
def WebAssemblyargument : SDNode<"WebAssemblyISD::ARGUMENT",
|
|
SDT_WebAssemblyArgument>;
|
|
def WebAssemblyreturn : SDNode<"WebAssemblyISD::RETURN",
|
|
SDT_WebAssemblyReturn,
|
|
[SDNPHasChain, SDNPVariadic]>;
|
|
def WebAssemblywrapper : SDNode<"WebAssemblyISD::Wrapper",
|
|
SDT_WebAssemblyWrapper>;
|
|
def WebAssemblywrapperPIC : SDNode<"WebAssemblyISD::WrapperPIC",
|
|
SDT_WebAssemblyWrapperPIC>;
|
|
def WebAssemblythrow : SDNode<"WebAssemblyISD::THROW", SDT_WebAssemblyThrow,
|
|
[SDNPHasChain, SDNPVariadic]>;
|
|
def WebAssemblycatch : SDNode<"WebAssemblyISD::CATCH", SDT_WebAssemblyCatch,
|
|
[SDNPHasChain, SDNPSideEffect]>;
|
|
def WebAssemblyglobal_get :
|
|
SDNode<"WebAssemblyISD::GLOBAL_GET", SDT_WebAssemblyGlobalGet,
|
|
[SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
|
|
def WebAssemblyglobal_set :
|
|
SDNode<"WebAssemblyISD::GLOBAL_SET", SDT_WebAssemblyGlobalSet,
|
|
[SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
|
|
def WebAssemblylocal_get :
|
|
SDNode<"WebAssemblyISD::LOCAL_GET", SDT_WebAssemblyLocalGet,
|
|
[SDNPHasChain, SDNPMayLoad]>;
|
|
def WebAssemblylocal_set :
|
|
SDNode<"WebAssemblyISD::LOCAL_SET", SDT_WebAssemblyLocalSet,
|
|
[SDNPHasChain, SDNPMayStore]>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly-specific Operands.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Default Operand has AsmOperandClass "Imm" which is for integers (and
|
|
// symbols), so specialize one for floats:
|
|
class FPImmAsmOperand<ValueType ty> : AsmOperandClass {
|
|
let Name = "FPImm" # ty;
|
|
let PredicateMethod = "isFPImm";
|
|
}
|
|
|
|
class FPOperand<ValueType ty> : Operand<ty> {
|
|
AsmOperandClass ParserMatchClass = FPImmAsmOperand<ty>;
|
|
}
|
|
|
|
let OperandNamespace = "WebAssembly" in {
|
|
|
|
let OperandType = "OPERAND_BASIC_BLOCK" in
|
|
def bb_op : Operand<OtherVT>;
|
|
|
|
let OperandType = "OPERAND_LOCAL" in
|
|
def local_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_GLOBAL" in {
|
|
// The operand to global instructions is always a 32-bit index.
|
|
def global_op32 : Operand<i32>;
|
|
// In PIC mode however, we temporarily represent this index as an external
|
|
// symbol, which to LLVM is a pointer, so in wasm64 mode it is easiest to
|
|
// pretend we use a 64-bit index for it.
|
|
def global_op64 : Operand<i64>;
|
|
}
|
|
|
|
let OperandType = "OPERAND_I32IMM" in
|
|
def i32imm_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_I64IMM" in
|
|
def i64imm_op : Operand<i64>;
|
|
|
|
let OperandType = "OPERAND_F32IMM" in
|
|
def f32imm_op : FPOperand<f32>;
|
|
|
|
let OperandType = "OPERAND_F64IMM" in
|
|
def f64imm_op : FPOperand<f64>;
|
|
|
|
let OperandType = "OPERAND_VEC_I8IMM" in
|
|
def vec_i8imm_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_VEC_I16IMM" in
|
|
def vec_i16imm_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_VEC_I32IMM" in
|
|
def vec_i32imm_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_VEC_I64IMM" in
|
|
def vec_i64imm_op : Operand<i64>;
|
|
|
|
let OperandType = "OPERAND_FUNCTION32" in
|
|
def function32_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_TABLE" in
|
|
def table32_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_OFFSET32" in
|
|
def offset32_op : Operand<i32>;
|
|
|
|
let OperandType = "OPERAND_OFFSET64" in
|
|
def offset64_op : Operand<i64>;
|
|
|
|
let OperandType = "OPERAND_P2ALIGN" in {
|
|
def P2Align : Operand<i32> {
|
|
let PrintMethod = "printWebAssemblyP2AlignOperand";
|
|
}
|
|
|
|
let OperandType = "OPERAND_TAG" in
|
|
def tag_op : Operand<i32>;
|
|
|
|
} // OperandType = "OPERAND_P2ALIGN"
|
|
|
|
let OperandType = "OPERAND_SIGNATURE" in
|
|
def Signature : Operand<i32> {
|
|
let PrintMethod = "printWebAssemblySignatureOperand";
|
|
}
|
|
|
|
let OperandType = "OPERAND_HEAPTYPE" in
|
|
def HeapType : Operand<i32> {
|
|
let PrintMethod = "printWebAssemblyHeapTypeOperand";
|
|
}
|
|
|
|
let OperandType = "OPERAND_TYPEINDEX" in
|
|
def TypeIndex : Operand<i32>;
|
|
|
|
} // OperandNamespace = "WebAssembly"
|
|
|
|
// TODO: Find more places to use this.
|
|
def bool_node : PatLeaf<(i32 I32:$cond), [{
|
|
return CurDAG->computeKnownBits(SDValue(N, 0)).countMinLeadingZeros() == 31;
|
|
}]>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly Register to Stack instruction mapping
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class StackRel;
|
|
def getStackOpcode : InstrMapping {
|
|
let FilterClass = "StackRel";
|
|
let RowFields = ["BaseName"];
|
|
let ColFields = ["StackBased"];
|
|
let KeyCol = ["false"];
|
|
let ValueCols = [["true"]];
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly Stack to Register instruction mapping
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class RegisterRel;
|
|
def getRegisterOpcode : InstrMapping {
|
|
let FilterClass = "RegisterRel";
|
|
let RowFields = ["BaseName"];
|
|
let ColFields = ["StackBased"];
|
|
let KeyCol = ["true"];
|
|
let ValueCols = [["false"]];
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly 32 to 64-bit instruction mapping
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
class Wasm64Rel;
|
|
def getWasm64Opcode : InstrMapping {
|
|
let FilterClass = "Wasm64Rel";
|
|
let RowFields = ["Wasm32Name"];
|
|
let ColFields = ["IsWasm64"];
|
|
let KeyCol = ["false"];
|
|
let ValueCols = [["true"]];
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// WebAssembly Instruction Format Definitions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
include "WebAssemblyInstrFormats.td"
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Additional instructions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
multiclass ARGUMENT<WebAssemblyRegClass rc, ValueType vt> {
|
|
let hasSideEffects = 1, isCodeGenOnly = 1, Defs = []<Register>,
|
|
Uses = [ARGUMENTS] in
|
|
defm ARGUMENT_#vt :
|
|
I<(outs rc:$res), (ins i32imm:$argno), (outs), (ins i32imm:$argno),
|
|
[(set (vt rc:$res), (WebAssemblyargument timm:$argno))]>;
|
|
}
|
|
defm "": ARGUMENT<I32, i32>;
|
|
defm "": ARGUMENT<I64, i64>;
|
|
defm "": ARGUMENT<F32, f32>;
|
|
defm "": ARGUMENT<F64, f64>;
|
|
defm "": ARGUMENT<FUNCREF, funcref>;
|
|
defm "": ARGUMENT<EXTERNREF, externref>;
|
|
|
|
// local.get and local.set are not generated by instruction selection; they
|
|
// are implied by virtual register uses and defs.
|
|
multiclass LOCAL<WebAssemblyRegClass rc, Operand global_op> {
|
|
let hasSideEffects = 0 in {
|
|
// COPY is not an actual instruction in wasm, but since we allow local.get and
|
|
// local.set to be implicit during most of codegen, we can have a COPY which
|
|
// is actually a no-op because all the work is done in the implied local.get
|
|
// and local.set. COPYs are eliminated (and replaced with
|
|
// local.get/local.set) in the ExplicitLocals pass.
|
|
let isAsCheapAsAMove = 1, isCodeGenOnly = 1 in
|
|
defm COPY_#rc : I<(outs rc:$res), (ins rc:$src), (outs), (ins), [],
|
|
"local.copy\t$res, $src", "local.copy">;
|
|
|
|
// TEE is similar to COPY, but writes two copies of its result. Typically
|
|
// this would be used to stackify one result and write the other result to a
|
|
// local.
|
|
let isAsCheapAsAMove = 1, isCodeGenOnly = 1 in
|
|
defm TEE_#rc : I<(outs rc:$res, rc:$also), (ins rc:$src), (outs), (ins), [],
|
|
"local.tee\t$res, $also, $src", "local.tee">;
|
|
|
|
// This is the actual local.get instruction in wasm. These are made explicit
|
|
// by the ExplicitLocals pass. It has mayLoad because it reads from a wasm
|
|
// local, which is a side effect not otherwise modeled in LLVM.
|
|
let mayLoad = 1, isAsCheapAsAMove = 1 in
|
|
defm LOCAL_GET_#rc : I<(outs rc:$res), (ins local_op:$local),
|
|
(outs), (ins local_op:$local), [],
|
|
"local.get\t$res, $local", "local.get\t$local", 0x20>;
|
|
|
|
// This is the actual local.set instruction in wasm. These are made explicit
|
|
// by the ExplicitLocals pass. It has mayStore because it writes to a wasm
|
|
// local, which is a side effect not otherwise modeled in LLVM.
|
|
let mayStore = 1, isAsCheapAsAMove = 1 in
|
|
defm LOCAL_SET_#rc : I<(outs), (ins local_op:$local, rc:$src),
|
|
(outs), (ins local_op:$local), [],
|
|
"local.set\t$local, $src", "local.set\t$local", 0x21>;
|
|
|
|
// This is the actual local.tee instruction in wasm. TEEs are turned into
|
|
// LOCAL_TEEs by the ExplicitLocals pass. It has mayStore for the same reason
|
|
// as LOCAL_SET.
|
|
let mayStore = 1, isAsCheapAsAMove = 1 in
|
|
defm LOCAL_TEE_#rc : I<(outs rc:$res), (ins local_op:$local, rc:$src),
|
|
(outs), (ins local_op:$local), [],
|
|
"local.tee\t$res, $local, $src", "local.tee\t$local",
|
|
0x22>;
|
|
|
|
// Unused values must be dropped in some contexts.
|
|
defm DROP_#rc : I<(outs), (ins rc:$src), (outs), (ins), [],
|
|
"drop\t$src", "drop", 0x1a>;
|
|
|
|
let mayLoad = 1 in
|
|
defm GLOBAL_GET_#rc : I<(outs rc:$res), (ins global_op:$addr),
|
|
(outs), (ins global_op:$addr), [],
|
|
"global.get\t$res, $addr", "global.get\t$addr",
|
|
0x23>;
|
|
|
|
let mayStore = 1 in
|
|
defm GLOBAL_SET_#rc : I<(outs), (ins global_op:$addr, rc:$src),
|
|
(outs), (ins global_op:$addr), [],
|
|
"global.set\t$addr, $src", "global.set\t$addr",
|
|
0x24>;
|
|
|
|
} // hasSideEffects = 0
|
|
foreach vt = rc.RegTypes in {
|
|
def : Pat<(vt (WebAssemblyglobal_get
|
|
(WebAssemblywrapper tglobaladdr:$addr))),
|
|
(!cast<NI>("GLOBAL_GET_" # rc) tglobaladdr:$addr)>;
|
|
def : Pat<(WebAssemblyglobal_set
|
|
vt:$src, (WebAssemblywrapper tglobaladdr:$addr)),
|
|
(!cast<NI>("GLOBAL_SET_" # rc) tglobaladdr:$addr, vt:$src)>;
|
|
def : Pat<(vt (WebAssemblylocal_get (i32 timm:$local))),
|
|
(!cast<NI>("LOCAL_GET_" # rc) timm:$local)>;
|
|
def : Pat<(WebAssemblylocal_set timm:$local, vt:$src),
|
|
(!cast<NI>("LOCAL_SET_" # rc) timm:$local, vt:$src)>;
|
|
}
|
|
}
|
|
defm "" : LOCAL<I32, global_op32>;
|
|
defm "" : LOCAL<I64, global_op64>; // 64-bit only needed for pointers.
|
|
defm "" : LOCAL<F32, global_op32>;
|
|
defm "" : LOCAL<F64, global_op32>;
|
|
defm "" : LOCAL<V128, global_op32>, Requires<[HasSIMD128]>;
|
|
defm "" : LOCAL<FUNCREF, global_op32>, Requires<[HasReferenceTypes]>;
|
|
defm "" : LOCAL<EXTERNREF, global_op32>, Requires<[HasReferenceTypes]>;
|
|
|
|
let isMoveImm = 1, isAsCheapAsAMove = 1, isReMaterializable = 1 in {
|
|
defm CONST_I32 : I<(outs I32:$res), (ins i32imm_op:$imm),
|
|
(outs), (ins i32imm_op:$imm),
|
|
[(set I32:$res, imm:$imm)],
|
|
"i32.const\t$res, $imm", "i32.const\t$imm", 0x41>;
|
|
defm CONST_I64 : I<(outs I64:$res), (ins i64imm_op:$imm),
|
|
(outs), (ins i64imm_op:$imm),
|
|
[(set I64:$res, imm:$imm)],
|
|
"i64.const\t$res, $imm", "i64.const\t$imm", 0x42>;
|
|
defm CONST_F32 : I<(outs F32:$res), (ins f32imm_op:$imm),
|
|
(outs), (ins f32imm_op:$imm),
|
|
[(set F32:$res, fpimm:$imm)],
|
|
"f32.const\t$res, $imm", "f32.const\t$imm", 0x43>;
|
|
defm CONST_F64 : I<(outs F64:$res), (ins f64imm_op:$imm),
|
|
(outs), (ins f64imm_op:$imm),
|
|
[(set F64:$res, fpimm:$imm)],
|
|
"f64.const\t$res, $imm", "f64.const\t$imm", 0x44>;
|
|
} // isMoveImm = 1, isAsCheapAsAMove = 1, isReMaterializable = 1
|
|
|
|
def : Pat<(i32 (WebAssemblywrapper tglobaladdr:$addr)),
|
|
(CONST_I32 tglobaladdr:$addr)>, Requires<[IsNotPIC, HasAddr32]>;
|
|
def : Pat<(i64 (WebAssemblywrapper tglobaladdr:$addr)),
|
|
(CONST_I64 tglobaladdr:$addr)>, Requires<[IsNotPIC, HasAddr64]>;
|
|
|
|
def : Pat<(i32 (WebAssemblywrapper tglobaladdr:$addr)),
|
|
(GLOBAL_GET_I32 tglobaladdr:$addr)>, Requires<[IsPIC, HasAddr32]>;
|
|
def : Pat<(i64 (WebAssemblywrapper tglobaladdr:$addr)),
|
|
(GLOBAL_GET_I64 tglobaladdr:$addr)>, Requires<[IsPIC, HasAddr64]>;
|
|
|
|
def : Pat<(i32 (WebAssemblywrapperPIC tglobaladdr:$addr)),
|
|
(CONST_I32 tglobaladdr:$addr)>, Requires<[IsPIC, HasAddr32]>;
|
|
def : Pat<(i64 (WebAssemblywrapperPIC tglobaladdr:$addr)),
|
|
(CONST_I64 tglobaladdr:$addr)>, Requires<[IsPIC, HasAddr64]>;
|
|
|
|
def : Pat<(i32 (WebAssemblywrapper tglobaltlsaddr:$addr)),
|
|
(CONST_I32 tglobaltlsaddr:$addr)>, Requires<[HasAddr32]>;
|
|
def : Pat<(i64 (WebAssemblywrapper tglobaltlsaddr:$addr)),
|
|
(CONST_I64 tglobaltlsaddr:$addr)>, Requires<[HasAddr64]>;
|
|
|
|
def : Pat<(i32 (WebAssemblywrapper texternalsym:$addr)),
|
|
(GLOBAL_GET_I32 texternalsym:$addr)>, Requires<[IsPIC, HasAddr32]>;
|
|
def : Pat<(i64 (WebAssemblywrapper texternalsym:$addr)),
|
|
(GLOBAL_GET_I64 texternalsym:$addr)>, Requires<[IsPIC, HasAddr64]>;
|
|
|
|
def : Pat<(i32 (WebAssemblywrapper texternalsym:$addr)),
|
|
(CONST_I32 texternalsym:$addr)>, Requires<[IsNotPIC, HasAddr32]>;
|
|
def : Pat<(i64 (WebAssemblywrapper texternalsym:$addr)),
|
|
(CONST_I64 texternalsym:$addr)>, Requires<[IsNotPIC, HasAddr64]>;
|
|
|
|
def : Pat<(i32 (WebAssemblywrapper mcsym:$sym)), (CONST_I32 mcsym:$sym)>;
|
|
def : Pat<(i64 (WebAssemblywrapper mcsym:$sym)), (CONST_I64 mcsym:$sym)>;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Additional sets of instructions.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
include "WebAssemblyInstrMemory.td"
|
|
include "WebAssemblyInstrCall.td"
|
|
include "WebAssemblyInstrControl.td"
|
|
include "WebAssemblyInstrInteger.td"
|
|
include "WebAssemblyInstrConv.td"
|
|
include "WebAssemblyInstrFloat.td"
|
|
include "WebAssemblyInstrAtomics.td"
|
|
include "WebAssemblyInstrSIMD.td"
|
|
include "WebAssemblyInstrRef.td"
|
|
include "WebAssemblyInstrBulkMemory.td"
|
|
include "WebAssemblyInstrTable.td"
|