[ELF] Print output name for command line errors

[evgeny777]

Summary

What I'm trying to do is to simplify processing lld output by automated parsing tool.
Ideally I'd like to have something like this for every warning or error message:

<path_to_ld.lld> : error|warning : <location> : <message>

This makes it easy to extract semantic values from error message and change its format if needed.
For instance MS Visual Studio expects error message in this format:

<location> : error : <message>

And one just needs to swap tokens to get the desired result.

I haven't updated unit tests yet - will do if this patch is a right thing.

[• rafael]

ELF/Driver.cpp

99

I am not sure it makes sense to always print the output name. In here the issue has nothing to do with the files, it is just a broken -m option.

If you want a common format, maybe printing something like" <command line>:" in here would be better.

[ruiu]

ELF/Driver.cpp

520–523

You can just do

... = getString(Args, OPT_o, "a.out");

[evgeny777]

ELF/Driver.cpp

99

So do you propose to use <command line> as tag for all command line arguments errors?

[ruiu]

Somewhat related, but I wish we are consistent with the filename+line number format with Clang. I believe this is our current style:

foo.o (143): symbol 'foo' not found

where 143 is a line number. That is different from

foo.o:143: symbol 'foo' not found

which is what clang would format.

[evgeny777]

Line is not applicable here, I think, so I'm still wondering what's your suggestion for this particular case. I don't mind using clang format for other cases (file:line, without space after ':'). I used round brackets to match file (.section) and file (function_name)

[ruiu]

ELF/Driver.cpp

99

How about showing the error message in this format for command line error for --foo?

error: -m: unknown emulation: xyz

ELF/Driver.cpp

 #include "SymbolTable.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Config/Version.h"
 #include "lld/Driver/Driver.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
   Driver = &D;
   ScriptConfig = &SC;
 
   Driver->main(Args, CanExitEarly);
   freeArena();
   return !HasError;
 }
 
+static std::string getOutputName() {
+  return sys::path::filename(Config->OutputFile);
+}
+
 // Parses a linker -m option.
 static std::tuple<ELFKind, uint16_t, uint8_t> parseEmulation(StringRef Emul) {
   uint8_t OSABI = 0;
   StringRef S = Emul;
   if (S.endswith("_fbsd")) {
     S = S.drop_back(5);
     OSABI = ELFOSABI_FREEBSD;
   }
std::pair<ELFKind, uint16_t> Ret =
           .Case("elf64ppc", {ELF64BEKind, EM_PPC64})
           .Cases("elf_amd64", "elf_x86_64", {ELF64LEKind, EM_X86_64})
           .Case("elf_i386", {ELF32LEKind, EM_386})
           .Case("elf_iamcu", {ELF32LEKind, EM_IAMCU})
           .Default({ELFNoneKind, EM_NONE});
 
   if (Ret.first == ELFNoneKind) {
     if (S == "i386pe" || S == "i386pep" || S == "thumb2pe")
-      error("Windows targets are not supported on the ELF frontend: " + Emul);
+      error(getOutputName() +
+            ": Windows targets are not supported on the ELF frontend: " + Emul);
     else
-      error("unknown emulation: " + Emul);
+      error(getOutputName() + ": unknown emulation: " + Emul);
   }
   return std::make_tuple(Ret.first, Ret.second, OSABI);
 }
 
 // Returns slices of MB by parsing MB as an archive file.
 // Each slice consists of a member file in the archive.
 std::vector<MemoryBufferRef>
 LinkerDriver::getArchiveMembers(MemoryBufferRef MB) {
if (InWholeArchive) {
       for (MemoryBufferRef MB : getArchiveMembers(MBRef))
         Files.push_back(createObjectFile(MB, Path));
       return;
     }
     Files.push_back(make<ArchiveFile>(MBRef));
     return;
   case file_magic::elf_shared_object:
     if (Config->Relocatable) {
-      error("attempted static link of dynamic object " + Path);
+      error(getOutputName() + ": attempted static link of dynamic object " +
+            Path);
       return;
     }
     Files.push_back(createSharedFile(MBRef));
     return;
   default:
     if (InLib)
       Files.push_back(make<LazyObjectFile>(MBRef));
     else
       Files.push_back(createObjectFile(MBRef));
   }
 }
 
 Optional<MemoryBufferRef> LinkerDriver::readFile(StringRef Path) {
   if (Config->Verbose)
     outs() << Path << "\n";
 
   auto MBOrErr = MemoryBuffer::getFile(Path);
   if (auto EC = MBOrErr.getError()) {
-    error(EC, "cannot open " + Path);
+    error(EC, getOutputName() + ": cannot open " + Path);
     return None;
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   OwningMBs.push_back(std::move(MB)); // take MB ownership
 
   if (Cpio)
     Cpio->append(relativeToRoot(Path), MBRef.getBuffer());
 
   return MBRef;
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   std::string Path = searchLibrary(Name);
   if (Path.empty())
-    error("unable to find library -l" + Name);
+    error(getOutputName() + ": unable to find library -l" + Name);
   else
     addFile(Path);
 }
 
 // This function is called on startup. We need this for LTO since
 // LTO calls LLVM functions to compile bitcode files to native code.
 // Technically this can be delayed until we read bitcode files, but
 // we don't bother to do lazily because the initialization is fast.

 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &Args) {
   // The MIPS ABI as of 2016 does not support the GNU-style symbol lookup
   // table which is a relatively new feature.
   if (Config->EMachine == EM_MIPS && Config->GnuHash)
-    error("the .gnu.hash section is not compatible with the MIPS target.");
+    error(getOutputName() +
+          ": the .gnu.hash section is not compatible with the MIPS target.");
 
   if (Config->EMachine == EM_AMDGPU && !Config->Entry.empty())
-    error("-e option is not valid for AMDGPU.");
+    error(getOutputName() + ": -e option is not valid for AMDGPU.");
 
   if (Config->Pie && Config->Shared)
-    error("-shared and -pie may not be used together");
+    error(getOutputName() + ": -shared and -pie may not be used together");
 
   if (Config->Relocatable) {
     if (Config->Shared)
-      error("-r and -shared may not be used together");
+      error(getOutputName() + ": -r and -shared may not be used together");
     if (Config->GcSections)
-      error("-r and --gc-sections may not be used together");
+      error(getOutputName() +
+            ": -r and --gc-sections may not be used together");
     if (Config->ICF)
-      error("-r and --icf may not be used together");
+      error(getOutputName() + ": -r and --icf may not be used together");
     if (Config->Pie)
-      error("-r and -pie may not be used together");
+      error(getOutputName() + ": -r and -pie may not be used together");
   }
 }
 
 static StringRef getString(opt::InputArgList &Args, unsigned Key,
                            StringRef Default = "") {
   if (auto *Arg = Args.getLastArg(Key))
     return Arg->getValue();
   return Default;
static uint64_t getZOptionValue(opt::InputArgList &Args, StringRef Key,
                                 uint64_t Default) {
   for (auto *Arg : Args.filtered(OPT_z)) {
     StringRef Value = Arg->getValue();
     size_t Pos = Value.find("=");
     if (Pos != StringRef::npos && Key == Value.substr(0, Pos)) {
       Value = Value.substr(Pos + 1);
       uint64_t Result;
       if (Value.getAsInteger(0, Result))
-        error("invalid " + Key + ": " + Value);
+        error(getOutputName() + ": invalid " + Key + ": " + Value);
       return Result;
     }
   }
   return Default;
 }
 
 void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
   ELFOptTable Parser;
if (const char *Path = getReproduceOption(Args)) {
     // if you are trying to understand the whole picture of the code.
     ErrorOr<CpioFile *> F = CpioFile::create(Path);
     if (F) {
       Cpio.reset(*F);
       Cpio->append("response.txt", createResponseFile(Args));
       Cpio->append("version.txt", getLLDVersion() + "\n");
     } else
       error(F.getError(),
-            Twine("--reproduce: failed to open ") + Path + ".cpio");
+            Twine(getOutputName() + ": --reproduce: failed to open ") + Path +
+                ".cpio");
   }
 
   readConfigs(Args);
   initLLVM(Args);
   createFiles(Args);
   inferMachineType();
   checkOptions(Args);
   if (HasError)
if (Config->Relocatable)
     return UnresolvedPolicy::Ignore;
 
   if (auto *Arg = Args.getLastArg(OPT_unresolved_symbols)) {
     StringRef S = Arg->getValue();
     if (S == "ignore-all" || S == "ignore-in-object-files")
       return UnresolvedPolicy::Ignore;
     if (S == "ignore-in-shared-libs" || S == "report-all")
       return UnresolvedPolicy::ReportError;
-    error("unknown --unresolved-symbols value: " + S);
+    error(getOutputName() + ": unknown --unresolved-symbols value: " + S);
   }
   return UnresolvedPolicy::ReportError;
 }
 
 static Target2Policy getTarget2Option(opt::InputArgList &Args) {
   if (auto *Arg = Args.getLastArg(OPT_target2)) {
     StringRef S = Arg->getValue();
     if (S == "rel")
       return Target2Policy::Rel;
     if (S == "abs")
       return Target2Policy::Abs;
     if (S == "got-rel")
       return Target2Policy::GotRel;
-    error("unknown --target2 option: " + S);
+    error(getOutputName() + ": unknown --target2 option: " + S);
   }
   return Target2Policy::GotRel;
 }
 
 static bool isOutputFormatBinary(opt::InputArgList &Args) {
   if (auto *Arg = Args.getLastArg(OPT_oformat)) {
     StringRef S = Arg->getValue();
     if (S == "binary")
       return true;
-    error("unknown --oformat value: " + S);
+    error(getOutputName() + ": unknown --oformat value: " + S);
   }
   return false;
 }
 
 static bool getArg(opt::InputArgList &Args, unsigned K1, unsigned K2,
                    bool Default) {
   if (auto *Arg = Args.getLastArg(K1, K2))
     return Arg->getOption().getID() == K1;
static StripPolicy getStripOption(opt::InputArgList &Args) {
   return StripPolicy::None;
 }
 
 static uint64_t parseSectionAddress(StringRef S, opt::Arg *Arg) {
   uint64_t VA = 0;
   if (S.startswith("0x"))
     S = S.drop_front(2);
   if (S.getAsInteger(16, VA))
-    error("invalid argument: " + stringize(Arg));
+    error(getOutputName() + ": invalid argument: " + stringize(Arg));
   return VA;
 }
 
 static StringMap<uint64_t> getSectionStartMap(opt::InputArgList &Args) {
   StringMap<uint64_t> Ret;
   for (auto *Arg : Args.filtered(OPT_section_start)) {
     StringRef Name;
     StringRef Addr;

 
 static SortSectionPolicy getSortKind(opt::InputArgList &Args) {
   StringRef S = getString(Args, OPT_sort_section);
   if (S == "alignment")
     return SortSectionPolicy::Alignment;
   if (S == "name")
     return SortSectionPolicy::Name;
   if (!S.empty())
-    error("unknown --sort-section rule: " + S);
+    error(getOutputName() + ": unknown --sort-section rule: " + S);
   return SortSectionPolicy::Default;
 }
 
 // Parse the --symbol-ordering-file argument. File has form:
 // symbolName1
 // [...]
 // symbolNameN
 static void parseSymbolOrderingList(MemoryBufferRef MB) {
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->WarnCommon = Args.hasArg(OPT_warn_common);
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   Config->LtoAAPipeline = getString(Args, OPT_lto_aa_pipeline);
   Config->LtoNewPmPasses = getString(Args, OPT_lto_newpm_passes);
   Config->OutputFile = getString(Args, OPT_o);
+  // Default output filename is "a.out" by the Unix tradition.
+  if (Config->OutputFile.empty())
+    Config->OutputFile = "a.out";
+
   Config->SoName = getString(Args, OPT_soname);
   Config->Sysroot = getString(Args, OPT_sysroot);
 
   Config->Optimize = getInteger(Args, OPT_O, 1);
   Config->LtoO = getInteger(Args, OPT_lto_O, 2);
   if (Config->LtoO > 3)
-    error("invalid optimization level for LTO: " + getString(Args, OPT_lto_O));
+    error(getOutputName() + ": invalid optimization level for LTO: " +
+          getString(Args, OPT_lto_O));
   Config->LtoPartitions = getInteger(Args, OPT_lto_partitions, 1);
   if (Config->LtoPartitions == 0)
-    error("--lto-partitions: number of threads must be > 0");
+    error(getOutputName() +
+          ": --lto-partitions: number of threads must be > 0");
   Config->ThinLtoJobs = getInteger(Args, OPT_thinlto_jobs, -1u);
   if (Config->ThinLtoJobs == 0)
-    error("--thinlto-jobs: number of threads must be > 0");
+    error(getOutputName() + ": --thinlto-jobs: number of threads must be > 0");
 
   Config->ZCombreloc = !hasZOption(Args, "nocombreloc");
   Config->ZExecstack = hasZOption(Args, "execstack");
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNow = hasZOption(Args, "now");
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = !hasZOption(Args, "norelro");
   Config->ZStackSize = getZOptionValue(Args, "stack-size", -1);
for (InputFile *F : Files) {
     if (F->EKind == ELFNoneKind)
       continue;
     Config->EKind = F->EKind;
     Config->EMachine = F->EMachine;
     Config->OSABI = F->OSABI;
     Config->MipsN32Abi = Config->EMachine == EM_MIPS && isMipsN32Abi(F);
     return;
   }
-  error("target emulation unknown: -m or at least one .o file required");
+  error(getOutputName() + ": target emulation unknown: -m or at least one .o file required");
 }
 
 // Parses -image-base option.
 static uint64_t getImageBase(opt::InputArgList &Args) {
   // Use default if no -image-base option is given.
   // Because we are using "Target" here, this function
   // has to be called after the variable is initialized.
   auto *Arg = Args.getLastArg(OPT_image_base);
template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   ScriptBase = Script<ELFT>::X = &LS;
 
   Config->Rela =
       ELFT::Is64Bits || Config->EMachine == EM_X86_64 || Config->MipsN32Abi;
   Config->Mips64EL =
       (Config->EMachine == EM_MIPS && Config->EKind == ELF64LEKind);
   Config->ImageBase = getImageBase(Args);
 
-  // Default output filename is "a.out" by the Unix tradition.
-  if (Config->OutputFile.empty())
-    Config->OutputFile = "a.out";
-
   // Handle --trace-symbol.
   for (auto *Arg : Args.filtered(OPT_trace_symbol))
     Symtab.trace(Arg->getValue());
 
   // Initialize Config->MaxPageSize. The default value is defined by
   // the target, but it can be overriden using the option.
   Config->MaxPageSize =
       getZOptionValue(Args, "max-page-size", Target->MaxPageSize);