[WebAssembly] Implement the wide-arithmetic proposal (#111598)

This commit implements the [wide-arithmetic] proposal which has recently reached phase 2 in the WebAssembly proposals process. The goal here is to implement support in LLVM for emitting these instructions which are gated behind a new feature flag by default. A new `wide-arithmetic` feature flag is introduced which gates these four new instructions from being emitted. Emission of each instruction itself is relatively simple given LLVM's preexisting lowering rules and infrastructure. The main gotcha is that due to the multi-result nature of all of these instructions it needed the lowerings to be implemented in C++ rather than in TableGen. [wide-arithmetic]: https://github.com/WebAssembly/wide-arithmetic

Author: alexcrichton

clang/include/clang/Driver/Options.td

@@ -5106,6 +5106,8 @@ def msimd128 : Flag<["-"], "msimd128">, Group<m_wasm_Features_Group>;
 def mno_simd128 : Flag<["-"], "mno-simd128">, Group<m_wasm_Features_Group>;
 def mtail_call : Flag<["-"], "mtail-call">, Group<m_wasm_Features_Group>;
 def mno_tail_call : Flag<["-"], "mno-tail-call">, Group<m_wasm_Features_Group>;
+def mwide_arithmetic : Flag<["-"], "mwide-arithmetic">, Group<m_wasm_Features_Group>;
+def mno_wide_arithmetic : Flag<["-"], "mno-wide-arithmetic">, Group<m_wasm_Features_Group>;
 def mexec_model_EQ : Joined<["-"], "mexec-model=">, Group<m_wasm_Features_Driver_Group>,
  Values<"command,reactor">,
  HelpText<"Execution model (WebAssembly only)">,

clang/lib/Basic/Targets/WebAssembly.cpp

@@ -59,6 +59,7 @@ bool WebAssemblyTargetInfo::hasFeature(StringRef Feature) const {
  .Case("sign-ext", HasSignExt)
  .Case("simd128", SIMDLevel >= SIMD128)
  .Case("tail-call", HasTailCall)
+ .Case("wide-arithmetic", HasWideArithmetic)
  .Default(false);
 }
 
@@ -102,6 +103,8 @@ void WebAssemblyTargetInfo::getTargetDefines(const LangOptions &Opts,
  Builder.defineMacro("__wasm_simd128__");
  if (HasTailCall)
  Builder.defineMacro("__wasm_tail_call__");
+ if (HasWideArithmetic)
+ Builder.defineMacro("__wasm_wide_arithmetic__");
 
  Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
  Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
@@ -166,6 +169,7 @@ bool WebAssemblyTargetInfo::initFeatureMap(
  Features["multimemory"] = true;
  Features["nontrapping-fptoint"] = true;
  Features["tail-call"] = true;
+ Features["wide-arithmetic"] = true;
  setSIMDLevel(Features, RelaxedSIMD, true);
  };
  if (CPU == "generic") {
@@ -293,6 +297,14 @@ bool WebAssemblyTargetInfo::handleTargetFeatures(
  HasTailCall = false;
  continue;
  }
+ if (Feature == "+wide-arithmetic") {
+ HasWideArithmetic = true;
+ continue;
+ }
+ if (Feature == "-wide-arithmetic") {
+ HasWideArithmetic = false;
+ continue;
+ }
 
  Diags.Report(diag::err_opt_not_valid_with_opt)
  << Feature << "-target-feature";

clang/lib/Basic/Targets/WebAssembly.h

@@ -65,6 +65,7 @@ class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo {
  bool HasReferenceTypes = false;
  bool HasSignExt = false;
  bool HasTailCall = false;
+ bool HasWideArithmetic = false;
 
  std::string ABI;
 

clang/test/Driver/wasm-features.c

@@ -94,3 +94,9 @@
 
 // TAIL-CALL: "-target-feature" "+tail-call"
 // NO-TAIL-CALL: "-target-feature" "-tail-call"
+
+// RUN: %clang --target=wasm32-unknown-unknown -### %s -mwide-arithmetic 2>&1 | FileCheck %s -check-prefix=WIDE-ARITH
+// RUN: %clang --target=wasm32-unknown-unknown -### %s -mno-wide-arithmetic 2>&1 | FileCheck %s -check-prefix=NO-WIDE-ARITH
+
+// WIDE-ARITH: "-target-feature" "+wide-arithmetic"
+// NO-WIDE-ARITH: "-target-feature" "-wide-arithmetic"

clang/test/Preprocessor/wasm-target-features.c

@@ -154,6 +154,7 @@
 // MVP-NOT: #define __wasm_sign_ext__ 1{{$}}
 // MVP-NOT: #define __wasm_simd128__ 1{{$}}
 // MVP-NOT: #define __wasm_tail_call__ 1{{$}}
+// MVP-NOT: #define __wasm_wide_arithmetic__ 1{{$}}
 
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN: -target wasm32-unknown-unknown -mcpu=generic \
@@ -184,6 +185,7 @@
 // GENERIC-NOT: #define __wasm_relaxed_simd__ 1{{$}}
 // GENERIC-NOT: #define __wasm_simd128__ 1{{$}}
 // GENERIC-NOT: #define __wasm_tail_call__ 1{{$}}
+// GENERIC-NOT: #define __wasm_wide_arithmetic__ 1{{$}}
 
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN: -target wasm32-unknown-unknown -mcpu=bleeding-edge \
@@ -206,6 +208,7 @@
 // BLEEDING-EDGE-INCLUDE-DAG: #define __wasm_sign_ext__ 1{{$}}
 // BLEEDING-EDGE-INCLUDE-DAG: #define __wasm_simd128__ 1{{$}}
 // BLEEDING-EDGE-INCLUDE-DAG: #define __wasm_tail_call__ 1{{$}}
+// BLEEDING-EDGE-INCLUDE-DAG: #define __wasm_wide_arithmetic__ 1{{$}}
 
 // RUN: %clang -E -dM %s -o - 2>&1 \
 // RUN: -target wasm32-unknown-unknown -mcpu=bleeding-edge -mno-simd128 \
@@ -215,3 +218,12 @@
 // RUN: | FileCheck %s -check-prefix=BLEEDING-EDGE-NO-SIMD128
 //
 // BLEEDING-EDGE-NO-SIMD128-NOT: #define __wasm_simd128__ 1{{$}}
+
+// RUN: %clang -E -dM %s -o - 2>&1 \
+// RUN: -target wasm32-unknown-unknown -mwide-arithmetic \
+// RUN: | FileCheck %s -check-prefix=WIDE-ARITHMETIC
+// RUN: %clang -E -dM %s -o - 2>&1 \
+// RUN: -target wasm64-unknown-unknown -mwide-arithmetic \
+// RUN: | FileCheck %s -check-prefix=WIDE-ARITHMETIC
+//
+// WIDE-ARITHMETIC: #define __wasm_wide_arithmetic__ 1{{$}}

llvm/lib/Target/WebAssembly/WebAssembly.td

@@ -78,6 +78,10 @@ def FeatureTailCall :
  SubtargetFeature<"tail-call", "HasTailCall", "true",
  "Enable tail call instructions">;
 
+def FeatureWideArithmetic :
+ SubtargetFeature<"wide-arithmetic", "HasWideArithmetic", "true",
+ "Enable wide-arithmetic instructions">;
+
 //===----------------------------------------------------------------------===//
 // Architectures.
 //===----------------------------------------------------------------------===//

llvm/lib/Target/WebAssembly/WebAssemblyISD.def

@@ -44,6 +44,10 @@ HANDLE_NODETYPE(TRUNC_SAT_ZERO_U)
 HANDLE_NODETYPE(DEMOTE_ZERO)
 HANDLE_NODETYPE(MEMORY_COPY)
 HANDLE_NODETYPE(MEMORY_FILL)
+HANDLE_NODETYPE(I64_ADD128)
+HANDLE_NODETYPE(I64_SUB128)
+HANDLE_NODETYPE(I64_MUL_WIDE_S)
+HANDLE_NODETYPE(I64_MUL_WIDE_U)
 
 // Memory intrinsics
 HANDLE_MEM_NODETYPE(GLOBAL_GET)

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

@@ -167,6 +167,13 @@ WebAssemblyTargetLowering::WebAssemblyTargetLowering(
  setOperationAction(Op, T, Expand);
  }
 
+ if (Subtarget->hasWideArithmetic()) {
+ setOperationAction(ISD::ADD, MVT::i128, Custom);
+ setOperationAction(ISD::SUB, MVT::i128, Custom);
+ setOperationAction(ISD::SMUL_LOHI, MVT::i64, Custom);
+ setOperationAction(ISD::UMUL_LOHI, MVT::i64, Custom);
+ }
+
  if (Subtarget->hasNontrappingFPToInt())
  for (auto Op : {ISD::FP_TO_SINT_SAT, ISD::FP_TO_UINT_SAT})
  for (auto T : {MVT::i32, MVT::i64})
@@ -1419,6 +1426,10 @@ void WebAssemblyTargetLowering::ReplaceNodeResults(
  // Do not add any results, signifying that N should not be custom lowered.
  // EXTEND_VECTOR_INREG is implemented for some vectors, but not all.
  break;
+ case ISD::ADD:
+ case ISD::SUB:
+ Results.push_back(Replace128Op(N, DAG));
+ break;
  default:
  llvm_unreachable(
  "ReplaceNodeResults not implemented for this op for WebAssembly!");
@@ -1495,6 +1506,9 @@ SDValue WebAssemblyTargetLowering::LowerOperation(SDValue Op,
  return DAG.UnrollVectorOp(Op.getNode());
  case ISD::CLEAR_CACHE:
  report_fatal_error("llvm.clear_cache is not supported on wasm");
+ case ISD::SMUL_LOHI:
+ case ISD::UMUL_LOHI:
+ return LowerMUL_LOHI(Op, DAG);
  }
 }
 
@@ -1593,6 +1607,63 @@ SDValue WebAssemblyTargetLowering::LowerLoad(SDValue Op,
  return Op;
 }
 
+SDValue WebAssemblyTargetLowering::LowerMUL_LOHI(SDValue Op,
+ SelectionDAG &DAG) const {
+ assert(Subtarget->hasWideArithmetic());
+ assert(Op.getValueType() == MVT::i64);
+ SDLoc DL(Op);
+ unsigned Opcode;
+ switch (Op.getOpcode()) {
+ case ISD::UMUL_LOHI:
+ Opcode = WebAssemblyISD::I64_MUL_WIDE_U;
+ break;
+ case ISD::SMUL_LOHI:
+ Opcode = WebAssemblyISD::I64_MUL_WIDE_S;
+ break;
+ default:
+ llvm_unreachable("unexpected opcode");
+ }
+ SDValue LHS = Op.getOperand(0);
+ SDValue RHS = Op.getOperand(1);
+ SDValue Hi =
+ DAG.getNode(Opcode, DL, DAG.getVTList(MVT::i64, MVT::i64), LHS, RHS);
+ SDValue Lo(Hi.getNode(), 1);
+ SDValue Ops[] = {Hi, Lo};
+ return DAG.getMergeValues(Ops, DL);
+}
+
+SDValue WebAssemblyTargetLowering::Replace128Op(SDNode *N,
+ SelectionDAG &DAG) const {
+ assert(Subtarget->hasWideArithmetic());
+ auto ValTy = N->getValueType(0);
+ assert(ValTy == MVT::i128);
+ SDLoc DL(N);
+ unsigned Opcode;
+ switch (N->getOpcode()) {
+ case ISD::ADD:
+ Opcode = WebAssemblyISD::I64_ADD128;
+ break;
+ case ISD::SUB:
+ Opcode = WebAssemblyISD::I64_SUB128;
+ break;
+ default:
+ llvm_unreachable("unexpected opcode");
+ }
+ SDValue LHS = N->getOperand(0);
+ SDValue RHS = N->getOperand(1);
+
+ SDValue C0 = DAG.getConstant(0, DL, MVT::i64);
+ SDValue C1 = DAG.getConstant(1, DL, MVT::i64);
+ SDValue LHS_0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, LHS, C0);
+ SDValue LHS_1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, LHS, C1);
+ SDValue RHS_0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, RHS, C0);
+ SDValue RHS_1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL, MVT::i64, RHS, C1);
+ SDValue Result_LO = DAG.getNode(Opcode, DL, DAG.getVTList(MVT::i64, MVT::i64),
+ LHS_0, LHS_1, RHS_0, RHS_1);
+ SDValue Result_HI(Result_LO.getNode(), 1);
+ return DAG.getNode(ISD::BUILD_PAIR, DL, N->getVTList(), Result_LO, Result_HI);
+}
+
 SDValue WebAssemblyTargetLowering::LowerCopyToReg(SDValue Op,
  SelectionDAG &DAG) const {
  SDValue Src = Op.getOperand(2);

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.h

@@ -136,6 +136,8 @@ class WebAssemblyTargetLowering final : public TargetLowering {
  SDValue LowerFP_TO_INT_SAT(SDValue Op, SelectionDAG &DAG) const;
  SDValue LowerLoad(SDValue Op, SelectionDAG &DAG) const;
  SDValue LowerStore(SDValue Op, SelectionDAG &DAG) const;
+ SDValue LowerMUL_LOHI(SDValue Op, SelectionDAG &DAG) const;
+ SDValue Replace128Op(SDNode *N, SelectionDAG &DAG) const;
 
  // Custom DAG combine hooks
  SDValue

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

@@ -84,6 +84,10 @@ def HasTailCall :
  Predicate<"Subtarget->hasTailCall()">,
  AssemblerPredicate<(all_of FeatureTailCall), "tail-call">;
 
+def HasWideArithmetic :
+ Predicate<"Subtarget->hasWideArithmetic()">,
+ AssemblerPredicate<(all_of FeatureWideArithmetic), "wide-arithmetic">;
+
 //===----------------------------------------------------------------------===//
 // WebAssembly-specific DAG Node Types.
 //===----------------------------------------------------------------------===//