Fail early if an output file is not writable.

[ruiu]

Summary

Fixes https://bugs.llvm.org/show_bug.cgi?id=36478

[zturner]

lld/COFF/Driver.cpp

1278

There's still a race condition here, in that a program could open the file after this call succeeds but before we get around to writing it. It would be nice if there were a way for this function to grab the file handle for exclusive write access up front, but this seems hard to do due to the several layers of indirection between here and when we actually write the output file.

[ruiu]

Yes, there's a chance that this test succeeds but the final output fails, but that should be acceptable. File writing could fail for other reasons, like disk full situation, and there's no way to know that before we actually write bytes to a file, so I think it's not worth to spend too much effort to be more accurate.

lld/COFF/Driver.cpp

 #include "MarkLive.h"
 #include "MinGW.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Timer.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/COFFImportFile.h"
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   }
 
   // Set default image name if neither /out or /def set it.
   if (Config->OutputFile.empty()) {
     Config->OutputFile =
         getOutputPath((*Args.filtered(OPT_INPUT).begin())->getValue());
   }
 
+  // Fail early if an output file is not writable.
+  if (auto E = tryCreateFile(Config->OutputFile)) {
+    error("cannot open output file " + Config->OutputFile + ": " + E.message());
+    return;
+  }
+
   // Put the PDB next to the image if no /pdb flag was passed.
   if (ShouldCreatePDB && Config->PDBPath.empty()) {
     Config->PDBPath = Config->OutputFile;
     sys::path::replace_extension(Config->PDBPath, ".pdb");
   }
 
   // Set default image base if /base is not given.
   if (Config->ImageBase == uint64_t(-1))

lld/Common/CMakeLists.txt

 if(NOT LLD_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lld_library(lldCommon
   Args.cpp
   ErrorHandler.cpp
+  Filesystem.cpp
   Memory.cpp
   Reproduce.cpp
   Strings.cpp
   TargetOptionsCommandFlags.cpp
   Threads.cpp
   Timer.cpp
   Version.cpp
 

lld/Common/Filesystem.cpp

 //===- Filesystem.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a few utility functions to handle files.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Filesystem.h"
-#include "Config.h"
+#include "lld/Common/Filesystem.h"
 #include "lld/Common/Threads.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #if LLVM_ON_UNIX
 #include <unistd.h>
 #endif
 #include <thread>
 
 using namespace llvm;
-
 using namespace lld;
-using namespace lld::elf;
 
 // Removes a given file asynchronously. This is a performance hack,
 // so remove this when operating systems are improved.
 //
 // On Linux (and probably on other Unix-like systems), unlink(2) is a
 // noticeably slow system call. As of 2016, unlink takes 250
 // milliseconds to remove a 1 GB file on ext4 filesystem on my machine.
 //
 // To create a new result file, we first remove existing file. So, if
 // you repeatedly link a 1 GB program in a regular compile-link-debug
 // cycle, every cycle wastes 250 milliseconds only to remove a file.
 // Since LLD can link a 1 GB binary in about 5 seconds, that waste
 // actually counts.
 //
 // This function spawns a background thread to remove the file.
 // The calling thread returns almost immediately.
-void elf::unlinkAsync(StringRef Path) {
+void lld::unlinkAsync(StringRef Path) {
 // Removing a file is async on windows.
 #if defined(LLVM_ON_WIN32)
   sys::fs::remove(Path);
 #else
   if (!ThreadsEnabled || !sys::fs::exists(Path) ||
       !sys::fs::is_regular_file(Path))
     return;
 

 // create a file. But we don't want to do that in this function
 // because LLD shouldn't update any file if it will end in a failure.
 // We also don't want to reimplement heuristics to determine if a
 // file is writable. So we'll let FileOutputBuffer do the work.
 //
 // FileOutputBuffer doesn't touch a desitnation file until commit()
 // is called. We use that class without calling commit() to predict
 // if the given file is writable.
-std::error_code elf::tryCreateFile(StringRef Path) {
+std::error_code lld::tryCreateFile(StringRef Path) {
   if (Path.empty())
     return std::error_code();
   if (Path == "-")
     return std::error_code();
   return errorToErrorCode(FileOutputBuffer::create(Path, 1).takeError());
 }

lld/ELF/CMakeLists.txt

add_lld_library(lldELF
   Arch/PPC.cpp
   Arch/PPC64.cpp
   Arch/SPARCV9.cpp
   Arch/X86.cpp
   Arch/X86_64.cpp
   Driver.cpp
   DriverUtils.cpp
   EhFrame.cpp
-  Filesystem.cpp
   GdbIndex.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MapFile.cpp
   MarkLive.cpp

lld/ELF/Driver.cpp

 // be harmful when you are doing cross-linking. Therefore, in LLD, we
 // simply trust the compiler driver to pass all required options and
 // don't try to make effort on our side.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Config.h"
-#include "Filesystem.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "LinkerScript.h"
 #include "MarkLive.h"
 #include "OutputSections.h"
 #include "ScriptParser.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/CommandLine.h"

lld/ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "AArch64ErrataFix.h"
 #include "Config.h"
-#include "Filesystem.h"
 #include "LinkerScript.h"
 #include "MapFile.h"
 #include "OutputSections.h"
 #include "Relocations.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
+#include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include <climits>
 
 using namespace llvm;
 using namespace llvm::ELF;

lld/include/lld/Common/Filesystem.h

 //===- Filesystem.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_FILESYSTEM_H
-#define LLD_ELF_FILESYSTEM_H
+#ifndef LLD_COMMON_FILESYSTEM_H
+#define LLD_COMMON_FILESYSTEM_H
 
 #include "lld/Common/LLVM.h"
 #include <system_error>
 
 namespace lld {
-namespace elf {
 void unlinkAsync(StringRef Path);
 std::error_code tryCreateFile(StringRef Path);
-} // namespace elf
 } // namespace lld
 
 #endif

lld/test/COFF/driver.test

 # RUN: not lld-link nosuchfile.obj >& %t.log
 # RUN: FileCheck -check-prefix=MISSING %s < %t.log
 MISSING: nosuchfile.obj: {{[Nn]}}o such file or directory
 
 # RUN: lld-link --version | FileCheck -check-prefix=VERSION %s
 VERSION: {{LLD [0-9]+\.[0-9]+}}
+
+# RUN: yaml2obj < %p/Inputs/hello32.yaml > %t.obj
+# RUN: not lld-link /out:/ %t.obj 2>&1 | FileCheck -check-prefix=DIR %s
+DIR: cannot open output file