[ELF] - Implemented -stats command line option.

[grimar]

Summary

-stats flag was not implemented before,
that is the reason of link fail for some FreeBSD ports, for example ncurses 6.0.3.

Initially I wanted just to ignore that flag, but then thought that probably
this can be useful for users when properly implemented.

[davide]

ehm, do you know what they use this for? It's supposed to be a debug only options, it shouldn't ship in any release.

[ruiu]

We can get the same information using "time" or "perf" command, so I think it is not necessary. We probably should just ignore the flag.

[grimar]

option was ignored instead

ELF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ELF.h"
+#include "llvm/Support/Timer.h"
 
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class InputFile;
 struct Symbol;
struct Configuration {
   bool Pic;
   bool Pie;
   bool PrintGcSections;
   bool Rela;
   bool Relocatable;
   bool SaveTemps;
   bool Shared;
   bool Static = false;
+  bool Stats;
   bool SysvHash = true;
   bool Target1Rel;
   bool Threads;
   bool Trace;
   bool Verbose;
   bool WarnCommon;
   bool ZCombreloc;
   bool ZExecstack;
struct Configuration {
   uint64_t EntryAddr = 0;
   uint64_t ImageBase;
   uint64_t MaxPageSize;
   uint64_t ZStackSize;
   unsigned LtoPartitions;
   unsigned LtoO;
   unsigned Optimize;
   unsigned ThinLtoJobs;
+  llvm::TimeRecord StartTime;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Driver.cpp

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 (Args.hasArg(OPT_stats))
+    Config->StartTime = TimeRecord::getCurrentTime(true);
+
   Config->ExitEarly = CanExitEarly && !Args.hasArg(OPT_full_shutdown);
 
   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);
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->NoGnuUnique = Args.hasArg(OPT_no_gnu_unique);
   Config->NoUndefinedVersion = Args.hasArg(OPT_no_undefined_version);
   Config->Nostdlib = Args.hasArg(OPT_nostdlib);
   Config->Pie = getArg(Args, OPT_pie, OPT_nopie, false);
   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->Stats = Args.hasArg(OPT_stats);
   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->WarnCommon = Args.hasArg(OPT_warn_common);
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);

ELF/Options.td

 
 def soname: J<"soname=">, HelpText<"Set DT_SONAME">;
 
 def sort_section: S<"sort-section">, HelpText<"Specifies sections sorting rule when linkerscript is used">;
 
 def start_lib: F<"start-lib">,
   HelpText<"Start a grouping of objects that should be treated as if they were together in an archive">;
 
+def stats: F<"stats">, HelpText<"Print resource usage statistics">;
+
 def strip_all: F<"strip-all">, HelpText<"Strip all symbols">;
 
 def strip_debug: F<"strip-debug">, HelpText<"Strip debugging information">;
 
 def sysroot: J<"sysroot=">, HelpText<"Set the system root">;
 
 def target1_rel: F<"target1-rel">, HelpText<"Interpret R_ARM_TARGET1 as R_ARM_REL32">;
 

ELF/Writer.cpp

 #include "Strings.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include <climits>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
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->Stats) {
+    TimeRecord T = TimeRecord::getCurrentTime(true);
+    outs() << format("Link user time:  %7.4f",
+                     T.getUserTime() - Config->StartTime.getUserTime())
+           << "\n";
+    outs() << format("Memory usage: %9" PRId64 "  ",
+                     (int64_t)sys::Process::GetMallocUsage())
+           << "\n";
+  }
   if (Config->ExitEarly) {
     // Flush the output streams and exit immediately.  A full shutdown is a good
     // test that we are keeping track of all allocated memory, but actually
     // freeing it is a waste of time in a regular linker run.
     exitLld(0);
   }
 }
 

test/ELF/stats.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: ld.lld -stats %t -o %t2 2>&1 | FileCheck %s -check-prefix=STATS
+
+# STATS: Link user time:
+# STATS: Memory usage: