[lld-link] preserve @llvm.used symbols in LTO

[inglorion]

Summary

We translate @llvm.used to COFF by generating /include directives
in the .drectve section. However, in LTO links, this happens after
directives have already been processed, so the new directives do
not take effect. This change marks @llvm.used symbols as GCRoots
so that they are preserved as intended.

Fixes PR40733.

[ruiu]

lld/COFF/InputFiles.cpp

691–692

It feels like it is cleaner to do this in MarkLive.cpp. When we execute markLive(), we have a list of Chunks, and we can iterate over the Chunks to add symbols to Worklist.

[inglorion]

lld/COFF/InputFiles.cpp

691–692

After looking into this, I'm not sure I like the suggested approach better. It would require

1. Iterating over more symbols in markLive() - namely all symbols, instead of only those reachable from GC roots.

2. Tracking which symbols are used, which we currently don't do.

The symbols this change matches are created first as DefinedRegular when reading from bitcode, then replaced with Undefined in LTO.cpp, then replaced with DefinedRegular when read from COFF objects. To do #2, we would need to either track the used attribute through these replacements, or we would need to re-parse the .drectve section of the COFF file to find the include directives. I don't think either option is particularly clean. And #1 sounds like extra work - even if it takes little real time, I'd rather not do it if we can avoid it.

By contrast, I think marking these symbols as GC roots is essentially the right thing to do. It's also how the /include command line flag is implemented.

[ruiu]

LGTM

lld/COFF/InputFiles.cpp

691–692

Fair enough.

lld/COFF/InputFiles.cpp

if (ObjSym.isUndefined()) {
       else if (Comdat[ComdatIndex].second)
         Sym = Symtab->addRegular(this, SymName);
       else
         Sym = Symtab->addUndefined(SymName, this, false);
     } else {
       Sym = Symtab->addRegular(this, SymName);
     }
     Symbols.push_back(Sym);
+    if (ObjSym.isUsed())
+      Config->GCRoot.push_back(Sym);
   }
   Directives = Obj->getCOFFLinkerOpts();
 }
 
 MachineTypes BitcodeFile::getMachineType() {
   switch (Triple(Obj->getTargetTriple()).getArch()) {
   case Triple::x86_64:
     return AMD64;

lld/test/COFF/used-lto.ll

+; REQUIRES: x86
+; RUN: llvm-as -o %t.obj %s
+; RUN: lld-link -dll -debug -opt:ref -noentry -out:%t.dll %t.obj
+; RUN: llvm-pdbutil dump -publics %t.pdb | FileCheck %s
+
+; CHECK: S_PUB32 {{.*}} `foo`
+
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc"
+
[e-mail] = appending global [1 x i8*] [i8* bitcast (void ()* @foo to i8*)], section "llvm.metadata"
+
+define void @foo() {
+  ret void
+}

llvm/include/llvm/LTO/LTO.h

public:
     using irsymtab::Symbol::canBeOmittedFromSymbolTable;
     using irsymtab::Symbol::isTLS;
     using irsymtab::Symbol::getComdatIndex;
     using irsymtab::Symbol::getCommonSize;
     using irsymtab::Symbol::getCommonAlignment;
     using irsymtab::Symbol::getCOFFWeakExternalFallback;
     using irsymtab::Symbol::getSectionName;
     using irsymtab::Symbol::isExecutable;
+    using irsymtab::Symbol::isUsed;
   };
 
   /// A range over the symbols in this InputFile.
   ArrayRef<Symbol> symbols() const { return Symbols; }
 
   /// Returns linker options specified in the input file.
   StringRef getCOFFLinkerOpts() const { return COFFLinkerOpts; }