Directly write to a -Map file.

[ruiu]

Summary

Previous code had a bug that if the program exits with an assert()
or fail() before the control reaches end of writeMapFile(), it left
a temporary file, because FileRemover's dtor didn't run.

I could fix that by removeFileOnSignal() and other functions, but
I think we can simply write to the result file directly. I think
that is straightforward and easy to understand.

Additionally, that allows something like -Map /dev/null or a bash
hack such as -Map >(grep -U symbol-im-looking-for). Previously,
that kind of things didn't work.

lld/trunk/COFF/MapFile.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "MapFile.h"
 #include "Error.h"
 #include "Symbols.h"
 #include "Writer.h"
 
-#include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::coff;
 
 static void writeOutSecLine(raw_fd_ostream &OS, uint64_t Address, uint64_t Size,
for (SymbolBody *Sym : Syms) {
     if (!DR || DR->getChunk() != SC ||
         DR->getCOFFSymbol().isSectionDefinition())
       continue;
     writeSymbolLine(OS, DR->getRVA(), SC->getSize(), toString(*Sym));
     OS << '\n';
   }
 }
 
-static void writeMapFile2(int FD,
+static void writeMapFile2(raw_fd_ostream &OS,
                           ArrayRef<OutputSection *> OutputSections) {
-  raw_fd_ostream OS(FD, true);
   OS << left_justify("Address", 8) << ' ' << left_justify("Size", 8)
      << ' ' << left_justify("Align", 5) << ' ' << left_justify("Out", 7) << ' '
      << left_justify("In", 7) << ' ' << left_justify("File", 7) << " Symbol\n";
+
   for (OutputSection *Sec : OutputSections) {
     uint32_t VA = Sec->getRVA();
     writeOutSecLine(OS, VA, Sec->getVirtualSize(), /*Align=*/PageSize,
                     Sec->getName());
     OS << '\n';
     StringRef PrevName = "";
     for (Chunk *C : Sec->getChunks())
       if (const auto *SC = dyn_cast<SectionChunk>(C))
         writeSectionChunk(OS, SC, PrevName);
   }
 }
 
 void coff::writeMapFile(ArrayRef<OutputSection *> OutputSections) {
-  StringRef MapFile = Config->MapFile;
-  if (MapFile.empty())
+  if (Config->MapFile.empty())
     return;
 
-  // Create new file in same directory but with random name.
-  SmallString<128> TempPath;
-  int FD;
-  std::error_code EC =
-      sys::fs::createUniqueFile(Twine(MapFile) + ".tmp%%%%%%%", FD, TempPath);
-  if (EC)
-    fatal(EC.message());
-  FileRemover RAII(TempPath);
-  writeMapFile2(FD, OutputSections);
-  EC = sys::fs::rename(TempPath, MapFile);
+  std::error_code EC;
+  raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None);
   if (EC)
-    fatal(EC.message());
+    fatal("cannot open " + Config->MapFile + ": " + EC.message());
+  writeMapFile2(OS, OutputSections);
 }

lld/trunk/ELF/MapFile.cpp

 // 00201005 00000000     0                         f(int)
 //
 //===----------------------------------------------------------------------===//
 
 #include "MapFile.h"
 #include "InputFiles.h"
 #include "Strings.h"
 
-#include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf;
 
 static void writeOutSecLine(raw_fd_ostream &OS, int Width, uint64_t Address,
if (DR->isSection())
       continue;
     writeSymbolLine(OS, Width, Sym->getVA<ELFT>(), Sym->getSize<ELFT>(),
                     toString(*Sym));
     OS << '\n';
   }
 }
 
 template <class ELFT>
-static void writeMapFile2(int FD,
+static void writeMapFile2(raw_fd_ostream &OS,
                           ArrayRef<OutputSectionBase *> OutputSections) {
-  raw_fd_ostream OS(FD, true);
   int Width = ELFT::Is64Bits ? 16 : 8;
 
   OS << left_justify("Address", Width) << ' ' << left_justify("Size", Width)
      << ' ' << left_justify("Align", 5) << ' ' << left_justify("Out", 7) << ' '
      << left_justify("In", 7) << ' ' << left_justify("File", 7) << " Symbol\n";
 
   for (OutputSectionBase *Sec : OutputSections) {
     writeOutSecLine(OS, Width, Sec->Addr, Sec->Size, Sec->Addralign,
                     Sec->getName());
     OS << '\n';
 
     StringRef PrevName = "";
     Sec->forEachInputSection([&](InputSectionData *S) {
       if (const auto *IS = dyn_cast<InputSection<ELFT>>(S))
         writeInputSection(OS, IS, PrevName);
     });
   }
 }
 
 template <class ELFT>
 void elf::writeMapFile(ArrayRef<OutputSectionBase *> OutputSections) {
-  StringRef MapFile = Config->MapFile;
-  if (MapFile.empty())
+  if (Config->MapFile.empty())
     return;
 
-  // Create new file in same directory but with random name.
-  SmallString<128> TempPath;
-  int FD;
-  std::error_code EC =
-      sys::fs::createUniqueFile(Twine(MapFile) + ".tmp%%%%%%%", FD, TempPath);
+  std::error_code EC;
+  raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None);
   if (EC)
-    fatal(EC.message());
-  FileRemover RAII(TempPath);
-  writeMapFile2<ELFT>(FD, OutputSections);
-  EC = sys::fs::rename(TempPath, MapFile);
-  if (EC)
-    fatal(EC.message());
+    fatal("cannot open " + Config->MapFile + ": " + EC.message());
+  writeMapFile2<ELFT>(OS, OutputSections);
 }
 
 template void elf::writeMapFile<ELF32LE>(ArrayRef<OutputSectionBase *>);
 template void elf::writeMapFile<ELF32BE>(ArrayRef<OutputSectionBase *>);
 template void elf::writeMapFile<ELF64LE>(ArrayRef<OutputSectionBase *>);
 template void elf::writeMapFile<ELF64BE>(ArrayRef<OutputSectionBase *>);