[ELF2] Add support for -Bsymbolic

[davide]

Summary

Needed by to build FreeBSD base system (see Ed's list).

[emaste]

ELF/OutputSections.cpp

415

Are there relevant rtlds that require DT_SYMBOLIC?

[davide]

ELF/OutputSections.cpp

415

Not that I'm aware of. That said, I mainly did it to match gold behavior.
If you think it's not required, I can drop it, although this comes almost for free, so I'm not that inclined to drop it.

[emaste]

If you think it's not required, I can drop it, although this comes almost for free, so I'm not that inclined to drop it.

It's a minor point and probably of no practical consequence so it

ELF/OutputSections.cpp

415

http://www.sco.com/developers/gabi/latest/ch5.dynamic.html

Its use has been superseded by the DF_SYMBOLIC flag.

[• rafael]

LGTM if setting only DF_SYMBOLIC.

It will be trivial to add DT_SYMBOLIC if we find a dynamic linker that needs that.

ELF/Config.h

struct Configuration {
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<llvm::StringRef> InputSearchPaths;
   bool AllowMultipleDefinition;
+  bool Bsymbolic;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool NoInhibitExec;
   bool NoUndefined;
   bool ZNow = false;

ELF/Driver.cpp

for (auto *Arg : Args.filtered(OPT_rpath))
     RPaths.push_back(Arg->getValue());
   if (!RPaths.empty())
     Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":");
 
   if (auto *Arg = Args.getLastArg(OPT_m))
     setELFType(Arg->getValue());
 
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
+  Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->DiscardAll = Args.hasArg(OPT_discard_all);
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->NoUndefined = Args.hasArg(OPT_no_undefined);
   Config->Shared = Args.hasArg(OPT_shared);

ELF/Options.td

 include "llvm/Option/OptParser.td"
 
+def Bsymbolic: Flag<["-"], "Bsymbolic">,
+  HelpText<"Bind defined symbols locally">;
+
 def Bdynamic: Flag<["-"], "Bdynamic">,
   HelpText<"Link against shared libraries">;
 
 def Bstatic: Flag<["-"], "Bstatic">,
   HelpText<"Do not link against shared libraries">;
 
 def L : Joined<["-"], "L">, MetaVarName<"<dir>">,
   HelpText<"Directory to search for libraries">;

ELF/OutputSections.cpp

template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (Symbol *S = SymTab.getSymbols().lookup(Config->Init))
     InitSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
   if (Symbol *S = SymTab.getSymbols().lookup(Config->Fini))
     FiniSym = dyn_cast<ELFSymbolBody<ELFT>>(S->Body);
   if (InitSym)
     ++NumEntries; // DT_INIT
   if (FiniSym)
     ++NumEntries; // DT_FINI
-  if (Config->ZNow)
+  if (Config->ZNow || Config->Bsymbolic)
     ++NumEntries; // DT_FLAGS_1
+  if (Config->Bsymbolic)
+    ++NumEntries; // DT_SYMBOLIC
 
   ++NumEntries; // DT_NULL
 
   Header.sh_size = NumEntries * Header.sh_entsize;
 }
 
 template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   for (const std::unique_ptr<SharedFileBase> &File : SharedFiles)
     WriteVal(DT_NEEDED, Out<ELFT>::DynStrTab->getFileOff(File->getSoName()));
 
   if (InitSym)
     WritePtr(DT_INIT, getSymVA<ELFT>(*InitSym));
   if (FiniSym)
     WritePtr(DT_FINI, getSymVA<ELFT>(*FiniSym));
 
+  uint32_t Flags = 0;
+  if (Config->Bsymbolic) {
+    // For back-compatibility with old dynamic linkers.
+    WriteVal(DT_SYMBOLIC, 0);
+
+    Flags |= DF_SYMBOLIC;
+  }
   if (Config->ZNow)
-    WriteVal(DT_FLAGS_1, DF_1_NOW);
+    Flags |= DF_1_NOW;
+  if (Flags)
+    WriteVal(DT_FLAGS_1, Flags);
 
   WriteVal(DT_NULL, 0);
 }
 
 template <class ELFT>
 OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t sh_type,
                                    uintX_t sh_flags)
     : OutputSectionBase<ELFT::Is64Bits>(Name, sh_type, sh_flags) {}

test/elf2/dt_flags.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: ld.lld2 -shared %t -o %t.so
-# RUN: ld.lld2 -z now %t %t.so -o %t1
+# RUN: ld.lld2 -z now -Bsymbolic %t %t.so -o %t1
 # RUN: ld.lld2 %t %t.so -o %t2
-# RUN: llvm-readobj -dynamic-table %t1 | FileCheck -check-prefix=NOW %s
+# RUN: llvm-readobj -dynamic-table %t1 | FileCheck -check-prefix=FLAGS %s
 # RUN: llvm-readobj -dynamic-table %t2 | FileCheck %s
 
-# NOW: DynamicSection [
-# NOW:   0x000000006FFFFFFB FLAGS_1 NOW
-# NOW: ]
+# FLAGS: DynamicSection [
+# FLAGS:   0x0000000000000010 SYMBOLIC             0x0
+# FLAGS:   0x000000006FFFFFFB FLAGS_1              NOW GLOBAL
+# FLAGS: ]
 
 # CHECK: DynamicSection [
-# CHECK-NOT:   0x000000006FFFFFFB FLAGS_1 NOW
+# CHECK-NOT:   0x0000000000000010 SYMBOLIC             0x0
+# CHECK-NOT:   0x000000006FFFFFFB FLAGS_1              NOW GLOBAL
 # CHECK: ]
 
 .globl _start
 _start:

test/elf2/now.s

-# REQUIRES: x86
-
-# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
-# RUN: ld.lld2 -shared %t -o %t.so
-# RUN: ld.lld2 -z now %t %t.so -o %t1
-# RUN: ld.lld2 %t %t.so -o %t2
-# RUN: llvm-readobj -dynamic-table %t1 | FileCheck -check-prefix=NOW %s
-# RUN: llvm-readobj -dynamic-table %t2 | FileCheck %s
-
-# NOW: DynamicSection [
-# NOW:   0x000000006FFFFFFB FLAGS_1 NOW
-# NOW: ]
-
-# CHECK: DynamicSection [
-# CHECK-NOT:   0x000000006FFFFFFB FLAGS_1 NOW
-# CHECK: ]
-
-.globl _start
-_start: