[ELF] Implemented -Bsymbolic-functions command line option

[grimar]

Summary

[ELF] Implemented -Bsymbolic-functions command line option.

-Bsymbolic-functions:
When creating a shared library, bind references to global
function symbols to the definition within the shared library, if any.

This patch also fixed behavior of already existent -Bsymbolic:
previously PLT entries were created even if -Bsymbolic was specified.

[ruiu]

ELF/OutputSections.cpp

1027–1030 ↗

(On Diff #45541)

The conditions inside these ifs seem to be arbitrarily grouped into two. Probably it is a bit verbose but slightly better.

if (!Config->Shared)
  return false;
if (Body->getVisibility() != STV_DEFAULT)
  return false;
if (Config->Bsymbolic)
  return false;
if (Config->BsymbolicFunction && Body->isFunction())
  return false;
return true;

ELF/Symbols.cpp

84 ↗

(On Diff #45541)

I don't think IsFunction is relevant to undefined symbols. You can remove this parameter and always pass false to the base class.

[grimar]

Review comments addressed.

ELF/OutputSections.cpp

1027–1030 ↗

(On Diff #45541)

I think we can group the last one, they are very close, what do you think ?

if (Config->Bsymbolic || (Config->BsymbolicFunctions && Body->isFunction()))
   return false;

[grimar]

• Rebased

[ruiu]

Let's do s/isFunction/isFunc/g. This is consistent with STT_FUNC.

Please wrap your commit message to 80 columns, and remove "**" from the body text.

[grimar]

• Addressed Rui's comments.

[ruiu]

LGTM

lld/trunk/ELF/Config.h

struct Configuration {
   llvm::StringRef Sysroot;
   std::string RPath;
   llvm::MapVector<llvm::StringRef, std::vector<llvm::StringRef>> OutputSections;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
+  bool BsymbolicFunctions;
   bool Demangle = true;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;
   bool EhFrameHdr;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool GcSections;

lld/trunk/ELF/Driver.cpp

if (auto *Arg = Args.getLastArg(OPT_m)) {
     // Parse ELF{32,64}{LE,BE} and CPU type.
     StringRef S = Arg->getValue();
     std::tie(Config->EKind, Config->EMachine) = parseEmulation(S);
     Config->Emulation = S;
   }
 
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
+  Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
   Config->Demangle = !Args.hasArg(OPT_no_demangle);
   Config->DiscardAll = Args.hasArg(OPT_discard_all);
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->GcSections = Args.hasArg(OPT_gc_sections);

lld/trunk/ELF/Options.td

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

lld/trunk/ELF/OutputSections.cpp

if (Body->isUndefined()) {
     // don't produce a dynamic relocation.
     //
     // As an extra hack, assume that if we are producing a shared library the
     // user knows what he or she is doing and can handle a dynamic relocation.
     return Config->Shared || NeedsGot;
   }
   if (!Config->Shared)
     return false;
-  return Body->getVisibility() == STV_DEFAULT;
+  if (Body->getVisibility() != STV_DEFAULT)
+    return false;
+  if (Config->Bsymbolic || (Config->BsymbolicFunctions && Body->isFunc()))
+    return false;
+  return true;
 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
   for (InputSection<ELFT> *C : Sections)
     C->writeTo(Buf);
 }
 
 template <class ELFT>

lld/trunk/ELF/Symbols.h

public:
   bool isDefined() const { return SymbolKind <= DefinedLast; }
   bool isCommon() const { return SymbolKind == DefinedCommonKind; }
   bool isLazy() const { return SymbolKind == LazyKind; }
   bool isShared() const { return SymbolKind == SharedKind; }
   bool isUsedInRegularObj() const { return IsUsedInRegularObj; }
   bool isUsedInDynamicReloc() const { return IsUsedInDynamicReloc; }
   void setUsedInDynamicReloc() { IsUsedInDynamicReloc = true; }
   bool isTls() const { return IsTls; }
+  bool isFunc() const { return IsFunc; }
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   uint8_t getVisibility() const { return Visibility; }
 
   unsigned DynsymIndex = 0;
   uint32_t GlobalDynIndex = -1;
public:
 
   // Decides which symbol should "win" in the symbol table, this or
   // the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
   // they are duplicate (conflicting) symbols.
   template <class ELFT> int compare(SymbolBody *Other);
 
 protected:
   SymbolBody(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility,
-             bool IsTls)
+             bool IsTls, bool IsFunc)
       : SymbolKind(K), IsWeak(IsWeak), Visibility(Visibility), IsTls(IsTls),
-        Name(Name) {
+        IsFunc(IsFunc), Name(Name) {
     IsUsedInRegularObj = K != SharedKind && K != LazyKind;
     IsUsedInDynamicReloc = 0;
   }
 
   const unsigned SymbolKind : 8;
   unsigned IsWeak : 1;
   unsigned Visibility : 2;
 
   // True if the symbol was used for linking and thus need to be
   // added to the output file's symbol table. It is usually true,
   // but if it is a shared symbol that were not referenced by anyone,
   // it can be false.
   unsigned IsUsedInRegularObj : 1;
 
   // If true, the symbol is added to .dynsym symbol table.
   unsigned IsUsedInDynamicReloc : 1;
 
   unsigned IsTls : 1;
+  unsigned IsFunc : 1;
   StringRef Name;
   Symbol *Backref = nullptr;
 };
 
 // The base class for any defined symbols.
 class Defined : public SymbolBody {
 public:
-  Defined(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility, bool IsTls);
+  Defined(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility, bool IsTls,
+          bool IsFunction);
   static bool classof(const SymbolBody *S) { return S->isDefined(); }
 };
 
 // Any defined symbol from an ELF file.
 template <class ELFT> class DefinedElf : public Defined {
 protected:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
   DefinedElf(Kind K, StringRef N, const Elf_Sym &Sym)
       : Defined(K, N, Sym.getBinding() == llvm::ELF::STB_WEAK,
-                Sym.getVisibility(), Sym.getType() == llvm::ELF::STT_TLS),
+                Sym.getVisibility(), Sym.getType() == llvm::ELF::STT_TLS,
+                Sym.getType() == llvm::ELF::STT_FUNC),
         Sym(Sym) {}
 
   const Elf_Sym &Sym;
   static bool classof(const SymbolBody *S) {
     return S->kind() <= DefinedElfLast;
   }
 };
 

 // This class represents a symbol defined in an archive file. It is
 // created from an archive file header, and it knows how to load an
 // object file from an archive to replace itself with a defined
 // symbol. If the resolver finds both Undefined and Lazy for
 // the same name, it will ask the Lazy to load a file.
 class Lazy : public SymbolBody {
 public:
   Lazy(ArchiveFile *F, const llvm::object::Archive::Symbol S)
-      : SymbolBody(LazyKind, S.getName(), false, llvm::ELF::STV_DEFAULT, false),
+      : SymbolBody(LazyKind, S.getName(), false, llvm::ELF::STV_DEFAULT,
+                   /*IsTls*/ false, /*IsFunction*/ false),
         File(F), Sym(S) {}
 
   static bool classof(const SymbolBody *S) { return S->kind() == LazyKind; }
 
   // Returns an object file for this symbol, or a nullptr if the file
   // was already returned.
   std::unique_ptr<InputFile> getMember();
 

lld/trunk/ELF/Symbols.cpp

if (isCommon()) {
     return -1;
   }
   if (Other->isCommon())
     return 1;
   return 0;
 }
 
 Defined::Defined(Kind K, StringRef Name, bool IsWeak, uint8_t Visibility,
-                 bool IsTls)
-    : SymbolBody(K, Name, IsWeak, Visibility, IsTls) {}
+                 bool IsTls, bool IsFunction)
+    : SymbolBody(K, Name, IsWeak, Visibility, IsTls, IsFunction) {}
 
 Undefined::Undefined(SymbolBody::Kind K, StringRef N, bool IsWeak,
                      uint8_t Visibility, bool IsTls)
-    : SymbolBody(K, N, IsWeak, Visibility, IsTls), CanKeepUndefined(false) {}
+    : SymbolBody(K, N, IsWeak, Visibility, IsTls, /*IsFunction*/ false),
+      CanKeepUndefined(false) {}
 
 Undefined::Undefined(StringRef N, bool IsWeak, uint8_t Visibility,
                      bool CanKeepUndefined)
     : Undefined(SymbolBody::UndefinedKind, N, IsWeak, Visibility,
                 /*IsTls*/ false) {
   this->CanKeepUndefined = CanKeepUndefined;
 }
 
 template <typename ELFT>
 UndefinedElf<ELFT>::UndefinedElf(StringRef N, const Elf_Sym &Sym)
     : Undefined(SymbolBody::UndefinedElfKind, N,
                 Sym.getBinding() == llvm::ELF::STB_WEAK, Sym.getVisibility(),
                 Sym.getType() == llvm::ELF::STT_TLS),
       Sym(Sym) {}
 
 template <typename ELFT>
 DefinedSynthetic<ELFT>::DefinedSynthetic(StringRef N, uintX_t Value,
                                          OutputSectionBase<ELFT> &Section)
-    : Defined(SymbolBody::DefinedSyntheticKind, N, false, STV_DEFAULT, false),
+    : Defined(SymbolBody::DefinedSyntheticKind, N, false, STV_DEFAULT,
+              /*IsTls*/ false, /*IsFunction*/ false),
       Value(Value), Section(Section) {}
 
 DefinedCommon::DefinedCommon(StringRef N, uint64_t Size, uint64_t Alignment,
                              bool IsWeak, uint8_t Visibility)
-    : Defined(SymbolBody::DefinedCommonKind, N, IsWeak, Visibility, false) {
+    : Defined(SymbolBody::DefinedCommonKind, N, IsWeak, Visibility,
+              /*IsTls*/ false, /*IsFunction*/ false) {
   MaxAlignment = Alignment;
   this->Size = Size;
 }
 
 std::unique_ptr<InputFile> Lazy::getMember() {
   MemoryBufferRef MBRef = File->getMember(&Sym);
 
   // getMember returns an empty buffer if the member was already

lld/trunk/test/ELF/bsymbolic.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+// RUN: ld.lld -shared %t.o -o %t0.so
+// RUN: ld.lld -shared -Bsymbolic %t.o -o %t1.so
+// RUN: ld.lld -shared -Bsymbolic-functions %t.o -o %t2.so
+// RUN: llvm-readobj -s %t0.so | FileCheck -check-prefix=NOOPTION %s
+// RUN: llvm-readobj -s %t1.so | FileCheck -check-prefix=SYMBOLIC %s
+// RUN: llvm-readobj -s %t2.so | FileCheck -check-prefix=SYMBOLIC %s
+
+// NOOPTION:     Section {
+// NOOPTION:       Name: .plt
+
+// SYMBOLIC: Section {
+// SYMBOLIC-NOT: Name: .plt
+
+.text
+.globl foo
+.type foo,@function
+foo:
+nop
+
+.globl bar
+.type bar,@function
+bar:
+nop
+
+.globl do
+.type do,@function
+do: 
+callq foo@PLT
+callq bar@PLT