[ELF] Synthesize STT_FILE if necessary (#209087)

lld groups local symbols in .symtab by input file, appending a symbol
converted to STB_LOCAL (hidden visibility, version script `local:`, or
--exclude-libs) to its file's group. The nearest preceding STT_FILE then
claims the symbol, but the attribution can be wrong: the file may
contain multiple STT_FILE symbols (-r output), or lack an STT_FILE for
the symbol's unit.

```
FILE    LOCAL  DEFAULT   ABS a.c
NOTYPE  LOCAL  DEFAULT     7 a_local
FILE    LOCAL  DEFAULT   ABS b.c
NOTYPE  LOCAL  DEFAULT     7 b_local
NOTYPE  LOCAL  DEFAULT     7 a_localized
```

Follow GNU ld:

- If the output contains an STT_FILE symbol, place at the end of the
  local part, after a synthetic STT_FILE with an empty name, every local
  that cannot be attributed to a file: symbols converted to STB_LOCAL,
  linker-synthesized symbols such as `_DYNAMIC`, and range-extension
  thunks (parented to the internal file, which has no STT_FILE).
- For -r output, synthesize an STT_FILE named after the input file for
an input that outputs local symbols but no STT_FILE, so that its locals
  are not attributed to a preceding file. We use the basename instead of
  the full name for local determinism (#47367).

GNU ld synthesizes this per-input STT_FILE for executable and
shared-object output as well. Restrict it to -r for now to minimize test
updates.

Close #47367 and #191478

Author: MaskRay

lld/ELF/SyntheticSections.cpp

@@ -2003,34 +2003,57 @@ void SymbolTableBaseSection::finalizeContents() {
     s.sym->dynsymIndex = ++i;
 }
 
-// The ELF spec requires that all local symbols precede global symbols, so we
-// sort symbol entries in this function. (For .dynsym, we don't do that because
-// symbols for dynamic linking are inherently all globals.)
+// The ELF spec requires local symbols to precede globals. We additionally group
+// the locals by file, each led by its first STT_FILE.
 //
-// Aside from above, we put local symbols in groups starting with the STT_FILE
-// symbol. That is convenient for purpose of identifying where are local symbols
-// coming from.
+// From firstGlobalIdx on, a local cannot be attributed to a file (a demoted
+// global, or a thunk/errata patch added later). Move these after the per-file
+// groups, behind the synthetic STT_FILE synthSttFileSym.
 void SymbolTableBaseSection::sortSymTabSymbols() {
-  // Move all local symbols before global symbols.
-  auto e = std::stable_partition(
-      symbols.begin(), symbols.end(),
-      [](const SymbolTableEntry &s) { return s.sym->isLocal(); });
-  size_t numLocals = e - symbols.begin();
-  getParent()->info = numLocals + 1;
-
-  // We want to group the local symbols by file. For that we rebuild the local
-  // part of the symbols vector. We do not need to care about the STT_FILE
-  // symbols, they are already naturally placed first in each group. That
-  // happens because STT_FILE is always the first symbol in the object and hence
-  // precede all other local symbols we add for a file.
-  MapVector<InputFile *, SmallVector<SymbolTableEntry, 0>> arr;
-  for (const SymbolTableEntry &s : llvm::make_range(symbols.begin(), e))
-    arr[s.sym->file].push_back(s);
+  MapVector<InputFile *, SmallVector<SymbolTableEntry, 0>> fileToLocals;
+  SmallVector<SymbolTableEntry, 0> localized, globals;
+  SymbolTableEntry fileEntry{};
+  for (size_t i = 0, e = symbols.size(); i != e; ++i) {
+    const SymbolTableEntry &s = symbols[i];
+    if (!s.sym->isLocal())
+      globals.push_back(s);
+    else if (s.sym == synthSttFileSym)
+      fileEntry = s;
+    else if (synthSttFileSym && i >= firstGlobalIdx)
+      localized.push_back(s);
+    else
+      fileToLocals[s.sym->file].push_back(s);
+  }
 
   auto i = symbols.begin();
-  for (auto &p : arr)
+  for (auto &p : fileToLocals)
     for (SymbolTableEntry &entry : p.second)
       *i++ = entry;
+  if (synthSttFileSym) {
+    *i++ = fileEntry;
+    i = std::copy(localized.begin(), localized.end(), i);
+  }
+  getParent()->info = i - symbols.begin() + 1;
+  std::copy(globals.begin(), globals.end(), i);
+}
+
+// A symbol converted to STB_LOCAL cannot be reliably attributed to a file:
+// within a file's group the wrong STT_FILE would claim it, as a file may hold
+// several STT_FILE symbols (relocatable output) or none. Like GNU ld, when the
+// output has an STT_FILE, add a synthetic empty-name STT_FILE.
+void SymbolTableBaseSection::maybeAddSttFile() {
+  ArrayRef<SymbolTableEntry> syms = symbols;
+  if (llvm::none_of(syms.take_front(firstGlobalIdx),
+                    [](const SymbolTableEntry &s) { return s.sym->isFile(); }))
+    return;
+  if (llvm::any_of(
+          syms.drop_front(firstGlobalIdx),
+          [](const SymbolTableEntry &s) { return s.sym->isLocal(); })) {
+    synthSttFileSym =
+        makeDefined(ctx, ctx.internalFile, "", STB_LOCAL, STV_DEFAULT, STT_FILE,
+                    /*value=*/0, /*size=*/0, nullptr);
+    addSymbol(synthSttFileSym);
+  }
 }
 
 void SymbolTableBaseSection::addSymbol(Symbol *b) {

lld/ELF/SyntheticSections.h

@@ -659,6 +659,8 @@ class SymbolTableBaseSection : public SyntheticSection {
   void finalizeContents() override;
   size_t getSize() const override { return getNumSymbols() * entsize; }
   void addSymbol(Symbol *sym);
+  void maybeAddSttFile();
+  void markGlobalPart() { firstGlobalIdx = symbols.size(); }
   unsigned getNumSymbols() const { return symbols.size() + 1; }
   size_t getSymbolIndex(const Symbol &sym);
   ArrayRef<SymbolTableEntry> getSymbols() const { return symbols; }
@@ -669,6 +671,14 @@ class SymbolTableBaseSection : public SyntheticSection {
   // A vector of symbols and their string table offsets.
   SmallVector<SymbolTableEntry, 0> symbols;
 
+  // Synthetic STT_FILE with an empty name, added by maybeAddSttFile and placed
+  // by sortSymTabSymbols before all locals that cannot be attributed to a file.
+  Defined *synthSttFileSym = nullptr;
+
+  // symbols.size() before the global loop. Locals from here on are not
+  // file-attributable and move behind synthSttFileSym.
+  size_t firstGlobalIdx = 0;
+
   StringTableSection &strTabSec;
 
   llvm::once_flag onceFlag;

lld/ELF/Writer.cpp

@@ -30,6 +30,7 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/BLAKE3.h"
 #include "llvm/Support/Parallel.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/xxhash.h"
@@ -466,9 +467,24 @@ static void demoteAndCopyLocalSymbols(Ctx &ctx) {
         symsVec[i].push_back(b);
     }
   });
-  for (auto &syms : ArrayRef(symsVec.get(), ctx.objectFiles.size()))
+  for (size_t i = 0, e = ctx.objectFiles.size(); i != e; ++i) {
+    // For -r, synthesize an STT_FILE named after the input file for an input
+    // that contributes local symbols but no STT_FILE, so that its symbols are
+    // not attributed to another file's STT_FILE (matching GNU ld).
+    // --discard-all discards STT_FILE symbols.
+    auto &syms = symsVec[i];
+    if (ctx.arg.relocatable && ctx.arg.discard != DiscardPolicy::All &&
+        !syms.empty() &&
+        llvm::none_of(syms, [](Symbol *s) { return s->isFile(); })) {
+      InputFile *file = ctx.objectFiles[i];
+      ctx.in.symTab->addSymbol(
+          makeDefined(ctx, file, sys::path::filename(file->getName()),
+                      STB_LOCAL, /*stOther=*/0, STT_FILE, /*value=*/0,
+                      /*size=*/0, nullptr));
+    }
     for (Symbol *sym : syms)
       ctx.in.symTab->addSymbol(sym);
+  }
 }
 
 // Create a section symbol for each output section so that we can represent
@@ -1944,6 +1960,8 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
 
   {
     llvm::TimeTraceScope timeScope("Add symbols to symtabs");
+    if (ctx.in.symTab)
+      ctx.in.symTab->markGlobalPart();
     // Now that we have defined all possible global symbols including linker-
     // synthesized ones. Visit all symbols to give the finishing touches.
     for (Symbol *sym : ctx.symtab->getSymbols()) {
@@ -1964,7 +1982,8 @@ template <class ELFT> void Writer<ELFT>::finalizeSections() {
             addVerneed(ctx, *sym);
       }
     }
-
+    if (ctx.in.symTab && !ctx.arg.relocatable)
+      ctx.in.symTab->maybeAddSttFile();
   }
 
   if (ctx.in.mipsGot)

lld/test/ELF/local-symbols-order.s

@@ -1,37 +1,145 @@
-# REQUIRES: x86
-
-# RUN: echo '.data; .file "file2"; foo2:; .global bar2; .hidden bar2; bar2:' > %t2.s
-# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %t2.s -o %t2.o
-# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
-
-# RUN: ld.lld -o %t %t1.o %t2.o --emit-relocs
-# RUN: llvm-readelf --symbols --sections %t | FileCheck %s
-
-## Check we sort local symbols to match the following order: 
-## file1, local1, section1, hidden1, file2, local2, section2, hidden2 ...
-
-# CHECK: Section Headers:
-# CHECK:   [Nr] Name
-# CHECK:   [ [[ST:.*]]] .text
-# CHECK:   [ [[SD:.*]]] .data
-# CHECK:   [ [[SC:.*]]] .comment
-
-# CHECK:      Size Type    Bind   Vis      Ndx Name
-# CHECK-NEXT:    0 NOTYPE  LOCAL  DEFAULT  UND
-# CHECK-NEXT:    0 FILE    LOCAL  DEFAULT  ABS file1
-# CHECK-NEXT:    0 NOTYPE  LOCAL  DEFAULT    1 foo1
-# CHECK-NEXT:    0 SECTION LOCAL  DEFAULT    [[ST]]
-# CHECK-NEXT:    0 NOTYPE  LOCAL  HIDDEN     1 bar1
-# CHECK-NEXT:    0 FILE    LOCAL  DEFAULT  ABS file2
-# CHECK-NEXT:    0 NOTYPE  LOCAL  DEFAULT    2 foo2
-# CHECK-NEXT:    0 SECTION LOCAL  DEFAULT    [[SD]]
-# CHECK-NEXT:    0 NOTYPE  LOCAL  HIDDEN     2 bar2
-# CHECK-NEXT:    0 SECTION LOCAL  DEFAULT    [[SC]]
-
-foo1:
-
-.global bar1
-.hidden bar1
-bar1:
-
-.file "file1"
+# REQUIRES: aarch64
+## Check the order of local symbols: grouped by file, each group led by the file's STT symbol.
+## Symbols converted to STB_LOCAL are placed at the end of the local part after a synthetic
+## STT_FILE with an empty name, omitted if the output has no STT_FILE.
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+## -implicit-mapsyms omits the input $x/$d mapping symbols; only the linker's
+## own thunk mapping symbols remain (THUNK below).
+# RUN: llvm-mc -filetype=obj -triple=aarch64 -implicit-mapsyms a.s -o a.o
+# RUN: llvm-mc -filetype=obj -triple=aarch64 -implicit-mapsyms b.s -o b.o
+# RUN: mkdir c && llvm-mc -filetype=obj -triple=aarch64 -implicit-mapsyms c.s -o c/a.o
+
+## Only b.c has an STT_FILE. a.o's a_local has no leading STT_FILE; the hidden
+## a_hidden follows the synthetic STT_FILE. --emit-relocs adds STT_SECTION
+## symbols to their file's group.
+# RUN: ld.lld --emit-relocs a.o b.o -o ab
+# RUN: llvm-readelf -s ab | FileCheck %s
+
+# CHECK:      NOTYPE  LOCAL  DEFAULT [[#]] a_local
+# CHECK-NEXT: SECTION LOCAL  DEFAULT [[#]] .text
+# CHECK-NEXT: FILE    LOCAL  DEFAULT   ABS b.c
+# CHECK-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] b_local
+# CHECK-NEXT: SECTION LOCAL  DEFAULT [[#]] .data
+# CHECK-NEXT: SECTION LOCAL  DEFAULT [[#]] .comment
+# CHECK-NEXT: FILE    LOCAL  DEFAULT   ABS{{ $}}
+# CHECK-NEXT: NOTYPE  LOCAL  HIDDEN  [[#]] a_hidden
+# CHECK-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] a_localized
+# CHECK-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] a_exported
+# CHECK-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] b_localized
+# CHECK-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] b_exported
+
+## For -r, synthesize STT_FILE for a.o, which lacks one.
+# RUN: ld.lld -r a.o b.o -o ab.o
+# RUN: llvm-readelf -s ab.o | FileCheck %s --check-prefix=RO
+
+# RO:      FILE    LOCAL  DEFAULT   ABS a.o
+# RO-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] a_local
+# RO-NEXT: SECTION LOCAL  DEFAULT [[#]] .text
+# RO-NEXT: FILE    LOCAL  DEFAULT   ABS b.c
+# RO-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] b_local
+# RO-NEXT: SECTION LOCAL  DEFAULT [[#]] .data
+# RO-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] a_localized
+# RO-NEXT: NOTYPE  GLOBAL HIDDEN  [[#]] a_hidden
+# RO-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] a_exported
+# RO-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] b_localized
+# RO-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] b_exported
+
+## Synthesize STT_FILE named after its basename, not its path, for local determinism (#47367).
+# RUN: ld.lld -r ab.o c/a.o -o abc.o
+# RUN: llvm-readelf -s abc.o | FileCheck %s --check-prefix=MULTI
+
+# MULTI:      FILE    LOCAL  DEFAULT   ABS a.o
+# MULTI-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] a_local
+# MULTI-NEXT: FILE    LOCAL  DEFAULT   ABS b.c
+# MULTI-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] b_local
+# MULTI-NEXT: SECTION LOCAL  DEFAULT [[#]] .text
+# MULTI-NEXT: SECTION LOCAL  DEFAULT [[#]] .data
+# MULTI-NEXT: FILE    LOCAL  DEFAULT   ABS a.o
+# MULTI-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] far
+
+## Symbols localized by a version script follow a synthetic STT_FILE with empty name.
+# RUN: ld.lld -shared --version-script=ver ab.o -o ab.so
+# RUN: llvm-readelf -s ab.so | FileCheck %s --check-prefix=VER
+
+# VER:      FILE    LOCAL  DEFAULT   ABS a.o
+# VER-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] a_local
+# VER-NEXT: FILE    LOCAL  DEFAULT   ABS b.c
+# VER-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] b_local
+# VER-NEXT: FILE    LOCAL  DEFAULT   ABS{{ $}}
+# VER-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] a_localized
+# VER-NEXT: NOTYPE  LOCAL  HIDDEN  [[#]] a_hidden
+# VER-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] b_localized
+# VER-NEXT: NOTYPE  LOCAL  HIDDEN  [[#]] _DYNAMIC
+# VER-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] a_exported
+# VER-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] b_exported
+
+## A range-extension thunk (and its $x/$d) is added by
+## finalizeAddressDependentContent and parented to the internal file, which has
+## no STT_FILE. Like the demoted c_hidden it cannot be attributed to a file, so
+## it follows the synthetic STT_FILE.
+# RUN: ld.lld c/a.o b.o -T lds -o cb
+# RUN: llvm-readelf -s cb | FileCheck %s --check-prefix=THUNK
+
+# THUNK:      NOTYPE  LOCAL  DEFAULT [[#]] far
+# THUNK-NEXT: FILE    LOCAL  DEFAULT   ABS b.c
+# THUNK-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] b_local
+# THUNK-NEXT: FILE    LOCAL  DEFAULT   ABS{{ $}}
+# THUNK-NEXT: NOTYPE  LOCAL  HIDDEN  [[#]] c_hidden
+# THUNK-NEXT: FUNC    LOCAL  DEFAULT [[#]] __AArch64AbsLongThunk_{{.*}}
+# THUNK-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] $x
+# THUNK-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] $d
+# THUNK-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] _start
+
+## --discard-all discards STT_FILE symbols as well. With no STT_FILE in the
+## output, no synthetic STT_FILE is added.
+# RUN: ld.lld -shared --discard-all --version-script=ver ab.o -o ab2.so
+# RUN: llvm-readelf -s ab2.so | FileCheck %s --check-prefix=DISCARD --implicit-check-not=FILE
+
+# DISCARD:      NOTYPE  LOCAL  DEFAULT [[#]] a_localized
+# DISCARD-NEXT: NOTYPE  LOCAL  HIDDEN  [[#]] a_hidden
+# DISCARD-NEXT: NOTYPE  LOCAL  DEFAULT [[#]] b_localized
+# DISCARD-NEXT: NOTYPE  LOCAL  HIDDEN  [[#]] _DYNAMIC
+# DISCARD-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] a_exported
+# DISCARD-NEXT: NOTYPE  GLOBAL DEFAULT [[#]] b_exported
+
+#--- a.s
+a_local:
+.globl a_localized
+a_localized:
+.globl a_hidden
+.hidden a_hidden
+a_hidden:
+.globl a_exported
+a_exported:
+  nop
+
+#--- b.s
+.file "b.c"
+.data
+b_local:
+.globl b_localized
+b_localized:
+.globl b_exported
+b_exported:
+  .byte 0
+
+#--- c.s
+.globl _start, c_hidden
+.hidden c_hidden
+_start:
+  bl far
+c_hidden:
+  ret
+.section .far,"ax"
+far:
+  ret
+
+#--- lds
+SECTIONS {
+  .text 0x10000    : { *(.text) }
+  .far  0x10000000 : { *(.far) }
+}
+
+#--- ver
+v1 { global: *_exported; local: *; };

lld/test/ELF/lto/parallel-internalize.ll

@@ -35,6 +35,15 @@
 ; CHECK-NEXT:     Section: Absolute
 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   Symbol {
+; CHECK-NEXT:     Name:  (0)
+; CHECK-NEXT:     Value: 0x0
+; CHECK-NEXT:     Size: 0
+; CHECK-NEXT:     Binding: Local
+; CHECK-NEXT:     Type: File
+; CHECK-NEXT:     Other: 0
+; CHECK-NEXT:     Section: Absolute
+; CHECK-NEXT:   }
+; CHECK-NEXT:   Symbol {
 ; CHECK-NEXT:     Name: bar
 ; CHECK-NEXT:     Value:
 ; CHECK-NEXT:     Size: 8

lld/test/ELF/ppc64-local-entry.s

@@ -2,7 +2,7 @@
 
 # RUN: llvm-mc -filetype=obj -triple=powerpc64 %s -o %t
 # RUN: ld.lld -r %t -o %t2
-# RUN: llvm-objdump -s --section=.symtab %t2 | FileCheck %s
+# RUN: llvm-readelf -s %t2 | FileCheck %s
 
 .text
 .abiversion 2
@@ -37,11 +37,6 @@ _start:
 	.type	g,@object               # @g
 	.lcomm	g,4,4
 
-// We expect the st_other byte to be 0x60:
-// localentry = 011 (gep + 2 instructions), reserved = 000,
-// visibility = 00 (STV_DEFAULT)
-// Currently, llvm-objdump does not support displaying
-// st_other's PPC64 specific flags, thus we check the
-// result of the hexdump of .symtab section.
-
-// CHECK: 0060 00000003 12600001 00000000 00000000
+## We expect st_other to be 0x60: localentry = 011 (gep + 2 instructions),
+## reserved = 000, visibility = 00 (STV_DEFAULT).
+# CHECK: FUNC    GLOBAL DEFAULT [<other: 0x60>] [[#]] _start

lld/test/ELF/relocatable-comdat-multiple.s

@@ -9,7 +9,7 @@
 # CHECK-NEXT:     Name: .group
 # CHECK-NEXT:     Index: 2
 # CHECK-NEXT:     Link: 9
-# CHECK-NEXT:     Info: 1
+# CHECK-NEXT:     Info: 2
 # CHECK-NEXT:     Type: COMDAT
 # CHECK-NEXT:     Signature: aaa
 # CHECK-NEXT:     Section(s) in group [
@@ -21,7 +21,7 @@
 # CHECK-NEXT:     Name: .group
 # CHECK-NEXT:     Index: 5
 # CHECK-NEXT:     Link: 9
-# CHECK-NEXT:     Info: 6
+# CHECK-NEXT:     Info: 8
 # CHECK-NEXT:     Type: COMDAT
 # CHECK-NEXT:     Signature: bbb
 # CHECK-NEXT:     Section(s) in group [