[ELF] Mention symbol name in reportRangeError()

[MaskRay]

Summary

For an out-of-range relocation referencing a non-local symbol, report the symbol name and the object file that defines the symbol. As an example:

t.o:(function func: .text.func+0x3): relocation R_X86_64_32S out of range: -281474974609120 is not in [-2147483648, 2147483647]

>

t.o:(function func: .text.func+0x3): relocation R_X86_64_32S out of range: -281474974609120 is not in [-2147483648, 2147483647]; references func
>>> defined in t1.o

[MaskRay]

.

[merge_guards_bot]

Unit tests: pass. 62251 tests passed, 0 failed and 816 were skipped.

clang-tidy: fail. clang-tidy found 0 errors and 16 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[merge_guards_bot]

Unit tests: pass. 62251 tests passed, 0 failed and 816 were skipped.

clang-tidy: fail. clang-tidy found 0 errors and 16 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[grimar]

lld/ELF/Relocations.cpp

105

It can probably print "references local symbol" for local symbols?

108

Seems there is no test case for this?

[grimar]

lld/ELF/Relocations.cpp

108

Ah, nevermind. I did not notice this piece was just moved.

[peter.smith]

I think this is step in the right direction. I tend to find that relocation out of range errors tend to be more useful to linker developers (via bug reports) as there is often little that a user can do about it, and it often represents either a fault in the linker or a misuse of a relocation in the compiler, I think we could tend to include information that would help us diagnose problems.

lld/ELF/Relocations.cpp

105

Another possibility would be to distinguish between symbol and PLT entry for symbol. I think that could be a future improvement though.

[MaskRay]

The improved diagnostics helped me locate a bug today (D73606) :)

lld/ELF/Relocations.cpp

105

Regarding ; references local symbol

A local symbol can only be referenced from within the same file. It is usually not easy to trigger a relocation overflow.
I think more than 99% cases are relocations referencing global symbols. We can start from global symbols first.

Another possibility would be to distinguish between symbol and PLT entry for symbol. I think that could be a future improvement though.

Ack.

[grimar]

LGTM

[MaskRay]

Update more tests to improve diagnostics

[merge_guards_bot]

Unit tests: pass. 62283 tests passed, 0 failed and 827 were skipped.

clang-tidy: fail. clang-tidy found 0 errors and 16 warnings. 0 of them are added as review comments below (why?).

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

lld/ELF/Relocations.cpp

 static Optional<std::string> getLinkerScriptLocation(const Symbol &sym) {
   for (BaseCommand *base : script->sectionCommands)
     if (auto *cmd = dyn_cast<SymbolAssignment>(base))
       if (cmd->sym == &sym)
         return cmd->location;
   return None;
 }
 
+static std::string getDefinedLocation(const Symbol &sym) {
+  std::string msg = "\n>>> defined in ";
+  if (sym.file)
+    msg += toString(sym.file);
+  else if (Optional<std::string> loc = getLinkerScriptLocation(sym))
+    msg += *loc;
+  return msg;
+}
+
 // Construct a message in the following format.
 //
 // >>> defined in /home/alice/src/foo.o
 // >>> referenced by bar.c:12 (/home/alice/src/bar.c:12)
 // >>>               /home/alice/src/bar.o:(.text+0x1)
 static std::string getLocation(InputSectionBase &s, const Symbol &sym,
                                uint64_t off) {
-  std::string msg = "\n>>> defined in ";
-  if (sym.file)
-    msg += toString(sym.file);
-  else if (Optional<std::string> loc = getLinkerScriptLocation(sym))
-    msg += *loc;
-
-  msg += "\n>>> referenced by ";
+  std::string msg = getDefinedLocation(sym) + "\n>>> referenced by ";
   std::string src = s.getSrcMsg(sym, off);
   if (!src.empty())
     msg += src + "\n>>>               ";
   return msg + s.getObjMsg(off);
 }
 
+void reportRangeError(uint8_t *loc, const Relocation &rel, const Twine &v,
+                      int64_t min, uint64_t max) {
+  ErrorPlace errPlace = getErrorPlace(loc);
+  std::string hint;
+  if (rel.sym && !rel.sym->isLocal())
+    hint = "; references " + lld::toString(*rel.sym) +
+           getDefinedLocation(*rel.sym);
+
+  if (errPlace.isec && errPlace.isec->name.startswith(".debug"))
+    hint += "; consider recompiling with -fdebug-types-section to reduce size "
+            "of debug sections";
+
+  errorOrWarn(errPlace.loc + "relocation " + lld::toString(rel.type) +
+              " out of range: " + v.str() + " is not in [" + Twine(min).str() +
+              ", " + Twine(max).str() + "]" + hint);
+}
+
 namespace {
 // Build a bitmask with one bit set for each RelExpr.
 //
 // Constexpr function arguments can't be used in static asserts, so we
 // use template arguments to build the mask.
 // But function template partial specializations don't exist (needed
 // for base case of the recursion), so we need a dummy struct.
 template <RelExpr... Exprs> struct RelExprMaskBuilder {

lld/ELF/Target.h

 uint64_t getPPC64TocBase();
 uint64_t getAArch64Page(uint64_t expr);
 
 extern const TargetInfo *target;
 TargetInfo *getTarget();
 
 template <class ELFT> bool isMipsPIC(const Defined *sym);
 
-static inline void reportRangeError(uint8_t *loc, const Relocation &rel,
-                                    const Twine &v, int64_t min, uint64_t max) {
-  ErrorPlace errPlace = getErrorPlace(loc);
-  StringRef hint;
-  if (errPlace.isec && errPlace.isec->name.startswith(".debug"))
-    hint = "; consider recompiling with -fdebug-types-section to reduce size "
-           "of debug sections";
-
-  errorOrWarn(errPlace.loc + "relocation " + lld::toString(rel.type) +
-              " out of range: " + v.str() + " is not in [" + Twine(min).str() +
-              ", " + Twine(max).str() + "]" + hint);
-}
+void reportRangeError(uint8_t *loc, const Relocation &rel, const Twine &v,
+                      int64_t min, uint64_t max);
 
 // Make sure that V can be represented as an N bit signed integer.
 inline void checkInt(uint8_t *loc, int64_t v, int n, const Relocation &rel) {
   if (v != llvm::SignExtend64(v, n))
     reportRangeError(loc, rel, Twine(v), llvm::minIntN(n), llvm::maxIntN(n));
 }
 
 // Make sure that V can be represented as an N bit unsigned integer.

lld/test/ELF/aarch64-abs16.s

 // CHECK: Contents of section .data:
 // 220158: S = 0x100, A = 0xfeff
 //         S + A = 0xffff
 // 22015c: S = 0x100, A = -0x8100
 //         S + A = 0x8000
 // CHECK-NEXT: 220158 ffff0080
 
 // RUN: not ld.lld %t.o %t255.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=OVERFLOW1
-// OVERFLOW1: relocation R_AARCH64_ABS16 out of range: -32769 is not in [-32768, 65535]
+// OVERFLOW1: relocation R_AARCH64_ABS16 out of range: -32769 is not in [-32768, 65535]; references foo
 
 // RUN: not ld.lld %t.o %t257.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=OVERFLOW2
-// OVERFLOW2: relocation R_AARCH64_ABS16 out of range: 65536 is not in [-32768, 65535]
+// OVERFLOW2: relocation R_AARCH64_ABS16 out of range: 65536 is not in [-32768, 65535]; references foo

lld/test/ELF/aarch64-abs32.s

 // CHECK: Contents of section .data:
 // 220158: S = 0x100, A = 0xfffffeff
 //         S + A = 0xffffffff
 // 22015c: S = 0x100, A = -0x80000100
 //         S + A = 0x80000000
 // CHECK-NEXT: 220158 ffffffff 00000080
 
 // RUN: not ld.lld %t.o %t255.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=OVERFLOW1
-// OVERFLOW1: relocation R_AARCH64_ABS32 out of range: -2147483649 is not in [-2147483648, 4294967295]
+// OVERFLOW1: relocation R_AARCH64_ABS32 out of range: -2147483649 is not in [-2147483648, 4294967295]; references foo
 
 // RUN: not ld.lld %t.o %t257.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=OVERFLOW2
-// OVERFLOW2: relocation R_AARCH64_ABS32 out of range: 4294967296 is not in [-2147483648, 4294967295]
+// OVERFLOW2: relocation R_AARCH64_ABS32 out of range: 4294967296 is not in [-2147483648, 4294967295]; references foo

lld/test/ELF/aarch64-prel16.s

 // CHECK: Contents of section .data:
 // 202158: S = 0x100, A = 0x212157, P = 0x202158
 //         S + A - P = 0xffff
 // 212a5a: S = 0x100, A = 0x1fa05a, P = 0x20215a
 //         S + A - P = 0x8000
 // CHECK-NEXT: 202158 ffff0080
 
 // RUN: not ld.lld -z max-page-size=4096 %t.o %t255.o -o %t2 2>&1 | FileCheck %s --check-prefix=OVERFLOW1
-// OVERFLOW1: relocation R_AARCH64_PREL16 out of range: -32769 is not in [-32768, 65535]
+// OVERFLOW1: relocation R_AARCH64_PREL16 out of range: -32769 is not in [-32768, 65535]; references foo
 
 // RUN: not ld.lld -z max-page-size=4096 %t.o %t257.o -o %t2 2>&1 | FileCheck %s --check-prefix=OVERFLOW2
-// OVERFLOW2: relocation R_AARCH64_PREL16 out of range: 65536 is not in [-32768, 65535]
+// OVERFLOW2: relocation R_AARCH64_PREL16 out of range: 65536 is not in [-32768, 65535]; references foo

lld/test/ELF/aarch64-prel32.s

 // CHECK: Contents of section .data:
 // 202158: S = 0x100, A = 0x100202057, P = 0x202158
 //         S + A - P = 0xffffffff
 // 20215c: S = 0x100, A = -0x7fdfdfa4, P = 0x20215c
 //         S + A - P = 0x80000000
 // CHECK-NEXT: 202158 ffffffff 00000080
 
 // RUN: not ld.lld -z max-page-size=4096 %t.o %t255.o -o %t2 2>&1 | FileCheck %s --check-prefix=OVERFLOW1
-// OVERFLOW1: relocation R_AARCH64_PREL32 out of range: -2147483649 is not in [-2147483648, 4294967295]
+// OVERFLOW1: relocation R_AARCH64_PREL32 out of range: -2147483649 is not in [-2147483648, 4294967295]; references foo
 
 // RUN: not ld.lld -z max-page-size=4096 %t.o %t257.o -o %t2 2>&1 | FileCheck %s --check-prefix=OVERFLOW2
-// OVERFLOW2: relocation R_AARCH64_PREL32 out of range: 4294967296 is not in [-2147483648, 4294967295]
+// OVERFLOW2: relocation R_AARCH64_PREL32 out of range: 4294967296 is not in [-2147483648, 4294967295]; references foo

lld/test/ELF/hexagon-jump-error.s

 # REQUIRES: hexagon
 # RUN: llvm-mc -filetype=obj -triple=hexagon-unknown-elf %s -o %t.o
 # RUN: not ld.lld %t.o -o %t 2>&1 | FileCheck --implicit-check-not "out of range" %s
 
   .globl  _start
   .type _start, @function
 _start:
 
 # CHECK: relocation R_HEX_B9_PCREL out of range: 1028 is not in [-1024, 1023]
 {r0 = #0; jump #1f}
 .space (1<<10)
 .section b9, "ax"
 1:
 
-# CHECK-NEXT: relocation R_HEX_B13_PCREL out of range: 16388 is not in [-16384, 16383]
+# CHECK: relocation R_HEX_B13_PCREL out of range: 16388 is not in [-16384, 16383]
 if (r0==#0) jump:t #1f
 .space (1<<14)
 .section b13, "ax"
 1:
 
-# CHECK-NEXT: relocation R_HEX_B15_PCREL out of range: 65540 is not in [-65536, 65535]
+# CHECK: relocation R_HEX_B15_PCREL out of range: 65540 is not in [-65536, 65535]
 if (p0) jump #1f
 .space (1<<16)
 .section b15, "ax"
 1:
 
-# CHECK-NEXT: relocation R_HEX_B22_PCREL out of range: 8388612 is not in [-2097152, 2097151]
+# CHECK: relocation R_HEX_B22_PCREL out of range: 8388612 is not in [-2097152, 2097151]
 jump #1f
 .space (1<<23)
 .section b22, "ax"
 1:

lld/test/ELF/i386-reloc-16.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i386 %s -o %t.o
 
 # RUN: ld.lld %t.o --defsym=a=0 --defsym=b=32768 -o %t
 # RUN: llvm-readelf -x .text %t | FileCheck %s
 # CHECK: b80080bb ffff
 
 # RUN: not ld.lld %t.o --defsym=a=-1 --defsym=b=0 -o /dev/null 2>&1 | \
 # RUN:   FileCheck --check-prefix=OVERFLOW1 %s
-# OVERFLOW1: relocation R_386_16 out of range: -32769 is not in [-32768, 65535]
+# OVERFLOW1: relocation R_386_16 out of range: -32769 is not in [-32768, 65535]; references a
 
 # RUN: not ld.lld %t.o --defsym=a=0 --defsym=b=32769 -o /dev/null 2>&1 | \
 # RUN:   FileCheck --check-prefix=OVERFLOW2 %s
-# OVERFLOW2: relocation R_386_16 out of range: 65536 is not in [-32768, 65535]
+# OVERFLOW2: relocation R_386_16 out of range: 65536 is not in [-32768, 65535]; references b
 
 .code16
 .global _start
 _start:
 movw $a-32768, %ax
 movw $b+32767, %bx

lld/test/ELF/i386-reloc-8.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=i386 %s -o %t.o
 
 # RUN: ld.lld %t.o --defsym=a=0 --defsym=b=128 -o %t
 # RUN: llvm-readelf -x .text %t | FileCheck %s
 # CHECK: b480b7ff
 
 # RUN: not ld.lld %t.o --defsym=a=-1 --defsym=b=0 -o /dev/null 2>&1 | \
 # RUN:   FileCheck --check-prefix=OVERFLOW1 %s
-# OVERFLOW1: relocation R_386_8 out of range: -129 is not in [-128, 255]
+# OVERFLOW1: relocation R_386_8 out of range: -129 is not in [-128, 255]; references a
 
 # RUN: not ld.lld %t.o --defsym=a=0 --defsym=b=129 -o /dev/null 2>&1 | \
 # RUN:   FileCheck --check-prefix=OVERFLOW2 %s
-# OVERFLOW2: relocation R_386_8 out of range: 256 is not in [-128, 255]
+# OVERFLOW2: relocation R_386_8 out of range: 256 is not in [-128, 255]; references b
 
 .code16
 .globl _start
 _start:
 movb $a-128, %ah
 movb $b+127, %bh

lld/test/ELF/i386-reloc-range.s

 // CHECK:        Disassembly of section .text:
 // CHECK-EMPTY:
 // CHECK-NEXT: _start:
 // CHECK-NEXT:      200:       jmp -1
 //              0x10202 - 0x203 == 0xffff
 
 // RUN: not ld.lld -Ttext 0x200 %t.o %t2.o -o /dev/null 2>&1 | FileCheck --check-prefix=ERR %s
 
-// ERR: {{.*}}:(.text+0x1): relocation R_386_PC16 out of range: 65536 is not in [-65536, 65535]
+// ERR: {{.*}}:(.text+0x1): relocation R_386_PC16 out of range: 65536 is not in [-65536, 65535]; references foo
 
         .global _start
 _start:
         jmp foo

lld/test/ELF/ppc64-reloc-addr.s

 # REQUIRES: ppc
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le %S/Inputs/abs255.s -o %t255.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le %S/Inputs/abs256.s -o %t256.o
 # RUN: llvm-mc -filetype=obj -triple=powerpc64le %S/Inputs/abs257.s -o %t257.o
 
 # RUN: ld.lld %t.o %t256.o -o %t
 # RUN: llvm-readelf -x .data %t | FileCheck %s
 # CHECK: 0x{{[0-9a-f]+}} ffff0080 ffffffff 00000080
 
 # RUN: not ld.lld %t.o %t255.o -o /dev/null 2>&1 | FileCheck --check-prefix=OVERFLOW1 %s
-# OVERFLOW1: relocation R_PPC64_ADDR16 out of range: -32769 is not in [-32768, 65535]
-# OVERFLOW1: relocation R_PPC64_ADDR32 out of range: -2147483649 is not in [-2147483648, 4294967295]
+# OVERFLOW1: relocation R_PPC64_ADDR16 out of range: -32769 is not in [-32768, 65535]; references foo
+# OVERFLOW1: relocation R_PPC64_ADDR32 out of range: -2147483649 is not in [-2147483648, 4294967295]; references foo
 
 # RUN: not ld.lld %t.o %t257.o -o /dev/null 2>&1 | FileCheck --check-prefix=OVERFLOW2 %s
-# OVERFLOW2: relocation R_PPC64_ADDR16 out of range: 65536 is not in [-32768, 65535]
-# OVERFLOW2: relocation R_PPC64_ADDR32 out of range: 4294967296 is not in [-2147483648, 4294967295]
+# OVERFLOW2: relocation R_PPC64_ADDR16 out of range: 65536 is not in [-32768, 65535]; references foo
+# OVERFLOW2: relocation R_PPC64_ADDR32 out of range: 4294967296 is not in [-2147483648, 4294967295]; references foo
 
 .globl _start
 _start:
 .data
 .word foo + 0xfeff
 .word foo - 0x8100
 .long foo + 0xfffffeff
 .long foo - 0x80000100

lld/test/ELF/riscv-branch.s

 # RUN: ld.lld %t.rv64.o --defsym foo=_start+0xffe --defsym bar=_start+4-0x1000 -o %t.rv64.limits
 # RUN: llvm-objdump -d %t.rv32.limits | FileCheck --check-prefix=LIMITS %s
 # RUN: llvm-objdump -d %t.rv64.limits | FileCheck --check-prefix=LIMITS %s
 # LIMITS:      e3 0f 00 7e     beqz    zero, 4094
 # LIMITS-NEXT: 63 10 00 80     bnez    zero, -4096
 
 # RUN: not ld.lld %t.rv32.o --defsym foo=_start+0x1000 --defsym bar=_start+4-0x1002 -o %t 2>&1 | FileCheck --check-prefix=ERROR-RANGE %s
 # RUN: not ld.lld %t.rv64.o --defsym foo=_start+0x1000 --defsym bar=_start+4-0x1002 -o %t 2>&1 | FileCheck --check-prefix=ERROR-RANGE %s
-# ERROR-RANGE:      relocation R_RISCV_BRANCH out of range: 2048 is not in [-2048, 2047]
-# ERROR-RANGE-NEXT: relocation R_RISCV_BRANCH out of range: -2049 is not in [-2048, 2047]
+# ERROR-RANGE: relocation R_RISCV_BRANCH out of range: 2048 is not in [-2048, 2047]; references foo
+# ERROR-RANGE: relocation R_RISCV_BRANCH out of range: -2049 is not in [-2048, 2047]; references bar
 
 # RUN: not ld.lld %t.rv32.o --defsym foo=_start+1 --defsym bar=_start-1 -o %t 2>&1 | FileCheck --check-prefix=ERROR-ALIGN %s
 # RUN: not ld.lld %t.rv64.o --defsym foo=_start+1 --defsym bar=_start-1 -o %t 2>&1 | FileCheck --check-prefix=ERROR-ALIGN %s
 # ERROR-ALIGN: improper alignment for relocation R_RISCV_BRANCH: 0x1 is not aligned to 2 bytes
 
 .global _start
 _start:
      beq x0, x0, foo
      bne x0, x0, bar

lld/test/ELF/riscv-call.s

 # RUN: llvm-objdump -d %t.rv32.limits | FileCheck --check-prefix=LIMITS %s
 # RUN: llvm-objdump -d %t.rv64.limits | FileCheck --check-prefix=LIMITS %s
 # LIMITS:      97 f0 ff 7f     auipc   ra, 524287
 # LIMITS-NEXT: e7 80 f0 7f     jalr    2047(ra)
 # LIMITS-NEXT: 97 00 00 80     auipc   ra, 524288
 # LIMITS-NEXT: e7 80 00 80     jalr    -2048(ra)
 
 # RUN: ld.lld %t.rv32.o --defsym foo=_start+0x7ffff800 --defsym bar=_start+8-0x80000801 -o %t
-# RUN: not ld.lld %t.rv64.o --defsym foo=_start+0x7ffff800 --defsym bar=_start+8-0x80000801 -o %t 2>&1 | FileCheck --check-prefix=ERROR %s
-# ERROR:      relocation R_RISCV_CALL out of range: 524288 is not in [-524288, 524287]
-# ERROR-NEXT: relocation R_RISCV_CALL out of range: -524289 is not in [-524288, 524287]
+# RUN: not ld.lld %t.rv64.o --defsym foo=_start+0x7ffff800 --defsym bar=_start+8-0x80000801 -o %t 2>&1 | \
+# RUN:   FileCheck --check-prefix=ERROR %s
+# ERROR: relocation R_RISCV_CALL out of range: 524288 is not in [-524288, 524287]; references foo
+# ERROR: relocation R_RISCV_CALL out of range: -524289 is not in [-524288, 524287]; references bar
 
 .global _start
 _start:
     call    foo
     call    bar

lld/test/ELF/riscv-hi20-lo12.s

 # LIMITS:      37 f5 ff 7f     lui     a0, 524287
 # LIMITS-NEXT: 13 05 f5 7f     addi    a0, a0, 2047
 # LIMITS-NEXT: a3 2f a5 7e     sw      a0, 2047(a0)
 # LIMITS-NEXT: b7 05 00 80     lui     a1, 524288
 # LIMITS-NEXT: 93 85 05 80     addi    a1, a1, -2048
 # LIMITS-NEXT: 23 a0 b5 80     sw      a1, -2048(a1)
 
 # RUN: not ld.lld %t.rv64.o --defsym foo=0x7ffff800 --defsym bar=0xffffffff7ffff7ff -o %t 2>&1 | FileCheck --check-prefix ERROR %s
-# ERROR:      relocation R_RISCV_HI20 out of range: 524288 is not in [-524288, 524287]
-# ERROR-NEXT: relocation R_RISCV_HI20 out of range: -524289 is not in [-524288, 524287]
+# ERROR: relocation R_RISCV_HI20 out of range: 524288 is not in [-524288, 524287]; references foo
+# ERROR: relocation R_RISCV_HI20 out of range: -524289 is not in [-524288, 524287]; references bar
 
 .global _start
 
 _start:
     lui     a0, %hi(foo)
     addi    a0, a0, %lo(foo)
     sw      a0, %lo(foo)(a0)
     lui     a1, %hi(bar)
     addi    a1, a1, %lo(bar)
     sw      a1, %lo(bar)(a1)

lld/test/ELF/riscv-jal.s

 # RUN: ld.lld %t.rv64.o --defsym foo=_start+0xffffe --defsym bar=_start+4-0x100000 -o %t.rv64.limits
 # RUN: llvm-objdump -d %t.rv32.limits | FileCheck --check-prefix=LIMITS %s
 # RUN: llvm-objdump -d %t.rv64.limits | FileCheck --check-prefix=LIMITS %s
 # LIMITS:      6f f0 ff 7f j   1048574
 # LIMITS-NEXT: ef 00 00 80 jal -1048576
 
 # RUN: not ld.lld %t.rv32.o --defsym foo=_start+0x100000 --defsym bar=_start+4-0x100002 -o %t 2>&1 | FileCheck --check-prefix=ERROR-RANGE %s
 # RUN: not ld.lld %t.rv64.o --defsym foo=_start+0x100000 --defsym bar=_start+4-0x100002 -o %t 2>&1 | FileCheck --check-prefix=ERROR-RANGE %s
-# ERROR-RANGE:      relocation R_RISCV_JAL out of range: 524288 is not in [-524288, 524287]
-# ERROR-RANGE-NEXT: relocation R_RISCV_JAL out of range: -524289 is not in [-524288, 524287]
+# ERROR-RANGE: relocation R_RISCV_JAL out of range: 524288 is not in [-524288, 524287]; references foo
+# ERROR-RANGE: relocation R_RISCV_JAL out of range: -524289 is not in [-524288, 524287]; references bar
 
 # RUN: not ld.lld %t.rv32.o --defsym foo=_start+1 --defsym bar=_start+4+3 -o %t 2>&1 | FileCheck --check-prefix=ERROR-ALIGN %s
 # RUN: not ld.lld %t.rv64.o --defsym foo=_start+1 --defsym bar=_start+4+3 -o %t 2>&1 | FileCheck --check-prefix=ERROR-ALIGN %s
-# ERROR-ALIGN:      improper alignment for relocation R_RISCV_JAL: 0x1 is not aligned to 2 bytes
-# ERROR-ALIGN-NEXT: improper alignment for relocation R_RISCV_JAL: 0x3 is not aligned to 2 bytes
+# ERROR-ALIGN: improper alignment for relocation R_RISCV_JAL: 0x1 is not aligned to 2 bytes
+# ERROR-ALIGN: improper alignment for relocation R_RISCV_JAL: 0x3 is not aligned to 2 bytes
 
 .global _start
 
 _start:
     jal x0, foo
     jal x1, bar

lld/test/ELF/riscv-pcrel-hilo.s

 # LIMITS-NEXT: addi    a0, a0, 2047
 # LIMITS-NEXT: sw      zero, 2047(a0)
 # LIMITS:      auipc   a0, 524288
 # LIMITS-NEXT: addi    a0, a0, -2048
 # LIMITS-NEXT: sw      zero, -2048(a0)
 
 # RUN: ld.lld %t.rv32.o --defsym foo=_start+0x7ffff800 --defsym bar=_start+12-0x80000801 -o %t
 # RUN: not ld.lld %t.rv64.o --defsym foo=_start+0x7ffff800 --defsym bar=_start+12-0x80000801 -o %t 2>&1 | FileCheck --check-prefix=ERROR %s
-# ERROR:      relocation R_RISCV_PCREL_HI20 out of range: 524288 is not in [-524288, 524287]
-# ERROR-NEXT: relocation R_RISCV_PCREL_HI20 out of range: -524289 is not in [-524288, 524287]
+# ERROR: relocation R_RISCV_PCREL_HI20 out of range: 524288 is not in [-524288, 524287]; references foo
+# ERROR: relocation R_RISCV_PCREL_HI20 out of range: -524289 is not in [-524288, 524287]; references bar
 
 .global _start
 _start:
     auipc   a0, %pcrel_hi(foo)
     addi    a0, a0, %pcrel_lo(_start)
     sw      x0, %pcrel_lo(_start)(a0)
 .L1:
     auipc   a0, %pcrel_hi(bar)
     addi    a0, a0, %pcrel_lo(.L1)
     sw      x0, %pcrel_lo(.L1)(a0)

lld/test/ELF/x86-64-reloc-error.s

 // REQUIRES: x86
-// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/x86-64-reloc-error.s -o %tabs
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/x86-64-reloc-error.s -o %t1.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
-// RUN: not ld.lld -shared %tabs %t -o /dev/null 2>&1 | FileCheck %s
+// RUN: not ld.lld -shared %t1.o %t -o /dev/null 2>&1 | FileCheck %s
 
   movl $big, %edx
   movq $foo - 0x1000000000000, %rdx
 
-# CHECK: {{.*}}:(.text+0x1): relocation R_X86_64_32 out of range: 68719476736 is not in [0, 4294967295]
-# CHECK: {{.*}}:(.text+0x8): relocation R_X86_64_32S out of range: -281474976710656 is not in [-2147483648, 2147483647]
+# CHECK: {{.*}}:(.text+0x1): relocation R_X86_64_32 out of range: 68719476736 is not in [0, 4294967295]; references big
+# CHECK-NEXT: >>> defined in {{.*}}1.o
+# CHECK: {{.*}}:(.text+0x8): relocation R_X86_64_32S out of range: -281474976710656 is not in [-2147483648, 2147483647]; references foo
+# CHECK-NEXT: >>> defined in {{.*}}1.o

lld/test/ELF/x86-64-reloc-error2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: not ld.lld --entry=func --gc-sections %t.o -o /dev/null 2>&1 | FileCheck %s
 
 ## Check we are able to find a function symbol that encloses
 ## a given location when reporting error messages.
-# CHECK: {{.*}}.o:(function func: .text.func+0x3): relocation R_X86_64_32S out of range: -281474974609120 is not in [-2147483648, 2147483647]
+# CHECK: {{.*}}.o:(function func: .text.func+0x3): relocation R_X86_64_32S out of range: -281474974609120 is not in [-2147483648, 2147483647]; references func
+# CHECK-NEXT: >>> defined in {{.*}}.o
 
 # This mergeable section will be garbage collected. We had a crash issue in that case. Test it.
 .section .rodata.str1,"aMS",@progbits,1
 .asciz "a"
 
 .section .text.func, "ax", %progbits
 .globl func
 .type func,@function
 func:
   movq $func - 0x1000000000000, %rdx
 .size func, .-func