[WebAssebmly][MC] Support .import_name/.import_field asm directives

[sbc100]

Summary

Convert the MC test to use asm rather than bitcode.

This is a precursor to https://reviews.llvm.org/D70520.

[sbc100]

ping..

[dschuff]

llvm/test/MC/WebAssembly/import-module.s

14

What should happen if there's a directive that refers to a symbol that doesn't exist in the asm file?

[sbc100]

llvm/test/MC/WebAssembly/import-module.s

14

I seems that it does the same thing we do for .functype above, basically nothing.

[sbc100]

llvm/test/MC/WebAssembly/import-module.s

14

To be a little more specific it seems that for these kind of attributes we call Ctx.getOrCreateSymbol then set a propoerty of the symbol, but if that symbol isn't used elsewhere it isn't included in the output.

[sbc100]

Ping ..

clang/include/clang/Basic/AttrDocs.td

 For more information see
 `gcc documentation <https://gcc.gnu.org/onlinedocs/gcc-7.2.0/gcc/Microsoft-Windows-Variable-Attributes.html>`_
 or `msvc documentation <https://docs.microsoft.com/pl-pl/cpp/cpp/selectany>`_.
 }]; }
 
 def WebAssemblyImportModuleDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
-Clang supports the ``__attribute__((import_module(<module_name>)))`` 
+Clang supports the ``__attribute__((import_module(<module_name>)))``
 attribute for the WebAssembly target. This attribute may be attached to a
 function declaration, where it modifies how the symbol is to be imported
 within the WebAssembly linking environment.
 
 WebAssembly imports use a two-level namespace scheme, consisting of a module
 name, which typically identifies a module from which to import, and a field
 name, which typically identifies a field from that module to import. By
 default, module names for C/C++ symbols are assigned automatically by the
 linker. This attribute can be used to override the default behavior, and
-reuqest a specific module name be used instead.
+request a specific module name be used instead.
   }];
 }
 
 def WebAssemblyImportNameDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
-Clang supports the ``__attribute__((import_name(<name>)))`` 
+Clang supports the ``__attribute__((import_name(<name>)))``
 attribute for the WebAssembly target. This attribute may be attached to a
 function declaration, where it modifies how the symbol is to be imported
 within the WebAssembly linking environment.
 
 WebAssembly imports use a two-level namespace scheme, consisting of a module
 name, which typically identifies a module from which to import, and a field
 name, which typically identifies a field from that module to import. By
 default, field names for C/C++ symbols are the same as their C/C++ symbol
 names. This attribute can be used to override the default behavior, and
-reuqest a specific field name be used instead.
+request a specific field name be used instead.
   }];
 }
 
 def ArtificialDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 The ``artificial`` attribute can be applied to an inline function. If such a
 function is inlined, the attribute indicates that debuggers should associate

llvm/include/llvm/MC/MCSymbolWasm.h

public:
   const StringRef getImportModule() const {
       if (ImportModule.hasValue()) {
           return ImportModule.getValue();
       }
       return "env";
   }
   void setImportModule(StringRef Name) { ImportModule = Name; }
 
+  bool hasImportName() const { return ImportName.hasValue(); }
   const StringRef getImportName() const {
       if (ImportName.hasValue()) {
           return ImportName.getValue();
       }
       return getName();
   }
   void setImportName(StringRef Name) { ImportName = Name; }
 

llvm/lib/MC/WasmObjectWriter.cpp

for (const MCSymbol &S : Asm.symbols()) {
     if (WS.isUndefined())
       Flags |= wasm::WASM_SYMBOL_UNDEFINED;
     if (WS.isNoStrip()) {
       Flags |= wasm::WASM_SYMBOL_NO_STRIP;
       if (isEmscripten()) {
         Flags |= wasm::WASM_SYMBOL_EXPORTED;
       }
     }
-    if (WS.getName() != WS.getImportName())
+    if (WS.hasImportName())
       Flags |= wasm::WASM_SYMBOL_EXPLICIT_NAME;
 
     wasm::WasmSymbolInfo Info;
     Info.Name = WS.getName();
     Info.Kind = WS.getType();
     Info.Flags = Flags;
     if (!WS.isData()) {
       assert(WasmIndices.count(&WS) > 0);

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

if (DirectiveID.getString() == ".functype") {
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       TOut.emitFunctionType(WasmSym);
       // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
+    if (DirectiveID.getString() == ".import_module") {
+      auto SymName = expectIdent();
+      if (SymName.empty())
+        return true;
+      if (expect(AsmToken::Comma, ","))
+        return true;
+      auto ImportModule = expectIdent();
+      auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
+      WasmSym->setImportModule(ImportModule);
+      TOut.emitImportModule(WasmSym, ImportModule);
+    }
+
+    if (DirectiveID.getString() == ".import_name") {
+      auto SymName = expectIdent();
+      if (SymName.empty())
+        return true;
+      if (expect(AsmToken::Comma, ","))
+        return true;
+      auto ImportName = expectIdent();
+      auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
+      WasmSym->setImportName(ImportName);
+      TOut.emitImportName(WasmSym, ImportName);
+    }
+
     if (DirectiveID.getString() == ".eventtype") {
       auto SymName = expectIdent();
       if (SymName.empty())
         return true;
       auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
       auto Signature = std::make_unique<wasm::WasmSignature>();
       if (parseRegTypeList(Signature->Params))
         return true;

llvm/test/MC/WebAssembly/import-module.ll

-; RUN: llc -filetype=obj %s -o - | obj2yaml | FileCheck %s
-
-target triple = "wasm32-unknown-unknown"
-
-define void @test() {
-  call void @foo()
-  call void @plain()
-  ret void
-}
-
-declare void @foo() #0
-declare void @plain()
-
-attributes #0 = { "wasm-import-module"="bar" "wasm-import-name"="qux" }
-
-; CHECK:        - Type:            IMPORT
-; CHECK-NEXT:     Imports:
-; CHECK:            - Module:          bar
-; CHECK-NEXT:         Field:           qux
-; CHECK-NEXT:         Kind:            FUNCTION
-
-; CHECK:            - Module:          env
-; CHECK-NEXT:         Field:           plain
-; CHECK-NEXT:         Kind:            FUNCTION
-
-; CHECK:        - Type:            CUSTOM
-; CHECK:              Name:            foo
-; CHECK-NEXT:         Flags:           [ UNDEFINED, EXPLICIT_NAME ]
-
-; CHECK:              Name:            plain
-; CHECK-NEXT:         Flags:           [ UNDEFINED ]

llvm/test/MC/WebAssembly/import-module.s

+# RUN: llvm-mc -triple=wasm32 < %s | FileCheck %s -check-prefix=CHECK-ASM
+# RUN: llvm-mc -triple=wasm32 -filetype=obj -o - < %s | obj2yaml | FileCheck %s
+
+test:
+  .functype test () -> ()
+  call      foo
+  call      plain
+  end_function
+
+  .functype foo () -> ()
+  .functype plain () -> ()
+  .import_module  foo, bar
+  .import_name  foo, qux
+
+# CHECK-ASM: .import_module  foo, bar
+# CHECK-ASM: .import_name  foo, qux
+
+# CHECK:        - Type:            IMPORT
+# CHECK-NEXT:     Imports:
+# CHECK:            - Module:          bar
+# CHECK-NEXT:         Field:           qux
+# CHECK-NEXT:         Kind:            FUNCTION
+
+# CHECK:            - Module:          env
+# CHECK-NEXT:         Field:           plain
+# CHECK-NEXT:         Kind:            FUNCTION
+
+# CHECK:        - Type:            CUSTOM
+# CHECK:              Name:            foo
+# CHECK-NEXT:         Flags:           [ UNDEFINED, EXPLICIT_NAME ]
+
+# CHECK:              Name:            plain
+# CHECK-NEXT:         Flags:           [ UNDEFINED ]