[ELF] - Teach LLD to hint about -fdebug-types-section.

[grimar]

Summary

Patch teaches LLD to hint user about -fdebug-types-section flag
if relocation overflow happens in debug section.

[grimar]

• Changed message format.

[ruiu]

ELF/Arch/AArch64.cpp

340

getErrorLocation(Loc).Loc looks odd by itself. getErrorLocation should, well, return an error location. If you need to access Loc member of its return value, that implies that the function does return something more than a location. Please revert this and other lines.

ELF/Target.cpp

90

If you need to get an input section, you can just define a different function, instead of making the return type more complex.

[grimar]

Thanks for comments, Rui. I'll update it after D40962 be landed (I think it will be and my patch intersects with it).

[grimar]

• Addressed comments, rebased.

[grimar]

Ping.

[grimar]

• Reimplemented.

[• rafael]

Most callers want just the location, so maybe leave a getErrorLocation
inline helper that returns getErrorPlace(Loc).Loc?

With that the implementation is fine, but is someone really hitting this
issue?

Cheers,
Rafael

George Rimar via Phabricator via llvm-commits
<[e-mail]> writes:

grimar updated this revision to Diff 138528.
grimar edited reviewers, added: espindola; removed: rafael.
grimar added a comment.
Herald added a subscriber: arichardson.

• Reimplemented.

https://reviews.llvm.org/D40954

Files:

ELF/Arch/AArch64.cpp
ELF/Arch/AMDGPU.cpp
ELF/Arch/ARM.cpp
ELF/Arch/AVR.cpp
ELF/Arch/Mips.cpp
ELF/Arch/PPC.cpp
ELF/Arch/PPC64.cpp
ELF/Arch/SPARCV9.cpp
ELF/Arch/X86.cpp
ELF/Arch/X86_64.cpp
ELF/Target.cpp
ELF/Target.h
test/ELF/x86-64-reloc-debug-overflow.s

Index: test/ELF/x86-64-reloc-debug-overflow.s

• test/ELF/x86-64-reloc-debug-overflow.s

+++ test/ELF/x86-64-reloc-debug-overflow.s
@@ -0,0 +1,12 @@
+# 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 -o %t
+# RUN: not ld.lld -shared %tabs %t -o %t2 2>&1 | FileCheck %s
+
+# CHECK: (.debug_info+0x1): relocation R_X86_64_32 out of range: 68719476736 is not in [0, 4294967295]; consider recompiling with -fdebug-types-section to reduce size of debug sections
+
+# CHECK: (.debug_info+0x8): relocation R_X86_64_32S out of range: -281474976710656 is not in [-2147483648, 2147483647]; consider recompiling with -fdebug-types-section to reduce size of debug sections
+
+.section .debug_info,"",@progbits
+ movl $big, %edx
+ movq $foo - 0x1000000000000, %rdx

Index: ELF/Target.h

• ELF/Target.h

+++ ELF/Target.h
@@ -139,7 +139,13 @@
TargetInfo *getX86_64TargetInfo();
template <class ELFT> TargetInfo *getMipsTargetInfo();

-std::string getErrorLocation(const uint8_t *Loc);
+struct ErrorPlace {
+ InputSectionBase *IS;
+ std::string Loc;
+};
+
+// Returns input section and corresponding source string for the given location.
+ErrorPlace getErrorPlace(const uint8_t *Loc);

uint64_t getPPC64TocBase();
uint64_t getAArch64Page(uint64_t Expr);
@@ -151,9 +157,15 @@

static inline void reportRangeError(uint8_t *Loc, RelType Type, const Twine &V,

int64_t Min, uint64_t Max) {

• error(getErrorLocation(Loc) + "relocation " + lld::toString(Type) +
• " out of range: " + V + " is not in [" + Twine(Min) + ", " +
• Twine(Max) + "]");

+ ErrorPlace ErrPlace = getErrorPlace(Loc);
+ StringRef Hint;
+ if (ErrPlace.IS && ErrPlace.IS->Name.startswith(".debug"))
+ Hint = "; consider recompiling with -fdebug-types-section to reduce size "
+ "of debug sections";
+
+ error(ErrPlace.Loc + "relocation " + lld::toString(Type) +
+ " out of range: " + V.str() + " is not in [" + Twine(Min).str() + ", " +
+ Twine(Max).str() + "]" + Hint);
}

template <unsigned N>
@@ -180,7 +192,7 @@
template <unsigned N>
static void checkAlignment(uint8_t *Loc, uint64_t V, RelType Type) {

if ((V & (N - 1)) != 0)

• error(getErrorLocation(Loc) + "improper alignment for relocation " +

+ error(getErrorPlace(Loc).Loc + "improper alignment for relocation " +

lld::toString(Type) + ": 0x" + llvm::utohexstr(V) +
" is not aligned to " + Twine(N) + " bytes");

}

Index: ELF/Target.cpp

• ELF/Target.cpp

+++ ELF/Target.cpp
@@ -87,29 +87,29 @@

fatal("unknown target machine");

}

-template <class ELFT> static std::string getErrorLoc(const uint8_t *Loc) {
+template <class ELFT> static ErrorPlace getErrPlace(const uint8_t *Loc) {

for (InputSectionBase *D : InputSections) {
  auto *IS = dyn_cast<InputSection>(D);
  if (!IS || !IS->getParent())
    continue;
 
  uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
  if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())

• return IS->template getLocation<ELFT>(Loc - ISLoc) + ": ";

+ return {IS, IS->template getLocation<ELFT>(Loc - ISLoc) + ": "};

}

• return "";

+ return {};
}

-std::string elf::getErrorLocation(const uint8_t *Loc) {
+ErrorPlace elf::getErrorPlace(const uint8_t *Loc) {

switch (Config->EKind) {
case ELF32LEKind:

• return getErrorLoc<ELF32LE>(Loc);

+ return getErrPlace<ELF32LE>(Loc);

case ELF32BEKind:

• return getErrorLoc<ELF32BE>(Loc);

+ return getErrPlace<ELF32BE>(Loc);

case ELF64LEKind:

• return getErrorLoc<ELF64LE>(Loc);

+ return getErrPlace<ELF64LE>(Loc);

case ELF64BEKind:

• return getErrorLoc<ELF64BE>(Loc);

+ return getErrPlace<ELF64BE>(Loc);

default:
  llvm_unreachable("unknown ELF type");
}

Index: ELF/Arch/X86_64.cpp

• ELF/Arch/X86_64.cpp

+++ ELF/Arch/X86_64.cpp
@@ -242,7 +242,7 @@

  memcpy(Inst, "\x48\xc7", 2);
  *RegSlot = 0xc0 | Reg;
} else {

• error(getErrorLocation(Loc - 3) +

+ error(getErrorPlace(Loc - 3).Loc +

        "R_X86_64_GOTTPOFF must be used in MOVQ or ADDQ instructions only");
}

@@ -320,7 +320,7 @@

  write64le(Loc, Val);
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/X86.cpp

• ELF/Arch/X86.cpp

+++ ELF/Arch/X86.cpp
@@ -304,7 +304,7 @@

  write32le(Loc, Val);
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/SPARCV9.cpp

• ELF/Arch/SPARCV9.cpp

+++ ELF/Arch/SPARCV9.cpp
@@ -118,7 +118,7 @@

  write64be(Loc, Val);
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/PPC64.cpp

• ELF/Arch/PPC64.cpp

+++ ELF/Arch/PPC64.cpp
@@ -206,7 +206,7 @@

  break;
}
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/PPC.cpp

• ELF/Arch/PPC.cpp

+++ ELF/Arch/PPC.cpp
@@ -66,7 +66,7 @@

  write32be(Loc, read32be(Loc) | (Val & 0x3FFFFFC));
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/Mips.cpp

• ELF/Arch/Mips.cpp

+++ ELF/Arch/Mips.cpp
@@ -463,7 +463,7 @@

if (Type2 == R_MICROMIPS_SUB &&
    (Type3 == R_MICROMIPS_HI16 || Type3 == R_MICROMIPS_LO16))
  return std::make_pair(Type3, -Val);

• error(getErrorLocation(Loc) + "unsupported relocations combination " +

+ error(getErrorPlace(Loc).Loc + "unsupported relocations combination " +

      Twine(Type));
return std::make_pair(Type & 0xff, Val);

}
@@ -650,7 +650,7 @@

  writeShuffleValue<E>(Loc, Val, 23, 2);
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/AVR.cpp

• ELF/Arch/AVR.cpp

+++ ELF/Arch/AVR.cpp
@@ -64,7 +64,7 @@

  break;
}
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + toString(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + toString(Type));

}

}

Index: ELF/Arch/ARM.cpp

• ELF/Arch/ARM.cpp

+++ ELF/Arch/ARM.cpp
@@ -499,7 +499,7 @@

                (Val & 0x00ff));           // imm8
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/AMDGPU.cpp

• ELF/Arch/AMDGPU.cpp

+++ ELF/Arch/AMDGPU.cpp
@@ -73,7 +73,7 @@

  write32le(Loc, Val >> 32);
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

Index: ELF/Arch/AArch64.cpp

• ELF/Arch/AArch64.cpp

+++ ELF/Arch/AArch64.cpp
@@ -337,7 +337,7 @@

  or32AArch64Imm(Loc, Val);
  break;
default:

• error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));

+ error(getErrorPlace(Loc).Loc + "unrecognized reloc " + Twine(Type));

}

}

---

llvm-commits mailing list
[e-mail]
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits

[grimar]

Most callers want just the location, so maybe leave a getErrorLocation
inline helper that returns getErrorPlace(Loc).Loc?

With that the implementation is fine, but is someone really hitting this
issue?

Cheers,
Rafael

Yes.
We have LLD bug: "lld fails with "relocation R_X86_64_32 out of range" (https://bugs.llvm.org//show_bug.cgi?id=31109).

-fdebug-types-section flag is disabled by default, but it can help to reduce size of output a lot.
For example one of the best results for llvm binaries for me was:

"I compared clang binaries to see the difference with and without the linker side optimisation:

1. Clang built with -g has size of 1.7 GB, .debug_info section size is 894.5 Mb.
2. Clang built with -g -fdebug-types-section has size of 1.0 GB. .debug_types size is 26.267 MB, .debug_info size is 227.7 MB."

With that .debug_info is significantly reduced in size, so such hint might help to solve the out of range
failure sometimes I believe.

George.

[grimar]

• Introduced getErrorLocation helper.

[• espindola]

LGTM with a test nit.

test/ELF/x86-64-reloc-debug-overflow.s

13

Having code in a .debug_info section is not very realistic.

ELF/Arch/AArch64.cpp

case R_AARCH64_TLSLE_ADD_TPREL_HI12:
     checkInt<24>(Loc, Val, Type);
     or32AArch64Imm(Loc, Val >> 12);
     break;
   case R_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
   case R_AARCH64_TLSDESC_ADD_LO12:
     or32AArch64Imm(Loc, Val);
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 void AArch64::relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
   // TLSDESC Global-Dynamic relocation are in the form:
   //   adrp    x0, :tlsdesc:v             [R_AARCH64_TLSDESC_ADR_PAGE21]
   //   ldr     x1, [x0, #:tlsdesc_lo12:v  [R_AARCH64_TLSDESC_LD64_LO12]
   //   add     x0, x0, :tlsdesc_los:v     [R_AARCH64_TLSDESC_ADD_LO12]

ELF/Arch/AMDGPU.cpp

void AMDGPU::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   case R_AMDGPU_ABS64:
     write64le(Loc, Val);
     break;
   case R_AMDGPU_GOTPCREL32_HI:
   case R_AMDGPU_REL32_HI:
     write32le(Loc, Val >> 32);
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 RelExpr AMDGPU::getRelExpr(RelType Type, const Symbol &S,
                            const uint8_t *Loc) const {
   switch (Type) {
   case R_AMDGPU_ABS32:
   case R_AMDGPU_ABS64:

ELF/Arch/ARM.cpp

write16le(Loc,
                   ((Val >> 1) & 0x0400) |  // i
                   ((Val >> 12) & 0x000f)); // imm4
     write16le(Loc + 2,
               (read16le(Loc + 2) & 0x8f00) | // opcode
                   ((Val << 4) & 0x7000) |    // imm3
                   (Val & 0x00ff));           // imm8
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 int64_t ARM::getImplicitAddend(const uint8_t *Buf, RelType Type) const {
   switch (Type) {
   default:
     return 0;
   case R_ARM_ABS32:

ELF/Arch/AVR.cpp

void AVR::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   case R_AVR_CALL: {
     uint16_t Hi = Val >> 17;
     uint16_t Lo = Val >> 1;
     write16le(Loc, read16le(Loc) | ((Hi >> 1) << 4) | (Hi & 1));
     write16le(Loc + 2, Lo);
     break;
   }
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + toString(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + toString(Type));
   }
 }
 
 TargetInfo *elf::getAVRTargetInfo() {
   static AVR Target;
   return &Target;
 }

ELF/Arch/Mips.cpp

if (Type2 == R_MIPS_NONE && Type3 == R_MIPS_NONE)
     return std::make_pair(Type, Val);
   if (Type2 == R_MIPS_64 && Type3 == R_MIPS_NONE)
     return std::make_pair(Type2, Val);
   if (Type2 == R_MIPS_SUB && (Type3 == R_MIPS_HI16 || Type3 == R_MIPS_LO16))
     return std::make_pair(Type3, -Val);
   if (Type2 == R_MICROMIPS_SUB &&
       (Type3 == R_MICROMIPS_HI16 || Type3 == R_MICROMIPS_LO16))
     return std::make_pair(Type3, -Val);
-  error(getErrorLocation(Loc) + "unsupported relocations combination " +
+  error(getErrorLocation(Loc).Loc + "unsupported relocations combination " +
         Twine(Type));
   return std::make_pair(Type & 0xff, Val);
 }
 
 template <class ELFT>
 void MIPS<ELFT>::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   const endianness E = ELFT::TargetEndianness;
 
case R_MICROMIPS_PC21_S1:
     checkInt<22>(Loc, Val, Type);
     writeMicroRelocation32<E>(Loc, Val, 21, 1);
     break;
   case R_MICROMIPS_PC23_S2:
     checkInt<25>(Loc, Val, Type);
     writeMicroRelocation32<E>(Loc, Val, 23, 2);
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc +"unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT> bool MIPS<ELFT>::usesOnlyLowPageBits(RelType Type) const {
   return Type == R_MIPS_LO16 || Type == R_MIPS_GOT_OFST ||
          Type == R_MICROMIPS_LO16 || Type == R_MICROMIPS_GOT_OFST;
 }
 

ELF/Arch/PPC.cpp

void PPC::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   case R_PPC_ADDR32:
   case R_PPC_REL32:
     write32be(Loc, Val);
     break;
   case R_PPC_REL24:
     write32be(Loc, read32be(Loc) | (Val & 0x3FFFFFC));
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 TargetInfo *elf::getPPCTargetInfo() {
   static PPC Target;
   return &Target;
 }

ELF/Arch/PPC64.cpp

case R_PPC64_TOC:
     break;
   case R_PPC64_REL24: {
     uint32_t Mask = 0x03FFFFFC;
     checkInt<24>(Loc, Val, Type);
     write32be(Loc, (read32be(Loc) & ~Mask) | (Val & Mask));
     break;
   }
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 TargetInfo *elf::getPPC64TargetInfo() {
   static PPC64 Target;
   return &Target;
 }

ELF/Arch/SPARCV9.cpp

case R_SPARC_PC10:
     break;
   case R_SPARC_64:
   case R_SPARC_UA64:
   case R_SPARC_GLOB_DAT:
     // V-xword64
     write64be(Loc, Val);
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 void SPARCV9::writePlt(uint8_t *Buf, uint64_t GotEntryAddr,
                        uint64_t PltEntryAddr, int32_t Index,
                        unsigned RelOff) const {
   const uint8_t PltData[] = {
       0x03, 0x00, 0x00, 0x00, // sethi   (. - .PLT0), %g1

ELF/Arch/X86.cpp

void X86::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   case R_386_TLS_LE:
   case R_386_TLS_LE_32:
   case R_386_TLS_TPOFF:
   case R_386_TLS_TPOFF32:
     checkInt<32>(Loc, Val, Type);
     write32le(Loc, Val);
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 void X86::relaxTlsGdToLe(uint8_t *Loc, RelType Type, uint64_t Val) const {
   // Convert
   //   leal x@tlsgd(, %ebx, 1),
   //   call __tls_get_addr@plt
   // to

ELF/Arch/X86_64.cpp

if (memcmp(Inst, "\x48\x03\x25", 3) == 0) {
     // "movq foo@gottpoff(%rip),%r[8-15]" -> "movq $foo,%r[8-15]"
     memcpy(Inst, "\x49\xc7", 2);
     *RegSlot = 0xc0 | Reg;
   } else if (memcmp(Inst, "\x48\x8b", 2) == 0) {
     // "movq foo@gottpoff(%rip),%reg" -> "movq $foo,%reg"
     memcpy(Inst, "\x48\xc7", 2);
     *RegSlot = 0xc0 | Reg;
   } else {
-    error(getErrorLocation(Loc - 3) +
+    error(getErrorLocation(Loc - 3).Loc +
           "R_X86_64_GOTTPOFF must be used in MOVQ or ADDQ instructions only");
   }
 
   // The original code used a PC relative relocation.
   // Need to compensate for the -4 it had in the addend.
   write32le(Loc, Val + 4);
 }
 
void X86_64<ELFT>::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   case R_X86_64_DTPOFF64:
   case R_X86_64_GLOB_DAT:
   case R_X86_64_PC64:
   case R_X86_64_SIZE64:
   case R_X86_64_GOT64:
     write64le(Loc, Val);
     break;
   default:
-    error(getErrorLocation(Loc) + "unrecognized reloc " + Twine(Type));
+    error(getErrorLocation(Loc).Loc + "unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
 RelExpr X86_64<ELFT>::adjustRelaxExpr(RelType Type, const uint8_t *Data,
                                       RelExpr RelExpr) const {
   if (Type != R_X86_64_GOTPCRELX && Type != R_X86_64_REX_GOTPCRELX)
     return RelExpr;

ELF/Target.h

 TargetInfo *getPPC64TargetInfo();
 TargetInfo *getPPCTargetInfo();
 TargetInfo *getSPARCV9TargetInfo();
 TargetInfo *getX32TargetInfo();
 TargetInfo *getX86TargetInfo();
 TargetInfo *getX86_64TargetInfo();
 template <class ELFT> TargetInfo *getMipsTargetInfo();
 
-std::string getErrorLocation(const uint8_t *Loc);
+struct ErrLoc {
+  std::string Loc;
+  InputSection *IS;
+};
+ErrLoc getErrorLocation(const uint8_t *Loc);
 
 uint64_t getPPC64TocBase();
 uint64_t getAArch64Page(uint64_t Expr);
 
 extern TargetInfo *Target;
 TargetInfo *getTarget();
 
 template <class ELFT> bool isMipsPIC(const Defined *Sym);
 
+static void reportOutOfRange(uint8_t *Loc, RelType Type) {
+  ErrLoc L = getErrorLocation(Loc);
+  std::string Msg =
+      L.Loc + "relocation " + lld::toString(Type) + " out of range";
+
+  if (L.IS && L.IS->Name.startswith(".debug"))
+    Msg += "\n>>>It could happen because relocation has too large value for "
+           "DWARF32 used,\n>>>consider recompiling with -fdebug-types-section "
+           "to reduce size of debug sections";
+  error(Msg);
+}
+
 template <unsigned N>
 static void checkInt(uint8_t *Loc, int64_t V, RelType Type) {
   if (!llvm::isInt<N>(V))
-    error(getErrorLocation(Loc) + "relocation " + lld::toString(Type) +
-          " out of range");
+    reportOutOfRange(Loc, Type);
 }
 
 template <unsigned N>
 static void checkUInt(uint8_t *Loc, uint64_t V, RelType Type) {
   if (!llvm::isUInt<N>(V))
-    error(getErrorLocation(Loc) + "relocation " + lld::toString(Type) +
-          " out of range");
+    reportOutOfRange(Loc, Type);
 }
 
 template <unsigned N>
 static void checkIntUInt(uint8_t *Loc, uint64_t V, RelType Type) {
   if (!llvm::isInt<N>(V) && !llvm::isUInt<N>(V))
-    error(getErrorLocation(Loc) + "relocation " + lld::toString(Type) +
-          " out of range");
+    reportOutOfRange(Loc, Type);
 }
 
 template <unsigned N>
 static void checkAlignment(uint8_t *Loc, uint64_t V, RelType Type) {
   if ((V & (N - 1)) != 0)
-    error(getErrorLocation(Loc) + "improper alignment for relocation " +
+    error(getErrorLocation(Loc).Loc + "improper alignment for relocation " +
           lld::toString(Type));
 }
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Target.cpp

TargetInfo *elf::getTarget() {
   case EM_X86_64:
     if (Config->EKind == ELF32LEKind)
       return getX32TargetInfo();
     return getX86_64TargetInfo();
   }
   fatal("unknown target machine");
 }
 
-template <class ELFT> static std::string getErrorLoc(const uint8_t *Loc) {
+template <class ELFT> static ErrLoc getErrorLoc(const uint8_t *Loc) {
   for (InputSectionBase *D : InputSections) {
     auto *IS = dyn_cast_or_null<InputSection>(D);
     if (!IS || !IS->getParent())
       continue;
 
     uint8_t *ISLoc = IS->getParent()->Loc + IS->OutSecOff;
     if (ISLoc <= Loc && Loc < ISLoc + IS->getSize())
-      return IS->template getLocation<ELFT>(Loc - ISLoc) + ": ";
+      return {IS->template getLocation<ELFT>(Loc - ISLoc) + ": ", IS};
   }
-  return "";
+  return {"", nullptr};
 }
 
-std::string elf::getErrorLocation(const uint8_t *Loc) {
+ErrLoc elf::getErrorLocation(const uint8_t *Loc) {
   switch (Config->EKind) {
   case ELF32LEKind:
     return getErrorLoc<ELF32LE>(Loc);
   case ELF32BEKind:
     return getErrorLoc<ELF32BE>(Loc);
   case ELF64LEKind:
     return getErrorLoc<ELF64LE>(Loc);
   case ELF64BEKind:

test/ELF/x86-64-reloc-debug-overflow.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 -o %t
+# RUN: not ld.lld -shared %tabs %t -o %t2 2>&1 | FileCheck %s
+
+# CHECK:      (.debug_info+0x1): relocation R_X86_64_32 out of range
+# CHECK-NEXT: >>>It could happen because relocation has too large value for DWARF32 used,
+# CHECK-NEXT: >>>consider recompiling with -fdebug-types-section to reduce size of debug sections
+
+# CHECK:      (.debug_info+0x8): relocation R_X86_64_32S out of range
+# CHECK-NEXT: >>>It could happen because relocation has too large value for DWARF32 used,
+# CHECK-NEXT: >>>consider recompiling with -fdebug-types-section to reduce size of debug sections
+
+.section .debug_info,"",@progbits
+  movl $big, %edx
+  movq $foo - 0x1000000000000, %rdx