[lld][WebAssembly] Add libcall symbols to the link when LTO is being used.

[sbc100]

Summary

This code is copied almost verbatim from the equivalent change to the
ELF linker:

• https://reviews.llvm.org/D50017
• https://reviews.llvm.org/D50475

The upshot is that libraries containing libcall (such as compiler-rt
and libc) can be compiled with LTO.

Fixes PR41384

[sbc100]

ping.. should be uncontroversial since this code its basically identical to ELF/COFF backends,.

[sbc100]

Adding pcc who wrote the original code.

[sbc100]

rebase

[pcc]

lld/wasm/Driver.cpp

450

Do you really need the isBitcode check in the wasm linker? We needed it in the ELF linker because of some badly behaving libgcc functions, but maybe wasm doesn't have anything like that?

[sbc100]

lld/wasm/Driver.cpp

450

But then wouldn't we end up fetching native object from libraries unnecessarily?

Without this check, if (for example) compiler-rt and libc are compiled as native object files, wouldn't we be loading in a lot of objects that we might never need.

[sbc100]

friendly ping.

[pcc]

lld/wasm/Driver.cpp

450

Sure, but does that matter? If the user passes --gc-sections (meaning that they care about binary size) that shouldn't make a difference to the final output file, I would have thought. Yes, there would be some overhead from loading the object files but maybe it's not enough to worry about. I think either way would be fine with me though.

768

This comment talks about the issue that we hit on ARM and doesn't apply to wasm. I guess you could talk about performance or file size here instead.

[sbc100]

• add comment

[pcc]

LGTM

lld/wasm/Driver.cpp

766

the the -> the

lld/test/wasm/lto/Inputs/libcall-archive.ll

+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+define void @memcpy() {
+  ret void
+}

lld/test/wasm/lto/libcall-archive.ll

+; RUN: rm -f %t.a
+; RUN: llvm-as -o %t.o %s
+; RUN: llvm-as -o %t2.o %S/Inputs/libcall-archive.ll
+; RUN: llvm-ar rcs %t.a %t2.o
+; RUN: wasm-ld -o %t %t.o %t.a
+; RUN: obj2yaml %t | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+define void @_start(i8* %a, i8* %b) {
+entry:
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1024, i1 false)
+  ret void
+}
+
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1)
+
+; CHECK:       - Type:            CUSTOM
+; CHECK-NEXT:    Name:            name
+; CHECK-NEXT:    FunctionNames:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        Name:            _start
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        Name:            memcpy

lld/wasm/Driver.cpp

static Symbol *handleUndefined(StringRef name) {
   sym->isUsedInRegularObj = true;
 
   if (auto *lazySym = dyn_cast<LazySymbol>(sym))
     lazySym->fetch();
 
   return sym;
 }
 
+static void handleLibcall(StringRef name) {
+  Symbol *sym = symtab->find(name);
+  if (!sym)
+    return;
+
+  if (auto *lazySym = dyn_cast<LazySymbol>(sym)) {
+    MemoryBufferRef mb = lazySym->getMemberBuffer();
+    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));
   config->allowUndefinedSymbols.insert(sym->getName());
   sym->isUsedInRegularObj = true;
   return sym;
 }
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   createOptionalSymbols();
 
   if (errorCount())
     return;
 
   // Create wrapped symbols for -wrap option.
   std::vector<WrappedSymbol> wrapped = addWrappedSymbols(args);
 
+  // If any of our inputs are bitcode files, the LTO code generator may create
+  // references to certain library functions that might not be explicit in the
+  // bitcode file's symbol table. If any of those library functions are defined
+  // in a bitcode file in an archive member, we need to arrange to use LTO to
+  // compile those archive members by adding them to the link beforehand.
+  //
+  // However, adding all libcall symbols to the link can have undesired
+  // consequences. For example, the libgcc implementation of
+  // __sync_val_compare_and_swap_8 on 32-bit ARM pulls in an .init_array entry
+  // that aborts the program if the Linux kernel does not support 64-bit
+  // atomics, which would prevent the program from running even if it does not
+  // use 64-bit atomics.
+  //
+  // Therefore, we only add libcall symbols to the link before LTO if we have
+  // to, i.e. if the symbol's definition is in bitcode. Any other required
+  // libcall symbols will be added to the link after LTO when we add the LTO
+  // object file to the link.
+  if (!symtab->bitcodeFiles.empty())
+    for (auto *s : lto::LTO::getRuntimeLibcallSymbols())
+      handleLibcall(s);
+  if (errorCount())
+    return;
+
   // Do link-time optimization if given files are LLVM bitcode files.
   // This compiles bitcode files into real object files.
   symtab->addCombinedLTOObject();
   if (errorCount())
     return;
 
   // Resolve any variant symbols that were created due to signature
   // mismatchs.

lld/wasm/InputFiles.h

explicit BitcodeFile(MemoryBufferRef m, StringRef archiveName)
     this->archiveName = archiveName;
   }
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
 
   void parse();
   std::unique_ptr<llvm::lto::InputFile> obj;
 };
 
+inline bool isBitcode(MemoryBufferRef mb) {
+  return identify_magic(mb.getBuffer()) == llvm::file_magic::bitcode;
+}
+
 // Will report a fatal() error if the input buffer is not a valid bitcode
 // or wasm object file.
 InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName = "");
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
 
 } // namespace wasm
 
 std::string toString(const wasm::InputFile *file);
 
 } // namespace lld
 
 #endif

lld/wasm/Symbols.h

 class LazySymbol : public Symbol {
 public:
   LazySymbol(StringRef name, uint32_t flags, InputFile *file,
              const llvm::object::Archive::Symbol &sym)
       : Symbol(name, LazyKind, flags, file), archiveSymbol(sym) {}
 
   static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
   void fetch();
+  MemoryBufferRef getMemberBuffer();
 
   // Lazy symbols can have a signature because they can replace an
   // UndefinedFunction which which case we need to be able to preserve the
   // signture.
   // TODO(sbc): This repetition of the signature field is inelegant.  Revisit
   // the use of class hierarchy to represent symbol taxonomy.
   const WasmSignature *signature = nullptr;
 

lld/wasm/Symbols.cpp

 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
+using namespace llvm::object;
 using namespace llvm::wasm;
 
 namespace lld {
 std::string toString(const wasm::Symbol &sym) {
   return maybeDemangleSymbol(sym.getName());
 }
 
 std::string maybeDemangleSymbol(StringRef name) {

 
 const OutputSectionSymbol *SectionSymbol::getOutputSectionSymbol() const {
   assert(section->outputSec && section->outputSec->sectionSym);
   return section->outputSec->sectionSym;
 }
 
 void LazySymbol::fetch() { cast<ArchiveFile>(file)->addMember(&archiveSymbol); }
 
+MemoryBufferRef LazySymbol::getMemberBuffer() {
+  Archive::Child c =
+      CHECK(archiveSymbol.getMember(),
+            "could not get the member for symbol " + toString(*this));
+
+  return CHECK(c.getMemoryBufferRef(),
+               "could not get the buffer for the member defining symbol " +
+                   toString(*this));
+}
+
 void printTraceSymbolUndefined(StringRef name, const InputFile* file) {
   message(toString(file) + ": reference to " + name);
 }
 
 // Print out a log message for --trace-symbol.
 void printTraceSymbol(Symbol *sym) {
   // Undefined symbols are traced via printTraceSymbolUndefined
   if (sym->isUndefined())