ELF: Use hidden visibility for all DefinedSynthetic symbols.

[pcc]

Summary

This simplifies the code by allowing us to remove the visibility argument
to functions that create synthetic symbols.

The only functional change is that the visibility of the MIPS "_gp" symbol
is now hidden. Because this symbol is defined in every executable or DSO, it
would be difficult to observe a visibility change here, so this seems safe,
but I'd like a MIPS expert to take a look.

[ruiu]

Looks good to me, but I'll let Simon to sign off.

[atanasyan]

LGTM

lld/trunk/ELF/SymbolTable.h

const std::vector<std::unique_ptr<SharedFile<ELFT>>> &getSharedFiles() const {
     return SharedFiles;
   }
 
   SymbolBody *addUndefined(StringRef Name);
   SymbolBody *addUndefinedOpt(StringRef Name);
   DefinedRegular<ELFT> *addAbsolute(StringRef Name,
                                     uint8_t Visibility = llvm::ELF::STV_HIDDEN);
   SymbolBody *addSynthetic(StringRef Name, OutputSectionBase<ELFT> &Section,
-                           uintX_t Value, uint8_t Visibility);
+                           uintX_t Value);
   DefinedRegular<ELFT> *addIgnored(StringRef Name,
                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN);
 
   void scanShlibUndefined();
   SymbolBody *find(StringRef Name);
   void wrap(StringRef Name);
   InputFile *findFile(SymbolBody *B);
 

lld/trunk/ELF/SymbolTable.cpp

DefinedRegular<ELFT> *SymbolTable<ELFT>::addAbsolute(StringRef Name,
   auto *Sym = new (Alloc) DefinedRegular<ELFT>(Name, STB_GLOBAL, Visibility);
   resolve(Sym);
   return Sym;
 }
 
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addSynthetic(StringRef Name,
                                             OutputSectionBase<ELFT> &Sec,
-                                            uintX_t Val, uint8_t Visibility) {
-  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Val, Sec, Visibility);
+                                            uintX_t Val) {
+  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Val, Sec);
   resolve(Sym);
   return Sym;
 }
 
 // Add Name as an "ignored" symbol. An ignored symbol is a regular
 // linker-synthesized defined symbol, but is only defined if needed.
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addIgnored(StringRef Name,

lld/trunk/ELF/Symbols.h

 
 // DefinedSynthetic is a class to represent linker-generated ELF symbols.
 // The difference from the regular symbol is that DefinedSynthetic symbols
 // don't belong to any input files or sections. Thus, its constructor
 // takes an output section to calculate output VA, etc.
 template <class ELFT> class DefinedSynthetic : public Defined {
 public:
   typedef typename ELFT::uint uintX_t;
-  DefinedSynthetic(StringRef N, uintX_t Value, OutputSectionBase<ELFT> &Section,
-                   uint8_t StOther);
+  DefinedSynthetic(StringRef N, uintX_t Value,
+                   OutputSectionBase<ELFT> &Section);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedSyntheticKind;
   }
 
   // Special value designates that the symbol 'points'
   // to the end of the section.
   static const uintX_t SectionEnd = uintX_t(-1);

lld/trunk/ELF/Symbols.cpp

UndefinedElf<ELFT>::UndefinedElf(const Elf_Sym &Sym)
     : SymbolBody(SymbolBody::UndefinedElfKind, Sym.st_name, Sym.st_other,
                  Sym.getType()),
       Size(Sym.st_size) {
   assert(Sym.getBinding() == STB_LOCAL);
 }
 
 template <typename ELFT>
 DefinedSynthetic<ELFT>::DefinedSynthetic(StringRef N, uintX_t Value,
-                                         OutputSectionBase<ELFT> &Section,
-                                         uint8_t StOther)
-    : Defined(SymbolBody::DefinedSyntheticKind, N, STB_GLOBAL, StOther,
+                                         OutputSectionBase<ELFT> &Section)
+    : Defined(SymbolBody::DefinedSyntheticKind, N, STB_GLOBAL, STV_HIDDEN,
               0 /* Type */),
       Value(Value), Section(Section) {}
 
 DefinedCommon::DefinedCommon(StringRef N, uint64_t Size, uint64_t Alignment,
                              uint8_t Binding, uint8_t StOther, uint8_t Type)
     : Defined(SymbolBody::DefinedCommonKind, N, Binding, StOther, Type),
       Alignment(Alignment), Size(Size) {}
 

lld/trunk/ELF/Writer.cpp

 bool Writer<ELFT>::isDiscarded(InputSectionBase<ELFT> *S) const {
   return !S || S == &InputSection<ELFT>::Discarded || !S->Live ||
          Script->isDiscarded(S);
 }
 
 template <class ELFT>
 static SymbolBody *
 addOptionalSynthetic(SymbolTable<ELFT> &Table, StringRef Name,
-                     OutputSectionBase<ELFT> &Sec, typename ELFT::uint Val,
-                     uint8_t Visibility) {
+                     OutputSectionBase<ELFT> &Sec, typename ELFT::uint Val) {
   if (!Table.find(Name))
     return nullptr;
-  return Table.addSynthetic(Name, Sec, Val, Visibility);
+  return Table.addSynthetic(Name, Sec, Val);
 }
 
 // The beginning and the ending of .rel[a].plt section are marked
 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked
 // executable. The runtime needs these symbols in order to resolve
 // all IRELATIVE relocs on startup. For dynamic executables, we don't
 // need these symbols, since IRELATIVE relocs are resolved through GOT
 // and PLT. For details, see http://www.airs.com/blog/archives/403.
 template <class ELFT>
 void Writer<ELFT>::addRelIpltSymbols() {
   if (isOutputDynamic() || !Out<ELFT>::RelaPlt)
     return;
   StringRef S = Config->Rela ? "__rela_iplt_start" : "__rel_iplt_start";
   ElfSym<ELFT>::RelaIpltStart =
-      addOptionalSynthetic(Symtab, S, *Out<ELFT>::RelaPlt, 0, STV_HIDDEN);
+      addOptionalSynthetic(Symtab, S, *Out<ELFT>::RelaPlt, 0);
 
   S = Config->Rela ? "__rela_iplt_end" : "__rel_iplt_end";
-  ElfSym<ELFT>::RelaIpltEnd =
-      addOptionalSynthetic(Symtab, S, *Out<ELFT>::RelaPlt,
-                           DefinedSynthetic<ELFT>::SectionEnd, STV_HIDDEN);
+  ElfSym<ELFT>::RelaIpltEnd = addOptionalSynthetic(
+      Symtab, S, *Out<ELFT>::RelaPlt, DefinedSynthetic<ELFT>::SectionEnd);
 }
 
 template <class ELFT> static bool includeInSymtab(const SymbolBody &B) {
   if (!B.isUsedInRegularObj())
     return false;
 
   if (auto *D = dyn_cast<DefinedRegular<ELFT>>(&B)) {
     // Exclude symbols pointing to garbage-collected sections.

 // the linking result. This function defines such symbols.
 template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
   if (Config->EMachine == EM_MIPS) {
     // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
     // so that it points to an absolute address which is relative to GOT.
     // See "Global Data Symbols" in Chapter 6 in the following document:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
     ElfSym<ELFT>::MipsGp =
-        Symtab.addSynthetic("_gp", *Out<ELFT>::Got, MipsGPOffset, STV_DEFAULT);
+        Symtab.addSynthetic("_gp", *Out<ELFT>::Got, MipsGPOffset);
 
     // On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
     // start of function and 'gp' pointer into GOT.
-    ElfSym<ELFT>::MipsGpDisp = addOptionalSynthetic(
-        Symtab, "_gp_disp", *Out<ELFT>::Got, MipsGPOffset, STV_HIDDEN);
+    ElfSym<ELFT>::MipsGpDisp =
+        addOptionalSynthetic(Symtab, "_gp_disp", *Out<ELFT>::Got, MipsGPOffset);
     // The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
     // pointer. This symbol is used in the code generated by .cpload pseudo-op
     // in case of using -mno-shared option.
     // https://sourceware.org/ml/binutils/2004-12/msg00094.html
     ElfSym<ELFT>::MipsLocalGp = addOptionalSynthetic(
-        Symtab, "__gnu_local_gp", *Out<ELFT>::Got, MipsGPOffset, STV_HIDDEN);
+        Symtab, "__gnu_local_gp", *Out<ELFT>::Got, MipsGPOffset);
   }
 
   // In the assembly for 32 bit x86 the _GLOBAL_OFFSET_TABLE_ symbol
   // is magical and is used to produce a R_386_GOTPC relocation.
   // The R_386_GOTPC relocation value doesn't actually depend on the
   // symbol value, so it could use an index of STN_UNDEF which, according
   // to the spec, means the symbol value is 0.
   // Unfortunately both gas and MC keep the _GLOBAL_OFFSET_TABLE_ symbol in
for (OutputSectionBase<ELFT> *Sec : RegularSections)
       addStartStopSymbols(Sec);
   }
 
   // Add _DYNAMIC symbol. Unlike GNU gold, our _DYNAMIC symbol has no type.
   // It should be okay as no one seems to care about the type.
   // Even the author of gold doesn't remember why gold behaves that way.
   // https://sourceware.org/ml/binutils/2002-03/msg00360.html
   if (isOutputDynamic())
-    Symtab.addSynthetic("_DYNAMIC", *Out<ELFT>::Dynamic, 0, STV_HIDDEN);
+    Symtab.addSynthetic("_DYNAMIC", *Out<ELFT>::Dynamic, 0);
 
   // Define __rel[a]_iplt_{start,end} symbols if needed.
   addRelIpltSymbols();
 
   if (Out<ELFT>::EhFrameHdr->Sec)
     Out<ELFT>::EhFrameHdr->Sec->finalize();
 
   // Scan relocations. This must be done after every symbol is declared so that

 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end
 // symbols for a few sections. This function defines them.
 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   auto Define = [&](StringRef Start, StringRef End,
                     OutputSectionBase<ELFT> *OS) {
     if (OS) {
-      Symtab.addSynthetic(Start, *OS, 0, STV_HIDDEN);
-      Symtab.addSynthetic(End, *OS, DefinedSynthetic<ELFT>::SectionEnd,
-                          STV_HIDDEN);
+      Symtab.addSynthetic(Start, *OS, 0);
+      Symtab.addSynthetic(End, *OS, DefinedSynthetic<ELFT>::SectionEnd);
     } else {
       Symtab.addIgnored(Start);
       Symtab.addIgnored(End);
     }
   };
 
   Define("__preinit_array_start", "__preinit_array_end",
          Out<ELFT>::Dynamic->PreInitArraySec);
void Writer<ELFT>::addStartStopSymbols(OutputSectionBase<ELFT> *Sec) {
   StringRef S = Sec->getName();
   if (!isValidCIdentifier(S))
     return;
   StringSaver Saver(Alloc);
   StringRef Start = Saver.save("__start_" + S);
   StringRef Stop = Saver.save("__stop_" + S);
   if (SymbolBody *B = Symtab.find(Start))
     if (B->isUndefined())
-      Symtab.addSynthetic(Start, *Sec, 0, STV_HIDDEN);
+      Symtab.addSynthetic(Start, *Sec, 0);
   if (SymbolBody *B = Symtab.find(Stop))
     if (B->isUndefined())
-      Symtab.addSynthetic(Stop, *Sec, DefinedSynthetic<ELFT>::SectionEnd,
-                          STV_HIDDEN);
+      Symtab.addSynthetic(Stop, *Sec, DefinedSynthetic<ELFT>::SectionEnd);
 }
 
 template <class ELFT> static bool needsPtLoad(OutputSectionBase<ELFT> *Sec) {
   if (!(Sec->getFlags() & SHF_ALLOC))
     return false;
 
   // Don't allocate VA space for TLS NOBITS sections. The PT_TLS PHDR is
   // responsible for allocating space for them, not the PT_LOAD that

lld/trunk/test/ELF/basic-mips.s

 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Local (0x0)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: Undefined (0x0)
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
-# CHECK-NEXT:     Name: __start
-# CHECK-NEXT:     Value: 0x20000
+# CHECK-NEXT:     Name: _gp
+# CHECK-NEXT:     Value: 0x37FF0
 # CHECK-NEXT:     Size: 0
-# CHECK-NEXT:     Binding: Global (0x1)
+# CHECK-NEXT:     Binding: Local
 # CHECK-NEXT:     Type: None (0x0)
-# CHECK-NEXT:     Other: 0
-# CHECK-NEXT:     Section: .text
+# CHECK-NEXT:     Other [ (0x2)
+# CHECK-NEXT:       STV_HIDDEN (0x2)
+# CHECK-NEXT:     ]
+# CHECK-NEXT:     Section: .got
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
-# CHECK-NEXT:     Name: _gp
-# CHECK-NEXT:     Value: 0x37FF0
+# CHECK-NEXT:     Name: __start
+# CHECK-NEXT:     Value: 0x20000
 # CHECK-NEXT:     Size: 0
-# CHECK-NEXT:     Binding: Global
+# CHECK-NEXT:     Binding: Global (0x1)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0
-# CHECK-NEXT:     Section: .got
+# CHECK-NEXT:     Section: .text
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: ProgramHeaders [
 # CHECK-NEXT:   ProgramHeader {
 # CHECK-NEXT:     Type: PT_PHDR (0x6)
 # CHECK-NEXT:     Offset: 0x34
 # CHECK-NEXT:     VirtualAddress: 0x10034
 # CHECK-NEXT:     PhysicalAddress: 0x10034

lld/trunk/test/ELF/mips-dynamic.s

 # EXE:      ]
 # EXE:      DynamicSection [
 # EXE-NEXT:   Tag        Type                 Name/Value
 # EXE-DAG:    0x00000003 PLTGOT               [[GOTADDR]]
 # EXE-DAG:    0x70000001 MIPS_RLD_VERSION     1
 # EXE-DAG:    0x70000005 MIPS_FLAGS           NOTPOT
 # EXE-DAG:    0x70000006 MIPS_BASE_ADDRESS
 # EXE-DAG:    0x7000000A MIPS_LOCAL_GOTNO     2
-# EXE-DAG:    0x70000011 MIPS_SYMTABNO        3
-# EXE-DAG:    0x70000013 MIPS_GOTSYM          0x3
+# EXE-DAG:    0x70000011 MIPS_SYMTABNO        2
+# EXE-DAG:    0x70000013 MIPS_GOTSYM          0x2
 # EXE-DAG:    0x70000016 MIPS_RLD_MAP         [[RLDMAPADDR]]
 # EXE:      ]
 
 # DSO:      Sections [
 # DSO:          Name: .dynamic
 # DSO-NEXT:     Type: SHT_DYNAMIC
 # DSO-NEXT:     Flags [
 # DSO-NEXT:       SHF_ALLOC
 # DSO-NEXT:     ]
 # DSO:          Name: .got
 # DSO-NEXT:     Type: SHT_PROGBITS
 # DSO-NEXT:     Flags [ (0x10000003)
 # DSO-NEXT:       SHF_ALLOC
 # DSO-NEXT:       SHF_MIPS_GPREL
 # DSO-NEXT:       SHF_WRITE
 # DSO-NEXT:     ]
 # DSO-NEXT:     Address: [[GOTADDR:0x[0-9a-f]+]]
 # DSO-NEXT:     Offset:
 # DSO-NEXT:     Size: 8
 # DSO:      ]
 # DSO:      DynamicSymbols [
 # DSO:          Name: @
 # DSO:          Name: __start@
 # DSO:          Name: _foo@
-# DSO:          Name: _gp@
 # DSO:      ]
 # DSO:      DynamicSection [
 # DSO-NEXT:   Tag        Type                 Name/Value
 # DSO-DAG:    0x00000003 PLTGOT               [[GOTADDR]]
 # DSO-DAG:    0x70000001 MIPS_RLD_VERSION     1
 # DSO-DAG:    0x70000005 MIPS_FLAGS           NOTPOT
 # DSO-DAG:    0x70000006 MIPS_BASE_ADDRESS    0x0
 # DSO-DAG:    0x7000000A MIPS_LOCAL_GOTNO     2
-# DSO-DAG:    0x70000011 MIPS_SYMTABNO        4
-# DSO-DAG:    0x70000013 MIPS_GOTSYM          0x4
+# DSO-DAG:    0x70000011 MIPS_SYMTABNO        3
+# DSO-DAG:    0x70000013 MIPS_GOTSYM          0x3
 # DSO:      ]
 
   .text
   .globl  __start,_foo
   .type _foo,@function
 __start:
   nop

lld/trunk/test/ELF/mips-got-relocs.s

__start:
   .type  v1,@object
   .size  v1,4
 v1:
   .word 0
 
 # EXE_SYM: Sections:
 # EXE_SYM: .got 0000000c 0000000000030000 DATA
 # EXE_SYM: SYMBOL TABLE:
-# EXE_SYM: 00040000 g       .data    00000004 v1
-# EXE_SYM: 00037ff0         .got     00000000 _gp
+# EXE_SYM: 00037ff0         .got     00000000 .hidden _gp
 #          ^-- .got + GP offset (0x7ff0)
+# EXE_SYM: 00040000 g       .data    00000004 v1
 
 
 # EXE_GOT_BE: Contents of section .got:
 # EXE_GOT_BE:  30000 00000000 80000000 00040000
 #                    ^        ^        ^-- v1 (0x40000)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # EXE_GOT_EL: Contents of section .got:
 # EXE_GOT_EL:  30000 00000000 00000080 00000400
 #                    ^        ^        ^-- v1 (0x40000)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # v1GotAddr (0x3000c) - _gp (0x37ff4) = -0x7fe8 => 0x8018 = 32792
 # EXE_DIS_BE:  20000:  3c 02 80 18  lui $2, 32792
 # EXE_DIS_EL:  20000:  18 80 02 3c  lui $2, 32792
 
 # DSO_SYM: Sections:
 # DSO_SYM: .got 0000000c 0000000000020000 DATA
 # DSO_SYM: SYMBOL TABLE:
-# DSO_SYM: 00030000 g       .data    00000004 v1
-# DSO_SYM: 00027ff0         .got     00000000 _gp
+# DSO_SYM: 00027ff0         .got     00000000 .hidden _gp
 #          ^-- .got + GP offset (0x7ff0)
+# DSO_SYM: 00030000 g       .data    00000004 v1
 
 # DSO_GOT_BE: Contents of section .got:
 # DSO_GOT_BE:  20000 00000000 80000000 00030000
 #                    ^        ^        ^-- v1 (0x30000)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # DSO_GOT_EL: Contents of section .got:

lld/trunk/test/ELF/mips-gp-disp.s

 # EXT-SO:      Name: _gp_disp
 # EXT-SO-NEXT: Value: 0x20000
 
 # DIS:      Disassembly of section .text:
 # DIS-NEXT: __start:
 # DIS-NEXT:    10000:  3c 08 00 01  lui   $8, 1
 # DIS-NEXT:    10004:  21 08 7f f0  addi  $8, $8, 32752
 #                                                 ^-- 0x37ff0 & 0xffff
-# DIS: 00027ff0  .got  00000000 _gp
+# DIS: 00027ff0  .got  00000000 .hidden _gp
 
 # REL:      Relocations [
 # REL-NEXT: ]
 
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(_gp_disp)
   addi   $t0,$t0,%lo(_gp_disp)
   lw     $v0,%call16(_foo)($gp)

lld/trunk/test/ELF/mips-gp-local.s

 # Check handling of relocations against __gnu_local_gp symbol.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld -o %t.exe %t.o
 # RUN: llvm-objdump -d -t %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Disassembly of section .text:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:  3c 08 00 03  lui   $8, 3
 # CHECK-NEXT:    20004:  21 08 7f f0  addi  $8, $8, 32752
 
-# CHECK: 00037ff0  .got  00000000 _gp
+# CHECK: 00037ff0  .got  00000000 .hidden _gp
 
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(__gnu_local_gp)
   addi   $t0,$t0,%lo(__gnu_local_gp)

lld/trunk/test/ELF/mips-gprel32-relocs-gp0.test

 # CHECK: Contents of section .rodata:
 # CHECK:  012c fffe8010 fffe8020
 #              ^ 0x10000 + 0xffff8011 + 0x7fef - 0x27ff0
 #                       ^ 0x10010 + 0xffff8011 + 0x7fef - 0x27ff0
 
 # CHECK: SYMBOL TABLE:
 # CHECK: 00010000         .text          00000000 foo
 # CHECK: 00010010         .text          00000000 bar
-# CHECK: 00027ff0         .got           00000000 _gp
+# CHECK: 00027ff0         .got           00000000 .hidden _gp

lld/trunk/test/ELF/mips-gprel32-relocs.s

 # CHECK: Contents of section .rodata:
 # CHECK:  0114 fffe8014 fffe8018
 #              ^ 0x10004 - 0x27ff0
 #                       ^ 0x10008 - 0x27ff0
 
 # CHECK: SYMBOL TABLE:
 # CHECK: 00010008         .text           00000000 bar
 # CHECK: 00010004         .text           00000000 foo
-# CHECK: 00027ff0         .got           00000000 _gp
+# CHECK: 00027ff0         .got           00000000 .hidden _gp

lld/trunk/test/ELF/mips-hilo-gp-disp.s

 # EXE:      Disassembly of section .text:
 # EXE-NEXT: __start:
 # EXE-NEXT:  20000:   3c 08 00 01   lui    $8, 1
 #                                              ^-- %hi(0x37ff0-0x20000)
 # EXE-NEXT:  20004:   21 08 7f f0   addi   $8, $8, 32752
 #                                                  ^-- %lo(0x37ff0-0x20004+4)
 
 # EXE: SYMBOL TABLE:
+# EXE: 00037ff0     .got    00000000 .hidden _gp
 # EXE: 00020000     .text   00000000 __start
 # EXE: 00020010     .text   00000000 _foo
-# EXE: 00037ff0     .got    00000000 _gp
 
 # SO:      Disassembly of section .text:
 # SO-NEXT: __start:
 # SO-NEXT:  10000:   3c 08 00 01   lui    $8, 1
 #                                             ^-- %hi(0x27ff0-0x10000)
 # SO-NEXT:  10004:   21 08 7f f0   addi   $8, $8, 32752
 #                                                 ^-- %lo(0x27ff0-0x10004+4)
 
 # SO: SYMBOL TABLE:
+# SO: 00027ff0     .got    00000000 .hidden _gp
 # SO: 00010000     .text   00000000 __start
 # SO: 00010010     .text   00000000 _foo
-# SO: 00027ff0     .got    00000000 _gp