Do not automatically append --full-shutdown to lld tests.

[ruiu]

Summary

I don't think appending "--full-shtudown" to every invocation of ld.lld
in the test suit doesn't make much sense. We havne't caught any errors
by doing that, and that's perhaps rather harmful from the testing point
of view because users are using ld.lld without "--full-shutdown" option.
So this patch I removed that rule.

I added one test so that ld.lld to make sure that ld.lld works with
"--full-shutdown".

[pcc]

Isn't --full-shutdown necessary for the leak sanitizer to work correctly?

[ruiu]

• rebased

[ruiu]

Isn't --full-shutdown necessary for the leak sanitizer to work correctly?

Hmm, that's probably true. I believe we do _exit in lld COFF linker. Maybe we should stop doing that as well?

[pcc]

In D43410#1010826, @ruiu wrote:

Isn't --full-shutdown necessary for the leak sanitizer to work correctly?

Hmm, that's probably true. I believe we do _exit in lld COFF linker. Maybe we should stop doing that as well?

Yes, it would probably be worth adding a /fullshutdown flag and using it in the tests to detect memory leaks. Same for wasm I'd imagine.

[ruiu]

If this is needed by all tests, how about making it an environment variable (e.g. "LLD_IN_TEST=1") and detect it in lld.cpp instead of in each driver?

[pcc]

In D43410#1010933, @ruiu wrote:

If this is needed by all tests, how about making it an environment variable (e.g. "LLD_IN_TEST=1") and detect it in lld.cpp instead of in each driver?

Yes, that sounds better.

[ruiu]

• redesign

[pcc]

lld/test/ELF/lto/timepasses.ll

3 ↗

(On Diff #134747)

Could this be env LLD_IN_TEST=0 ld.lld %t.o ...? Then you wouldn't need a --no-full-shutdown flag.

[ruiu]

• removed --full-shutdown

[pcc]

LGTM with an updated commit message.

lld/trunk/ELF/Config.h

struct Configuration {
   bool ZNodelete;
   bool ZNodlopen;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
   bool ZRodynamic;
   bool ZText;
   bool ZRetpolineplt;
-  bool ExitEarly;
   bool ZWxneeded;
   DiscardPolicy Discard;
   OrphanHandlingPolicy OrphanHandling;
   SortSectionPolicy SortSection;
   StripPolicy Strip;
   UnresolvedPolicy UnresolvedSymbols;
   Target2Policy Target2;
   BuildIdKind BuildId = BuildIdKind::None;

lld/trunk/ELF/Driver.h

 
 namespace lld {
 namespace elf {
 
 extern class LinkerDriver *Driver;
 
 class LinkerDriver {
 public:
-  void main(ArrayRef<const char *> Args, bool CanExitEarly);
+  void main(ArrayRef<const char *> Args);
   void addFile(StringRef Path, bool WithLOption);
   void addLibrary(StringRef Name);
 
 private:
   void readConfigs(llvm::opt::InputArgList &Args);
   void createFiles(llvm::opt::InputArgList &Args);
   void inferMachineType();
   template <class ELFT> void link(llvm::opt::InputArgList &Args);

lld/trunk/ELF/Driver.cpp

 
 bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
                raw_ostream &Error) {
   errorHandler().LogName = Args[0];
   errorHandler().ErrorLimitExceededMsg =
       "too many errors emitted, stopping now (use "
       "-error-limit=0 to see all errors)";
   errorHandler().ErrorOS = &Error;
+  errorHandler().ExitEarly = CanExitEarly;
   errorHandler().ColorDiagnostics = Error.has_colors();
+
   InputSections.clear();
   OutputSections.clear();
   Tar = nullptr;
   BinaryFiles.clear();
   BitcodeFiles.clear();
   ObjectFiles.clear();
   SharedFiles.clear();
 
   Config = make<Configuration>();
   Driver = make<LinkerDriver>();
   Script = make<LinkerScript>();
   Symtab = make<SymbolTable>();
   Config->ProgName = Args[0];
 
-  Driver->main(Args, CanExitEarly);
+  Driver->main(Args);
 
   // Exit immediately if we don't need to return to the caller.
   // This saves time because the overhead of calling destructors
   // for all globally-allocated objects is not negligible.
-  if (Config->ExitEarly)
+  if (CanExitEarly)
     exitLld(errorCount() ? 1 : 0);
 
   freeArena();
   return !errorCount();
 }
 
 // Parses a linker -m option.
 static std::tuple<ELFKind, uint16_t, uint8_t> parseEmulation(StringRef Emul) {

 
 static bool hasZOption(opt::InputArgList &Args, StringRef Key) {
   for (auto *Arg : Args.filtered(OPT_z))
     if (Key == Arg->getValue())
       return true;
   return false;
 }
 
-void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
+void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
   ELFOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
 
   // Interpret this flag early because error() depends on them.
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   // Handle -help
   if (Args.hasArg(OPT_help)) {
void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
 
   // The behavior of -v or --version is a bit strange, but this is
   // needed for compatibility with GNU linkers.
   if (Args.hasArg(OPT_v) && !Args.hasArg(OPT_INPUT))
     return;
   if (Args.hasArg(OPT_version))
     return;
 
-  Config->ExitEarly = CanExitEarly && !Args.hasArg(OPT_full_shutdown);
-  errorHandler().ExitEarly = Config->ExitEarly;
-
   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.
     Expected<std::unique_ptr<TarWriter>> ErrOrWriter =
         TarWriter::create(Path, path::stem(Path));
     if (ErrOrWriter) {
       Tar = ErrOrWriter->get();
       Tar->append("response.txt", createResponseFile(Args));

lld/trunk/ELF/Options.td

defm filter: Eq<"filter">,
   HelpText<"Set DT_FILTER field to the specified name">;
 
 defm fini: Eq<"fini">,
   HelpText<"Specify a finalizer function">, MetaVarName<"<symbol>">;
 
 def fix_cortex_a53_843419: F<"fix-cortex-a53-843419">,
   HelpText<"Apply fixes for AArch64 Cortex-A53 erratum 843419">;
 
-def full_shutdown : F<"full-shutdown">, Flags<[HelpHidden]>,
-  HelpText<"Perform a full shutdown instead of calling _exit">;
-
 defm format: Eq<"format">,
   HelpText<"Change the input format of the inputs following this option">,
   MetaVarName<"<input-format>">;
 
 defm gc_sections: B<"gc-sections",
     "Enable garbage collection of unused sections",
     "Disable garbage collection of unused sections">;
 

lld/trunk/test/ELF/lto/timepasses.ll

-; We use lld -flavor gnu because llvm-lit will append --full-shutdown to
-; the ld.lld invocation.
 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
-; RUN: lld -flavor gnu %t.o -o %t.so -shared -mllvm -time-passes 2>&1 | FileCheck %s
+; RUN: env LLD_IN_TEST=0 ld.lld %t.o -o %t.so -shared -mllvm \
+; RUN:   -time-passes 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @patatino() {
   ret void
 }
 
-; We should get the output of -time-passes even when --full-shutdown is not specified.
+; We should get the output of -time-passes even when full shutdown is not specified.
 ; CHECK: Total Execution Time

lld/trunk/test/lit.cfg.py

('--targets-built', {'AArch64': 'aarch64',
                           'PowerPC': 'ppc',
                           'Sparc': 'sparc',
                           'WebAssembly': 'wasm',
                           'X86': 'x86'})
      ])
 
 # Set a fake constant version so that we get consitent output.
 config.environment['LLD_VERSION'] = 'LLD 1.0'
+config.environment['LLD_IN_TEST'] = '1'
 
 # Indirectly check if the mt.exe Microsoft utility exists by searching for
 # cvtres, which always accompanies it.  Alternatively, check if we can use
 # libxml2 to merge manifests.
 if (lit.util.which('cvtres', config.environment['PATH'])) or \
         (config.llvm_libxml2_enabled == '1'):
     config.available_features.add('manifest_tool')
 

lld/trunk/tools/lld/lld.cpp

 #include "lld/Common/Driver.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
+#include <cstdlib>
 
 using namespace lld;
 using namespace llvm;
 using namespace llvm::sys;
 
 enum Flavor {
   Invalid,
   Gnu,     // -flavor gnu
static Flavor parseFlavor(std::vector<const char *> &V) {
 
   // Deduct the flavor from argv[0].
   StringRef Arg0 = path::filename(V[0]);
   if (Arg0.endswith_lower(".exe"))
     Arg0 = Arg0.drop_back(4);
   return parseProgname(Arg0);
 }
 
+// If this function returns true, lld calls _exit() so that it quickly
+// exits without invoking destructors of globally allocated objects.
+//
+// We don't want to do that if we are running tests though, because
+// doing that breaks leak sanitizer. So, lit sets this environment variable,
+// and we use it to detect whether we are running tests or not.
+static bool canExitEarly() { return StringRef(getenv("LLD_IN_TEST")) != "1"; }
+
 /// Universal linker main(). This linker emulates the gnu, darwin, or
 /// windows linker based on the argv[0] or -flavor option.
 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:
     if (isPETarget(Args))
       return !mingw::link(Args);
-    return !elf::link(Args, true);
+    return !elf::link(Args, canExitEarly());
   case WinLink:
-    return !coff::link(Args, true);
+    return !coff::link(Args, canExitEarly());
   case Darwin:
     return !mach_o::link(Args);
   case Wasm:
-    return !wasm::link(Args, true);
+    return !wasm::link(Args, canExitEarly());
   default:
     die("lld is a generic driver.\n"
         "Invoke ld.lld (Unix), ld64.lld (macOS) or lld-link (Windows) instead.");
   }
 }

llvm/trunk/utils/lit/lit/llvm/config.py

def use_lld(self, required=True):
         if lld_tools_dir:
             tool_dirs = tool_dirs + [lld_tools_dir]
         if lld_libs_dir:
             lib_dirs = lib_dirs + [lld_libs_dir]
 
         self.with_environment('PATH', tool_dirs, append_path=True)
         self.with_environment('LD_LIBRARY_PATH', lib_dirs, append_path=True)
 
-        self.config.substitutions.append(
-            (r"\bld.lld\b", 'ld.lld --full-shutdown'))
-
         tool_patterns = ['lld', 'ld.lld', 'lld-link', 'ld64.lld', 'wasm-ld']
 
         self.add_tool_substitutions(tool_patterns, tool_dirs)