[ELF] Change some global pointers to unique_ptr

[MaskRay]

Summary

Currently the singleton config is assigned by config = make<Configuration>()
and (if canExitEarly is false) destroyed by lld::freeArena.

make<Configuration> allocates a stab with malloc(4096). This both wastes
memory and bloats the executable (every type instantiates BumpPtrAllocator
which costs more than 1KiB code on x86-64).

(No need to worry about clang::no_destroy. Regular invocations (canExitEarly
is true) call _Exit (via llvm::sys::Process::ExitNoCleanup).)

[lichray]

Looks reasonable to me.

[MaskRay]

I'll push now as the benefit is obvious enough.

lld/ELF/Config.h

 #include "llvm/ADT/StringSet.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include <atomic>
+#include <memory>
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class InputFile;
 class InputSectionBase;
 
struct Configuration {
   // True if we are creating position-independent code.
   bool isPic;
 
   // 4 for ELF32, 8 for ELF64.
   int wordsize;
 };
 
 // The only instance of Configuration struct.
-extern Configuration *config;
+extern std::unique_ptr<Configuration> config;
 
 // The first two elements of versionDefinitions represent VER_NDX_LOCAL and
 // VER_NDX_GLOBAL. This helper returns other elements.
 static inline ArrayRef<VersionDefinition> namedVersionDefs() {
   return llvm::makeArrayRef(config->versionDefinitions).slice(2);
 }
 
 static inline void errorOrWarn(const Twine &msg) {

lld/ELF/Driver.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace elf {
 
-extern class LinkerDriver *driver;
+extern std::unique_ptr<class LinkerDriver> driver;
 
 class LinkerDriver {
 public:
   void linkerMain(ArrayRef<const char *> args);
   void addFile(StringRef path, bool withLOption);
   void addLibrary(StringRef name);
 
 private:

lld/ELF/Driver.cpp

 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::sys;
 using namespace llvm::support;
 using namespace lld;
 using namespace lld::elf;
 
-Configuration *elf::config;
-LinkerDriver *elf::driver;
+std::unique_ptr<Configuration> elf::config;
+std::unique_ptr<LinkerDriver> elf::driver;
 
 static void setConfigs(opt::InputArgList &args);
 static void readConfigs(opt::InputArgList &args);
 
 bool elf::link(ArrayRef<const char *> args, bool canExitEarly,
                raw_ostream &stdoutOS, raw_ostream &stderrOS) {
   lld::stdoutOS = &stdoutOS;
   lld::stderrOS = &stderrOS;
bool elf::link(ArrayRef<const char *> args, bool canExitEarly,
 
   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
   errorHandler().errorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
   errorHandler().exitEarly = canExitEarly;
   stderrOS.enable_colors(stderrOS.has_colors());
 
-  config = make<Configuration>();
-  driver = make<LinkerDriver>();
-  script = make<LinkerScript>();
-  symtab = make<SymbolTable>();
+  config = std::make_unique<Configuration>();
+  driver = std::make_unique<LinkerDriver>();
+  script = std::make_unique<LinkerScript>();
+  symtab = std::make_unique<SymbolTable>();
 
   partitions = {Partition()};
 
   config->progName = args[0];
 
   driver->linkerMain(args);
 
   // Exit immediately if we don't need to return to the caller.

lld/ELF/LinkerScript.h

public:
 
   // OutputSections specified by OVERWRITE_SECTIONS.
   std::vector<OutputSection *> overwriteSections;
 
   // Sections that will be warned/errored by --orphan-handling.
   std::vector<const InputSectionBase *> orphanSections;
 };
 
-extern LinkerScript *script;
+extern std::unique_ptr<LinkerScript> script;
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_ELF_LINKER_SCRIPT_H

lld/ELF/LinkerScript.cpp

 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 
-LinkerScript *elf::script;
+std::unique_ptr<LinkerScript> elf::script;
 
 static bool isSectionPrefix(StringRef prefix, StringRef name) {
   return name.consume_front(prefix) && (name.empty() || name[0] == '.');
 }
 
 static StringRef getOutputSectionName(const InputSectionBase *s) {
   if (config->relocatable)
     return s->name;

lld/ELF/SymbolTable.h

private:
 
   // A map from demangled symbol names to their symbol objects.
   // This mapping is 1:N because two symbols with different versions
   // can have the same name. We use this map to handle "extern C++ {}"
   // directive in version scripts.
   llvm::Optional<llvm::StringMap<std::vector<Symbol *>>> demangledSyms;
 };
 
-extern SymbolTable *symtab;
+extern std::unique_ptr<SymbolTable> symtab;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/SymbolTable.cpp

 #include "llvm/ADT/STLExtras.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;
 
-SymbolTable *elf::symtab;
+std::unique_ptr<SymbolTable> elf::symtab;
 
 void SymbolTable::wrap(Symbol *sym, Symbol *real, Symbol *wrap) {
   // Redirect __real_foo to the original foo and foo to the original __wrap_foo.
   int &idx1 = symMap[CachedHashStringRef(sym->getName())];
   int &idx2 = symMap[CachedHashStringRef(real->getName())];
   int &idx3 = symMap[CachedHashStringRef(wrap->getName())];
 
   idx2 = idx1;