[WebAssembly] Use llvm::Optional to store optional symbol attributes. NFC.

[sbc100]

Summary

The changes the in-memory representation of wasm symbols such that their
optional ImportName and ImportModule use llvm::Optional.

ImportName is set whenever WASM_SYMBOL_EXPLICIT_NAME flag is set.
ImportField is set whenever the field in the object file is non-empty.

ImportName is set whenever WASM_SYMBOL_EXPLICIT_NAME flag is set.
ImportModule (for imports) is currently always set since it defaults to
"env".

In the future we can possibly extent to binary format distingish
import which have explit module names.

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: CMakeCache.txt, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[sbc100]

rebase and cut down

[sunfish]

LGTM!

[sbc100]

• clang-format

lld/wasm/Driver.cpp

if (auto *lazySym = dyn_cast<LazySymbol>(sym)) {
     if (isBitcode(mb))
       lazySym->fetch();
   }
 }
 
 static UndefinedGlobal *
 createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) {
   auto *sym = cast<UndefinedGlobal>(symtab->addUndefinedGlobal(
-      name, name, defaultModule, WASM_SYMBOL_UNDEFINED, nullptr, type));
+      name, None, None, WASM_SYMBOL_UNDEFINED, nullptr, type));
   config->allowUndefinedSymbols.insert(sym->getName());
   sym->isUsedInRegularObj = true;
   return sym;
 }
 
 static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable,
                                           int value) {
   llvm::wasm::WasmGlobal wasmGlobal;

 // This data structure is instantiated for each -wrap option.
 struct WrappedSymbol {
   Symbol *sym;
   Symbol *real;
   Symbol *wrap;
 };
 
 static Symbol *addUndefined(StringRef name) {
-  return symtab->addUndefinedFunction(name, "", "", WASM_SYMBOL_UNDEFINED,
+  return symtab->addUndefinedFunction(name, None, None, WASM_SYMBOL_UNDEFINED,
                                       nullptr, nullptr, false);
 }
 
 // Handles -wrap option.
 //
 // This function instantiates wrapper symbols. At this point, they seem
 // like they are not being used at all, so we explicitly set some flags so
 // that LTO won't eliminate them.

lld/wasm/InputFiles.cpp

static Symbol *createBitcodeSymbol(const std::vector<bool> &keptComdats,
   flags |= mapVisibility(objSym.getVisibility());
 
   int c = objSym.getComdatIndex();
   bool excludedByComdat = c != -1 && !keptComdats[c];
 
   if (objSym.isUndefined() || excludedByComdat) {
     flags |= WASM_SYMBOL_UNDEFINED;
     if (objSym.isExecutable())
-      return symtab->addUndefinedFunction(name, "", "", flags, &f, nullptr,
+      return symtab->addUndefinedFunction(name, None, None, flags, &f, nullptr,
                                           true);
     return symtab->addUndefinedData(name, flags, &f);
   }
 
   if (objSym.isExecutable())
     return symtab->addDefinedFunction(name, flags, &f, nullptr);
   return symtab->addDefinedData(name, flags, &f, nullptr, 0, 0);
 }

lld/wasm/LTO.cpp

 }
 
 BitcodeCompiler::BitcodeCompiler() : ltoObj(createLTO()) {}
 
 BitcodeCompiler::~BitcodeCompiler() = default;
 
 static void undefine(Symbol *s) {
   if (auto f = dyn_cast<DefinedFunction>(s))
-    replaceSymbol<UndefinedFunction>(f, f->getName(), "", "", 0, f->getFile(),
-                                     f->signature);
+    replaceSymbol<UndefinedFunction>(f, f->getName(), None, None, 0,
+                                     f->getFile(), f->signature);
   else if (isa<DefinedData>(s))
     replaceSymbol<UndefinedData>(s, s->getName(), 0, s->getFile());
   else
     llvm_unreachable("unexpected symbol kind");
 }
 
 void BitcodeCompiler::add(BitcodeFile &f) {
   lto::InputFile &obj = *f.obj;

lld/wasm/SymbolTable.h

 #define LLD_WASM_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
 #include "LTO.h"
 #include "Symbols.h"
 #include "lld/Common/LLVM.h"
 #include "llvm/ADT/CachedHashString.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/Optional.h"
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
public:
   Symbol *addDefinedData(StringRef name, uint32_t flags, InputFile *file,
                          InputSegment *segment, uint32_t address,
                          uint32_t size);
   Symbol *addDefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
                            InputGlobal *g);
   Symbol *addDefinedEvent(StringRef name, uint32_t flags, InputFile *file,
                           InputEvent *e);
 
-  Symbol *addUndefinedFunction(StringRef name, StringRef importName,
-                               StringRef importModule, uint32_t flags,
-                               InputFile *file, const WasmSignature *signature,
+  Symbol *addUndefinedFunction(StringRef name,
+                               llvm::Optional<StringRef> importName,
+                               llvm::Optional<StringRef> importModule,
+                               uint32_t flags, InputFile *file,
+                               const WasmSignature *signature,
                                bool isCalledDirectly);
   Symbol *addUndefinedData(StringRef name, uint32_t flags, InputFile *file);
-  Symbol *addUndefinedGlobal(StringRef name, StringRef importName,
-                             StringRef importModule,  uint32_t flags,
-                             InputFile *file, const WasmGlobalType *type);
+  Symbol *addUndefinedGlobal(StringRef name,
+                             llvm::Optional<StringRef> importName,
+                             llvm::Optional<StringRef> importModule,
+                             uint32_t flags, InputFile *file,
+                             const WasmGlobalType *type);
 
   void addLazy(ArchiveFile *f, const llvm::object::Archive::Symbol *sym);
 
   bool addComdat(StringRef name);
 
   DefinedData *addSyntheticDataSymbol(StringRef name, uint32_t flags);
   DefinedGlobal *addSyntheticGlobal(StringRef name, uint32_t flags,
                                     InputGlobal *global);

lld/wasm/SymbolTable.cpp

 
 // This function get called when an undefined symbol is added, and there is
 // already an existing one in the symbols table.  In this case we check that
 // custom 'import-module' and 'import-field' symbol attributes agree.
 // With LTO these attributes are not available when the bitcode is read and only
 // become available when the LTO object is read.  In this case we silently
 // replace the empty attributes with the valid ones.
 template <typename T>
-static void setImportAttributes(T *existing, StringRef importName,
-                                StringRef importModule, InputFile *file) {
-  if (!importName.empty()) {
-    if (existing->importName.empty())
+static void setImportAttributes(T *existing, Optional<StringRef> importName,
+                                Optional<StringRef> importModule,
+                                InputFile *file) {
+  if (importName) {
+    if (!existing->importName)
       existing->importName = importName;
     if (existing->importName != importName)
       error("import name mismatch for symbol: " + toString(*existing) +
-            "\n>>> defined as " + existing->importName + " in " +
-            toString(existing->getFile()) + "\n>>> defined as " + importName +
+            "\n>>> defined as " + *existing->importName + " in " +
+            toString(existing->getFile()) + "\n>>> defined as " + *importName +
             " in " + toString(file));
   }
 
-  if (!importModule.empty()) {
-    if (existing->importModule.empty())
+  if (importModule) {
+    if (!existing->importModule)
       existing->importModule = importModule;
     if (existing->importModule != importModule)
       error("import module mismatch for symbol: " + toString(*existing) +
-            "\n>>> defined as " + existing->importModule + " in " +
-            toString(existing->getFile()) + "\n>>> defined as " + importModule +
-            " in " + toString(file));
+            "\n>>> defined as " + *existing->importModule + " in " +
+            toString(existing->getFile()) + "\n>>> defined as " +
+            *importModule + " in " + toString(file));
   }
 }
 
-Symbol *SymbolTable::addUndefinedFunction(StringRef name, StringRef importName,
-                                          StringRef importModule,
+Symbol *SymbolTable::addUndefinedFunction(StringRef name,
+                                          Optional<StringRef> importName,
+                                          Optional<StringRef> importModule,
                                           uint32_t flags, InputFile *file,
                                           const WasmSignature *sig,
                                           bool isCalledDirectly) {
   LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << name << " ["
                     << (sig ? toString(*sig) : "none")
                     << "] IsCalledDirectly:" << isCalledDirectly << "\n");
   assert(flags & WASM_SYMBOL_UNDEFINED);
 
if (wasInserted)
     replaceSymbol<UndefinedData>(s, name, flags, file);
   else if (auto *lazy = dyn_cast<LazySymbol>(s))
     lazy->fetch();
   else if (s->isDefined())
     checkDataType(s, file);
   return s;
 }
 
-Symbol *SymbolTable::addUndefinedGlobal(StringRef name, StringRef importName,
-                                        StringRef importModule, uint32_t flags,
-                                        InputFile *file,
+Symbol *SymbolTable::addUndefinedGlobal(StringRef name,
+                                        Optional<StringRef> importName,
+                                        Optional<StringRef> importModule,
+                                        uint32_t flags, InputFile *file,
                                         const WasmGlobalType *type) {
   LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << name << "\n");
   assert(flags & WASM_SYMBOL_UNDEFINED);
 
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
   if (s->traced)

lld/wasm/Symbols.h

 //===- Symbols.h ------------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_SYMBOLS_H
 #define LLD_WASM_SYMBOLS_H
 
 #include "Config.h"
 #include "lld/Common/LLVM.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 
 namespace lld {
 namespace wasm {
 
 // Shared string constants
 
static bool classof(const Symbol *s) {
     return s->kind() == DefinedFunctionKind;
   }
 
   InputFunction *function;
 };
 
 class UndefinedFunction : public FunctionSymbol {
 public:
-  UndefinedFunction(StringRef name, StringRef importName,
-                    StringRef importModule, uint32_t flags,
+  UndefinedFunction(StringRef name, llvm::Optional<StringRef> importName,
+                    llvm::Optional<StringRef> importModule, uint32_t flags,
                     InputFile *file = nullptr,
                     const WasmSignature *type = nullptr,
                     bool isCalledDirectly = true)
       : FunctionSymbol(name, UndefinedFunctionKind, flags, file, type),
-        importName(importName), importModule(importModule), isCalledDirectly(isCalledDirectly) {}
+        importName(importName), importModule(importModule),
+        isCalledDirectly(isCalledDirectly) {}
 
   static bool classof(const Symbol *s) {
     return s->kind() == UndefinedFunctionKind;
   }
 
-  StringRef importName;
-  StringRef importModule;
+  llvm::Optional<StringRef> importName;
+  llvm::Optional<StringRef> importModule;
   bool isCalledDirectly;
 };
 
 // Section symbols for output sections are different from those for input
 // section.  These are generated by the linker and point the OutputSection
 // rather than an InputSection.
 class OutputSectionSymbol : public Symbol {
 public:
static bool classof(const Symbol *s) {
     return s->kind() == DefinedGlobalKind;
   }
 
   InputGlobal *global;
 };
 
 class UndefinedGlobal : public GlobalSymbol {
 public:
-  UndefinedGlobal(StringRef name, StringRef importName, StringRef importModule,
-                  uint32_t flags, InputFile *file = nullptr,
+  UndefinedGlobal(StringRef name, llvm::Optional<StringRef> importName,
+                  llvm::Optional<StringRef> importModule, uint32_t flags,
+                  InputFile *file = nullptr,
                   const WasmGlobalType *type = nullptr)
       : GlobalSymbol(name, UndefinedGlobalKind, flags, file, type),
         importName(importName), importModule(importModule) {}
 
   static bool classof(const Symbol *s) {
     return s->kind() == UndefinedGlobalKind;
   }
 
-  StringRef importName;
-  StringRef importModule;
+  llvm::Optional<StringRef> importName;
+  llvm::Optional<StringRef> importModule;
 };
 
 // Wasm events are features that suspend the current execution and transfer the
 // control flow to a corresponding handler. Currently the only supported event
 // kind is exceptions.
 //
 // Event tags are values to distinguish different events. For exceptions, they
 // can be used to distinguish different language's exceptions, i.e., all C++
union SymbolUnion {
   alignas(UndefinedData) char g[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char h[sizeof(UndefinedGlobal)];
   alignas(SectionSymbol) char i[sizeof(SectionSymbol)];
 };
 
 // It is important to keep the size of SymbolUnion small for performance and
 // memory usage reasons. 96 bytes is a soft limit based on the size of
 // UndefinedFunction on a 64-bit system.
-static_assert(sizeof(SymbolUnion) <= 96, "SymbolUnion too large");
+static_assert(sizeof(SymbolUnion) <= 112, "SymbolUnion too large");
 
 void printTraceSymbol(Symbol *sym);
 void printTraceSymbolUndefined(StringRef name, const InputFile* file);
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *s, ArgT &&... arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");

lld/wasm/SyntheticSections.cpp

if (config->importTable) {
     import.Table.ElemType = WASM_TYPE_FUNCREF;
     import.Table.Limits = {0, tableSize, 0};
     writeImport(os, import);
   }
 
   for (const Symbol *sym : importedSymbols) {
     WasmImport import;
     if (auto *f = dyn_cast<UndefinedFunction>(sym)) {
-      import.Field = f->importName;
-      import.Module = f->importModule;
+      import.Field = f->importName ? *f->importName : sym->getName();
+      import.Module = f->importModule ? *f->importModule : defaultModule;
     } else if (auto *g = dyn_cast<UndefinedGlobal>(sym)) {
-      import.Field = g->importName;
-      import.Module = g->importModule;
+      import.Field = g->importName ? *g->importName : sym->getName();
+      import.Module = g->importModule ? *g->importModule : defaultModule;
     } else {
       import.Field = sym->getName();
       import.Module = defaultModule;
     }
 
     if (auto *functionSym = dyn_cast<FunctionSymbol>(sym)) {
       import.Kind = WASM_EXTERNAL_FUNCTION;
       import.SigIndex = out.typeSec->lookupType(*functionSym->signature);

llvm/include/llvm/BinaryFormat/Wasm.h

 // See: https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BINARYFORMAT_WASM_H
 #define LLVM_BINARYFORMAT_WASM_H
 
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 namespace wasm {
 
 // Object file magic string.
 const char WasmMagic[] = {'\0', 'a', 's', 'm'};
struct WasmInitFunc {
   uint32_t Priority;
   uint32_t Symbol;
 };
 
 struct WasmSymbolInfo {
   StringRef Name;
   uint8_t Kind;
   uint32_t Flags;
-  StringRef ImportModule; // For undefined symbols the module of the import
-  StringRef ImportName;   // For undefined symbols the name of the import
-  StringRef ExportName;   // For symbols to be exported from the final module
+  // For undefined symbols the module of the import
+  Optional<StringRef> ImportModule;
+  // For undefined symbols the name of the import
+  Optional<StringRef> ImportName;
+  // For symbols to be exported from the final module
+  Optional<StringRef> ExportName;
   union {
     // For function or global symbols, the index in function or global index
     // space.
     uint32_t ElementIndex;
     // For a data symbols, the address of the data relative to segment.
     WasmDataReference DataRef;
   };
 };

llvm/include/llvm/MC/MCSymbolWasm.h

class MCSymbolWasm : public MCSymbol {
   Optional<wasm::WasmGlobalType> GlobalType;
   Optional<wasm::WasmEventType> EventType;
 
   /// An expression describing how to calculate the size of a symbol. If a
   /// symbol has no size this field will be NULL.
   const MCExpr *SymbolSize = nullptr;
 
 public:
-  // Use a module name of "env" for now, for compatibility with existing tools.
-  // This is temporary, and may change, as the ABI is not yet stable.
   MCSymbolWasm(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindWasm, Name, isTemporary) {}
   static bool classof(const MCSymbol *S) { return S->isWasm(); }
 
   const MCExpr *getSize() const { return SymbolSize; }
   void setSize(const MCExpr *SS) { SymbolSize = SS; }
 
   bool isFunction() const { return Type == wasm::WASM_SYMBOL_TYPE_FUNCTION; }
public:
   void setWeak(bool isWeak) { IsWeak = isWeak; }
 
   bool isHidden() const { return IsHidden; }
   void setHidden(bool isHidden) { IsHidden = isHidden; }
 
   bool isComdat() const { return IsComdat; }
   void setComdat(bool isComdat) { IsComdat = isComdat; }
 
+  bool hasImportModule() const { return ImportModule.hasValue(); }
   const StringRef getImportModule() const {
       if (ImportModule.hasValue()) {
           return ImportModule.getValue();
       }
+      // Use a default module name of "env" for now, for compatibility with
+      // existing tools.
+      // TODO(sbc): Find a way to specify a default value in the object format
+      // without picking a hardcoded value like this.
       return "env";
   }
   void setImportModule(StringRef Name) {
     ImportModule = std::string(std::string(Name));
   }
 
   bool hasImportName() const { return ImportName.hasValue(); }
   const StringRef getImportName() const {

llvm/lib/Object/WasmObjectFile.cpp

case wasm::WASM_SYMBOL_TYPE_FUNCTION:
         Info.Name = readString(Ctx);
         unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
         Signature = &Signatures[FunctionTypes[FuncIndex]];
         wasm::WasmFunction &Function = Functions[FuncIndex];
         if (Function.SymbolName.empty())
           Function.SymbolName = Info.Name;
       } else {
         wasm::WasmImport &Import = *ImportedFunctions[Info.ElementIndex];
-        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
+        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
           Info.Name = readString(Ctx);
-        else
+          Info.ImportName = Import.Field;
+        } else {
           Info.Name = Import.Field;
+        }
         Signature = &Signatures[Import.SigIndex];
-        Info.ImportName = Import.Field;
+        if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
+      }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_GLOBAL:
       Info.ElementIndex = readVaruint32(Ctx);
       if (!isValidGlobalIndex(Info.ElementIndex) ||
           IsDefined != isDefinedGlobalIndex(Info.ElementIndex))
         return make_error<GenericBinaryError>("invalid global symbol index",
                                               object_error::parse_failed);
       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
                             wasm::WASM_SYMBOL_BINDING_WEAK)
         return make_error<GenericBinaryError>("undefined weak global symbol",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
         unsigned GlobalIndex = Info.ElementIndex - NumImportedGlobals;
         wasm::WasmGlobal &Global = Globals[GlobalIndex];
         GlobalType = &Global.Type;
         if (Global.SymbolName.empty())
           Global.SymbolName = Info.Name;
       } else {
         wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
-        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
+        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
           Info.Name = readString(Ctx);
-        else
+          Info.ImportName = Import.Field;
+        } else {
           Info.Name = Import.Field;
+        }
         GlobalType = &Import.Global;
         Info.ImportName = Import.Field;
+        if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
+      }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_DATA:
       Info.Name = readString(Ctx);
       if (IsDefined) {
         uint32_t Index = readVaruint32(Ctx);
         if (Index >= DataSegments.size())
           return make_error<GenericBinaryError>("invalid data symbol index",
case wasm::WASM_SYMBOL_TYPE_EVENT: {
         wasm::WasmEvent &Event = Events[EventIndex];
         Signature = &Signatures[Event.Type.SigIndex];
         EventType = &Event.Type;
         if (Event.SymbolName.empty())
           Event.SymbolName = Info.Name;
 
       } else {
         wasm::WasmImport &Import = *ImportedEvents[Info.ElementIndex];
-        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
+        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
           Info.Name = readString(Ctx);
-        else
+          Info.ImportName = Import.Field;
+        } else {
           Info.Name = Import.Field;
+        }
         EventType = &Import.Event;
         Signature = &Signatures[EventType->SigIndex];
-        Info.ImportName = Import.Field;
+        if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
+      }
       break;
     }
 
     default:
       return make_error<GenericBinaryError>("Invalid symbol type",
                                             object_error::parse_failed);
     }
 

llvm/test/MC/WebAssembly/debug-info.ll

 ; CHECK-NEXT:    Size: 0x4
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: myextern
 ; CHECK-NEXT:    Type: DATA (0x1)
 ; CHECK-NEXT:    Flags [ (0x10)
 ; CHECK-NEXT:      UNDEFINED (0x10)
 ; CHECK-NEXT:    ]
-; CHECK-NEXT:    ImportName:
-; CHECK-NEXT:    ImportModule:
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: ptr2
 ; CHECK-NEXT:    Type: DATA (0x1)
 ; CHECK-NEXT:    Flags [ (0x4)
 ; CHECK-NEXT:      VISIBILITY_HIDDEN (0x4)
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:    Offset: 0x0

llvm/test/tools/llvm-readobj/wasm/symbols.test

 # CHECK-NEXT:     Size: 0xD
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: puts
 # CHECK-NEXT:     Type: FUNCTION (0x0)
 # CHECK-NEXT:     Flags [ (0x10)
 # CHECK-NEXT:       UNDEFINED (0x10)
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     ImportName: puts
 # CHECK-NEXT:     ImportModule: env
 # CHECK-NEXT:     ElementIndex: 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: .LSomeOtherFunction_bitcast
 # CHECK-NEXT:     Type: FUNCTION (0x0)
 # CHECK-NEXT:     Flags [ (0x2)
 # CHECK-NEXT:       BINDING_LOCAL (0x2)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     ElementIndex: 0x3
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: SomeOtherFunction
 # CHECK-NEXT:     Type: FUNCTION (0x0)
 # CHECK-NEXT:     Flags [ (0x10)
 # CHECK-NEXT:       UNDEFINED (0x10)
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     ImportName: SomeOtherFunction
 # CHECK-NEXT:     ImportModule: env
 # CHECK-NEXT:     ElementIndex: 0x1
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]

llvm/test/tools/llvm-readobj/wasm/wasm-imports.test

 # CHECK-NEXT:     ElementIndex: 0x3
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: foo
 # CHECK-NEXT:     Type: FUNCTION (0x0)
 # CHECK-NEXT:     Flags [ (0x10)
 # CHECK-NEXT:       UNDEFINED (0x10)
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     ImportName: foo
 # CHECK-NEXT:     ImportModule: red
 # CHECK-NEXT:     ElementIndex: 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: bar
 # CHECK-NEXT:     Type: FUNCTION (0x0)
 # CHECK-NEXT:     Flags [ (0x50)
 # CHECK-NEXT:       EXPLICIT_NAME (0x40)

llvm/tools/llvm-readobj/WasmDumper.cpp

 void WasmDumper::printSymbol(const SymbolRef &Sym) {
   DictScope D(W, "Symbol");
   WasmSymbol Symbol = Obj->getWasmSymbol(Sym.getRawDataRefImpl());
   W.printString("Name", Symbol.Info.Name);
   W.printEnum("Type", Symbol.Info.Kind, makeArrayRef(WasmSymbolTypes));
   W.printFlags("Flags", Symbol.Info.Flags, makeArrayRef(WasmSymbolFlags));
 
   if (Symbol.Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) {
-    W.printString("ImportName", Symbol.Info.ImportName);
-    W.printString("ImportModule", Symbol.Info.ImportModule);
+    if (Symbol.Info.ImportName) {
+      W.printString("ImportName", *Symbol.Info.ImportName);
+    }
+    if (Symbol.Info.ImportModule) {
+      W.printString("ImportModule", *Symbol.Info.ImportModule);
+    }
   }
   if (Symbol.Info.Kind != wasm::WASM_SYMBOL_TYPE_DATA) {
     W.printHex("ElementIndex", Symbol.Info.ElementIndex);
   } else if (!(Symbol.Info.Flags & wasm::WASM_SYMBOL_UNDEFINED)) {
     W.printHex("Offset", Symbol.Info.DataRef.Offset);
     W.printHex("Segment", Symbol.Info.DataRef.Segment);
     W.printHex("Size", Symbol.Info.DataRef.Size);
   }