Make sure the temporary file is almost always deleted

[• rafael]

Summary

It is really hard to cover restarts in a debug, SIGKILL or power failures.

RemoveFileOnSignal takes care of crashes.

So what is left is making sure all regular exits delete the file. This patch does that by moving the buffer to error handling. That is a bit of hack, but seemed better than to generalize it to take a callback on construction.

Sending for review with just ELF. It something like this is OK I will update COFF too.

[ruiu]

LGTM

Yeah, this is a bit hacky and we could implement a more abstract way of implementing it (e.g. implementing at_lld_exit() and add this feature using it), but I think this would be too much. Practically, this is probably the best way of doing it.

[• espindola]

318060

Common/ErrorHandler.cpp

 }
 
 ErrorHandler &lld::errorHandler() {
   static ErrorHandler Handler;
   return Handler;
 }
 
 void lld::exitLld(int Val) {
+  // Delete the output buffer so that any tempory file is deleted.
+  errorHandler().OutputBuffer.reset();
+
   // Dealloc/destroy ManagedStatic variables before calling
   // _exit(). In a non-LTO build, this is a nop. In an LTO
   // build allows us to get the output of -time-passes.
   llvm_shutdown();
 
   outs().flush();
   errs().flush();
   _exit(Val);

ELF/Writer.cpp

 #include "Relocations.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/FileOutputBuffer.h"
 #include <climits>
 
 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;
 
 namespace {
 // The writer writes a SymbolTable result to a file.
 template <class ELFT> class Writer {
 public:
+  Writer() : Buffer(errorHandler().OutputBuffer) {}
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
 
   void run();
 
 private:
   void createSyntheticSections();
private:
   void fixSectionAlignments();
   void openFile();
   void writeTrapInstr();
   void writeHeader();
   void writeSections();
   void writeSectionsBinary();
   void writeBuildId();
 
-  std::unique_ptr<FileOutputBuffer> Buffer;
+  std::unique_ptr<FileOutputBuffer> &Buffer;
 
   void addRelIpltSymbols();
   void addStartEndSymbols();
   void addStartStopSymbols(OutputSection *Sec);
   uint64_t getEntryAddr();
   OutputSection *findSection(StringRef Name);
 
   std::vector<PhdrEntry *> Phdrs;

include/lld/Common/ErrorHandler.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COMMON_ERRORHANDLER_H
 #define LLD_COMMON_ERRORHANDLER_H
 
 #include "lld/Common/LLVM.h"
 
 #include "llvm/Support/Error.h"
+#include "llvm/Support/FileOutputBuffer.h"
 
 namespace lld {
 
 class ErrorHandler {
 public:
   uint64_t ErrorCount = 0;
   uint64_t ErrorLimit = 20;
   StringRef ErrorLimitExceededMsg = "too many errors emitted, stopping now";
   StringRef LogName = "lld";
   llvm::raw_ostream *ErrorOS = &llvm::errs();
   bool ColorDiagnostics = llvm::errs().has_colors();
   bool ExitEarly = true;
   bool FatalWarnings = false;
   bool Verbose = false;
 
   void error(const Twine &Msg);
   LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg);
   void log(const Twine &Msg);
   void message(const Twine &Msg);
   void warn(const Twine &Msg);
 
+  std::unique_ptr<llvm::FileOutputBuffer> OutputBuffer;
+
 private:
   void print(StringRef S, raw_ostream::Colors C);
 };
 
 /// Returns the default error handler.
 ErrorHandler &errorHandler();
 
 inline void error(const Twine &Msg) { errorHandler().error(Msg); }