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

Unrelated? Or update the patch description.

ELF/Target.cpp

263

Unrelated.

273

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

Removed.

ELF/Writer.cpp

168–173

Done.

178

Done.

[ruiu]

• Removed unreacahble code.

[• rafael]

LGTM with a testcase and a few nits.

ELF/Target.cpp

468

This is a broken file.

931

This is a broken file.

974

This is a broken file.

1187

This is a broken file.

1428

This is a broken file.

1609

This is a broken file.

[ruiu]

Committed as r259435.

ELF/Driver.cpp

void LinkerDriver::createFiles(opt::InputArgList &Args) {
 
   if (Files.empty() && !HasError)
     error("no input files.");
 }
 
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   SymbolTable<ELFT> Symtab;
   Target.reset(createTarget());
+  if (!Target)
+    return;
 
   if (!Config->Shared) {
     // Add entry symbol.
     //
     // There is no entry symbol for AMDGPU binaries, so skip adding one to avoid
     // having and undefined symbol.
     if (Config->Entry.empty() && Config->EMachine != EM_AMDGPU)
       Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";

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");
+      error("Unsupported MIPS target");
+      return nullptr;
     }
   case EM_PPC:
     return new PPCTargetInfo();
   case EM_PPC64:
     return new PPC64TargetInfo();
   case EM_X86_64:
     return new X86_64TargetInfo();
   }
-  fatal("Unknown target machine");
+  error("Unknown target machine");
+  return nullptr;
 }
 
 TargetInfo::~TargetInfo() {}
 
 bool TargetInfo::isTlsOptimized(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::isTlsOptimized(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 ||
bool X86_64TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   default:
     return false;
   case R_X86_64_32:
   case R_X86_64_64:
   case R_X86_64_PC32:
     // This relocation is defined to have a value of (S + A - P).
     // The problems start when a non PIC program calls a function in a shared
     // library.
-    // In an ideal world, we could just report an fatal saying the relocation
+    // In an ideal world, we could just report an error saying the relocation
     // can overflow at runtime.
     // In the real world with glibc, crt1.o has a R_X86_64_PC32 pointing to
     // libc.so.
     //
     // The general idea on how to handle such cases is to create a PLT entry
     // and use that as the function value.
     //
     // For the static linking part, we just return true and everything else
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() {
   PCRelReloc = R_PPC64_REL24;
   GotReloc = R_PPC64_GLOB_DAT;
   RelativeReloc = 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() {
   CopyReloc = R_AARCH64_COPY;
   IRelativeReloc = R_AARCH64_IRELATIVE;
   GotReloc = R_AARCH64_GLOB_DAT;
   PltReloc = R_AARCH64_JUMP_SLOT;
   TlsGotReloc = R_AARCH64_TLS_TPREL64;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 32;
 }
 
 unsigned AArch64TargetInfo::getDynReloc(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::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
   write64le(Buf, Out<ELF64LE>::Plt->getVA());
 }
 
 void AArch64TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                           uint64_t PltEntryAddr) const {
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));
   }
 }
 
 AMDGPUTargetInfo::AMDGPUTargetInfo() {}
 
 void AMDGPUTargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
   llvm_unreachable("not implemented");
 }
template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   RelativeReloc = R_MIPS_REL32;
 }
 
 template <class ELFT>
 unsigned MipsTargetInfo<ELFT>::getDynReloc(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>::writeGotHeaderEntries(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>::isHintReloc(uint32_t Type) const {
   return Type == R_MIPS_JALR;
 }
 

ELF/Writer.cpp

 #include "Config.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/StringSaver.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
void scanRelocs(InputSectionBase<ELFT> &C,
                   iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels);
 
   void scanRelocs(InputSection<ELFT> &C);
   void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
   void updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr, uintX_t VA);
   void assignAddresses();
   void buildSectionMap();
   void fixAbsoluteSymbols();
-  void openFile(StringRef OutputPath);
+  bool openFile();
   void writeHeader();
   void writeSections();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
   StringRef getOutputSectionName(StringRef S) const;
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
   bool isOutputDynamic() const {
template <class ELFT> void Writer<ELFT>::run() {
   buildSectionMap();
   if (!Config->DiscardAll)
     copyLocalSymbols();
   addReservedSymbols();
   if (!createSections())
     return;
   assignAddresses();
   fixAbsoluteSymbols();
-  openFile(Config->OutputFile);
+  if (!openFile())
+    return;
   writeHeader();
   writeSections();
-  fatal(Buffer->commit());
+  error(Buffer->commit());
+
+  // If there was an error at this stage, the generated file is broken.
+  // Remove it rather than leave it to not confuse users.
+  if (HasError)
+    sys::fs::remove(Config->OutputFile);
 }
 
 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>> {
template <class ELFT> void Writer<ELFT>::writeHeader() {
   memcpy(Buf + EHdr->e_phoff, &Phdrs[0], Phdrs.size() * sizeof(Phdrs[0]));
 
   // Write the section header table. Note that the first table entry is null.
   auto SHdrs = reinterpret_cast<Elf_Shdr *>(Buf + EHdr->e_shoff);
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Sec->writeHeaderTo(++SHdrs);
 }
 
-template <class ELFT> void Writer<ELFT>::openFile(StringRef Path) {
+template <class ELFT> bool Writer<ELFT>::openFile() {
   ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
-      FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable);
-  fatal(BufferOrErr, "failed to open " + Path);
+      FileOutputBuffer::create(Config->OutputFile, FileSize,
+                               FileOutputBuffer::F_executable);
+  if (error(BufferOrErr, "failed to open " + Config->OutputFile))
+    return false;
   Buffer = std::move(*BufferOrErr);
+  return true;
 }
 
 // Write section contents to a mmap'ed file.
 template <class ELFT> void Writer<ELFT>::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
 
   // PPC64 needs to process relocations in the .opd section before processing
   // relocations in code-containing sections.