ELF: Move initSymbols to Symbols.cpp.

[ruiu]

Summary

This effectively rolls back r263133. I think moving this code to
Driver was a violation of modularization, and it felt odd to me that
driver was manipulating the details of the internal symbols.

[grimar]

Ok, but why don't you want to stay on initial version http://reviews.llvm.org/D18047 ?
That keeps initSymbols() in symbols.cpp, but does not initialize them for each ELFT.

May be revert of r263214 is enough here ?

[ruiu]

Sorry, I replied to a different thread.

So, it's ecause that Symbol.cpp needs to initialize symbols for each ELF type is an internal detail of the file. initSymbol, or in general, init<filename> is the initializer function for a file. Callers of the initializer should not take care of the details whether the function works on ELFT-specialized objects or not.

[• rafael]

I would probably hold this until we need a second initSomething function.

Cheers,
Rafael

[grimar]

In D18135#374658, @ruiu wrote:

Callers of the initializer should not take care of the details whether the function works on ELFT-specialized objects or not.

That is arguable. Here it do excessive work when initializing something that is not used. That has no impact on perfomance but actually confuses, makes code reader to think that these symbols are required somehow when them are not.

I would agree with Rafael here to hold it if possible until we see any other initXXX function.

[grimar]

If you don't plan to commit this - please abandon.

[ruiu]

I'm not convinced that that is not worth it, but no reason to push this strongly, so I'm okay to abandon it for now.

ELF/Driver.cpp

 
 using namespace lld;
 using namespace lld::elf;
 
 Configuration *elf::Config;
 LinkerDriver *elf::Driver;
 
 bool elf::link(ArrayRef<const char *> Args, raw_ostream &Error) {
+  initSymbols();
+
   HasError = false;
   ErrorOS = &Error;
   Configuration C;
   LinkerDriver D;
   LinkerScript LS;
   Config = &C;
   Driver = &D;
   Script = &LS;
case OPT_no_whole_archive:
       break;
     }
   }
 
   if (Files.empty() && !HasError)
     error("no input files.");
 }
 
-template <class ELFT> static void initSymbols() {
-  ElfSym<ELFT>::Etext.setBinding(STB_GLOBAL);
-  ElfSym<ELFT>::Edata.setBinding(STB_GLOBAL);
-  ElfSym<ELFT>::End.setBinding(STB_GLOBAL);
-  ElfSym<ELFT>::Ignored.setBinding(STB_WEAK);
-  ElfSym<ELFT>::Ignored.setVisibility(STV_HIDDEN);
-}
-
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   // For LTO
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
 
-  initSymbols<ELFT>();
-
   SymbolTable<ELFT> Symtab;
   std::unique_ptr<TargetInfo> TI(createTarget());
   Target = TI.get();
 
   Config->Rela = ELFT::Is64Bits;
 
   if (!Config->Shared && !Config->Relocatable) {
     // Add entry symbol.

ELF/Symbols.h

 class ArchiveFile;
 class InputFile;
 class SymbolBody;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class OutputSection;
 template <class ELFT> class OutputSectionBase;
 template <class ELFT> class SharedFile;
 
+// Initializes global objects defined in this file.
+// Called at the beginning of main().
+void initSymbols();
+
 // Returns a demangled C++ symbol name. If Name is not a mangled
 // name or the system does not provide __cxa_demangle function,
 // it returns the unmodified string.
 std::string demangle(StringRef Name);
 
 // A real symbol object, SymbolBody, is usually accessed indirectly
 // through a Symbol. There's always one Symbol for each symbol name.
 // The resolver updates SymbolBody pointers as it resolves symbols.

ELF/Symbols.cpp

std::unique_ptr<InputFile> Lazy::getMember() {
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBRef.getBuffer().empty())
     return std::unique_ptr<InputFile>(nullptr);
   return createObjectFile(MBRef, File->getName());
 }
 
+template <class ELFT> static void doInitSymbols() {
+  ElfSym<ELFT>::Etext.setBinding(STB_GLOBAL);
+  ElfSym<ELFT>::Edata.setBinding(STB_GLOBAL);
+  ElfSym<ELFT>::End.setBinding(STB_GLOBAL);
+  ElfSym<ELFT>::Ignored.setBinding(STB_WEAK);
+  ElfSym<ELFT>::Ignored.setVisibility(STV_HIDDEN);
+}
+
+void elf::initSymbols() {
+  doInitSymbols<ELF32LE>();
+  doInitSymbols<ELF32BE>();
+  doInitSymbols<ELF64LE>();
+  doInitSymbols<ELF64BE>();
+}
+
 // Returns the demangled C++ symbol name for Name.
 std::string elf::demangle(StringRef Name) {
 #if !defined(HAVE_CXXABI_H)
   return Name;
 #else
   if (!Config->Demangle)
     return Name;