[WebAssembly] Add support for externref to MC and wasm-ld

[sbc100]

Summary

This allows code for handling externref values to be processed by the
assembler and linker.

[sbc100]

Should be an easy review for somebody ?

[sbc100]

clang-tidy

[dschuff]

llvm/include/llvm/BinaryFormat/Wasm.h

262

are there any tests for ref.null?

[sbc100]

llvm/include/llvm/BinaryFormat/Wasm.h

262

This is used in the binary format init expressions only.. nothing to do with the llvm or its codegen. You can see it tested in externref.s

[sbc100]

ping..

[dschuff]

oh i missed that it's tested in the initexprs.

lld/test/wasm/externref.s

+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -o %t.o %s
+# RUN: wasm-ld %t.o -o %t.wasm
+# RUN: obj2yaml %t.wasm | FileCheck %s
+
+# Tests use of externref type, including storing it in a global
+
+.globaltype my_global, externref
+
+.globl read_externref
+read_externref:
+  .functype read_externref () -> (externref)
+  global.get my_global
+  end_function
+
+.globl write_externref
+write_externref:
+  .functype write_externref (externref) -> ()
+  local.get 0
+  global.set my_global
+  end_function
+
+my_global:
+
+.globl _start
+_start:
+  .functype _start () -> ()
+  call read_externref
+  call write_externref
+  end_function
+
+#      CHECK:  - Type:            GLOBAL
+# CHECK-NEXT:    Globals:
+# CHECK-NEXT:      - Index:           0
+# CHECK-NEXT:        Type:            I32
+# CHECK-NEXT:        Mutable:         true
+# CHECK-NEXT:        InitExpr:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           66560
+# CHECK-NEXT:      - Index:           1
+# CHECK-NEXT:        Type:            EXTERNREF
+# CHECK-NEXT:        Mutable:         true
+# CHECK-NEXT:        InitExpr:
+# CHECK-NEXT:          Opcode:          REF_NULL
+# CHECK-NEXT:          Type:            EXTERNREF

lld/wasm/WriterUtils.cpp

std::string toString(ValType type) {
   case ValType::F32:
     return "f32";
   case ValType::F64:
     return "f64";
   case ValType::V128:
     return "v128";
   case ValType::EXNREF:
     return "exnref";
+  case ValType::EXTERNREF:
+    return "externref";
   }
   llvm_unreachable("Invalid wasm::ValType");
 }
 
 std::string toString(const WasmSignature &sig) {
   SmallString<128> s("(");
   for (ValType type : sig.Params) {
     if (s.size() != 1)
case WASM_OPCODE_F32_CONST:
     writeU32(os, initExpr.Value.Float32, "literal (f32)");
     break;
   case WASM_OPCODE_F64_CONST:
     writeU64(os, initExpr.Value.Float64, "literal (f64)");
     break;
   case WASM_OPCODE_GLOBAL_GET:
     writeUleb128(os, initExpr.Value.Global, "literal (global index)");
     break;
+  case WASM_OPCODE_REF_NULL:
+    writeValueType(os, ValType::EXTERNREF, "literal (externref type)");
+    break;
   default:
     fatal("unknown opcode in init expr: " + Twine(initExpr.Opcode));
   }
   writeU8(os, WASM_OPCODE_END, "opcode:end");
 }
 
 void writeLimits(raw_ostream &os, const WasmLimits &limits) {
   writeU8(os, limits.Flags, "limits flags");

llvm/include/llvm/BinaryFormat/Wasm.h

 enum : unsigned {
   WASM_TYPE_I32 = 0x7F,
   WASM_TYPE_I64 = 0x7E,
   WASM_TYPE_F32 = 0x7D,
   WASM_TYPE_F64 = 0x7C,
   WASM_TYPE_V128 = 0x7B,
   WASM_TYPE_FUNCREF = 0x70,
   WASM_TYPE_EXNREF = 0x68,
+  WASM_TYPE_EXTERNREF = 0x6F,
   WASM_TYPE_FUNC = 0x60,
   WASM_TYPE_NORESULT = 0x40, // for blocks with no result values
 };
 
 // Kinds of externals (for imports and exports).
 enum : unsigned {
   WASM_EXTERNAL_FUNCTION = 0x0,
   WASM_EXTERNAL_TABLE = 0x1,
enum : unsigned {
   WASM_OPCODE_GLOBAL_GET = 0x23,
   WASM_OPCODE_GLOBAL_SET = 0x24,
   WASM_OPCODE_I32_STORE = 0x36,
   WASM_OPCODE_I32_CONST = 0x41,
   WASM_OPCODE_I64_CONST = 0x42,
   WASM_OPCODE_F32_CONST = 0x43,
   WASM_OPCODE_F64_CONST = 0x44,
   WASM_OPCODE_I32_ADD = 0x6a,
+  WASM_OPCODE_REF_NULL = 0xd0,
 };
 
 // Opcodes used in synthetic functions.
 enum : unsigned {
   WASM_OPCODE_IF = 0x04,
   WASM_OPCODE_ELSE = 0x05,
   WASM_OPCODE_DROP = 0x1a,
   WASM_OPCODE_MISC_PREFIX = 0xfc,

 // Subset of types that a value can have
 enum class ValType {
   I32 = WASM_TYPE_I32,
   I64 = WASM_TYPE_I64,
   F32 = WASM_TYPE_F32,
   F64 = WASM_TYPE_F64,
   V128 = WASM_TYPE_V128,
   EXNREF = WASM_TYPE_EXNREF,
+  EXTERNREF = WASM_TYPE_EXTERNREF,
 };
 
 struct WasmSignature {
   SmallVector<ValType, 1> Returns;
   SmallVector<ValType, 4> Params;
   // Support empty and tombstone instances, needed by DenseMap.
   enum { Plain, Empty, Tombstone } State = Plain;
 

llvm/lib/MC/WasmObjectWriter.cpp

case wasm::WASM_TYPE_I64:
       encodeSLEB128(0, W.OS);
       break;
     case wasm::WASM_TYPE_F32:
       writeI32(0);
       break;
     case wasm::WASM_TYPE_F64:
       writeI64(0);
       break;
+    case wasm::WASM_TYPE_EXTERNREF:
+      writeValueType(wasm::ValType::EXTERNREF);
+      break;
     default:
       llvm_unreachable("unexpected type");
     }
     W.OS << char(wasm::WASM_OPCODE_END);
   }
 
   endSection(Section);
 }
if (WS.isFunction()) {
           Global.InitExpr.Opcode = wasm::WASM_OPCODE_I64_CONST;
           break;
         case wasm::WASM_TYPE_F32:
           Global.InitExpr.Opcode = wasm::WASM_OPCODE_F32_CONST;
           break;
         case wasm::WASM_TYPE_F64:
           Global.InitExpr.Opcode = wasm::WASM_OPCODE_F64_CONST;
           break;
+        case wasm::WASM_TYPE_EXTERNREF:
+          Global.InitExpr.Opcode = wasm::WASM_OPCODE_REF_NULL;
+          break;
         default:
           llvm_unreachable("unexpected type");
         }
         WasmIndices[&WS] = Global.Index;
         Globals.push_back(Global);
       } else {
         // An import; the index was assigned above
         LLVM_DEBUG(dbgs() << "  -> global index: "

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_OPCODE_F32_CONST:
     Expr.Value.Float32 = readFloat32(Ctx);
     break;
   case wasm::WASM_OPCODE_F64_CONST:
     Expr.Value.Float64 = readFloat64(Ctx);
     break;
   case wasm::WASM_OPCODE_GLOBAL_GET:
     Expr.Value.Global = readULEB128(Ctx);
     break;
+  case wasm::WASM_OPCODE_REF_NULL: {
+    wasm::ValType Ty = static_cast<wasm::ValType>(readULEB128(Ctx));
+    if (Ty != wasm::ValType::EXTERNREF) {
+      return make_error<GenericBinaryError>("Invalid type for ref.null",
+                                            object_error::parse_failed);
+    }
+    break;
+  }
   default:
     return make_error<GenericBinaryError>("Invalid opcode in init_expr",
                                           object_error::parse_failed);
   }
 
   uint8_t EndOpcode = readOpcode(Ctx);
   if (EndOpcode != wasm::WASM_OPCODE_END) {
     return make_error<GenericBinaryError>("Invalid init_expr",

llvm/lib/ObjectYAML/WasmYAML.cpp

case wasm::WASM_OPCODE_F32_CONST:
     IO.mapRequired("Value", Expr.Value.Float32);
     break;
   case wasm::WASM_OPCODE_F64_CONST:
     IO.mapRequired("Value", Expr.Value.Float64);
     break;
   case wasm::WASM_OPCODE_GLOBAL_GET:
     IO.mapRequired("Index", Expr.Value.Global);
     break;
+  case wasm::WASM_OPCODE_REF_NULL: {
+    WasmYAML::ValueType Ty = wasm::WASM_TYPE_EXTERNREF;
+    IO.mapRequired("Type", Ty);
+    break;
+  }
   }
 }
 
 void MappingTraits<WasmYAML::DataSegment>::mapping(
     IO &IO, WasmYAML::DataSegment &Segment) {
   IO.mapOptional("SectionOffset", Segment.SectionOffset);
   IO.mapRequired("InitFlags", Segment.InitFlags);
   if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX) {
void ScalarEnumerationTraits<WasmYAML::ValueType>::enumeration(
     IO &IO, WasmYAML::ValueType &Type) {
 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
   ECase(I32);
   ECase(I64);
   ECase(F32);
   ECase(F64);
   ECase(V128);
   ECase(FUNCREF);
+  ECase(EXNREF);
+  ECase(EXTERNREF);
   ECase(FUNC);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::ExportKind>::enumeration(
     IO &IO, WasmYAML::ExportKind &Kind) {
 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_EXTERNAL_##X);
   ECase(FUNCTION);
   ECase(TABLE);
   ECase(MEMORY);
   ECase(GLOBAL);
   ECase(EVENT);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::Opcode>::enumeration(
     IO &IO, WasmYAML::Opcode &Code) {
 #define ECase(X) IO.enumCase(Code, #X, wasm::WASM_OPCODE_##X);
   ECase(END);
   ECase(I32_CONST);
   ECase(I64_CONST);
   ECase(F64_CONST);
   ECase(F32_CONST);
   ECase(GLOBAL_GET);
+  ECase(REF_NULL);
 #undef ECase
 }
 
 void ScalarEnumerationTraits<WasmYAML::TableType>::enumeration(
     IO &IO, WasmYAML::TableType &Type) {
 #define ECase(X) IO.enumCase(Type, #X, wasm::WASM_TYPE_##X);
   ECase(FUNCREF);
 #undef ECase

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

Optional<wasm::ValType> parseType(const StringRef &Type) {
     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 == "exnref")
       return wasm::ValType::EXNREF;
+    if (Type == "externref")
+      return wasm::ValType::EXTERNREF;
     return Optional<wasm::ValType>();
   }
 
   WebAssembly::BlockType parseBlockType(StringRef ID) {
     // Multivalue block types are handled separately in parseSignature
     return StringSwitch<WebAssembly::BlockType>(ID)
         .Case("i32", WebAssembly::BlockType::I32)
         .Case("i64", WebAssembly::BlockType::I64)

llvm/test/MC/WebAssembly/externref.s

+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck %s
+
+# Tests use of externref type, including storing it in a global
+
+.globaltype my_global, externref
+
+.globl read_externref
+read_externref:
+  .functype read_externref () -> (externref)
+  global.get my_global
+  end_function
+
+.globl write_externref
+write_externref:
+  .functype write_externref (externref) -> ()
+  local.get 0
+  global.set my_global
+  end_function
+
+.globl call_with_ref
+call_with_ref:
+  .functype call_with_ref () -> ()
+  call read_externref
+  call write_externref
+  end_function
+
+my_global:
+
+#      CHECK:  - Type:            GLOBAL
+# CHECK-NEXT:    Globals:
+# CHECK-NEXT:      - Index:           0
+# CHECK-NEXT:        Type:            EXTERNREF
+# CHECK-NEXT:        Mutable:         true
+# CHECK-NEXT:        InitExpr:
+# CHECK-NEXT:          Opcode:          REF_NULL
+# CHECK-NEXT:          Type:            EXTERNREF