Call _exit

[• rafael]

Summary

As the state of lld gets more complicated, shutting down gets more expensive.

In a normal lld run we can just call _exit immediately after renaming the temporary output file. We still want the ability to run a full shutdown since that is useful for detecting memory leaks.

The attached patch adds a --full-shutdown flag and changes lit to use it.

The speedups I got were

firefox

master 7.230308488
patch  7.208082567 1.00308347203x faster

firefox-gc

master 7.427749933
patch  7.418814415 1.00120444016x faster

chromium

master 5.205103172
patch  5.125736748 1.01548390561x faster

chromium fast

master 2.049300081
patch  1.969078119 1.04074087322x faster

the gold plugin

master 0.355730113
patch  0.349688155 1.01727813171x faster

clang

master 0.600935753
patch  0.59087035 1.01703487576x faster

llvm-as

master 0.034656451
patch  0.034052431 1.01773794065x faster

the gold plugin fsds

master 0.386335917
patch  0.378535563 1.02060666094x faster

clang fsds

master 0.686066136
patch  0.672882627 1.01959258342x faster

llvm-as fsds

master 0.032056437
patch  0.031330437 1.02317235473x faster

scylla

master 3.24018577
patch  3.232975627 1.00223018786x faster

This also makes sure we don't have to worry to much about the shutdown cost of future changes.

[emaste]

Nifty idea

ELF/Options.td

83

need a better description :)

[ruiu]

ELF/Driver.cpp

55

Instead of propagating CanExitEarly, you can set Config->ExitEarly before calling this function.

ELF/Writer.cpp

326

Is even exit() expensive? If you use exit() instead of _exit(), you don't need to flush the streams.

[• rafael]

Update docs and set Config variable earlier.

[ruiu]

LGTM with these changes. As a record, we are doing the same thing for the COFF LLD.

ELF/Options.td

83

Please use F<> instead of Flag<> because we should accept both -full-shutdown and --full-shutdown .

ELF/Writer.cpp

323

Please add a comment that we exit as soon as we finished writing the output file to avoid the cost of destructors which gives us a few percent performance improvement.

[Eugene.Zelenko]

Committed in rL285224. Please specify "Differential revision: <URL>" as last line of commit message.

[malcolm.parsons]

Could quick_exit() be used instead?

[ruiu]

What is better in quick_exit than _exit?

[malcolm.parsons]

In D25997#593232, @ruiu wrote:

What is better in quick_exit than _exit?

It calls functions registered with at_quick_exit().
e.g. it could call llvm_shutdown().

ELF/Config.h

struct Configuration {
   bool Verbose;
   bool WarnCommon;
   bool ZCombreloc;
   bool ZExecstack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
+  bool ExitEarly;
   bool ZWxneeded;
   DiscardPolicy Discard;
   SortSectionPolicy SortSection;
   StripPolicy Strip = StripPolicy::None;
   UnresolvedPolicy UnresolvedSymbols;
   Target2Policy Target2 = Target2Policy::GotRel;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;

ELF/Driver.h

 
 namespace lld {
 namespace elf {
 
 extern class LinkerDriver *Driver;
 
 class LinkerDriver {
 public:
-  void main(ArrayRef<const char *> Args);
+  void main(ArrayRef<const char *> Args, bool CanExitEarly);
   void addFile(StringRef Path);
   void addLibrary(StringRef Name);
   llvm::LLVMContext Context;      // to parse bitcode files
   std::unique_ptr<CpioFile> Cpio; // for reproduce
 
 private:
   std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef MB);
   llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
-  void readConfigs(llvm::opt::InputArgList &Args);
+  void readConfigs(llvm::opt::InputArgList &Args, bool CanExitEarly);
   void createFiles(llvm::opt::InputArgList &Args);
   void inferMachineType();
   template <class ELFT> void link(llvm::opt::InputArgList &Args);
 
   // True if we are in --whole-archive and --no-whole-archive.
   bool InWholeArchive = false;
 
   // True if we are in --start-lib and --end-lib.

ELF/Driver.cpp

 using namespace llvm::sys;
 
 using namespace lld;
 using namespace lld::elf;
 
 Configuration *elf::Config;
 LinkerDriver *elf::Driver;
 
-bool elf::link(ArrayRef<const char *> Args, raw_ostream &Error) {
+bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
+               raw_ostream &Error) {
   HasError = false;
   ErrorOS = &Error;
   Argv0 = Args[0];
 
   Configuration C;
   LinkerDriver D;
   ScriptConfiguration SC;
   Config = &C;
   Driver = &D;
   ScriptConfig = &SC;
 
-  Driver->main(Args);
+  Driver->main(Args, CanExitEarly);
   InputFile::freePool();
   return !HasError;
 }
 
 // Parses a linker -m option.
 static std::pair<ELFKind, uint16_t> parseEmulation(StringRef Emul) {
   StringRef S = Emul;
   if (S.endswith("_fbsd"))
if (Pos != StringRef::npos && Key == Value.substr(0, Pos)) {
       if (Value.getAsInteger(0, Result))
         error("invalid " + Key + ": " + Value);
       return Result;
     }
   }
   return Default;
 }
 
-void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
+void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
   ELFOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
   if (Args.hasArg(OPT_help)) {
     printHelp(ArgsArr[0]);
     return;
   }
   if (Args.hasArg(OPT_version))
     outs() << getLLDVersion() << "\n";
 
   if (const char *Path = getReproduceOption(Args)) {
     // Note that --reproduce is a debug option so you can ignore it
     // if you are trying to understand the whole picture of the code.
     ErrorOr<CpioFile *> F = CpioFile::create(Path);
     if (F) {
       Cpio.reset(*F);
       Cpio->append("response.txt", createResponseFile(Args));
       Cpio->append("version.txt", getLLDVersion() + "\n");
     } else
       error(F.getError(),
             Twine("--reproduce: failed to open ") + Path + ".cpio");
   }
 
-  readConfigs(Args);
+  readConfigs(Args, CanExitEarly);
   initLLVM(Args);
   createFiles(Args);
   inferMachineType();
   checkOptions(Args);
   if (HasError)
     return;
 
   switch (Config->EKind) {
static SortSectionPolicy getSortKind(opt::InputArgList &Args) {
   if (S == "name")
     return SortSectionPolicy::Name;
   if (!S.empty())
     error("unknown --sort-section rule: " + S);
   return SortSectionPolicy::Default;
 }
 
 // Initializes Config members by the command line options.
-void LinkerDriver::readConfigs(opt::InputArgList &Args) {
+void LinkerDriver::readConfigs(opt::InputArgList &Args, bool CanExitEarly) {
   for (auto *Arg : Args.filtered(OPT_L))
     Config->SearchPaths.push_back(Arg->getValue());
 
   std::vector<StringRef> RPaths;
   for (auto *Arg : Args.filtered(OPT_rpath))
     RPaths.push_back(Arg->getValue());
   if (!RPaths.empty())
     Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":");
void LinkerDriver::readConfigs(opt::InputArgList &Args, bool CanExitEarly) {
   Config->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Relocatable = Args.hasArg(OPT_relocatable);
   Config->SaveTemps = Args.hasArg(OPT_save_temps);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->Target1Rel = getArg(Args, OPT_target1_rel, OPT_target1_abs, false);
   Config->Threads = Args.hasArg(OPT_threads);
   Config->Trace = Args.hasArg(OPT_trace);
   Config->Verbose = Args.hasArg(OPT_verbose);
+  Config->ExitEarly = CanExitEarly && !Args.hasArg(OPT_full_shutdown);
   Config->WarnCommon = Args.hasArg(OPT_warn_common);
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   Config->LtoAAPipeline = getString(Args, OPT_lto_aa_pipeline);
   Config->LtoNewPmPasses = getString(Args, OPT_lto_newpm_passes);

ELF/Options.td

def export_dynamic_symbol: S<"export-dynamic-symbol">,
   HelpText<"Put a symbol in the dynamic symbol table">;
 
 def fatal_warnings: F<"fatal-warnings">,
   HelpText<"Treat warnings as errors">;
 
 def fini: S<"fini">, MetaVarName<"<symbol>">,
   HelpText<"Specify a finalizer function">;
 
+def full_shutdown : Flag<["--"], "full-shutdown">,  HelpText<"foobar">;
+
 def format: J<"format=">, MetaVarName<"<input-format>">,
   HelpText<"Change the input format of the inputs following this option">;
 
 def gc_sections: F<"gc-sections">,
   HelpText<"Enable garbage collection of unused sections">;
 
 def gdb_index: F<"gdb-index">,
   HelpText<"Generate .gdb_index section">;

ELF/Writer.cpp

 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
 #include <climits>
 
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+#include <unistd.h>
+#endif
+
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
template <class ELFT> void Writer<ELFT>::run() {
   } else {
     writeSectionsBinary();
   }
   writeBuildId();
   if (HasError)
     return;
   if (auto EC = Buffer->commit())
     error(EC, "failed to write to the output file");
+  if (Config->ExitEarly) {
+    outs().flush();
+    errs().flush();
+    _exit(0);
+  }
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile())
     return false;
 

include/lld/Driver/Driver.h

 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace coff {
 bool link(llvm::ArrayRef<const char *> Args);
 }
 
 namespace elf {
-bool link(llvm::ArrayRef<const char *> Args,
+bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 
 namespace mach_o {
 bool link(llvm::ArrayRef<const char *> Args,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 }
 
 #endif

test/ELF/amdgpu-globals.s

 # RUN: llvm-mc -filetype=obj -triple amdgcn--amdhsa -mcpu=kaveri %s -o %t.o
-# RUN: lld -flavor gnu %t.o -o %t
+# RUN: ld.lld %t.o -o %t
 # RUN: llvm-readobj -sections -symbols -program-headers %t | FileCheck %s
 
 # REQUIRES: amdgpu
 
   .amdgpu_hsa_module_global module_global_program
   .size module_global_program, 4
   .hsadata_global_program
 module_global_program:

test/lit.cfg

 # tools that might happen to be in the user's PATH.
 
 # Regex assertions to reject neighbor hyphens/dots (seen in some tests).
 # For example, we want to prefix 'lld' and 'ld.lld' but not the 'lld' inside
 # of 'ld.lld'.
 NoPreJunk = r"(?<!(-|\.|/))"
 NoPostJunk = r"(?!(-|\.))"
 
+config.substitutions.append( (r"\bld.lld\b", 'ld.lld --full-shutdown') )
+
 tool_patterns = [r"\bFileCheck\b",
                  r"\bnot\b",
                  NoPreJunk + r"\blld\b" + NoPostJunk,
                  r"\bld.lld\b",
                  r"\blld-link\b",
                  r"\bllvm-as\b",
                  r"\bllvm-mc\b",
                  r"\bllvm-nm\b",

tools/lld/lld.cpp

int main(int Argc, const char **Argv) {
   // Standard set up, so program fails gracefully.
   sys::PrintStackTraceOnErrorSignal(Argv[0]);
   PrettyStackTraceProgram StackPrinter(Argc, Argv);
   llvm_shutdown_obj Shutdown;
 
   std::vector<const char *> Args(Argv, Argv + Argc);
   switch (parseFlavor(Args)) {
   case Gnu:
-    return !elf::link(Args);
+    return !elf::link(Args, true);
   case WinLink:
     return !coff::link(Args);
   case Darwin:
     return !mach_o::link(Args);
   default:
     die("lld is a generic driver.\n"
         "Invoke ld.lld (Unix), ld (Mac) or lld-link (Windows) instead.");
   }
 }