ELF: Find invalid relocations as many as possible.

[ruiu]

• Made a change to remove a file only when we actually created it.

[• rafael]

ELF/Driver.cpp

295 ↗

(On Diff #46174)

Unrelated? Or update the patch description.

ELF/Target.cpp

229

Unrelated.

238

unrelated.

ELF/Writer.cpp

168

unrelated?

173

Is this needed? I thought the library we were using deleted the file if commit was not called or it failed.

[ruiu]

• Update as per Rafael's comments.

ELF/Driver.cpp

295 ↗

(On Diff #46174)

Removed.

ELF/Writer.cpp

168

Done.

173

Done.

[ruiu]

• Removed unreacahble code.

[• rafael]

LGTM with a testcase and a few nits.

ELF/Target.cpp

447

This is a broken file.

906

This is a broken file.

936

This is a broken file.

1144

This is a broken file.

1381

This is a broken file.

1523

This is a broken file.

[ruiu]

Committed as r259435.

ELF/Target.cpp

 
 static void add32le(uint8_t *P, int32_t V) { add32<support::little>(P, V); }
 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
 
 template <unsigned N> static void checkInt(int64_t V, uint32_t Type) {
   if (isInt<N>(V))
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  fatal("Relocation " + S + " out of range");
+  error("Relocation " + S + " out of range");
 }
 
 template <unsigned N> static void checkUInt(uint64_t V, uint32_t Type) {
   if (isUInt<N>(V))
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  fatal("Relocation " + S + " out of range");
+  error("Relocation " + S + " out of range");
 }
 
 template <unsigned N> static void checkIntUInt(uint64_t V, uint32_t Type) {
   if (isInt<N>(V) || isUInt<N>(V))
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  fatal("Relocation " + S + " out of range");
+  error("Relocation " + S + " out of range");
 }
 
 template <unsigned N> static void checkAlignment(uint64_t V, uint32_t Type) {
   if ((V & (N - 1)) == 0)
     return;
   StringRef S = getELFRelocationTypeName(Config->EMachine, Type);
-  fatal("Improper alignment for relocation " + S);
+  error("Improper alignment for relocation " + S);
 }
 
 template <class ELFT> bool isGnuIFunc(const SymbolBody &S) {
   if (auto *SS = dyn_cast<DefinedElf<ELFT>>(&S))
     return SS->Sym.getType() == STT_GNU_IFUNC;
   return false;
 }
 
case EM_AMDGPU:
     return new AMDGPUTargetInfo();
   case EM_MIPS:
     switch (Config->EKind) {
     case ELF32LEKind:
       return new MipsTargetInfo<ELF32LE>();
     case ELF32BEKind:
       return new MipsTargetInfo<ELF32BE>();
     default:
       fatal("Unsupported MIPS target");
     }
   case EM_PPC:
     return new PPCTargetInfo();
   case EM_PPC64:
     return new PPC64TargetInfo();
   case EM_X86_64:
     return new X86_64TargetInfo();
   }
   fatal("Unknown target machine");
 }
 
 TargetInfo::~TargetInfo() {}
 
 bool TargetInfo::canRelaxTls(unsigned Type, const SymbolBody *S) const {
   return false;
 }
 
case R_386_TLS_LDO_32:
     break;
   case R_386_TLS_LE:
     write32le(Loc, SA - Out<ELF32LE>::TlsPhdr->p_memsz);
     break;
   case R_386_TLS_LE_32:
     write32le(Loc, Out<ELF32LE>::TlsPhdr->p_memsz - SA);
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    error("unrecognized reloc " + Twine(Type));
   }
 }
 
 bool X86TargetInfo::canRelaxTls(unsigned Type, const SymbolBody *S) const {
   if (Config->Shared || (S && !S->isTls()))
     return false;
   return Type == R_386_TLS_LDO_32 || Type == R_386_TLS_LDM ||
          Type == R_386_TLS_GD ||
case R_X86_64_TPOFF32: {
     checkInt<32>(Val, Type);
     write32le(Loc, Val);
     break;
   }
   case R_X86_64_TPOFF64:
     write32le(Loc, SA - P);
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    error("unrecognized reloc " + Twine(Type));
   }
 }
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
 // document.
 static uint16_t applyPPCLo(uint64_t V) { return V; }
void PPCTargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   switch (Type) {
   case R_PPC_ADDR16_HA:
     write16be(Loc, applyPPCHa(SA));
     break;
   case R_PPC_ADDR16_LO:
     write16be(Loc, applyPPCLo(SA));
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    error("unrecognized reloc " + Twine(Type));
   }
 }
 
 PPC64TargetInfo::PPC64TargetInfo() {
   GotRel = R_PPC64_GLOB_DAT;
   RelativeRel = R_PPC64_RELATIVE;
   PltEntrySize = 32;
 
case R_PPC64_REL32:
     break;
   case R_PPC64_REL64:
     write64be(Loc, SA - P);
     break;
   case R_PPC64_TOC:
     write64be(Loc, SA);
     break;
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    error("unrecognized reloc " + Twine(Type));
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
   CopyRel = R_AARCH64_COPY;
   IRelativeRel = R_AARCH64_IRELATIVE;
   GotRel = R_AARCH64_GLOB_DAT;
   PltRel = R_AARCH64_JUMP_SLOT;
   TlsGotRel = R_AARCH64_TLS_TPREL64;
   UseLazyBinding = true;
   PltEntrySize = 16;
   PltZeroSize = 32;
 }
 
 unsigned AArch64TargetInfo::getDynRel(unsigned Type) const {
   if (Type == R_AARCH64_ABS32 || Type == R_AARCH64_ABS64)
     return Type;
   StringRef S = getELFRelocationTypeName(EM_AARCH64, Type);
-  fatal("Relocation " + S + " cannot be used when making a shared object; "
+  error("Relocation " + S + " cannot be used when making a shared object; "
                             "recompile with -fPIC.");
+  // Keep it going with a dummy value so that we can find more reloc errors.
+  return R_AARCH64_ABS32;
 }
 
 void AArch64TargetInfo::writeGotPlt(uint8_t *Buf, uint64_t Plt) const {
   write64le(Buf, Out<ELF64LE>::Plt->getVA());
 }
 
 void AArch64TargetInfo::writePltZero(uint8_t *Buf) const {
   const uint8_t PltData[] = {
case R_AARCH64_PREL64:
     break;
   case R_AARCH64_TSTBR14: {
     uint64_t X = SA - P;
     checkInt<16>(X, Type);
     or32le(Loc, (X & 0xFFFC) << 3);
     break;
   }
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    error("unrecognized reloc " + Twine(Type));
   }
 }
 
 // Implementing relocations for AMDGPU is low priority since most
 // programs don't use relocations now. Thus, this function is not
 // actually called (relocateOne is called for each relocation).
 // That's why the AMDGPU port works without implementing this function.
 void AMDGPUTargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA, uint64_t ZA,
                                    uint8_t *PairedLoc) const {
   llvm_unreachable("not implemented");
 }
 
 template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   PageSize = 65536;
   GotHeaderEntriesNum = 2;
   RelativeRel = R_MIPS_REL32;
 }
 
 template <class ELFT>
 unsigned MipsTargetInfo<ELFT>::getDynRel(unsigned Type) const {
   if (Type == R_MIPS_32 || Type == R_MIPS_64)
     return R_MIPS_REL32;
   StringRef S = getELFRelocationTypeName(EM_MIPS, Type);
-  fatal("Relocation " + S + " cannot be used when making a shared object; "
+  error("Relocation " + S + " cannot be used when making a shared object; "
                             "recompile with -fPIC.");
+  // Keep it going with a dummy value so that we can find more reloc errors.
+  return R_MIPS_32;
 }
 
 template <class ELFT>
 void MipsTargetInfo<ELFT>::writeGotHeader(uint8_t *Buf) const {
   typedef typename ELFFile<ELFT>::Elf_Off Elf_Off;
   auto *P = reinterpret_cast<Elf_Off *>(Buf);
   // Module pointer
   P[1] = ELFT::Is64Bits ? 0x8000000000000000 : 0x80000000;
void MipsTargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint8_t *BufEnd,
   }
   case R_MIPS_PCLO16: {
     uint32_t Instr = read32<E>(Loc);
     int64_t AHL = SignExtend64<16>(Instr & 0xffff);
     write32<E>(Loc, (Instr & 0xffff0000) | ((SA + AHL - P) & 0xffff));
     break;
   }
   default:
-    fatal("unrecognized reloc " + Twine(Type));
+    error("unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::isHintRel(uint32_t Type) const {
   return Type == R_MIPS_JALR;
 }
 

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
   addReservedSymbols();
   if (!createSections())
     return;
   assignAddresses();
   fixAbsoluteSymbols();
   openFile(Config->OutputFile);
   writeHeader();
   writeSections();
+  if (HasError)
+    return;
   fatal(Buffer->commit());
 }
 
 namespace {
 template <bool Is64Bits> struct SectionKey {
   typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
   StringRef Name;
   uint32_t Type;
   uintX_t Flags;
   uintX_t EntSize;
 };
 }
 namespace llvm {
 template <bool Is64Bits> struct DenseMapInfo<SectionKey<Is64Bits>> {