ELF: Make link() to take an output stream to which error messages are written.

[ruiu]

Summary

Now that we can do this.

[• rafael]

I don't think so.

The problem is that we were not at 100% coverage with fatal. There are many cases where we would just follow a broken offset and crash. If we can produce a segmentation fault, we can call fatal.

If we cannot produce a segmentation fault, we will need another way of fixing this.

[silvas]

In D16668#340546, @rafael wrote:

I don't think so.

The problem is that we were not at 100% coverage with fatal. There are many cases where we would just follow a broken offset and crash. If we can produce a segmentation fault, we can call fatal.

If we cannot produce a segmentation fault, we will need another way of fixing this.

I think this does cover the case of programmatic invocation of LLD (i.e., with known-good object files, which seems like the primary use case for programmatic invocation), so it does still seem worth it.

Bulletproofing against all possible defective object files (i.e. guaranteeing no segfaults) is a huge amount of work I suspect (and probably not worth it?), but this change does seem to cover a real (and requested by many people in the community) use case.

[ruiu]

• Adjust the scope of this patch.

[• rafael]

LGTM

[Eugene.Zelenko]

Committed in r259597.

ELF/Driver.h

 //===- Driver.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_DRIVER_H
 #define LLD_ELF_DRIVER_H
 
 #include "SymbolTable.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace elf2 {
 
 extern class LinkerDriver *Driver;
 
 // Entry point of the ELF linker. Returns true on success.
-bool link(ArrayRef<const char *> Args);
+bool link(ArrayRef<const char *> Args, llvm::raw_ostream &Error = llvm::errs());
 
 class LinkerDriver {
 public:
   void main(ArrayRef<const char *> Args);
   void addFile(StringRef Path);
 
 private:
   void readConfigs(llvm::opt::InputArgList &Args);

ELF/Driver.cpp

 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 Configuration *elf2::Config;
 LinkerDriver *elf2::Driver;
 
-bool elf2::link(ArrayRef<const char *> Args) {
+bool elf2::link(ArrayRef<const char *> Args, raw_ostream &Error) {
   HasError = false;
+  ErrorOS = &Error;
   Configuration C;
   LinkerDriver D;
   Config = &C;
   Driver = &D;
   Driver->main(Args.slice(1));
   return !HasError;
 }
 

ELF/Error.h

 //===- Error.h --------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_ERROR_H
 #define LLD_COFF_ERROR_H
 
 #include "lld/Core/LLVM.h"
 
+namespace llvm {
+class raw_ostream;
+}
+
 namespace lld {
 namespace elf2 {
 
 extern bool HasError;
+extern llvm::raw_ostream *ErrorOS;
 
 void warning(const Twine &Msg);
 
 void error(const Twine &Msg);
 void error(std::error_code EC, const Twine &Prefix);
 void error(std::error_code EC);
 
 template <typename T> void error(const ErrorOr<T> &V, const Twine &Prefix) {

ELF/Error.cpp

 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace elf2 {
 
 bool HasError;
+llvm::raw_ostream *ErrorOS;
 
 void warning(const Twine &Msg) { llvm::errs() << Msg << "\n"; }
 
 void error(const Twine &Msg) {
-  llvm::errs() << Msg << "\n";
+  *ErrorOS << Msg << "\n";
   HasError = true;
 }
 
 void error(std::error_code EC, const Twine &Prefix) {
   if (EC)
     error(Prefix + ": " + EC.message());
 }
 

include/lld/Driver/Driver.h

 };
 
 /// Driver for Windows 'link.exe' command line options
 namespace coff {
 void link(llvm::ArrayRef<const char *> args);
 }
 
 namespace elf2 {
-bool link(llvm::ArrayRef<const char *> args);
+bool link(llvm::ArrayRef<const char *> args, raw_ostream &diag = llvm::errs());
 }
 
 /// Driver for lld unit tests
 class CoreDriver : public Driver {
 public:
   /// Parses command line arguments same as lld-core and performs link.
   /// Returns true iff there was an error.
   static bool link(llvm::ArrayRef<const char *> args,

lib/Driver/UniversalDriver.cpp

bool UniversalDriver::link(llvm::MutableArrayRef<const char *> args,
 
   Flavor flavor = getFlavor(args, parsedArgs);
 
   // Switch to appropriate driver.
   switch (flavor) {
   case Flavor::old_gnu_ld:
     return GnuLdDriver::linkELF(args, diagnostics);
   case Flavor::gnu_ld:
-    return elf2::link(args);
+    return elf2::link(args, diagnostics);
   case Flavor::darwin_ld:
     return DarwinLdDriver::linkMachO(args, diagnostics);
   case Flavor::win_link:
     coff::link(args);
     return true;
   case Flavor::core:
     return CoreDriver::link(args, diagnostics);
   case Flavor::invalid:
     diagnostics << "Select the appropriate flavor\n";
     table.PrintHelp(llvm::outs(), programName.data(), "LLVM Linker", false);
     return false;
   }
   llvm_unreachable("Unrecognised flavor");
 }
 
 } // end namespace lld