[WebAssembly] Add assembly syntax for mutable globals

[sbc100]

Summary

This adds and optional ", immutable" to the end of a .globaltype
declaration. I would have prefered to match the .wat syntax
where immutable is the default and mut is the signifier for
mutable globals. Sadly changing the default would break backwards
compat with existing assembly in the wild so I think its best
to stick with this approach.

lld/test/wasm/globals.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
 # RUN: wasm-ld %t.o -o %t.wasm
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 .globl _start
 .globl read_global
 .globl write_global
 
 .globaltype foo_global, i32
 .globaltype bar_global, f32
+.globaltype immutable_global, i32, immutable
 
 read_global:
   .functype read_global () -> (i32)
-  global.get foo_global
+  global.get immutable_global
   end_function
 
 write_global:
   .functype write_global (i32) -> ()
   local.get 0
   global.set foo_global
   f32.const 1.0
   global.set bar_global
   end_function
 
 _start:
   .functype _start () -> ()
   i32.const 1
   call write_global
+  call read_global
+  drop
   end_function
 
 foo_global:
 bar_global:
+immutable_global:
 
 # 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:            I32
-# CHECK-NEXT:        Mutable:         true
-# CHECK-NEXT:        InitExpr:
-# CHECK-NEXT:          Opcode:          I32_CONST
-# CHECK-NEXT:          Value:           0
+# CHECK-NEXT:       - Index:           1
+# CHECK-NEXT:         Type:            I32
+# CHECK-NEXT:         Mutable:         false
+# CHECK-NEXT:         InitExpr:
+# CHECK-NEXT:           Opcode:          I32_CONST
+# CHECK-NEXT:           Value:           0
 # CHECK-NEXT:      - Index:           2
+# CHECK-NEXT:        Type:            I32
+# CHECK-NEXT:        Mutable:         true
+# CHECK-NEXT:        InitExpr:
+# CHECK-NEXT:          Opcode:          I32_CONST
+# CHECK-NEXT:          Value:           0
+# CHECK-NEXT:      - Index:           3
 # CHECK-NEXT:        Type:            F32
 # CHECK-NEXT:        Mutable:         true
 # CHECK-NEXT:        InitExpr:
 # CHECK-NEXT:          Opcode:          F32_CONST
 # CHECK-NEXT:          Value:           0

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

if (DirectiveID.getString() == ".globaltype") {
         return true;
       auto TypeTok = Lexer.getTok();
       auto TypeName = expectIdent();
       if (TypeName.empty())
         return true;
       auto Type = parseType(TypeName);
       if (!Type)
         return error("Unknown type in .globaltype directive: ", TypeTok);
+      // Optional mutable modifier. Default to mutable for historical reasons.
+      // Ideally we would have gone with immutable as the default and used `mut`
+      // as the modifier to match the `.wat` format.
+      bool Mutable = true;
+      if (isNext(AsmToken::Comma)) {
+        TypeTok = Lexer.getTok();
+        auto Id = expectIdent();
+        if (Id == "immutable")
+          Mutable = false;
+        else
+          // Should we also allow `mutable` and `mut` here for clarity?
+          return error("Unknown type in .globaltype modifier: ", TypeTok);
+      }
       // Now set this symbol with the correct type.
       auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
       WasmSym->setGlobalType(
-          wasm::WasmGlobalType{uint8_t(Type.getValue()), true});
+          wasm::WasmGlobalType{uint8_t(Type.getValue()), Mutable});
       // And emit the directive again.
       TOut.emitGlobalType(WasmSym);
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
     if (DirectiveID.getString() == ".functype") {
       // This code has to send things to the streamer similar to
       // WebAssemblyAsmPrinter::EmitFunctionBodyStart.

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

void WebAssemblyTargetAsmStreamer::emitFunctionType(const MCSymbolWasm *Sym) {
   OS << WebAssembly::signatureToString(Sym->getSignature());
   OS << "\n";
 }
 
 void WebAssemblyTargetAsmStreamer::emitGlobalType(const MCSymbolWasm *Sym) {
   assert(Sym->isGlobal());
   OS << "\t.globaltype\t" << Sym->getName() << ", "
      << WebAssembly::typeToString(
-            static_cast<wasm::ValType>(Sym->getGlobalType().Type))
-     << '\n';
+            static_cast<wasm::ValType>(Sym->getGlobalType().Type));
+  if (!Sym->getGlobalType().Mutable)
+    OS << ", immutable";
+  OS << '\n';
 }
 
 void WebAssemblyTargetAsmStreamer::emitEventType(const MCSymbolWasm *Sym) {
   assert(Sym->isEvent());
   OS << "\t.eventtype\t" << Sym->getName() << " ";
   OS << WebAssembly::typeListToString(Sym->getSignature()->Params);
   OS << "\n";
 }

llvm/test/MC/WebAssembly/globals.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown < %s | FileCheck %s
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck -check-prefix=BIN %s
 
 # Tests creating an accessing actual wasm globals
 
 .globl read_global
 .globl write_global
 .globaltype foo_global, i32
-.globaltype global2, i64
+.globaltype global2, i64, immutable
 .globaltype global3, f32
 .globaltype global4, f64
 
 read_global:
   .functype read_global () -> (i32)
   global.get foo_global
   end_function
 

 #      BIN: - Type:            GLOBAL
 # BIN-NEXT:   Globals:
 # BIN-NEXT:     - Index:           0
 # BIN-NEXT:       Type:            I32
 # BIN-NEXT:       Mutable:         true
 # BIN-NEXT:       InitExpr:
 # BIN-NEXT:         Opcode:          I32_CONST
 # BIN-NEXT:         Value:           0
+# BIN-NEXT:     - Index:           1
+# BIN-NEXT:       Type:            I64
+# BIN-NEXT:       Mutable:         false
+# BIN-NEXT:       InitExpr:
+# BIN-NEXT:         Opcode:          I64_CONST
+# BIN-NEXT:         Value:           0
 
 #      BIN:  - Type:            CUSTOM
 # BIN-NEXT:    Name:            linking
 # BIN-NEXT:    Version:         2
 # BIN-NEXT:    SymbolTable:
 # BIN-NEXT:      - Index:           0
 # BIN-NEXT:        Kind:            FUNCTION
 # BIN-NEXT:        Name:            read_global