[WebAssembly] Split WebAssemblyUtils to fix library layering for MC tools.

[craig.topper]

Summary

WebAssemblyUtils depends on CodeGen which depends on all middle end
optimization libraries.

This component is used by WebAssembly's AsmParser, Disassembler, and
MCTargetDesc libraries. Because of this, any MC layer tool built with
WebAssembly support includes a larger portion of LLVM than it should.

To fix this I've created MC only versions of WebAssemblyUtilties.cpp
and WebAssemblyTypeUtilities.cpp in MCTargetDesc to be used by the MC
components.

This shrinks llvm-objdump and llvm-mc on my local release+asserts
build by 5-6 MB.

This is a pretty naive splitting so I welcome feedback on how
WebAssembly developers would like to see this structured.

[dschuff]

The general idea of this makes sense to me.
@pmatos and @asb have been thinking more about the type system recently, they might have an opinion.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCUtilities.cpp

21 ↗

(On Diff #498694)

@aheejin these should maybe be on the CodeGen side rather than on the MC side, right?

[aheejin]

Thanks! The idea makes sense to me.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCUtilities.cpp

21 ↗

(On Diff #498694)

Yeah, I don't think this file is very relevant to MC.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCUtilities.h

1 ↗

(On Diff #498694)

It looks MCTargetDesc/WebAssemblyMCUtilities.h and MCTargetDesc/WebAssemblyMCUtilities.cpp don't have any MC-related functionalities. Why do they need to be moved into MCTargetDesc/?

[craig.topper]

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCUtilities.h

1 ↗

(On Diff #498694)

Two of the options are used here.

WebAssemblyMCAsmInfo.cpp
53:  if (WebAssembly::WasmEnableEH || WebAssembly::WasmEnableSjLj)

I didn't look too closely to notice the other two aren't used in MC.

[MaskRay]

There are some missing dependencies in a -DBUILD_SHARED_LIBS=on build.

[MaskRay]

The change looks good.

... This results in any MC layer tool built with WebAssembly including a larger portion of LLVM that it should.

s/should/shouldn't/

[craig.topper]

Make WebAssembly AsmParser depended on WebAssemblyDesc

[MaskRay]

LGTM. Note that there is unresolved comment about enable-emscripten-cxx-exceptions and its friends belonging to the CodeGen part rather than the MC part.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCUtilities.cpp

34 ↗

(On Diff #499920)

Drop , cl::init(false) (default)

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCUtilities.h

20 ↗

(On Diff #499920)

With C++17 we can use namespace llvm::WebAssembly

[MaskRay]

-DBUILD_SHARED_LIBS=on builds still fail.

[2540/2713] Linking CXX shared library lib/libLLVMWebAssemblyUtils.so.17git
FAILED: lib/libLLVMWebAssemblyUtils.so.17git

[craig.topper]

In D144354#4148115, @MaskRay wrote:

-DBUILD_SHARED_LIBS=on builds still fail.

[2540/2713] Linking CXX shared library lib/libLLVMWebAssemblyUtils.so.17git
FAILED: lib/libLLVMWebAssemblyUtils.so.17git

Thanks. I fixed one problem and then went back to the wrong build directory. Rebuilding the shared build now.

[craig.topper]

Fix -DBUILD_SHARED_LIBS=on

[craig.topper]

Address review comments

[aheejin]

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCUtilities.h

1 ↗

(On Diff #498694)

Ah, right... That was added in D115893, and the reason we needed that in MCAsmInfo was we couldn't determine the EH mode only with the triple. Yeah, this is not very ideal, but I can't think of any other way around this atm. Sorry for making you revert the change, but can we bring back the two other options (WasmEnableEmEH and WasmEnableEmSjLj) here? I think it's clearer to gather all EH/SjLj options in one place. Also given that this file only contains options, can we change the file name to, say, WebAssemblyEHSjLjOptions.cpp/h?

[craig.topper]

Move the commannd line options to WebAssemblyMCTargetDesc.cpp/h. 4 command line options didn't seem to warrant a new file and this header is already included pretty heavily.

[aheejin]

Thank you!

llvm/lib/Target/WebAssembly/AsmParser/CMakeLists.txt

 add_llvm_component_library(LLVMWebAssemblyAsmParser
   WebAssemblyAsmParser.cpp
   WebAssemblyAsmTypeCheck.cpp
 
   LINK_COMPONENTS
   MC
   MCParser
+  WebAssemblyDesc
   WebAssemblyInfo
-  WebAssemblyUtils
   Support
   TargetParser
 
   ADD_TO_COMPONENT
   WebAssembly
   )

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

 /// This file is part of the WebAssembly Assembler.
 ///
 /// It contains code to translate a parsed .s file into MCInsts.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "AsmParser/WebAssemblyAsmTypeCheck.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
+#include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
-#include "Utils/WebAssemblyTypeUtilities.h"
-#include "Utils/WebAssemblyUtilities.h"
 #include "WebAssembly.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCParser/MCAsmLexer.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmTypeCheck.cpp

 /// This file is part of the WebAssembly Assembler.
 ///
 /// It contains code to translate a parsed .s file into MCInsts.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "AsmParser/WebAssemblyAsmTypeCheck.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
+#include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
-#include "Utils/WebAssemblyTypeUtilities.h"
-#include "Utils/WebAssemblyUtilities.h"
 #include "WebAssembly.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
 #include "llvm/MC/MCSectionWasm.h"

llvm/lib/Target/WebAssembly/Disassembler/CMakeLists.txt

 add_llvm_component_library(LLVMWebAssemblyDisassembler
   WebAssemblyDisassembler.cpp
 
   LINK_COMPONENTS
   WebAssemblyDesc
   MCDisassembler
   WebAssemblyInfo
-  WebAssemblyUtils
   Support
   MC
 
   ADD_TO_COMPONENT
   WebAssembly
   )

llvm/lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

 //==- WebAssemblyDisassembler.cpp - Disassembler for WebAssembly -*- C++ -*-==//
 //
 // 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
 /// This file is part of the WebAssembly Disassembler.
 ///
 /// It contains code to translate the data produced by the decoder into
 /// MCInsts.
 ///
 //===----------------------------------------------------------------------===//
 
+#include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
-#include "Utils/WebAssemblyTypeUtilities.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDecoderOps.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolWasm.h"

llvm/lib/Target/WebAssembly/MCTargetDesc/CMakeLists.txt

 add_llvm_component_library(LLVMWebAssemblyDesc
   WebAssemblyAsmBackend.cpp
   WebAssemblyInstPrinter.cpp
   WebAssemblyMCAsmInfo.cpp
   WebAssemblyMCCodeEmitter.cpp
   WebAssemblyMCTargetDesc.cpp
+  WebAssemblyMCTypeUtilities.cpp
   WebAssemblyTargetStreamer.cpp
   WebAssemblyWasmObjectWriter.cpp
 
   LINK_COMPONENTS
   MC
   Support
   TargetParser
   WebAssemblyInfo
-  WebAssemblyUtils
 
   ADD_TO_COMPONENT
   WebAssembly
 )

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.cpp

 //=- WebAssemblyInstPrinter.cpp - WebAssembly assembly instruction printing -=//
 //
 // 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
 /// Print MCInst instructions to wasm format.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/WebAssemblyInstPrinter.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
-#include "Utils/WebAssemblyTypeUtilities.h"
-#include "Utils/WebAssemblyUtilities.h"
+#include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "WebAssembly.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCAsmInfo.cpp

 //===-- WebAssemblyMCAsmInfo.cpp - WebAssembly asm properties -------------===//
 //
 // 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
 /// This file contains the declarations of the WebAssemblyMCAsmInfo
 /// properties.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyMCAsmInfo.h"
-#include "Utils/WebAssemblyUtilities.h"
+#include "WebAssemblyMCTargetDesc.h"
 #include "llvm/TargetParser/Triple.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "wasm-mc-asm-info"
 
 WebAssemblyMCAsmInfo::~WebAssemblyMCAsmInfo() = default; // anchor.
 

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

 MCCodeEmitter *createWebAssemblyMCCodeEmitter(const MCInstrInfo &MCII);
 
 MCAsmBackend *createWebAssemblyAsmBackend(const Triple &TT);
 
 std::unique_ptr<MCObjectTargetWriter>
 createWebAssemblyWasmObjectWriter(bool Is64Bit, bool IsEmscripten);
 
 namespace WebAssembly {
+
+// Exception handling / setjmp-longjmp handling command-line options
+extern cl::opt<bool> WasmEnableEmEH;   // asm.js-style EH
+extern cl::opt<bool> WasmEnableEmSjLj; // asm.js-style SjLJ
+extern cl::opt<bool> WasmEnableEH;     // EH using Wasm EH instructions
+extern cl::opt<bool> WasmEnableSjLj;   // SjLj using Wasm EH instructions
+
 enum OperandType {
   /// Basic block label in a branch construct.
   OPERAND_BASIC_BLOCK = MCOI::OPERAND_FIRST_TARGET,
   /// Local index.
   OPERAND_LOCAL,
   /// Global index.
   OPERAND_GLOBAL,
   /// 32-bit integer immediates.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.cpp

 #include "WebAssemblyGenInstrInfo.inc"
 
 #define GET_SUBTARGETINFO_MC_DESC
 #include "WebAssemblyGenSubtargetInfo.inc"
 
 #define GET_REGINFO_MC_DESC
 #include "WebAssemblyGenRegisterInfo.inc"
 
+// Exception handling & setjmp-longjmp handling related options.
+
+// Emscripten's asm.js-style exception handling
+cl::opt<bool> WebAssembly::WasmEnableEmEH(
+    "enable-emscripten-cxx-exceptions",
+    cl::desc("WebAssembly Emscripten-style exception handling"),
+    cl::init(false));
+// Emscripten's asm.js-style setjmp/longjmp handling
+cl::opt<bool> WebAssembly::WasmEnableEmSjLj(
+    "enable-emscripten-sjlj",
+    cl::desc("WebAssembly Emscripten-style setjmp/longjmp handling"),
+    cl::init(false));
+// Exception handling using wasm EH instructions
+cl::opt<bool>
+    WebAssembly::WasmEnableEH("wasm-enable-eh",
+                              cl::desc("WebAssembly exception handling"));
+// setjmp/longjmp handling using wasm EH instrutions
+cl::opt<bool> WebAssembly::WasmEnableSjLj(
+    "wasm-enable-sjlj", cl::desc("WebAssembly setjmp/longjmp handling"));
+
 static MCAsmInfo *createMCAsmInfo(const MCRegisterInfo & /*MRI*/,
                                   const Triple &TT,
                                   const MCTargetOptions &Options) {
   return new WebAssemblyMCAsmInfo(TT, Options);
 }
 
 static MCInstrInfo *createMCInstrInfo() {
   auto *X = new MCInstrInfo();

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTypeUtilities.h

-//===-- WebAssemblyTypeUtilities - WebAssembly Type Utilities---*- C++ -*-====//
+//===-- WebAssemblyMCTypeUtilities - WebAssembly Type Utilities-*- C++ -*-====//
 //
 // 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
 /// This file contains the declaration of the WebAssembly-specific type parsing
 /// utility functions.
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYTYPEUTILITIES_H
-#define LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYTYPEUTILITIES_H
+#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYMCTYPEUTILITIES_H
+#define LLVM_LIB_TARGET_WEBASSEMBLY_MCTARGETDESC_WEBASSEMBLYMCTYPEUTILITIES_H
 
 #include "llvm/BinaryFormat/Wasm.h"
-#include "llvm/IR/DerivedTypes.h"
-#include "llvm/MC/MCSymbolWasm.h"
-#include "llvm/Support/MachineValueType.h"
 
 namespace llvm {
 
-class TargetRegisterClass;
-
 namespace WebAssembly {
 
 /// Used as immediate MachineOperands for block signatures
 enum class BlockType : unsigned {
   Invalid = 0x00,
   Void = 0x40,
   I32 = unsigned(wasm::ValType::I32),
   I64 = unsigned(wasm::ValType::I64),
   F32 = unsigned(wasm::ValType::F32),
   F64 = unsigned(wasm::ValType::F64),
   V128 = unsigned(wasm::ValType::V128),
   Externref = unsigned(wasm::ValType::EXTERNREF),
   Funcref = unsigned(wasm::ValType::FUNCREF),
   // Multivalue blocks (and other non-void blocks) are only emitted when the
   // blocks will never be exited and are at the ends of functions (see
   // WebAssemblyCFGStackify::fixEndsAtEndOfFunction). They also are never made
   // to pop values off the stack, so the exact multivalue signature can always
   // be inferred from the return type of the parent function in MCInstLower.
   Multivalue = 0xffff,
 };
 
-enum WasmAddressSpace : unsigned {
-  // Default address space, for pointers to linear memory (stack, heap, data).
-  WASM_ADDRESS_SPACE_DEFAULT = 0,
-  // A non-integral address space for pointers to named objects outside of
-  // linear memory: WebAssembly globals or WebAssembly locals.  Loads and stores
-  // to these pointers are lowered to global.get / global.set or local.get /
-  // local.set, as appropriate.
-  WASM_ADDRESS_SPACE_VAR = 1,
-  // A non-integral address space for externref values
-  WASM_ADDRESS_SPACE_EXTERNREF = 10,
-  // A non-integral address space for funcref values
-  WASM_ADDRESS_SPACE_FUNCREF = 20,
-};
-
-inline bool isDefaultAddressSpace(unsigned AS) {
-  return AS == WASM_ADDRESS_SPACE_DEFAULT;
-}
-inline bool isWasmVarAddressSpace(unsigned AS) {
-  return AS == WASM_ADDRESS_SPACE_VAR;
-}
-inline bool isValidAddressSpace(unsigned AS) {
-  return isDefaultAddressSpace(AS) || isWasmVarAddressSpace(AS);
-}
-inline bool isFuncrefType(const Type *Ty) {
-  return isa<PointerType>(Ty) &&
-         Ty->getPointerAddressSpace() ==
-             WasmAddressSpace::WASM_ADDRESS_SPACE_FUNCREF;
-}
-inline bool isExternrefType(const Type *Ty) {
-  return isa<PointerType>(Ty) &&
-         Ty->getPointerAddressSpace() ==
-             WasmAddressSpace::WASM_ADDRESS_SPACE_EXTERNREF;
-}
-inline bool isRefType(const Type *Ty) {
-  return isFuncrefType(Ty) || isExternrefType(Ty);
-}
-
 inline bool isRefType(wasm::ValType Type) {
   return Type == wasm::ValType::EXTERNREF || Type == wasm::ValType::FUNCREF;
 }
 
-// Convert StringRef to ValType / HealType / BlockType
-
-std::optional<wasm::ValType> parseType(StringRef Type);
-BlockType parseBlockType(StringRef Type);
-MVT parseMVT(StringRef Type);
-
 // Convert ValType or a list/signature of ValTypes to a string.
 
 // Convert an unsinged integer, which can be among wasm::ValType enum, to its
 // type name string. If the input is not within wasm::ValType, returns
 // "invalid_type".
 const char *anyTypeToString(unsigned Type);
 const char *typeToString(wasm::ValType Type);
 // Convert a list of ValTypes into a string in the format of
 // "type0, type1, ... typeN"
 std::string typeListToString(ArrayRef<wasm::ValType> List);
 // Convert a wasm signature into a string in the format of
 // "(params) -> (results)", where params and results are a string of ValType
 // lists.
 std::string signatureToString(const wasm::WasmSignature *Sig);
 
-// Convert a MVT into its corresponding wasm ValType.
-wasm::ValType toValType(MVT Type);
-
 // Convert a register class ID to a wasm ValType.
 wasm::ValType regClassToValType(unsigned RC);
 
-// Convert a register class to a wasm ValType.
-wasm::ValType regClassToValType(const TargetRegisterClass *RC);
+// Convert StringRef to ValType / HealType / BlockType
 
-/// Sets a Wasm Symbol Type.
-void wasmSymbolSetType(MCSymbolWasm *Sym, const Type *GlobalVT,
-                       const SmallVector<MVT, 1> &VTs);
+std::optional<wasm::ValType> parseType(StringRef Type);
+BlockType parseBlockType(StringRef Type);
 
 } // end namespace WebAssembly
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTypeUtilities.cpp

-//===-- WebAssemblyTypeUtilities.cpp - WebAssembly Type Utility Functions -===//
+//===- WebAssemblyMCTypeUtilities.cpp - WebAssembly Type Utility Functions-===//
 //
 // 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
 /// This file implements several utility functions for WebAssembly type parsing.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "WebAssemblyTypeUtilities.h"
+#include "WebAssemblyMCTypeUtilities.h"
+#include "WebAssemblyMCTargetDesc.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "llvm/CodeGen/TargetRegisterInfo.h"
-
-// Get register classes enum.
-#define GET_REGINFO_ENUM
-#include "WebAssemblyGenRegisterInfo.inc"
 
 using namespace llvm;
 
 std::optional<wasm::ValType> WebAssembly::parseType(StringRef Type) {
   // FIXME: can't use StringSwitch because wasm::ValType doesn't have a
   // "invalid" value.
   if (Type == "i32")
     return wasm::ValType::I32;
return StringSwitch<WebAssembly::BlockType>(Type)
       .Case("f64", WebAssembly::BlockType::F64)
       .Case("v128", WebAssembly::BlockType::V128)
       .Case("funcref", WebAssembly::BlockType::Funcref)
       .Case("externref", WebAssembly::BlockType::Externref)
       .Case("void", WebAssembly::BlockType::Void)
       .Default(WebAssembly::BlockType::Invalid);
 }
 
-MVT WebAssembly::parseMVT(StringRef Type) {
-  return StringSwitch<MVT>(Type)
-      .Case("i32", MVT::i32)
-      .Case("i64", MVT::i64)
-      .Case("f32", MVT::f32)
-      .Case("f64", MVT::f64)
-      .Case("i64", MVT::i64)
-      .Case("v16i8", MVT::v16i8)
-      .Case("v8i16", MVT::v8i16)
-      .Case("v4i32", MVT::v4i32)
-      .Case("v2i64", MVT::v2i64)
-      .Case("funcref", MVT::funcref)
-      .Case("externref", MVT::externref)
-      .Default(MVT::INVALID_SIMPLE_VALUE_TYPE);
-}
-
 // We have various enums representing a subset of these types, use this
 // function to convert any of them to text.
 const char *WebAssembly::anyTypeToString(unsigned Type) {
   switch (Type) {
   case wasm::WASM_TYPE_I32:
     return "i32";
   case wasm::WASM_TYPE_I64:
     return "i64";
std::string WebAssembly::signatureToString(const wasm::WasmSignature *Sig) {
   std::string S("(");
   S += typeListToString(Sig->Params);
   S += ") -> (";
   S += typeListToString(Sig->Returns);
   S += ")";
   return S;
 }
 
-wasm::ValType WebAssembly::toValType(MVT Type) {
-  switch (Type.SimpleTy) {
-  case MVT::i32:
-    return wasm::ValType::I32;
-  case MVT::i64:
-    return wasm::ValType::I64;
-  case MVT::f32:
-    return wasm::ValType::F32;
-  case MVT::f64:
-    return wasm::ValType::F64;
-  case MVT::v16i8:
-  case MVT::v8i16:
-  case MVT::v4i32:
-  case MVT::v2i64:
-  case MVT::v4f32:
-  case MVT::v2f64:
-    return wasm::ValType::V128;
-  case MVT::funcref:
-    return wasm::ValType::FUNCREF;
-  case MVT::externref:
-    return wasm::ValType::EXTERNREF;
-  default:
-    llvm_unreachable("unexpected type");
-  }
-}
-
 wasm::ValType WebAssembly::regClassToValType(unsigned RC) {
   switch (RC) {
   case WebAssembly::I32RegClassID:
     return wasm::ValType::I32;
   case WebAssembly::I64RegClassID:
     return wasm::ValType::I64;
   case WebAssembly::F32RegClassID:
     return wasm::ValType::F32;
   case WebAssembly::F64RegClassID:
     return wasm::ValType::F64;
   case WebAssembly::V128RegClassID:
     return wasm::ValType::V128;
   case WebAssembly::FUNCREFRegClassID:
     return wasm::ValType::FUNCREF;
   case WebAssembly::EXTERNREFRegClassID:
     return wasm::ValType::EXTERNREF;
   default:
     llvm_unreachable("unexpected type");
   }
 }
-
-wasm::ValType WebAssembly::regClassToValType(const TargetRegisterClass *RC) {
-  assert(RC != nullptr);
-  return regClassToValType(RC->getID());
-}
-
-void WebAssembly::wasmSymbolSetType(MCSymbolWasm *Sym, const Type *GlobalVT,
-                                    const SmallVector<MVT, 1> &VTs) {
-  assert(!Sym->getType());
-
-  // Tables are represented as Arrays in LLVM IR therefore
-  // they reach this point as aggregate Array types with an element type
-  // that is a reference type.
-  wasm::ValType ValTy;
-  bool IsTable = false;
-  if (GlobalVT->isArrayTy() &&
-      WebAssembly::isRefType(GlobalVT->getArrayElementType())) {
-    IsTable = true;
-    const Type *ElTy = GlobalVT->getArrayElementType();
-    if (WebAssembly::isExternrefType(ElTy))
-      ValTy = wasm::ValType::EXTERNREF;
-    else if (WebAssembly::isFuncrefType(ElTy))
-      ValTy = wasm::ValType::FUNCREF;
-    else
-      report_fatal_error("unhandled reference type");
-  } else if (VTs.size() == 1) {
-    ValTy = WebAssembly::toValType(VTs[0]);
-  } else
-    report_fatal_error("Aggregate globals not yet implemented");
-
-  if (IsTable) {
-    Sym->setType(wasm::WASM_SYMBOL_TYPE_TABLE);
-    Sym->setTableType(ValTy);
-  } else {
-    Sym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
-    Sym->setGlobalType(wasm::WasmGlobalType{uint8_t(ValTy), /*Mutable=*/true});
-  }
-}

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

 //==-- WebAssemblyTargetStreamer.cpp - WebAssembly Target Streamer Methods --=//
 //
 // 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
 /// This file defines WebAssembly-specific target streamer classes.
 /// These are for implementing support for target-specific assembly directives.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
-#include "Utils/WebAssemblyTypeUtilities.h"
+#include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 using namespace llvm;

llvm/lib/Target/WebAssembly/Utils/CMakeLists.txt

 add_llvm_component_library(LLVMWebAssemblyUtils
   WebAssemblyUtilities.cpp
   WebAssemblyTypeUtilities.cpp
 
   LINK_COMPONENTS
   CodeGen
   Core
   MC
   Support
+  WebAssemblyDesc
 
   ADD_TO_COMPONENT
   WebAssembly
   )

llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.h

 /// This file contains the declaration of the WebAssembly-specific type parsing
 /// utility functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYTYPEUTILITIES_H
 #define LLVM_LIB_TARGET_WEBASSEMBLY_UTILS_WEBASSEMBLYTYPEUTILITIES_H
 
+#include "MCTargetDesc/WebAssemblyMCTypeUtilities.h"
 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/MachineValueType.h"
 
 namespace llvm {
 
 class TargetRegisterClass;
 
 namespace WebAssembly {
 
-/// Used as immediate MachineOperands for block signatures
-enum class BlockType : unsigned {
-  Invalid = 0x00,
-  Void = 0x40,
-  I32 = unsigned(wasm::ValType::I32),
-  I64 = unsigned(wasm::ValType::I64),
-  F32 = unsigned(wasm::ValType::F32),
-  F64 = unsigned(wasm::ValType::F64),
-  V128 = unsigned(wasm::ValType::V128),
-  Externref = unsigned(wasm::ValType::EXTERNREF),
-  Funcref = unsigned(wasm::ValType::FUNCREF),
-  // Multivalue blocks (and other non-void blocks) are only emitted when the
-  // blocks will never be exited and are at the ends of functions (see
-  // WebAssemblyCFGStackify::fixEndsAtEndOfFunction). They also are never made
-  // to pop values off the stack, so the exact multivalue signature can always
-  // be inferred from the return type of the parent function in MCInstLower.
-  Multivalue = 0xffff,
-};
-
 enum WasmAddressSpace : unsigned {
   // Default address space, for pointers to linear memory (stack, heap, data).
   WASM_ADDRESS_SPACE_DEFAULT = 0,
   // A non-integral address space for pointers to named objects outside of
   // linear memory: WebAssembly globals or WebAssembly locals.  Loads and stores
   // to these pointers are lowered to global.get / global.set or local.get /
   // local.set, as appropriate.
   WASM_ADDRESS_SPACE_VAR = 1,
inline bool isExternrefType(const Type *Ty) {
   return isa<PointerType>(Ty) &&
          Ty->getPointerAddressSpace() ==
              WasmAddressSpace::WASM_ADDRESS_SPACE_EXTERNREF;
 }
 inline bool isRefType(const Type *Ty) {
   return isFuncrefType(Ty) || isExternrefType(Ty);
 }
 
-inline bool isRefType(wasm::ValType Type) {
-  return Type == wasm::ValType::EXTERNREF || Type == wasm::ValType::FUNCREF;
-}
-
 // Convert StringRef to ValType / HealType / BlockType
 
-std::optional<wasm::ValType> parseType(StringRef Type);
-BlockType parseBlockType(StringRef Type);
 MVT parseMVT(StringRef Type);
 
-// Convert ValType or a list/signature of ValTypes to a string.
-
-// Convert an unsinged integer, which can be among wasm::ValType enum, to its
-// type name string. If the input is not within wasm::ValType, returns
-// "invalid_type".
-const char *anyTypeToString(unsigned Type);
-const char *typeToString(wasm::ValType Type);
-// Convert a list of ValTypes into a string in the format of
-// "type0, type1, ... typeN"
-std::string typeListToString(ArrayRef<wasm::ValType> List);
-// Convert a wasm signature into a string in the format of
-// "(params) -> (results)", where params and results are a string of ValType
-// lists.
-std::string signatureToString(const wasm::WasmSignature *Sig);
-
 // Convert a MVT into its corresponding wasm ValType.
 wasm::ValType toValType(MVT Type);
 
-// Convert a register class ID to a wasm ValType.
-wasm::ValType regClassToValType(unsigned RC);
-
 // Convert a register class to a wasm ValType.
 wasm::ValType regClassToValType(const TargetRegisterClass *RC);
 
 /// Sets a Wasm Symbol Type.
 void wasmSymbolSetType(MCSymbolWasm *Sym, const Type *GlobalVT,
                        const SmallVector<MVT, 1> &VTs);
 
 } // end namespace WebAssembly
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.cpp

 #include "llvm/CodeGen/TargetRegisterInfo.h"
 
 // Get register classes enum.
 #define GET_REGINFO_ENUM
 #include "WebAssemblyGenRegisterInfo.inc"
 
 using namespace llvm;
 
-std::optional<wasm::ValType> WebAssembly::parseType(StringRef Type) {
-  // FIXME: can't use StringSwitch because wasm::ValType doesn't have a
-  // "invalid" value.
-  if (Type == "i32")
-    return wasm::ValType::I32;
-  if (Type == "i64")
-    return wasm::ValType::I64;
-  if (Type == "f32")
-    return wasm::ValType::F32;
-  if (Type == "f64")
-    return wasm::ValType::F64;
-  if (Type == "v128" || Type == "i8x16" || Type == "i16x8" || Type == "i32x4" ||
-      Type == "i64x2" || Type == "f32x4" || Type == "f64x2")
-    return wasm::ValType::V128;
-  if (Type == "funcref")
-    return wasm::ValType::FUNCREF;
-  if (Type == "externref")
-    return wasm::ValType::EXTERNREF;
-  return std::nullopt;
-}
-
-WebAssembly::BlockType WebAssembly::parseBlockType(StringRef Type) {
-  // Multivalue block types are handled separately in parseSignature
-  return StringSwitch<WebAssembly::BlockType>(Type)
-      .Case("i32", WebAssembly::BlockType::I32)
-      .Case("i64", WebAssembly::BlockType::I64)
-      .Case("f32", WebAssembly::BlockType::F32)
-      .Case("f64", WebAssembly::BlockType::F64)
-      .Case("v128", WebAssembly::BlockType::V128)
-      .Case("funcref", WebAssembly::BlockType::Funcref)
-      .Case("externref", WebAssembly::BlockType::Externref)
-      .Case("void", WebAssembly::BlockType::Void)
-      .Default(WebAssembly::BlockType::Invalid);
-}
-
 MVT WebAssembly::parseMVT(StringRef Type) {
   return StringSwitch<MVT>(Type)
       .Case("i32", MVT::i32)
       .Case("i64", MVT::i64)
       .Case("f32", MVT::f32)
       .Case("f64", MVT::f64)
       .Case("i64", MVT::i64)
       .Case("v16i8", MVT::v16i8)
       .Case("v8i16", MVT::v8i16)
       .Case("v4i32", MVT::v4i32)
       .Case("v2i64", MVT::v2i64)
       .Case("funcref", MVT::funcref)
       .Case("externref", MVT::externref)
       .Default(MVT::INVALID_SIMPLE_VALUE_TYPE);
 }
 
-// We have various enums representing a subset of these types, use this
-// function to convert any of them to text.
-const char *WebAssembly::anyTypeToString(unsigned Type) {
-  switch (Type) {
-  case wasm::WASM_TYPE_I32:
-    return "i32";
-  case wasm::WASM_TYPE_I64:
-    return "i64";
-  case wasm::WASM_TYPE_F32:
-    return "f32";
-  case wasm::WASM_TYPE_F64:
-    return "f64";
-  case wasm::WASM_TYPE_V128:
-    return "v128";
-  case wasm::WASM_TYPE_FUNCREF:
-    return "funcref";
-  case wasm::WASM_TYPE_EXTERNREF:
-    return "externref";
-  case wasm::WASM_TYPE_FUNC:
-    return "func";
-  case wasm::WASM_TYPE_NORESULT:
-    return "void";
-  default:
-    return "invalid_type";
-  }
-}
-
-const char *WebAssembly::typeToString(wasm::ValType Type) {
-  return anyTypeToString(static_cast<unsigned>(Type));
-}
-
-std::string WebAssembly::typeListToString(ArrayRef<wasm::ValType> List) {
-  std::string S;
-  for (const auto &Type : List) {
-    if (&Type != &List[0])
-      S += ", ";
-    S += WebAssembly::typeToString(Type);
-  }
-  return S;
-}
-
-std::string WebAssembly::signatureToString(const wasm::WasmSignature *Sig) {
-  std::string S("(");
-  S += typeListToString(Sig->Params);
-  S += ") -> (";
-  S += typeListToString(Sig->Returns);
-  S += ")";
-  return S;
-}
-
 wasm::ValType WebAssembly::toValType(MVT Type) {
   switch (Type.SimpleTy) {
   case MVT::i32:
     return wasm::ValType::I32;
   case MVT::i64:
     return wasm::ValType::I64;
   case MVT::f32:
     return wasm::ValType::F32;
case MVT::funcref:
     return wasm::ValType::FUNCREF;
   case MVT::externref:
     return wasm::ValType::EXTERNREF;
   default:
     llvm_unreachable("unexpected type");
   }
 }
 
-wasm::ValType WebAssembly::regClassToValType(unsigned RC) {
-  switch (RC) {
-  case WebAssembly::I32RegClassID:
-    return wasm::ValType::I32;
-  case WebAssembly::I64RegClassID:
-    return wasm::ValType::I64;
-  case WebAssembly::F32RegClassID:
-    return wasm::ValType::F32;
-  case WebAssembly::F64RegClassID:
-    return wasm::ValType::F64;
-  case WebAssembly::V128RegClassID:
-    return wasm::ValType::V128;
-  case WebAssembly::FUNCREFRegClassID:
-    return wasm::ValType::FUNCREF;
-  case WebAssembly::EXTERNREFRegClassID:
-    return wasm::ValType::EXTERNREF;
-  default:
-    llvm_unreachable("unexpected type");
-  }
-}
-
 wasm::ValType WebAssembly::regClassToValType(const TargetRegisterClass *RC) {
   assert(RC != nullptr);
   return regClassToValType(RC->getID());
 }
 
 void WebAssembly::wasmSymbolSetType(MCSymbolWasm *Sym, const Type *GlobalVT,
                                     const SmallVector<MVT, 1> &VTs) {
   assert(!Sym->getType());

llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.h

 class WebAssemblyFunctionInfo;
 class WebAssemblySubtarget;
 
 namespace WebAssembly {
 
 bool isChild(const MachineInstr &MI, const WebAssemblyFunctionInfo &MFI);
 bool mayThrow(const MachineInstr &MI);
 
-// Exception handling / setjmp-longjmp handling command-line options
-extern cl::opt<bool> WasmEnableEmEH;   // asm.js-style EH
-extern cl::opt<bool> WasmEnableEmSjLj; // asm.js-style SjLJ
-extern cl::opt<bool> WasmEnableEH;     // EH using Wasm EH instructions
-extern cl::opt<bool> WasmEnableSjLj;   // SjLj using Wasm EH instructions
-
 // Exception-related function names
 extern const char *const ClangCallTerminateFn;
 extern const char *const CxaBeginCatchFn;
 extern const char *const CxaRethrowFn;
 extern const char *const StdTerminateFn;
 extern const char *const PersonalityWrapperFn;
 
 /// Returns the operand number of a callee, assuming the argument is a call

llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.cpp

 
 #include "WebAssemblyUtilities.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineLoopInfo.h"
 #include "llvm/MC/MCContext.h"
 using namespace llvm;
 
-// Exception handling & setjmp-longjmp handling related options. These are
-// defined here to be shared between WebAssembly and its subdirectories.
-
-// Emscripten's asm.js-style exception handling
-cl::opt<bool> WebAssembly::WasmEnableEmEH(
-    "enable-emscripten-cxx-exceptions",
-    cl::desc("WebAssembly Emscripten-style exception handling"),
-    cl::init(false));
-// Emscripten's asm.js-style setjmp/longjmp handling
-cl::opt<bool> WebAssembly::WasmEnableEmSjLj(
-    "enable-emscripten-sjlj",
-    cl::desc("WebAssembly Emscripten-style setjmp/longjmp handling"),
-    cl::init(false));
-// Exception handling using wasm EH instructions
-cl::opt<bool>
-    WebAssembly::WasmEnableEH("wasm-enable-eh",
-                              cl::desc("WebAssembly exception handling"),
-                              cl::init(false));
-// setjmp/longjmp handling using wasm EH instrutions
-cl::opt<bool>
-    WebAssembly::WasmEnableSjLj("wasm-enable-sjlj",
-                                cl::desc("WebAssembly setjmp/longjmp handling"),
-                                cl::init(false));
-
 // Function names in libc++abi and libunwind
 const char *const WebAssembly::CxaBeginCatchFn = "__cxa_begin_catch";
 const char *const WebAssembly::CxaRethrowFn = "__cxa_rethrow";
 const char *const WebAssembly::StdTerminateFn = "_ZSt9terminatev";
 const char *const WebAssembly::PersonalityWrapperFn =
     "_Unwind_Wasm_CallPersonality";
 
 /// Test whether MI is a child of some other node in an expression tree.

llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 ///   %val = load 'val' field from __WasmLongjmpArgs
 ///   %label = testSetjmp(mem[%env], setjmpTable, setjmpTableSize);
 ///   if (%label == 0)
 ///     __wasm_longjmp(%env, %val)
 ///   catchret to %setjmp.dispatch
 ///
 ///===----------------------------------------------------------------------===//
 
-#include "Utils/WebAssemblyUtilities.h"
+#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
 #include "WebAssembly.h"
 #include "WebAssemblyTargetMachine.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/WasmEHFuncInfo.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"