[ELF] Replace internalLinkerError(getErrorLoc(ctx, buf) + ...) with InternalErr(ctx, buf)

MaskRay · MaskRay · commit be5dad012eb7 · 2024-11-16T13:07:17.000-08:00
and simplify `+ toStr(ctx, x)` to `&lt;&lt; x`.
The trailing '\n' &lt;&lt; llvm::getBugReportMsg() is not very useful and
therefore removed.
diff --git a/lld/ELF/Arch/AArch64.cpp b/lld/ELF/Arch/AArch64.cpp
@@ -348,9 +348,7 @@ int64_t AArch64::getImplicitAddend(const uint8_t *buf, RelType type) const {
     return SignExtend64<28>(getBits(read32le(buf), 0, 25) << 2);
 
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/AMDGPU.cpp b/lld/ELF/Arch/AMDGPU.cpp
@@ -213,9 +213,7 @@ int64_t AMDGPU::getImplicitAddend(const uint8_t *buf, RelType type) const {
   case R_AMDGPU_RELATIVE64:
     return read64(ctx, buf);
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/ARM.cpp b/lld/ELF/Arch/ARM.cpp
@@ -875,9 +875,7 @@ void ARM::relocate(uint8_t *loc, const Relocation &rel, uint64_t val) const {
 int64_t ARM::getImplicitAddend(const uint8_t *buf, RelType type) const {
   switch (type) {
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   case R_ARM_ABS32:
   case R_ARM_BASE_PREL:
diff --git a/lld/ELF/Arch/Hexagon.cpp b/lld/ELF/Arch/Hexagon.cpp
@@ -411,9 +411,7 @@ int64_t Hexagon::getImplicitAddend(const uint8_t *buf, RelType type) const {
   case R_HEX_TPREL_32:
     return SignExtend64<32>(read32(ctx, buf));
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/LoongArch.cpp b/lld/ELF/Arch/LoongArch.cpp
@@ -279,9 +279,7 @@ uint32_t LoongArch::calcEFlags() const {
 int64_t LoongArch::getImplicitAddend(const uint8_t *buf, RelType type) const {
   switch (type) {
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   case R_LARCH_32:
   case R_LARCH_TLS_DTPMOD32:
diff --git a/lld/ELF/Arch/Mips.cpp b/lld/ELF/Arch/Mips.cpp
@@ -475,9 +475,7 @@ int64_t MIPS<ELFT>::getImplicitAddend(const uint8_t *buf, RelType type) const {
     // These relocations are defined as not having an implicit addend.
     return 0;
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/PPC.cpp b/lld/ELF/Arch/PPC.cpp
@@ -296,9 +296,7 @@ int64_t PPC::getImplicitAddend(const uint8_t *buf, RelType type) const {
   case R_PPC_TPREL32:
     return SignExtend64<32>(read32(ctx, buf));
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/PPC64.cpp b/lld/ELF/Arch/PPC64.cpp
@@ -1130,9 +1130,7 @@ int64_t PPC64::getImplicitAddend(const uint8_t *buf, RelType type) const {
   case R_PPC64_TPREL64:
     return read64(ctx, buf);
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/RISCV.cpp b/lld/ELF/Arch/RISCV.cpp
@@ -172,9 +172,7 @@ uint32_t RISCV::calcEFlags() const {
 int64_t RISCV::getImplicitAddend(const uint8_t *buf, RelType type) const {
   switch (type) {
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   case R_RISCV_32:
   case R_RISCV_TLS_DTPMOD32:
diff --git a/lld/ELF/Arch/SystemZ.cpp b/lld/ELF/Arch/SystemZ.cpp
@@ -261,9 +261,7 @@ int64_t SystemZ::getImplicitAddend(const uint8_t *buf, RelType type) const {
     // These relocations are defined as not having an implicit addend.
     return 0;
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/X86.cpp b/lld/ELF/Arch/X86.cpp
@@ -280,9 +280,7 @@ int64_t X86::getImplicitAddend(const uint8_t *buf, RelType type) const {
     // These relocations are defined as not having an implicit addend.
     return 0;
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Arch/X86_64.cpp b/lld/ELF/Arch/X86_64.cpp
@@ -768,9 +768,7 @@ int64_t X86_64::getImplicitAddend(const uint8_t *buf, RelType type) const {
     // These relocations are defined as not having an implicit addend.
     return 0;
   default:
-    internalLinkerError(getErrorLoc(ctx, buf),
-                        "cannot read addend for relocation " +
-                            toStr(ctx, type));
+    InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
     return 0;
   }
 }
diff --git a/lld/ELF/Config.h b/lld/ELF/Config.h
@@ -674,10 +674,6 @@ static inline ArrayRef<VersionDefinition> namedVersionDefs(Ctx &ctx) {
   return llvm::ArrayRef(ctx.arg.versionDefinitions).slice(2);
 }
 
-void errorOrWarn(const Twine &msg);
-
-void internalLinkerError(StringRef loc, const Twine &msg);
-
 struct ELFSyncStream : SyncStream {
   Ctx &ctx;
   ELFSyncStream(Ctx &ctx, DiagLevel level)
@@ -721,6 +717,8 @@ ELFSyncStream Fatal(Ctx &ctx);
 
 uint64_t errCount(Ctx &ctx);
 
+ELFSyncStream InternalErr(Ctx &ctx, const uint8_t *buf);
+
 #define CHECK2(E, S) lld::check2((E), [&] { return toStr(ctx, S); })
 
 } // namespace lld::elf
diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp
@@ -93,9 +93,10 @@ ELFSyncStream elf::ErrAlways(Ctx &ctx) { return {ctx, DiagLevel::Err}; }
 ELFSyncStream elf::Fatal(Ctx &ctx) { return {ctx, DiagLevel::Fatal}; }
 uint64_t elf::errCount(Ctx &ctx) { return ctx.errHandler->errorCount; }
 
-void elf::internalLinkerError(StringRef loc, const Twine &msg) {
-  ELFSyncStream(ctx, DiagLevel::Err) << "internal linker error: " << msg << '\n'
-                                     << llvm::getBugReportMsg();
+ELFSyncStream elf::InternalErr(Ctx &ctx, const uint8_t *buf) {
+  ELFSyncStream s(ctx, DiagLevel::Err);
+  s << "internal linker error: ";
+  return s;
 }
 
 Ctx::Ctx() : driver(*this) {}
diff --git a/lld/ELF/OutputSections.cpp b/lld/ELF/OutputSections.cpp
@@ -908,13 +908,12 @@ void OutputSection::checkDynRelAddends(Ctx &ctx) {
               ? 0
               : ctx.target->getImplicitAddend(relocTarget, rel.type);
       if (addend != writtenAddend)
-        internalLinkerError(
-            getErrorLoc(ctx, relocTarget),
-            "wrote incorrect addend value 0x" + utohexstr(writtenAddend) +
-                " instead of 0x" + utohexstr(addend) +
-                " for dynamic relocation " + toStr(ctx, rel.type) +
-                " at offset 0x" + utohexstr(rel.getOffset()) +
-                (rel.sym ? " against symbol " + toStr(ctx, *rel.sym) : ""));
+        InternalErr(ctx, relocTarget)
+            << "wrote incorrect addend value 0x" << utohexstr(writtenAddend)
+            << " instead of 0x" << utohexstr(addend)
+            << " for dynamic relocation " << rel.type << " at offset 0x"
+            << utohexstr(rel.getOffset())
+            << (rel.sym ? " against symbol " + rel.sym->getName() : "");
     }
   });
 }
diff --git a/lld/ELF/Target.cpp b/lld/ELF/Target.cpp
@@ -46,11 +46,7 @@ std::string elf::toStr(Ctx &ctx, RelType type) {
 }
 
 const ELFSyncStream &elf::operator<<(const ELFSyncStream &s, RelType type) {
-  StringRef buf = getELFRelocationTypeName(s.ctx.arg.emachine, type);
-  if (buf == "Unknown")
-    s << "Unknown (" << type << ')';
-  else
-    s << buf;
+  s << toStr(s.ctx, type);
   return s;
 }
 
@@ -122,8 +118,7 @@ ErrorPlace elf::getErrorPlace(Ctx &ctx, const uint8_t *loc) {
 TargetInfo::~TargetInfo() {}
 
 int64_t TargetInfo::getImplicitAddend(const uint8_t *buf, RelType type) const {
-  internalLinkerError(getErrorLoc(ctx, buf),
-                      "cannot read addend for relocation " + toStr(ctx, type));
+  InternalErr(ctx, buf) << "cannot read addend for relocation " << type;
   return 0;
 }
 
diff --git a/lld/include/lld/Common/ErrorHandler.h b/lld/include/lld/Common/ErrorHandler.h
@@ -164,6 +164,7 @@ class SyncStream {
 public:
   mutable llvm::raw_string_ostream os{buf};
   SyncStream(ErrorHandler &e, DiagLevel level) : e(e), level(level) {}
+  SyncStream(SyncStream &&o) : e(o.e), level(o.level), buf(std::move(o.buf)) {}
   ~SyncStream();
 };
 

Original file line number	Diff line number	Diff line change
`@@ -348,9 +348,7 @@ int64_t AArch64::getImplicitAddend(const uint8_t *buf, RelType type) const {`
`348`	`348`	`return SignExtend64<28>(getBits(read32le(buf), 0, 25) << 2);`
`349`	`349`
`350`	`350`	`default:`
`351`		`- internalLinkerError(getErrorLoc(ctx, buf),`
`352`		`- "cannot read addend for relocation " +`
`353`		`- toStr(ctx, type));`
	`351`	`+ InternalErr(ctx, buf) << "cannot read addend for relocation " << type;`
`354`	`352`	`return 0;`
`355`	`353`	`}`
`356`	`354`	`}`
Original file line number	Diff line number	Diff line change
`@@ -213,9 +213,7 @@ int64_t AMDGPU::getImplicitAddend(const uint8_t *buf, RelType type) const {`
`213`	`213`	`case R_AMDGPU_RELATIVE64:`
`214`	`214`	`return read64(ctx, buf);`
`215`	`215`	`default:`
`216`		`- internalLinkerError(getErrorLoc(ctx, buf),`
`217`		`- "cannot read addend for relocation " +`
`218`		`- toStr(ctx, type));`
	`216`	`+ InternalErr(ctx, buf) << "cannot read addend for relocation " << type;`
`219`	`217`	`return 0;`
`220`	`218`	`}`
`221`	`219`	`}`
Original file line number	Diff line number	Diff line change
`@@ -411,9 +411,7 @@ int64_t Hexagon::getImplicitAddend(const uint8_t *buf, RelType type) const {`
`411`	`411`	`case R_HEX_TPREL_32:`
`412`	`412`	`return SignExtend64<32>(read32(ctx, buf));`
`413`	`413`	`default:`
`414`		`- internalLinkerError(getErrorLoc(ctx, buf),`
`415`		`- "cannot read addend for relocation " +`
`416`		`- toStr(ctx, type));`
	`414`	`+ InternalErr(ctx, buf) << "cannot read addend for relocation " << type;`
`417`	`415`	`return 0;`
`418`	`416`	`}`
`419`	`417`	`}`
Original file line number	Diff line number	Diff line change
`@@ -475,9 +475,7 @@ int64_t MIPS<ELFT>::getImplicitAddend(const uint8_t *buf, RelType type) const {`
`475`	`475`	`// These relocations are defined as not having an implicit addend.`
`476`	`476`	`return 0;`
`477`	`477`	`default:`
`478`		`- internalLinkerError(getErrorLoc(ctx, buf),`
`479`		`- "cannot read addend for relocation " +`
`480`		`- toStr(ctx, type));`
	`478`	`+ InternalErr(ctx, buf) << "cannot read addend for relocation " << type;`
`481`	`479`	`return 0;`
`482`	`480`	`}`
`483`	`481`	`}`
Original file line number	Diff line number	Diff line change
`@@ -296,9 +296,7 @@ int64_t PPC::getImplicitAddend(const uint8_t *buf, RelType type) const {`
`296`	`296`	`case R_PPC_TPREL32:`
`297`	`297`	`return SignExtend64<32>(read32(ctx, buf));`
`298`	`298`	`default:`
`299`		`- internalLinkerError(getErrorLoc(ctx, buf),`
`300`		`- "cannot read addend for relocation " +`
`301`		`- toStr(ctx, type));`
	`299`	`+ InternalErr(ctx, buf) << "cannot read addend for relocation " << type;`
`302`	`300`	`return 0;`
`303`	`301`	`}`
`304`	`302`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1130,9 +1130,7 @@ int64_t PPC64::getImplicitAddend(const uint8_t *buf, RelType type) const {`
`1130`	`1130`	`case R_PPC64_TPREL64:`
`1131`	`1131`	`return read64(ctx, buf);`
`1132`	`1132`	`default:`
`1133`		`- internalLinkerError(getErrorLoc(ctx, buf),`
`1134`		`- "cannot read addend for relocation " +`
`1135`		`- toStr(ctx, type));`
	`1133`	`+ InternalErr(ctx, buf) << "cannot read addend for relocation " << type;`
`1136`	`1134`	`return 0;`
`1137`	`1135`	`}`
`1138`	`1136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -261,9 +261,7 @@ int64_t SystemZ::getImplicitAddend(const uint8_t *buf, RelType type) const {`
`261`	`261`	`// These relocations are defined as not having an implicit addend.`
`262`	`262`	`return 0;`
`263`	`263`	`default:`
`264`		`- internalLinkerError(getErrorLoc(ctx, buf),`
`265`		`- "cannot read addend for relocation " +`
`266`		`- toStr(ctx, type));`
	`264`	`+ InternalErr(ctx, buf) << "cannot read addend for relocation " << type;`
`267`	`265`	`return 0;`
`268`	`266`	`}`
`269`	`267`	`}`