[ELF] - Define linkerscript symbols early.

[grimar]

Summary

Currently symbols assigned or created by linkerscript are not processed early
enough. As a result it is not possible to version them or assign any other flags/properties.

Patch creates Defined symbols for -defsym and linkerscript symbols early,
so that issue from above can be addressed.

It is based on Rafael Espindola's version of D38239 patch.

[grimar]

rL323633 was landed and this one is unblocked now. Rebased.

[smeenai]

Thank you!

I don't see a test case for actually being able to version a symbol (or symbol alias) defined in a linker script?

This should fix PR34121 (if you wanna note that in the summary).

[grimar]

In D41987#990768, @smeenai wrote:

Thank you!

I don't see a test case for actually being able to version a symbol (or symbol alias) defined in a linker script?

This should fix PR34121 (if you wanna note that in the summary).

Thanks. Looks just forgot to add the test file to diff. It is ELF/linkerscript/version-script.s,
it is a testcase used in D36579 with additions done by Rafael.

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   // addReservedSymbols to mark the created symbols as not absolute.
   Out::ElfHeader = make<OutputSection>("", 0, SHF_ALLOC);
   Out::ElfHeader->Size = sizeof(typename ELFT::Ehdr);
 
   // We need to create some reserved symbols such as _end. Create them.
   if (!Config->Relocatable)
     addReservedSymbols();
 
+  // We want to declare linker script's symbols early, so that we can version
+  // them.
+  Script->declareSymbols();
+
   // Apply version scripts.
   Symtab->scanVersionScript();
 
   // Create wrapped symbols for -wrap option.
   for (auto *Arg : Args.filtered(OPT_wrap))
     Symtab->addSymbolWrap<ELFT>(Arg->getValue());
 
   Symtab->addCombinedLTOObject<ELFT>();

ELF/LTO.cpp

 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
   unsigned SymNum = 0;
   std::vector<Symbol *> Syms = F.getSymbols();
   std::vector<lto::SymbolResolution> Resols(Syms.size());
 
-  DenseSet<StringRef> ScriptSymbols;
-  for (BaseCommand *Base : Script->SectionCommands)
-    if (auto *Cmd = dyn_cast<SymbolAssignment>(Base))
-      ScriptSymbols.insert(Cmd->Name);
-
   // Provide a resolution to the LTO API for each symbol.
   for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     Symbol *Sym = Syms[SymNum];
     lto::SymbolResolution &R = Resols[SymNum];
     ++SymNum;
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
     // reports two symbols for module ASM defined. Without this check, lld
for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     if (R.Prevailing)
       undefine(Sym);
 
     // We tell LTO to not apply interprocedural optimization for following
     // symbols because otherwise LTO would inline them while their values are
     // still not final:
     // 1) Aliased (with --defsym) or wrapped (with --wrap) symbols.
     // 2) Symbols redefined in linker script.
-    R.LinkerRedefined = !Sym->CanInline || ScriptSymbols.count(Sym->getName());
+    R.LinkerRedefined = !Sym->CanInline;
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting ObjectFile(s).
 std::vector<InputFile *> BitcodeCompiler::compile() {
   std::vector<InputFile *> Ret;

ELF/LinkerScript.h

public:
 
   std::vector<PhdrEntry *> createPhdrs();
   bool needsInterpSection();
 
   bool shouldKeep(InputSectionBase *S);
   void assignAddresses();
   void allocateHeaders(std::vector<PhdrEntry *> &Phdrs);
   void processSectionCommands();
+  void declareSymbols();
 
   // SECTIONS command list.
   std::vector<BaseCommand *> SectionCommands;
 
   // PHDRS command list.
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool HasSectionsCommand = false;

ELF/LinkerScript.cpp

error(Loc + ": unable to move location counter backward for: " +
           Ctx->OutSec->Name);
   Dot = Val;
 
   // Update to location counter means update to section size.
   if (InSec)
     Ctx->OutSec->Size = Dot - Ctx->OutSec->Addr;
 }
 
-// This function is called from processSectionCommands,
-// while we are fixing the output section layout.
-void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
+// Used for handling linker symbol assignments, for both finalizing
+// their values and doing early declarations. Returns true if symbol
+// should be defined from linker script.
+static bool shouldDefineSym(SymbolAssignment *Cmd) {
   if (Cmd->Name == ".")
-    return;
+    return false;
+
+  if (!Cmd->Provide)
+    return true;
 
-  // If a symbol was in PROVIDE(), we need to define it only when
-  // it is a referenced undefined symbol.
+  // If a symbol was in PROVIDE(), we need to define it only
+  // when it is a referenced undefined symbol.
   Symbol *B = Symtab->find(Cmd->Name);
-  if (Cmd->Provide && (!B || B->isDefined()))
+  if (!B || B->isDefined())
+    return false;
+  return true;
+}
+
+// This function is called from processSectionCommands,
+// while we are fixing the output section layout.
+void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
+  if (!shouldDefineSym(Cmd))
     return;
 
   // Define a symbol.
   Symbol *Sym;
   uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
   std::tie(Sym, std::ignore) = Symtab->insert(Cmd->Name, /*Type*/ 0, Visibility,
                                               /*CanOmitFromDynSym*/ false,
                                               /*File*/ nullptr);
void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
   // write expressions like this: `alignment = 16; . = ALIGN(., alignment)`.
   uint64_t SymValue = Value.Sec ? 0 : Value.getValue();
 
   replaceSymbol<Defined>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
                          STT_NOTYPE, SymValue, 0, Sec);
   Cmd->Sym = cast<Defined>(Sym);
 }
 
+// Symbols defined in script should not be inlined by LTO. At the same time
+// we don't know their final values until late stages of link. Here we scan
+// over symbol assignment commands and create placeholder symbols if needed.
+void LinkerScript::declareSymbols() {
+  assert(!Ctx);
+  for (BaseCommand *Base : SectionCommands) {
+    auto *Cmd = dyn_cast<SymbolAssignment>(Base);
+    if (!Cmd || !shouldDefineSym(Cmd))
+      continue;
+
+    // We can't calculate final value right now.
+    Symbol *Sym;
+    uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
+    std::tie(Sym, std::ignore) =
+        Symtab->insert(Cmd->Name, /*Type*/ 0, Visibility,
+                       /*CanOmitFromDynSym*/ false,
+                       /*File*/ nullptr);
+    replaceSymbol<Defined>(Sym, nullptr, Cmd->Name, STB_GLOBAL, Visibility,
+                           STT_NOTYPE, 0, 0, nullptr);
+    // FIXME: Setting CanInline is necessary to force thinlto to omit
+    // this symbol. It is not clear why.
+    Sym->CanInline = false;
+    Cmd->Sym = cast<Defined>(Sym);
+
+    Cmd->Provide = false;
+  }
+}
+
 // This function is called from assignAddresses, while we are
 // fixing the output section addresses. This function is supposed
 // to set the final value for a given symbol assignment.
 void LinkerScript::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
   if (Cmd->Name == ".") {
     setDot(Cmd->Expression, Cmd->Location, InSec);
     return;
   }

test/ELF/linkerscript/symbols-synthetic.s

 # RUN:        PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text)); }" > %t.script
 # RUN: ld.lld -o %t1 --eh-frame-hdr --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=IN-SEC %s
 
 # SIMPLE:      0000000000000128         .foo    00000000 .hidden _end_sec
 # SIMPLE-NEXT: 0000000000000120         .foo    00000000 _begin_sec
 # SIMPLE-NEXT: 0000000000000128         *ABS*   00000000 _end_sec_abs
 # SIMPLE-NEXT: 0000000000001048         .text   00000000 _start
+# SIMPLE-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_3
 # SIMPLE-NEXT: 0000000000000120         .foo    00000000 begin_foo
 # SIMPLE-NEXT: 0000000000000128         .foo    00000000 end_foo
 # SIMPLE-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1
 # SIMPLE-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1_abs
 # SIMPLE-NEXT: 0000000000001000         .foo    00000000 begin_bar
 # SIMPLE-NEXT: 0000000000001004         .foo    00000000 end_bar
 # SIMPLE-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_2
-# SIMPLE-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_3
 # SIMPLE-NEXT: 0000000000001004         .eh_frame_hdr     00000000 __eh_frame_hdr_start
 # SIMPLE-NEXT: 0000000000001010         *ABS*             00000000 __eh_frame_hdr_start2
 # SIMPLE-NEXT: 0000000000001018         .eh_frame_hdr     00000000 __eh_frame_hdr_end
 # SIMPLE-NEXT: 0000000000001020         *ABS*             00000000 __eh_frame_hdr_end2
 
 # NO-SEC:       0000000000201000         .text     00000000 .hidden _begin_sec
 # NO-SEC-NEXT:  0000000000201001         .text     00000000 .hidden _end_sec
 

test/ELF/lto/defsym.ll

 ; REQUIRES: x86
 ; LTO
 ; RUN: llvm-as %s -o %t.o
 ; RUN: llvm-as %S/Inputs/defsym-bar.ll -o %t1.o
-; RUN: ld.lld %t.o %t1.o -shared -o %t.so -defsym=bar2=bar3
+; RUN: ld.lld %t.o %t1.o -shared -o %t.so -defsym=bar2=bar3 -save-temps
+; RUN: llvm-readelf -t %t.so.lto.o | FileCheck --check-prefix=OBJ %s
 ; RUN: llvm-objdump -d %t.so | FileCheck %s
 
 ; ThinLTO
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: opt -module-summary %S/Inputs/defsym-bar.ll -o %t1.o
-; RUN: ld.lld %t.o %t1.o -shared -o %t.so -defsym=bar2=bar3
-; RUN: llvm-objdump -d %t.so | FileCheck %s --check-prefix=THIN
+; RUN: ld.lld %t.o %t1.o -shared -o %t2.so -defsym=bar2=bar3 -save-temps
+; RUN: llvm-readelf -t %t2.so1.lto.o | FileCheck --check-prefix=OBJ %s
+; RUN: llvm-objdump -d %t2.so | FileCheck %s --check-prefix=THIN
+
+; OBJ:  UND bar2
 
 ; Call to bar2() should not be inlined and should be routed to bar3()
 ; Symbol bar3 should not be eliminated
 
 ; CHECK:      foo:
 ; CHECK-NEXT: pushq %rax
 ; CHECK-NEXT: callq
 ; CHECK-NEXT: callq{{.*}}<bar3>

test/ELF/lto/linker-script-symbols-assign.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: echo "foo = 1;" > %t.script
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 --script %t.script -save-temps
 ; RUN: llvm-readobj -symbols %t2.lto.o | FileCheck %s
 
 ; CHECK-NOT: bar
-; CHECK:     Symbol {
-; CHECK:         Name: foo
-; CHECK-NEXT:    Value: 0x0
-; CHECK-NEXT:    Size: 4
-; CHECK-NEXT:    Binding: Weak
-; CHECK-NEXT:    Type: Object
-; CHECK-NEXT:    Other: 0
-; CHECK-NEXT:    Section: .bss.foo
-; CHECK-NEXT:  }
-; CHECK-NEXT:]
+; CHECK-NOT: foo
 
 ; RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=VAL
 ; VAL:       Symbol {
 ; VAL:        Name: foo
 ; VAL-NEXT:   Value: 0x1
 ; VAL-NEXT:   Size:
 ; VAL-NEXT:   Binding: Global
 ; VAL-NEXT:   Type: None

test/ELF/lto/linker-script-symbols-ipo.ll

 ; IPO-NEXT:   201000: {{.*}} movl $1, %eax
 ; IPO-NEXT:   201005: {{.*}} retq
 
 ;; Check that LTO does not do IPO for symbols assigned by script.
 ; RUN: ld.lld  -m elf_x86_64 %t1.o %t2.o -o %t4 --script %t.script -save-temps
 ; RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=NOIPO
 ; NOIPO:      Disassembly of section .text:
 ; NOIPO:      foo:
-; NOIPO-NEXT:   201010: {{.*}} movl $2, %eax
+; NOIPO-NEXT:   {{.*}} movl $2, %eax
 ; NOIPO:      _start:
-; NOIPO-NEXT:   201020: {{.*}} jmp -21 <foo>
+; NOIPO-NEXT:   {{.*}} jmp -21 <foo>
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @bar() {
   ret i32 1
 }
 
 define i32 @foo() {
   ret i32 2
 }