[lld-macho] Standardize error messages

[int3]

Summary

Errors / warnings that originate from a particular file should be of the
form $file: $message.

[thakis]

Nice!

lld/MachO/Arch/ARM64.cpp

auto findSection = [&](uint64_t addr) {
     section = isec;
     sectionAddr = subsec.offset + sec->addr;
     buf = outBuf + section->outSecOff + section->parent->fileOff;
     return true;
   };
 
   auto isValidOffset = [&](uint64_t offset) {
     if (offset < sectionAddr || offset >= sectionAddr + section->getSize()) {
-      error("linker optimization hint spans multiple sections");
+      error(toString(&obj) +
+            ": linker optimization hint spans multiple sections");
       return false;
     }
     return true;
   };
 
   bool hasAdrpAdrp = false;
   forEachHint(data, [&](uint64_t kind, ArrayRef<uint64_t> args) {
     if (kind == LOH_ARM64_ADRP_ADRP) {

lld/MachO/InputFiles.h

DylibFile *getSyntheticDylib(StringRef installName, uint32_t currentVersion,
                                uint32_t compatVersion);
 
   bool handleLDSymbol(StringRef originalName);
   void handleLDPreviousSymbol(StringRef name, StringRef originalName);
   void handleLDInstallNameSymbol(StringRef name, StringRef originalName);
   void handleLDHideSymbol(StringRef name, StringRef originalName);
   void checkAppExtensionSafety(bool dylibIsAppExtensionSafe) const;
   void parseExportedSymbols(uint32_t offset, uint32_t size);
+  void loadReexport(StringRef path, DylibFile *umbrella,
+                    const llvm::MachO::InterfaceFile *currentTopLevelTapi);
 
   llvm::DenseSet<llvm::CachedHashStringRef> hiddenSymbols;
 };
 
 // .a file
 class ArchiveFile final : public InputFile {
 public:
   explicit ArchiveFile(std::unique_ptr<llvm::object::Archive> &&file,

lld/MachO/InputFiles.cpp

static bool isImplicitlyLinked(StringRef path) {
   if (path.consume_front("/System/Library/Frameworks/")) {
     StringRef frameworkName = path.take_until([](char c) { return c == '.'; });
     return path::filename(path) == frameworkName;
   }
 
   return false;
 }
 
-static void loadReexport(StringRef path, DylibFile *umbrella,
+void DylibFile::loadReexport(StringRef path, DylibFile *umbrella,
                          const InterfaceFile *currentTopLevelTapi) {
   DylibFile *reexport = findDylib(path, umbrella, currentTopLevelTapi);
   if (!reexport)
-    error("unable to locate re-export with install name " + path);
+    error(toString(this) + ": unable to locate re-export with install name " +
+          path);
 }
 
 DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
                      bool isBundleLoader, bool explicitlyLinked)
     : InputFile(DylibKind, mb), refState(RefState::Unreferenced),
       explicitlyLinked(explicitlyLinked), isBundleLoader(isBundleLoader) {
   assert(!isBundleLoader || !umbrella);
   if (umbrella == nullptr)
     umbrella = this;
   this->umbrella = umbrella;
 
   auto *hdr = reinterpret_cast<const mach_header *>(mb.getBufferStart());
 
   // Initialize installName.
   if (const load_command *cmd = findCommand(hdr, LC_ID_DYLIB)) {
     auto *c = reinterpret_cast<const dylib_command *>(cmd);
     currentVersion = read32le(&c->dylib.current_version);
     compatibilityVersion = read32le(&c->dylib.compatibility_version);
     installName =
         reinterpret_cast<const char *>(cmd) + read32le(&c->dylib.name);
   } else if (!isBundleLoader) {
     // macho_executable and macho_bundle don't have LC_ID_DYLIB,
     // so it's OK.
-    error("dylib " + toString(this) + " missing LC_ID_DYLIB load command");
+    error(toString(this) + ": dylib missing LC_ID_DYLIB load command");
     return;
   }
 
   if (config->printEachFile)
     message(toString(this));
   inputFiles.insert(this);
 
   deadStrippable = hdr->flags & MH_DEAD_STRIPPABLE_DYLIB;
DylibFile::DylibFile(MemoryBufferRef mb, DylibFile *umbrella,
   exportingFile = isImplicitlyLinked(installName) ? this : this->umbrella;
 
   const auto *dyldInfo = findCommand<dyld_info_command>(hdr, LC_DYLD_INFO_ONLY);
   const auto *exportsTrie =
       findCommand<linkedit_data_command>(hdr, LC_DYLD_EXPORTS_TRIE);
   if (dyldInfo && exportsTrie) {
     // It's unclear what should happen in this case. Maybe we should only error
     // out if the two load commands refer to different data?
-    error("dylib " + toString(this) +
-          " has both LC_DYLD_INFO_ONLY and LC_DYLD_EXPORTS_TRIE");
+    error(toString(this) +
+          ": dylib has both LC_DYLD_INFO_ONLY and LC_DYLD_EXPORTS_TRIE");
     return;
   } else if (dyldInfo) {
     parseExportedSymbols(dyldInfo->export_off, dyldInfo->export_size);
   } else if (exportsTrie) {
     parseExportedSymbols(exportsTrie->dataoff, exportsTrie->datasize);
   } else {
     error("No LC_DYLD_INFO_ONLY or LC_DYLD_EXPORTS_TRIE found in " +
           toString(this));
void DylibFile::handleLDPreviousSymbol(StringRef name, StringRef originalName) {
   // FIXME: Does this do the right thing for zippered files?
   unsigned platform;
   if (platformStr.getAsInteger(10, platform) ||
       platform != static_cast<unsigned>(config->platform()))
     return;
 
   VersionTuple start;
   if (start.tryParse(startVersion)) {
-    warn("failed to parse start version, symbol '" + originalName +
-         "' ignored");
+    warn(toString(this) + ": failed to parse start version, symbol '" +
+         originalName + "' ignored");
     return;
   }
   VersionTuple end;
   if (end.tryParse(endVersion)) {
-    warn("failed to parse end version, symbol '" + originalName + "' ignored");
+    warn(toString(this) + ": failed to parse end version, symbol '" +
+         originalName + "' ignored");
     return;
   }
   if (config->platformInfo.minimum < start ||
       config->platformInfo.minimum >= end)
     return;
 
   // Initialized to compatibilityVersion for the symbolName branch below.
   uint32_t newCompatibilityVersion = compatibilityVersion;
   uint32_t newCurrentVersionForSymbol = currentVersion;
   if (!compatVersion.empty()) {
     VersionTuple cVersion;
     if (cVersion.tryParse(compatVersion)) {
-      warn("failed to parse compatibility version, symbol '" + originalName +
+      warn(toString(this) +
+           ": failed to parse compatibility version, symbol '" + originalName +
            "' ignored");
       return;
     }
     newCompatibilityVersion = encodeVersion(cVersion);
     newCurrentVersionForSymbol = newCompatibilityVersion;
   }
 
   if (!symbolName.empty()) {

 
 void DylibFile::handleLDInstallNameSymbol(StringRef name,
                                           StringRef originalName) {
   // originalName: $ld$ install_name $ os<version> $ install_name
   StringRef condition, installName;
   std::tie(condition, installName) = name.split('$');
   VersionTuple version;
   if (!condition.consume_front("os") || version.tryParse(condition))
-    warn("failed to parse os version, symbol '" + originalName + "' ignored");
+    warn(toString(this) + ": failed to parse os version, symbol '" +
+         originalName + "' ignored");
   else if (version == config->platformInfo.minimum)
     this->installName = saver().save(installName);
 }
 
 void DylibFile::handleLDHideSymbol(StringRef name, StringRef originalName) {
   StringRef symbolName;
   bool shouldHide = true;
   if (name.startswith("os")) {
     // If it's hidden based on versions.
     name = name.drop_front(2);
     StringRef minVersion;
     std::tie(minVersion, symbolName) = name.split('$');
     VersionTuple versionTup;
     if (versionTup.tryParse(minVersion)) {
-      warn("Failed to parse hidden version, symbol `" + originalName +
+      warn(toString(this) + ": failed to parse hidden version, symbol `" + originalName +
            "` ignored.");
       return;
     }
     shouldHide = versionTup == config->platformInfo.minimum;
   } else {
     symbolName = name;
   }
 

lld/test/MachO/invalid/invalid-loh.s

 # REQUIRES: aarch64
+# RUN: rm -rf %t; mkdir -p %t
 
-# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t.o
-# RUN: not %lld -arch arm64 %t.o -o /dev/null 2>&1 | FileCheck %s
+# RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t/test.o
+# RUN: not %lld -arch arm64 %t/test.o -o /dev/null 2>&1 | FileCheck %s
 
-# CHECK: error: linker optimization hint spans multiple sections
+# CHECK: error: {{.*}}test.o: linker optimization hint spans multiple sections
 
 .globl _main
 _main:
 L1:
   adrp x0, _target@PAGE
 
 _foo:
 L2:
   add x0, x0, _target@PAGEOFF
 
 _target:
 
 .loh AdrpAdd L1, L2
 .subsections_via_symbols

lld/test/MachO/invalid/no-id-dylink.yaml

 # REQUIRES: x86
 # RUN: mkdir -p %t
 # RUN: yaml2obj %s -o %t/libnoid.dylib
 # RUN: echo ".globl _main; .text; _main: ret" | llvm-mc -filetype=obj -triple=x86_64-apple-darwin -o %t/no-id-dylink.o
 # RUN: not %lld -o %t/no-id-dylink -L%t -lnoid %t/no-id-dylink.o 2>&1 | FileCheck %s
-# CHECK: error: dylib {{.*}}libnoid.dylib missing LC_ID_DYLIB load command
+# CHECK: error: {{.*}}libnoid.dylib: dylib missing LC_ID_DYLIB load command
 
 ## This YAML file was originally generated from linking the following source
 ## input with ld64 and passing the resulting binary through obj2yaml:
 ##
 ## .section __TEXT,__cstring
 ## .globl _hello_world
 ##
 ## _hello_world:

lld/test/MachO/link-search-at-executable-path.s

 ## by the path of the executable.
 # RUN: %lld -lSystem %t/main.o %t/libbar.dylib -o %t/subdir/test
 
 ## This doesn't work for non-executables.
 # RUN: not %lld -dylib -lSystem %t/main.o %t/libbar.dylib -o %t/subdir/libtest.dylib 2>&1 | FileCheck --check-prefix=ERR %s
 
 ## It also doesn't help if the needed reexport isn't next to the library.
 # RUN: not %lld -lSystem %t/main.o %t/libbar.dylib -o %t/test 2>&1 | FileCheck --check-prefix=ERR %s
-# ERR: error: unable to locate re-export with install name @executable_path/libfoo.dylib
+# ERR: error: {{.*}}libbar.dylib: unable to locate re-export with install name @executable_path/libfoo.dylib
 
 #--- foo.s
 .globl _foo
 _foo:
   retq
 
 #--- bar.s
 .globl _bar

lld/test/MachO/special-symbol-ld-install-name.s

 # RUN: llvm-otool -L %t/libfoo2.dylib | FileCheck --check-prefix=CASE2 %s
 # CASE2: /Old (compatibility version 1.1.1, current version 5.0.0)
 
 ## Check that we emit a warning for an invalid os version.
 
 # RUN: %no-fatal-warnings-lld -o %t/libfoo3.dylib %t/libLDInstallNameInvalid.tbd %t/foo.o -dylib \
 # RUN:  -platform_version macos 11.0.0 11.0.0 2>&1 | FileCheck --check-prefix=INVALID-VERSION %s
 
-# INVALID-VERSION: failed to parse os version, symbol '$ld$install_name$os11.a$/New' ignored
+# INVALID-VERSION: libLDInstallNameInvalid.tbd(/Old): failed to parse os version, symbol '$ld$install_name$os11.a$/New' ignored
 
 ## Case 3: If there's another library that has '/New' as its original
 ## install_name, we should take current-version and compatibility-version from
 ## the first library we load with that install name. For a reexport,
 ## the first loaded library is the library doing the reexport, not the
 ## reexported library.
 # RUN: %lld -o %t/libfoo3.dylib %t/libLDInstallNameNew.tbd %t/foo.o -dylib -platform_version macos 11.0.0 11.0.0
 # RUN: llvm-otool -L %t/libfoo3.dylib | FileCheck --check-prefix=CASE3 %s

lld/test/MachO/special-symbol-ld-previous.s

 # CASE5-DAG: /Another (compatibility version 1.1.1, current version 5.0.0)
 # CASE5-DAG: /Old (compatibility version 1.2.3, current version 1.2.3)
 
 ## Check that we emit a warning for an invalid start, end and compatibility versions.
 
 # RUN: %no-fatal-warnings-lld -o %t/libfoo1.dylib %t/libLDPreviousInvalid.tbd %t/ref_xxx.o -dylib \
 # RUN:  -platform_version macos 11.0.0 11.0.0 2>&1 | FileCheck --check-prefix=INVALID-VERSION %s
 
-# INVALID-VERSION-DAG: failed to parse start version, symbol '$ld$previous$/New$1.2.3$1$3.a$14.0$$' ignored
-# INVALID-VERSION-DAG: failed to parse end version, symbol '$ld$previous$/New$1.2.3$1$3.0$14.b$$' ignored
-# INVALID-VERSION-DAG: failed to parse compatibility version, symbol '$ld$previous$/New$1.2.c$1$3.0$14.0$$' ignored
+# INVALID-VERSION-DAG: libLDPreviousInvalid.tbd(/Old): failed to parse start version, symbol '$ld$previous$/New$1.2.3$1$3.a$14.0$$' ignored
+# INVALID-VERSION-DAG: libLDPreviousInvalid.tbd(/Old): failed to parse end version, symbol '$ld$previous$/New$1.2.3$1$3.0$14.b$$' ignored
+# INVALID-VERSION-DAG: libLDPreviousInvalid.tbd(/Old): failed to parse compatibility version, symbol '$ld$previous$/New$1.2.c$1$3.0$14.0$$' ignored
 
 #--- ref_xxx.s
 .long _xxx@GOTPCREL
 
 #--- ref_ySyy.s
 .long _y$yy@GOTPCREL
 
 #--- ref_zzz.s

lld/test/MachO/sub-library.s

 
 ## Check that we fail gracefully if the sub-library is missing
 # RUN: not %lld -dylib -o %t/sub-library -sub_library libmissing %t/sub-library.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MISSING-SUB-LIBRARY
 # MISSING-SUB-LIBRARY: error: -sub_library libmissing does not match a supplied dylib
 # RUN: rm -f %t/libgoodbye.dylib
 # RUN: not %lld -o %t/sub-library -L%t -lsuper %t/sub-library.o 2>&1 \
 # RUN:  | FileCheck %s --check-prefix=MISSING-REEXPORT -DDIR=%t
-# MISSING-REEXPORT: error: unable to locate re-export with install name [[DIR]]/libgoodbye.dylib
+# MISSING-REEXPORT: error: {{.*}}libsuper.dylib: unable to locate re-export with install name [[DIR]]/libgoodbye.dylib
 
 
 ## We can match dylibs without extensions too.
 # RUN: mkdir -p %t/Hello.framework
 # RUN: %lld -dylib %t/libhello.o -o %t/Hello.framework/Hello
 # RUN: %lld -dylib -o %t/libgoodbye2.dylib -sub_library Hello %t/Hello.framework/Hello %t/libgoodbye.o
 # RUN: llvm-otool -l %t/libgoodbye2.dylib | FileCheck %s \
 # RUN:   --check-prefix=REEXPORT-HEADERS -DPATH=%t/Hello.framework/Hello