ELF: Implement basic support for module asm in bitcode files.

[• rafael]

LGTM

ELF/InputFiles.cpp

static uint8_t getGvVisibility(const GlobalValue *GV) {
   llvm_unreachable("unknown visibility");
 }
 
 SymbolBody *
 BitcodeFile::createSymbolBody(const DenseSet<const Comdat *> &KeptComdats,
                               const IRObjectFile &Obj,
                               const BasicSymbolRef &Sym) {
   const GlobalValue *GV = Obj.getSymbolGV(Sym.getRawDataRefImpl());
-  assert(GV);
+  if (GV)
     if (const Comdat *C = GV->getComdat())
       if (!KeptComdats.count(C))
         return nullptr;
 
-  uint8_t Visibility = getGvVisibility(GV);
+  uint32_t Flags = Sym.getFlags();
+  uint8_t Visibility;
+  if (GV)
+    Visibility = getGvVisibility(GV);
+  else
+    // FIXME: Set SF_Hidden flag correctly for module asm symbols, and expose
+    // protected visibility.
+    Visibility = STV_DEFAULT;
 
   SmallString<64> Name;
   raw_svector_ostream OS(Name);
   Sym.printName(OS);
   StringRef NameRef = Saver.save(StringRef(Name));
 
   const Module &M = Obj.getModule();
   SymbolBody *Body;
-  uint32_t Flags = Sym.getFlags();
   bool IsWeak = Flags & BasicSymbolRef::SF_Weak;
   if (Flags & BasicSymbolRef::SF_Undefined) {
     Body = new (Alloc) UndefinedBitcode(NameRef, IsWeak, Visibility);
   } else if (Flags & BasicSymbolRef::SF_Common) {
+    // FIXME: Set SF_Common flag correctly for module asm symbols, and expose
+    // size and alignment.
+    assert(GV);
     const DataLayout &DL = M.getDataLayout();
     uint64_t Size = DL.getTypeAllocSize(GV->getValueType());
     Body = new (Alloc)
         DefinedCommon(NameRef, Size, GV->getAlignment(),
                       IsWeak ? STB_WEAK : STB_GLOBAL, Visibility, /*Type*/ 0);
   } else {
     Body = new (Alloc) DefinedBitcode(NameRef, IsWeak, Visibility);
   }
-  if (GV->isThreadLocal())
+  // FIXME: Expose a thread-local flag for module asm symbols.
+  if (GV && GV->isThreadLocal())
     Body->Type = STT_TLS;
   return Body;
 }
 
 bool BitcodeFile::shouldSkip(const BasicSymbolRef &Sym) {
   uint32_t Flags = Sym.getFlags();
   if (!(Flags & BasicSymbolRef::SF_Global))
     return true;

ELF/LTO.cpp

void BitcodeCompiler::add(BitcodeFile &F) {
   // If a symbol appears in @llvm.used, the linker is required
   // to treat the symbol as there is a reference to the symbol
   // that it cannot see. Therefore, we can't internalize.
   SmallPtrSet<GlobalValue *, 8> Used;
   collectUsedGlobalVariables(M, Used, /* CompilerUsed */ false);
 
   for (const BasicSymbolRef &Sym : Obj->symbols()) {
     GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl());
-    assert(GV);
+    // Ignore module asm symbols.
+    if (!GV)
+      continue;
     if (GV->hasAppendingLinkage()) {
       Keep.push_back(GV);
       continue;
     }
     if (BitcodeFile::shouldSkip(Sym))
       continue;
     SymbolBody *B = Bodies[BodyIndex++];
     if (!B || &B->repl() != B || !isa<DefinedBitcode>(B))

test/ELF/lto/module-asm.ll

+; REQUIRES: x86
+; RUN: llvm-as %s -o %t.o
+; RUN: ld.lld -m elf_x86_64 %t.o -o %t
+; RUN: llvm-nm %t | FileCheck %s
+
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+module asm ".text"
+module asm ".globl foo"
+; CHECK: T foo
+module asm "foo: ret"
+
+declare void @foo()
+
+define void @_start() {
+  call void @foo()
+  ret void
+}