[WebAssembly] Implementation of table.get/set for reftypes in LLVM IR

[pmatos]

Summary

This change implements new DAG nodes TABLE_GET/TABLE_SET, and lowering
methods for load and stores of reference types from IR arrays. These
global LLVM IR arrays represent tables at the Wasm level.

[pmatos]

Updating over current HEAD to allow it to build in buildbot.

[tlively]

It's very cool to see this all coming together!

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

91

I think the MVT::Other can be rolled into the existing loop. It would also be good to add a comment here about why MVT::Other comes up here.

821

I expect that you'll have to do something here as well.

1429

This can just be a cast if we can assume that it will succeed. (Or maybe we should be checking for success here?)

1471

It would be helpful to add a comment here about what DAG patterns we are expecting to find.

1476–1478

Is there still an ADD when the index is a constant zero?

1487

It seems strange to use a dyn_cast for this (and I'm surprised that works at all!)

1551–1575

It would be good to deduplicate this code with the store case as much as possible.

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

48

Would be good to fix before landing if possible!

llvm/test/CodeGen/WebAssembly/externref-tableget.ll

8

It would be good to add tests with different access patterns as well like constant indices, base + offset indices, etc.

20

Does this need more information to say it is a table?

llvm/test/CodeGen/WebAssembly/funcref-table_call.ll

25–27

Do you think it would be a good idea to skip setting this table slot back to null? I know we discussed this before, but I don't remember what the pros and cons were.

[pmatos]

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

91

Makes sense.

821

I am confused. Is this comment maybe related to D111227 instead?

1429

Right, the will always succeed because of the IsWebAssemblyGlobal condition. Moving to cast.

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

48

Oh, yes, I forgot this. Thanks for pointing it out.

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

821

Oh, actually I think I was confused as well. Disregard this.

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

77

Do you have ideas for this simplification as well?

[pmatos]

llvm/test/CodeGen/WebAssembly/externref-tableget.ll

8

This is a good point and I am looking at this at the moment. Adding a few tests, reveals a couple of issues with hardcoding how a table shows up in the DAG. For example, an access with an offset reveals that the DAG is way more complicated than it needs to be. For example, for:

define %externref @get_externref_from_table_with_offset(i32 %i) {
  %off = add nsw i32 %i, 2
  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
  %ref = load %externref, %externref addrspace(1)* %p
  ret %externref %ref
}

So, an access with a 2 offset from the argument index causes this dag to be generated for the access:

        t2: i32 = WebAssemblyISD::ARGUMENT TargetConstant:i32<0>
      t12: i32 = shl t2, Constant:i32<2>
    t15: i32 = add t12, GlobalAddress:i32<[0 x %extern addrspace(10)*] addrspace(1)* @externref_table> 0
  t16: i32 = add t15, Constant:i32<8>
t10: externref,ch = load<(load (s0) from %ir.p, addrspace 1)> t0, t16, undef:i32

Which looks like: (add (add (shl arg 2) table) 8).
I need to transform this back into a table load from (add arg 2) which seems suboptimal. I am trying to understand if it's possible to tell LLVM not to generate these address offsets for these types of accesses. It certainly seems cleaner than to reverse the computation to find the correct index to access.

[tlively]

llvm/test/CodeGen/WebAssembly/externref-tableget.ll

8

I wonder if there is a way to tell LLVM that the width of an element in the table is just 1. That looks like it would simplify this a lot, if not completely.

[pmatos]

Simplified a lot of code that required some further fixes and de-duplication.

Most importantly, I added many more testcases to ensure different addressing modes are supported.
The way to tell LLVM that externref and funcref pointers should not have complex addressing DAGS with shift/add/muls,
was to add that information to the DataLayout string (p10:8:8-p20:8:8). This forced changes in many testfiles.

This looks now ready for another round of reviewing.

[pmatos]

llvm/test/CodeGen/WebAssembly/externref-tableget.ll

8

I managed to get that sorted in the last patch - which was to add to the datalayout string p10:8:8 and p20:8:8

llvm/test/CodeGen/WebAssembly/funcref-table_call.ll

25–27

So the reason to do this was that if we leave the funcref in the slot, this could create hidden GC roots. Comes from this comment by @wingo : https://reviews.llvm.org/D95425#inline-929792

[tlively]

This is looking good! I'll take a more thorough pass through tomorrow so we can get this landed.

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

1451

Would it make sense to use GlobalAddressSDNode *&GA here to match using a reference for the Idx out-param? That would slightly simplify the code below as well.

llvm/test/CodeGen/WebAssembly/funcref-table_call.ll

25–27

Ah right, thanks!

[pmatos]

Use reference to pointer instead of pointer to pointer as @tlively suggested.

[tlively]

Nice! Just a couple nits but I think this is good to go.

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

1474–1475

It would be nice to switch the if arms around so the else corresponds with the null case.

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

80–83

It would be good to explicitly check the externref address space as well so we can error out if we get an unexpected address space.

[pmatos]

In D111154#3074221, @tlively wrote:

Nice! Just a couple nits but I think this is good to go.

Perfect, thanks for the comments. Fixed nits and landed.

llvm/lib/Target/WebAssembly/WebAssemblyISD.def

 HANDLE_NODETYPE(DEMOTE_ZERO)
 HANDLE_NODETYPE(MEMORY_COPY)
 HANDLE_NODETYPE(MEMORY_FILL)
 
 // Memory intrinsics
 HANDLE_MEM_NODETYPE(LOAD_SPLAT)
 HANDLE_MEM_NODETYPE(GLOBAL_GET)
 HANDLE_MEM_NODETYPE(GLOBAL_SET)
+HANDLE_MEM_NODETYPE(TABLE_GET)
 HANDLE_MEM_NODETYPE(TABLE_SET)

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

WebAssemblyTargetLowering::WebAssemblyTargetLowering(
   if (Subtarget->hasSIMD128()) {
     for (auto T : {MVT::v16i8, MVT::v8i16, MVT::v4i32, MVT::v4f32, MVT::v2i64,
                    MVT::v2f64}) {
       setOperationAction(ISD::LOAD, T, Custom);
       setOperationAction(ISD::STORE, T, Custom);
     }
   }
   if (Subtarget->hasReferenceTypes()) {
     for (auto T : {MVT::externref, MVT::funcref}) {
       setOperationAction(ISD::LOAD, T, Custom);
       setOperationAction(ISD::STORE, T, Custom);
     }
+    setOperationAction(ISD::LOAD, MVT::Other, Custom);
+    setOperationAction(ISD::STORE, MVT::Other, Custom);
   }
 
   setOperationAction(ISD::GlobalAddress, MVTPtr, Custom);
   setOperationAction(ISD::GlobalTLSAddress, MVTPtr, Custom);
   setOperationAction(ISD::ExternalSymbol, MVTPtr, Custom);
   setOperationAction(ISD::JumpTable, MVTPtr, Custom);
   setOperationAction(ISD::BlockAddress, MVTPtr, Custom);
   setOperationAction(ISD::BRIND, MVT::Other, Custom);
EVT WebAssemblyTargetLowering::getSetCCResultType(const DataLayout &DL,
 
   // So far, all branch instructions in Wasm take an I32 condition.
   // The default TargetLowering::getSetCCResultType returns the pointer size,
   // which would be useful to reduce instruction counts when testing
   // against 64-bit pointers/values if at some point Wasm supports that.
   return EVT::getIntegerVT(C, 32);
 }
 
 bool WebAssemblyTargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
                                                    const CallInst &I,
                                                    MachineFunction &MF,
                                                    unsigned Intrinsic) const {
   switch (Intrinsic) {
   case Intrinsic::wasm_memory_atomic_notify:
     Info.opc = ISD::INTRINSIC_W_CHAIN;
     Info.memVT = MVT::i32;
     Info.ptrVal = I.getArgOperand(0);
static Optional<unsigned> IsWebAssemblyLocal(SDValue Op, SelectionDAG &DAG) {
   const FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Op);
   if (!FI)
     return None;
 
   auto &MF = DAG.getMachineFunction();
   return WebAssemblyFrameLowering::getLocalForStackObject(MF, FI->getIndex());
 }
 
+// This function will accept as Op any access to a table, so Op can
+// be the actual table or an offset into the table.
+static bool IsWebAssemblyTable(SDValue Op) {
+  if (Op->getOpcode() == ISD::ADD && Op->getNumOperands() == 2)
+    return IsWebAssemblyTable(Op->getOperand(0));
+  if (IsWebAssemblyGlobal(Op)) {
+    const GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op);
+    const GlobalValue *Value = GA->getGlobal();
+    const Type *Ty = Value->getValueType();
+
+    if (Ty->isArrayTy() &&
+        (WebAssembly::isFuncrefType(Ty->getArrayElementType()) ||
+         WebAssembly::isExternrefType(Ty->getArrayElementType())))
+      return true;
+  }
+  return false;
+}
+
 SDValue WebAssemblyTargetLowering::LowerStore(SDValue Op,
                                               SelectionDAG &DAG) const {
   SDLoc DL(Op);
   StoreSDNode *SN = cast<StoreSDNode>(Op.getNode());
   const SDValue &Value = SN->getValue();
   const SDValue &Base = SN->getBasePtr();
   const SDValue &Offset = SN->getOffset();
 
   if (IsWebAssemblyGlobal(Base)) {
     if (!Offset->isUndef())
       report_fatal_error("unexpected offset when storing to webassembly global",
                          false);
 
     SDVTList Tys = DAG.getVTList(MVT::Other);
     SDValue Ops[] = {SN->getChain(), Value, Base};
     return DAG.getMemIntrinsicNode(WebAssemblyISD::GLOBAL_SET, DL, Tys, Ops,
                                    SN->getMemoryVT(), SN->getMemOperand());
   }
 
   if (Optional<unsigned> Local = IsWebAssemblyLocal(Base, DAG)) {
     if (!Offset->isUndef())
       report_fatal_error("unexpected offset when storing to webassembly local",
                          false);
 
     SDValue Idx = DAG.getTargetConstant(*Local, Base, MVT::i32);
     SDVTList Tys = DAG.getVTList(MVT::Other); // The chain.
     SDValue Ops[] = {SN->getChain(), Idx, Value};
     return DAG.getNode(WebAssemblyISD::LOCAL_SET, DL, Tys, Ops);
   }
 
+  if (IsWebAssemblyTable(Base)) {
+    if (!Offset->isUndef())
+      report_fatal_error(
+          "unexpected offset when storing from webassembly table", false);
+
+    if (Base->getOpcode() != ISD::ADD || Base->getNumOperands() != 2)
+      report_fatal_error("unexpected base when storing from webassembly table",
+                         false);
+
+    GlobalAddressSDNode *GA =
+        dyn_cast<GlobalAddressSDNode>(Base->getOperand(0));
+    if (!GA)
+      report_fatal_error(
+          "unexpected table address when storing from webassembly table",
+          false);
+
+    const SDNode *PtrOffset = dyn_cast<SDNode>(Base->getOperand(1));
+    if (!PtrOffset || PtrOffset->getOpcode() != ISD::SHL)
+      report_fatal_error(
+          "unexpected ptr offset when storing from webassembly table", false);
+
+    SDNode *Idx = dyn_cast<SDNode>(PtrOffset->getOperand(0));
+    if (!Idx)
+      report_fatal_error("unexpected index when storing from webassembly table",
+                         false);
+
+    if (GA->getNumValues() != 1 || Idx->getNumValues() != 1)
+      report_fatal_error(
+          "unexpected number of values when storing from webassembly table",
+          false);
+
+    SDVTList Tys = DAG.getVTList(MVT::Other);
+    SDValue TableSetOps[] = {SN->getChain(), SDValue(GA, 0), SDValue(Idx, 0),
+                             Value};
+    SDValue TableSet =
+        DAG.getMemIntrinsicNode(WebAssemblyISD::TABLE_SET, DL, Tys, TableSetOps,
+                                SN->getMemoryVT(), SN->getMemOperand());
+    return TableSet;
+  }
+
   return Op;
 }
 
 SDValue WebAssemblyTargetLowering::LowerLoad(SDValue Op,
                                              SelectionDAG &DAG) const {
   SDLoc DL(Op);
   LoadSDNode *LN = cast<LoadSDNode>(Op.getNode());
   const SDValue &Base = LN->getBasePtr();
if (Optional<unsigned> Local = IsWebAssemblyLocal(Base, DAG)) {
     EVT LocalVT = LN->getValueType(0);
     SDValue LocalGet = DAG.getNode(WebAssemblyISD::LOCAL_GET, DL, LocalVT,
                                    {LN->getChain(), Idx});
     SDValue Result = DAG.getMergeValues({LocalGet, LN->getChain()}, DL);
     assert(Result->getNumValues() == 2 && "Loads must carry a chain!");
     return Result;
   }
 
+  if (IsWebAssemblyTable(Base)) {
+    if (!Offset->isUndef())
+      report_fatal_error(
+          "unexpected offset when loading from webassembly table", false);
+
+    if (Base->getOpcode() != ISD::ADD || Base->getNumOperands() != 2)
+      report_fatal_error("unexpected base when loading from webassembly table",
+                         false);
+
+    GlobalAddressSDNode *GA =
+        dyn_cast<GlobalAddressSDNode>(Base->getOperand(0));
+    if (!GA)
+      report_fatal_error(
+          "unexpected table address when loading from webassembly table",
+          false);
+
+    const SDNode *PtrOffset = dyn_cast<SDNode>(Base->getOperand(1));
+    if (!PtrOffset || PtrOffset->getOpcode() != ISD::SHL)
+      report_fatal_error(
+          "unexpected ptr offset when loading from webassembly table", false);
+
+    SDNode *Idx = dyn_cast<SDNode>(PtrOffset->getOperand(0));
+    if (!Idx)
+      report_fatal_error("unexpected index when loading from webassembly table",
+                         false);
+
+    if (GA->getNumValues() != 1 || Idx->getNumValues() != 1)
+      report_fatal_error(
+          "unexpected number of values when loading from webassembly table",
+          false);
+
+    SDVTList Tys = DAG.getVTList(LN->getValueType(0), MVT::Other);
+    SDValue TableGetOps[] = {LN->getChain(), SDValue(GA, 0), SDValue(Idx, 0)};
+    SDValue TableGet =
+        DAG.getMemIntrinsicNode(WebAssemblyISD::TABLE_GET, DL, Tys, TableGetOps,
+                                LN->getMemoryVT(), LN->getMemOperand());
+    return TableGet;
+  }
+
   return Op;
 }
 
 SDValue WebAssemblyTargetLowering::LowerCopyToReg(SDValue Op,
                                                   SelectionDAG &DAG) const {
   SDValue Src = Op.getOperand(2);
   if (isa<FrameIndexSDNode>(Src.getNode())) {
     // CopyToReg nodes don't support FrameIndex operands. Other targets select

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

 // WebAssemblyInstrTable.td - WebAssembly Table codegen support -*- 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 Table operand code-gen constructs.
 /// Instructions that handle tables
 //===----------------------------------------------------------------------===//
 
-multiclass TABLE<WebAssemblyRegClass rt> {
+def WebAssemblyTableSet_t : SDTypeProfile<0, 3, [SDTCisPtrTy<1>]>;
+def WebAssemblyTableSet : SDNode<"WebAssemblyISD::TABLE_SET", WebAssemblyTableSet_t,
+                                 [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
+
+def WebAssemblyTableGet_t : SDTypeProfile<1, 2, [SDTCisPtrTy<1>]>;
+def WebAssemblyTableGet : SDNode<"WebAssemblyISD::TABLE_GET", WebAssemblyTableGet_t,
+                                 [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
+
+
+multiclass TABLE<WebAssemblyRegClass rc> {
   let mayLoad = 1 in
-  defm TABLE_GET_#rt : I<(outs rt:$res), (ins table32_op:$table, I32:$i),
+  defm TABLE_GET_#rc : I<(outs rc:$res), (ins table32_op:$table, I32:$i),
                          (outs), (ins table32_op:$table),
                          [],
                          "table.get\t$res, $table, $i",
                          "table.get\t$table",
                          0x25>;
 
   let mayStore = 1 in
-  defm TABLE_SET_#rt : I<(outs), (ins table32_op:$table, I32:$i, rt:$val),
+  defm TABLE_SET_#rc : I<(outs), (ins table32_op:$table, I32:$i, rc:$val),
                          (outs), (ins table32_op:$table),
                          [],
                          "table.set\t$table, $i, $val",
                          "table.set\t$table",
                          0x26>;
 
-  defm TABLE_GROW_#rt : I<(outs I32:$sz), (ins table32_op:$table, rt:$val, I32:$n),
+  defm TABLE_GROW_#rc : I<(outs I32:$sz), (ins table32_op:$table, rc:$val, I32:$n),
                           (outs), (ins table32_op:$table),
                           [],
                           "table.grow\t$sz, $table, $val, $n",
                           "table.grow\t$table",
                           0xfc0f>;
 
-  defm TABLE_FILL_#rt : I<(outs), (ins table32_op:$table, I32:$i, rt:$val, I32:$n),
+  defm TABLE_FILL_#rc : I<(outs), (ins table32_op:$table, I32:$i, rc:$val, I32:$n),
                           (outs), (ins table32_op:$table),
                           [],
                           "table.fill\t$table, $i, $val, $n",
                           "table.fill\t$table",
                           0xfc11>;
 
+  foreach vt = rc.RegTypes in {
+    def : Pat<(vt (WebAssemblyTableGet (WebAssemblyWrapper tglobaladdr:$table), i32:$idx)),
+              (!cast<NI>("TABLE_GET_" # rc) tglobaladdr:$table, i32:$idx)>;
+    def : Pat<(WebAssemblyTableSet
+               (WebAssemblyWrapper tglobaladdr:$table),
+               i32:$idx,
+               vt:$src),
+              (!cast<NI>("TABLE_SET_" # rc) tglobaladdr:$table, i32:$idx, vt:$src)>;
+  }
 }
 
 defm "" : TABLE<FUNCREF>, Requires<[HasReferenceTypes]>;
 defm "" : TABLE<EXTERNREF>, Requires<[HasReferenceTypes]>;
 
-def wasm_table_set_t : SDTypeProfile<0, 3, []>;
-def wasm_table_set : SDNode<"WebAssemblyISD::TABLE_SET", wasm_table_set_t,
-                            [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
-
-def : Pat<(wasm_table_set i32:$table, i32:$idx, funcref:$r),
-          (TABLE_SET_FUNCREF i32:$table, i32:$idx, funcref:$r)>,
-          Requires<[HasReferenceTypes]>;
-def : Pat<(wasm_table_set i32:$table, i32:$idx, externref:$r),
-          (TABLE_SET_EXTERNREF i32:$table, i32:$idx, externref:$r)>,
+def : Pat<(WebAssemblyTableSet mcsym:$table, i32:$idx, funcref:$r),
+          (TABLE_SET_FUNCREF mcsym:$table, i32:$idx, funcref:$r)>,
           Requires<[HasReferenceTypes]>;
 
 defm TABLE_SIZE : I<(outs I32:$sz), (ins table32_op:$table),
                     (outs), (ins table32_op:$table),
                     [],
                     "table.size\t$sz, $table",
                     "table.size\t$table",
                     0xfc10>,

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyMCInstLower.h"
 #include "TargetInfo/WebAssemblyTargetInfo.h"
 #include "Utils/WebAssemblyTypeUtilities.h"
 #include "Utils/WebAssemblyUtilities.h"
 #include "WebAssemblyAsmPrinter.h"
+#include "WebAssemblyISelLowering.h"
 #include "WebAssemblyMachineFunctionInfo.h"
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSymbolWasm.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
+
 using namespace llvm;
 
 // This disables the removal of registers when lowering into MC, as required
 // by some current tests.
 cl::opt<bool>
     WasmKeepRegisters("wasm-keep-registers", cl::Hidden,
                       cl::desc("WebAssembly: output stack registers in"
                                " instruction output for test purposes only."),
                       cl::init(false));
 
 extern cl::opt<bool> WasmEnableEmEH;
 extern cl::opt<bool> WasmEnableEmSjLj;
 
 static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI);
 
+// FIXME: this is sort of duplicated into WebAssemblyISelLowering...
+static bool isRefType(const Type *Ty) {
+  return isa<PointerType>(Ty) &&
+         (Ty->getPointerAddressSpace() ==
+              WebAssembly::WasmAddressSpace::WASM_ADDRESS_SPACE_FUNCREF ||
+          Ty->getPointerAddressSpace() ==
+              WebAssembly::WasmAddressSpace::WASM_ADDRESS_SPACE_EXTERNREF);
+}
+
 MCSymbol *
 WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
   const GlobalValue *Global = MO.getGlobal();
   if (!isa<Function>(Global)) {
     auto *WasmSym = cast<MCSymbolWasm>(Printer.getSymbol(Global));
     // If the symbol doesn't have an explicit WasmSymbolType yet and the
     // GlobalValue is actually a WebAssembly global, then ensure the symbol is a
     // WASM_SYMBOL_TYPE_GLOBAL.
     if (WebAssembly::isWasmVarAddressSpace(Global->getAddressSpace()) &&
         !WasmSym->getType()) {
       const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
       const TargetMachine &TM = MF.getTarget();
       const Function &CurrentFunc = MF.getFunction();
+      Type *GlobalVT = Global->getValueType();
       SmallVector<MVT, 1> VTs;
-      computeLegalValueVTs(CurrentFunc, TM, Global->getValueType(), VTs);
-      if (VTs.size() != 1)
-        report_fatal_error("Aggregate globals not yet implemented");
+      computeLegalValueVTs(CurrentFunc, TM, GlobalVT, VTs);
 
+      // 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.
+      // FIXME: the following code can be simplified.
+      if (GlobalVT->isArrayTy() && isRefType(GlobalVT->getArrayElementType())) {
+        bool Mutable = true;
+        MVT VT =
+            GlobalVT->getArrayElementType()->getPointerAddressSpace() ==
+                    WebAssembly::WasmAddressSpace::WASM_ADDRESS_SPACE_FUNCREF
+                ? MVT::funcref
+                : MVT::externref;
+        wasm::ValType Type = WebAssembly::toValType(VT);
+        WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
+        WasmSym->setGlobalType(wasm::WasmGlobalType{uint8_t(Type), Mutable});
+      } else if (VTs.size() == 1) {
         bool Mutable = true;
         wasm::ValType Type = WebAssembly::toValType(VTs[0]);
         WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
         WasmSym->setGlobalType(wasm::WasmGlobalType{uint8_t(Type), Mutable});
+      } else
+        report_fatal_error("Aggregate globals not yet implemented");
     }
     return WasmSym;
   }
 
   const auto *FuncTy = cast<FunctionType>(Global->getValueType());
   const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
   const TargetMachine &TM = MF.getTarget();
   const Function &CurrentFunc = MF.getFunction();

llvm/lib/Target/WebAssembly/WebAssemblyRegStackify.cpp

static unsigned getTeeOpcode(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::I64RegClass)
     return WebAssembly::TEE_I64;
   if (RC == &WebAssembly::F32RegClass)
     return WebAssembly::TEE_F32;
   if (RC == &WebAssembly::F64RegClass)
     return WebAssembly::TEE_F64;
   if (RC == &WebAssembly::V128RegClass)
     return WebAssembly::TEE_V128;
+  if (RC == &WebAssembly::EXTERNREFRegClass)
+    return WebAssembly::TEE_EXTERNREF;
+  if (RC == &WebAssembly::FUNCREFRegClass)
+    return WebAssembly::TEE_FUNCREF;
   llvm_unreachable("Unexpected register class");
 }
 
 // Shrink LI to its uses, cleaning up LI.
 static void shrinkToUses(LiveInterval &LI, LiveIntervals &LIS) {
   if (LIS.shrinkToUses(&LI)) {
     SmallVector<LiveInterval *, 4> SplitLIs;
     LIS.splitSeparateComponents(LI, SplitLIs);

llvm/test/CodeGen/WebAssembly/externref-tableget.ll

+; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
+
+%extern = type opaque
+%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+
+@externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+define %externref @get_externref_from_table(i32 %i) {
+  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %i
+  %ref = load %externref, %externref addrspace(1)* %p
+  ret %externref %ref
+}
+
+; CHECK-LABEL: get_externref_from_table:
+; CHECK-NEXT: .functype       get_externref_from_table (i32) -> (externref)
+; CHECK-NEXT: local.get 0
+; CHECK-NEXT: table.get externref_table
+; CHECK-NEXT: end_function
+
+; CHECK: .globl externref_table

llvm/test/CodeGen/WebAssembly/externref-tableset.ll

+; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
+
+%extern = type opaque
+%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+
+@externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+define void @set_externref_table(%externref %g, i32 %i) {
+  ;; this generates a table.set of @externref_table
+  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %i
+  store %externref %g, %externref addrspace(1)* %p
+  ret void
+}
+
+; CHECK-LABEL: set_externref_table:
+; CHECK-NEXT: .functype       set_externref_table (externref, i32) -> ()
+; CHECK-NEXT: local.get      1
+; CHECK-NEXT: local.get      0
+; CHECK-NEXT: table.set     externref_table
+; CHECK-NEXT: end_function
+
+; CHECK: .globl externref_table

llvm/test/CodeGen/WebAssembly/funcref-table_call.ll

+; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
+
+%func = type void ()
+%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+
+@funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
+
+define void @call_funcref_from_table(i32 %i) {
+  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %i
+  %ref = load %funcref, %funcref addrspace(1)* %p
+  call addrspace(20) void %ref()
+  ret void
+}
+
+; CHECK: .tabletype __funcref_call_table, funcref, 1
+
+; CHECK-LABEL: call_funcref_from_table:
+; CHECK-NEXT: .functype       call_funcref_from_table (i32) -> ()
+; CHECK-NEXT: i32.const       0
+; CHECK-NEXT: local.get       0
+; CHECK-NEXT: table.get       funcref_table
+; CHECK-NEXT: table.set       __funcref_call_table
+; CHECK-NEXT: i32.const       0
+; CHECK-NEXT: call_indirect    __funcref_call_table, () -> ()
+; CHECK-NEXT: i32.const       0
+; CHECK-NEXT: ref.null        func
+; CHECK-NEXT: table.set       __funcref_call_table
+; CHECK-NEXT: end_function
+
+
+; CHECK:     .globl funcref_table
+; CHECK-NEXT .globaltype     funcref_table, funcref

llvm/test/CodeGen/WebAssembly/funcref-tableget.ll

+; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
+
+%func = type void ()
+%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+
+@funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
+
+define %funcref @get_funcref_from_table(i32 %i) {
+  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %i
+  %ref = load %funcref, %funcref addrspace(1)* %p
+  ret %funcref %ref
+}
+
+; CHECK-LABEL: get_funcref_from_table:
+; CHECK-NEXT: .functype       get_funcref_from_table (i32) -> (funcref)
+; CHECK-NEXT: local.get 0
+; CHECK-NEXT: table.get funcref_table
+; CHECK-NEXT: end_function
+
+; CHECK: .globl funcref_table