ELF: Do not use fatal in {Input,Output}Sections.cpp.

[ruiu]

Summary

Just like http://reviews.llvm.org/D16665, this change is mostly
mechanical.

[• rafael]

This reduces the quality of the error message, which is the main thing I would like to avoid with *any* change to our error handling.

ELF/InputSection.h

 public:
   SplitInputSection(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
                     typename InputSectionBase<ELFT>::Kind SectionKind);
 
   // For each piece of data, we maintain the offsets in the input section and
   // in the output section. The latter may be -1 if it is not assigned yet.
   std::vector<std::pair<uintX_t, uintX_t>> Offsets;
 
-  std::pair<std::pair<uintX_t, uintX_t> *, uintX_t>
-  getRangeAndSize(uintX_t Offset);
+  bool getRangeAndSize(uintX_t Offset, std::pair<uintX_t, uintX_t> *&P,
+                       uintX_t &End);
 };
 
 // This corresponds to a SHF_MERGE section of an input file.
 template <class ELFT> class MergeInputSection : public SplitInputSection<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
 

ELF/InputSection.cpp

 template <class ELFT>
 InputSectionBase<ELFT>::InputSectionBase(ObjectFile<ELFT> *File,
                                          const Elf_Shdr *Header,
                                          Kind SectionKind)
     : Header(Header), File(File), SectionKind(SectionKind) {}
 
 template <class ELFT> StringRef InputSectionBase<ELFT>::getSectionName() const {
   ErrorOr<StringRef> Name = File->getObj().getSectionName(this->Header);
-  fatal(Name);
+  if (error(Name, "getSectionName failed"))
+    return "";
   return *Name;
 }
 
 template <class ELFT>
 ArrayRef<uint8_t> InputSectionBase<ELFT>::getSectionData() const {
   ErrorOr<ArrayRef<uint8_t>> Ret =
       this->File->getObj().getSectionContents(this->Header);
-  fatal(Ret);
+  if (error(Ret, "getSectionContents failed"))
+    return {};
   return *Ret;
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t
 InputSectionBase<ELFT>::getOffset(uintX_t Offset) {
   switch (SectionKind) {
   case Regular:

 template <class ELFT>
 typename EHInputSection<ELFT>::uintX_t
 EHInputSection<ELFT>::getOffset(uintX_t Offset) {
   // The file crtbeginT.o has relocations pointing to the start of an empty
   // .eh_frame that is known to be the first in the link. It does that to
   // identify the start of the output .eh_frame. Handle this special case.
   if (this->getSectionHdr()->sh_size == 0)
     return Offset;
-  std::pair<uintX_t, uintX_t> *I = this->getRangeAndSize(Offset).first;
+
+  std::pair<uintX_t, uintX_t> *I;
+  uintX_t End;
+  if (!this->getRangeAndSize(Offset, I, End))
+    return 0; // Returns a dummy value for a broken symbol.
   uintX_t Base = I->second;
   if (Base == uintX_t(-1))
     return -1; // Not in the output
 
   uintX_t Addend = Offset - I->first;
   return Base + Addend;
 }
 
 template <class ELFT>
 MergeInputSection<ELFT>::MergeInputSection(ObjectFile<ELFT> *F,
                                            const Elf_Shdr *Header)
     : SplitInputSection<ELFT>(F, Header, InputSectionBase<ELFT>::Merge) {}
 
 template <class ELFT>
 bool MergeInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == InputSectionBase<ELFT>::Merge;
 }
 
 template <class ELFT>
-std::pair<std::pair<typename ELFFile<ELFT>::uintX_t,
-                    typename ELFFile<ELFT>::uintX_t> *,
-          typename ELFFile<ELFT>::uintX_t>
-SplitInputSection<ELFT>::getRangeAndSize(uintX_t Offset) {
+bool SplitInputSection<ELFT>::getRangeAndSize(uintX_t Offset,
+                                              std::pair<uintX_t, uintX_t> *&P,
+                                              uintX_t &End) {
   ArrayRef<uint8_t> D = this->getSectionData();
   StringRef Data((const char *)D.data(), D.size());
   uintX_t Size = Data.size();
-  if (Offset >= Size)
-    fatal("Entry is past the end of the section");
+  if (Offset >= Size) {
+    error("Entry is past the end of the section");
+    return false;
+  }
 
   // Find the element this offset points to.
   auto I = std::upper_bound(
       Offsets.begin(), Offsets.end(), Offset,
       [](const uintX_t &A, const std::pair<uintX_t, uintX_t> &B) {
         return A < B.first;
       });
-  uintX_t End = I == Offsets.end() ? Data.size() : I->first;
+  End = I == Offsets.end() ? Data.size() : I->first;
   --I;
-  return std::make_pair(&*I, End);
+  P = &*I;
+  return true;
 }
 
 template <class ELFT>
 typename MergeInputSection<ELFT>::uintX_t
 MergeInputSection<ELFT>::getOffset(uintX_t Offset) {
-  std::pair<std::pair<uintX_t, uintX_t> *, uintX_t> T =
-      this->getRangeAndSize(Offset);
-  std::pair<uintX_t, uintX_t> *I = T.first;
-  uintX_t End = T.second;
+  std::pair<uintX_t, uintX_t> *I;
+  uintX_t End;
+  if (!this->getRangeAndSize(Offset, I, End))
+    return 0; // Returns a dummy value for a broken symbol.
   uintX_t Start = I->first;
 
   // Compute the Addend and if the Base is cached, return.
   uintX_t Addend = Offset - Start;
   uintX_t &Base = I->second;
   if (Base != uintX_t(-1))
     return Base + Addend;
 
   // Map the base to the offset in the output section and cache it.
   ArrayRef<uint8_t> D = this->getSectionData();
   StringRef Data((const char *)D.data(), D.size());
   StringRef Entry = Data.substr(Start, End - Start);
   Base =
       static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(Entry);
   return Base + Addend;
 }
 
 template <class ELFT>
 MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(ObjectFile<ELFT> *F,
                                                        const Elf_Shdr *Hdr)
     : InputSectionBase<ELFT>(F, Hdr, InputSectionBase<ELFT>::MipsReginfo) {
   // Initialize this->Reginfo.
   ArrayRef<uint8_t> D = this->getSectionData();
   if (D.size() != sizeof(Elf_Mips_RegInfo<ELFT>))
-    fatal("Invalid size of .reginfo section");
+    error("Invalid size of .reginfo section");
+  else
     Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(D.data());
 }
 
 template <class ELFT>
 bool MipsReginfoInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == InputSectionBase<ELFT>::MipsReginfo;
 }
 
 template class elf2::InputSectionBase<ELF32LE>;

ELF/OutputSections.h

public:
   void addSectionAux(
       EHInputSection<ELFT> *S,
       llvm::iterator_range<const llvm::object::Elf_Rel_Impl<ELFT, IsRela> *>
           Rels);
 
   void addSection(InputSectionBase<ELFT> *S) override;
 
 private:
-  uint8_t getFdeEncoding(ArrayRef<uint8_t> D);
-  uintX_t readEntryLength(ArrayRef<uint8_t> D);
+  bool getFdeEncoding(ArrayRef<uint8_t> D, uint8_t &Result);
+  bool readEntryLength(ArrayRef<uint8_t> D, uintX_t &Result);
 
   std::vector<EHInputSection<ELFT> *> Sections;
   std::vector<Cie<ELFT>> Cies;
 
   // Maps CIE content + personality to a index in Cies.
   llvm::DenseMap<std::pair<StringRef, StringRef>, unsigned> CieMap;
 };
 

 
 private:
   struct FdeData {
     uint8_t Enc;
     size_t Off;
     uint8_t *PCRel;
   };
 
-  uintX_t getFdePc(uintX_t EhVA, const FdeData &F);
+  bool getFdePc(uintX_t EhVA, const FdeData &F, uintX_t &Result);
 
   EHOutputSection<ELFT> *Sec = nullptr;
   std::vector<FdeData> FdeList;
 };
 
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.

ELF/OutputSections.cpp

 }
 
 // We have to get PC values of FDEs. They depend on relocations
 // which are target specific, so we run this code after performing
 // all relocations. We read the values from ouput buffer according to the
 // encoding given for FDEs. Return value is an offset to the initial PC value
 // for the FDE.
 template <class ELFT>
-typename EhFrameHeader<ELFT>::uintX_t
-EhFrameHeader<ELFT>::getFdePc(uintX_t EhVA, const FdeData &F) {
+bool EhFrameHeader<ELFT>::getFdePc(uintX_t EhVA, const FdeData &F,
+                                   uintX_t &Result) {
   const endianness E = ELFT::TargetEndianness;
   assert((F.Enc & 0xF0) != dwarf::DW_EH_PE_datarel);
 
   uintX_t FdeOff = EhVA + F.Off + 8;
   switch (F.Enc & 0xF) {
   case dwarf::DW_EH_PE_udata2:
   case dwarf::DW_EH_PE_sdata2:
-    return FdeOff + read16<E>(F.PCRel);
+    Result = FdeOff + read16<E>(F.PCRel);
+    return true;
   case dwarf::DW_EH_PE_udata4:
   case dwarf::DW_EH_PE_sdata4:
-    return FdeOff + read32<E>(F.PCRel);
+    Result = FdeOff + read32<E>(F.PCRel);
+    return true;
   case dwarf::DW_EH_PE_udata8:
   case dwarf::DW_EH_PE_sdata8:
-    return FdeOff + read64<E>(F.PCRel);
+    Result = FdeOff + read64<E>(F.PCRel);
+    return true;
   case dwarf::DW_EH_PE_absptr:
     if (sizeof(uintX_t) == 8)
-      return FdeOff + read64<E>(F.PCRel);
-    return FdeOff + read32<E>(F.PCRel);
+      Result = FdeOff + read64<E>(F.PCRel);
+    else
+      Result = FdeOff + read32<E>(F.PCRel);
+    return true;
   }
-  fatal("unknown FDE size encoding");
+  error("unknown FDE size encoding");
+  return false;
 }
 
 template <class ELFT> void EhFrameHeader<ELFT>::writeTo(uint8_t *Buf) {
   const endianness E = ELFT::TargetEndianness;
 
   const uint8_t Header[] = {1, dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4,
                             dwarf::DW_EH_PE_udata4,
                             dwarf::DW_EH_PE_datarel | dwarf::DW_EH_PE_sdata4};
   memcpy(Buf, Header, sizeof(Header));
 
   uintX_t EhVA = Sec->getVA();
   uintX_t VA = this->getVA();
   uintX_t EhOff = EhVA - VA - 4;
   write32<E>(Buf + 4, EhOff);
   write32<E>(Buf + 8, this->FdeList.size());
   Buf += 12;
 
   // InitialPC -> Offset in .eh_frame, sorted by InitialPC.
   std::map<uintX_t, size_t> PcToOffset;
-  for (const FdeData &F : FdeList)
-    PcToOffset[getFdePc(EhVA, F)] = F.Off;
+  for (const FdeData &F : FdeList) {
+    uintX_t PC;
+    if (!getFdePc(EhVA, F, PC))
+      return;
+    PcToOffset[PC] = F.Off;
+  }
 
   for (auto &I : PcToOffset) {
     // The first four bytes are an offset to the initial PC value for the FDE.
     write32<E>(Buf, I.first - VA);
     // The last four bytes are an offset to the FDE data itself.
     write32<E>(Buf + 4, EhVA + I.second - VA);
     Buf += 8;
   }
 }
 
 template <class ELFT>
 void EhFrameHeader<ELFT>::assignEhFrame(EHOutputSection<ELFT> *Sec) {
   assert((!this->Sec || this->Sec == Sec) &&
          "multiple .eh_frame sections not supported for .eh_frame_hdr");
   Live = Config->EhFrameHdr;
   this->Sec = Sec;
 }
 
 template <class ELFT>
 void EhFrameHeader<ELFT>::addFde(uint8_t Enc, size_t Off, uint8_t *PCRel) {
   if (Live && (Enc & 0xF0) == dwarf::DW_EH_PE_datarel)
-    fatal("DW_EH_PE_datarel encoding unsupported for FDEs by .eh_frame_hdr");
+    error("DW_EH_PE_datarel encoding unsupported for FDEs by .eh_frame_hdr");
+  else
     FdeList.push_back(FdeData{Enc, Off, PCRel});
 }
 
 template <class ELFT> void EhFrameHeader<ELFT>::reserveFde() {
   // Each FDE entry is 8 bytes long:
   // The first four bytes are an offset to the initial PC value for the FDE. The
   // last four byte are an offset to the FDE data itself.
   this->Header.sh_size += 8;
 }
elf2::getLocalRelTarget(const ObjectFile<ELFT> &File,
   // PPC64 has a special relocation representing the TOC base pointer
   // that does not have a corresponding symbol.
   if (Config->EMachine == EM_PPC64 && RI.getType(false) == R_PPC64_TOC)
     return getPPC64TocBase() + Addend;
 
   const Elf_Sym *Sym =
       File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
 
-  if (!Sym)
-    fatal("Unsupported relocation without symbol");
+  if (!Sym) {
+    error("Unsupported relocation without symbol");
+    return 0;
+  }
 
   InputSectionBase<ELFT> *Section = File.getSection(*Sym);
 
   if (Sym->getType() == STT_TLS)
     return (Section->OutSec->getVA() + Section->getOffset(*Sym) + Addend) -
            Out<ELFT>::TlsPhdr->p_vaddr;
 
   // According to the ELF spec reference to a local symbol from outside
template <class ELFT> StringRef EHRegion<ELFT>::data() const {
   return StringRef((const char *)SecData.data() + Start, End - Start);
 }
 
 template <class ELFT>
 Cie<ELFT>::Cie(EHInputSection<ELFT> *S, unsigned Index)
     : EHRegion<ELFT>(S, Index) {}
 
 // Read a byte and advance D by one byte.
-static uint8_t readByte(ArrayRef<uint8_t> &D) {
-  if (D.empty())
-    fatal("corrupted or unsupported CIE information");
-  uint8_t B = D.front();
+static bool readByte(ArrayRef<uint8_t> &D, uint8_t &Result) {
+  if (D.empty()) {
+    error("corrupted or unsupported CIE information");
+    return false;
+  }
+  Result = D.front();
   D = D.slice(1);
-  return B;
+  return true;
 }
 
-static void skipLeb128(ArrayRef<uint8_t> &D) {
+static bool skipLeb128(ArrayRef<uint8_t> &D) {
   while (!D.empty()) {
     uint8_t Val = D.front();
     D = D.slice(1);
     if ((Val & 0x80) == 0)
-      return;
+      return true;
   }
-  fatal("corrupted or unsupported CIE information");
+  error("corrupted or unsupported CIE information");
+  return false;
 }
 
-template <class ELFT> static unsigned getSizeForEncoding(unsigned Enc) {
+template <class ELFT>
+static bool getSizeForEncoding(unsigned Enc, unsigned &Result) {
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
   switch (Enc & 0x0f) {
   default:
-    fatal("unknown FDE encoding");
+    error("unknown FDE encoding");
+    return false;
   case dwarf::DW_EH_PE_absptr:
   case dwarf::DW_EH_PE_signed:
-    return sizeof(uintX_t);
+    Result = sizeof(uintX_t);
+    return true;
   case dwarf::DW_EH_PE_udata2:
   case dwarf::DW_EH_PE_sdata2:
-    return 2;
+    Result = 2;
+    return true;
   case dwarf::DW_EH_PE_udata4:
   case dwarf::DW_EH_PE_sdata4:
-    return 4;
+    Result = 4;
+    return true;
   case dwarf::DW_EH_PE_udata8:
   case dwarf::DW_EH_PE_sdata8:
-    return 8;
+    Result = 8;
+    return true;
   }
 }
 
 template <class ELFT>
-uint8_t EHOutputSection<ELFT>::getFdeEncoding(ArrayRef<uint8_t> D) {
-  auto Check = [](bool C) {
-    if (!C)
-      fatal("corrupted or unsupported CIE information");
-  };
-
-  Check(D.size() >= 8);
+bool EHOutputSection<ELFT>::getFdeEncoding(ArrayRef<uint8_t> D,
+                                           uint8_t &Result) {
+  if (D.size() < 8) {
+    error("CIE too small");
+    return false;
+  }
   D = D.slice(8);
 
-  uint8_t Version = readByte(D);
-  if (Version != 1 && Version != 3)
-    fatal("FDE version 1 or 3 expected, but got " + Twine((unsigned)Version));
+  uint8_t Version;
+  if (!readByte(D, Version))
+    return false;
+  if (Version != 1 && Version != 3) {
+    error("FDE version 1 or 3 expected, but got " + Twine((unsigned)Version));
+    return false;
+  }
 
   auto AugEnd = std::find(D.begin() + 1, D.end(), '\0');
-  Check(AugEnd != D.end());
+  if (AugEnd == D.end()) {
+    error("corrupted or unsupported CIE information");
+    return false;
+  }
   ArrayRef<uint8_t> AugString(D.begin(), AugEnd - D.begin());
   D = D.slice(AugString.size() + 1);
 
   // Code alignment factor should always be 1 for .eh_frame.
-  if (readByte(D) != 1)
-    fatal("CIE code alignment must be 1");
+  uint8_t Align;
+  if (!readByte(D, Align))
+    return false;
+  if (Align != 1) {
+    error("CIE code alignment must be 1");
+    return false;
+  }
+
   // Skip data alignment factor
-  skipLeb128(D);
+  if (!skipLeb128(D))
+    return false;
 
   // Skip the return address register. In CIE version 1 this is a single
   // byte. In CIE version 3 this is an unsigned LEB128.
-  if (Version == 1)
-    readByte(D);
-  else
-    skipLeb128(D);
+  uint8_t Discard;
+  if (Version == 1) {
+    if (!readByte(D, Discard))
+      return false;
+  } else {
+    if (!skipLeb128(D))
+      return false;
+  }
 
   while (!AugString.empty()) {
-    switch (readByte(AugString)) {
+    uint8_t B;
+    if (!readByte(AugString, B))
+      return false;
+    switch (B) {
     case 'z':
-      skipLeb128(D);
+      if (!skipLeb128(D))
+        return false;
       break;
     case 'R':
-      return readByte(D);
+      return readByte(D, Result);
     case 'P': {
-      uint8_t Enc = readByte(D);
-      if ((Enc & 0xf0) == dwarf::DW_EH_PE_aligned)
-        fatal("DW_EH_PE_aligned encoding for address of a personality routine "
+      uint8_t Enc;
+      if (!readByte(D, Enc))
+        return false;
+      if ((Enc & 0xf0) == dwarf::DW_EH_PE_aligned) {
+        error("DW_EH_PE_aligned encoding for address of a personality routine "
               "handler not supported");
-      unsigned EncSize = getSizeForEncoding<ELFT>(Enc);
-      Check(D.size() >= EncSize);
+        return false;
+      }
+      unsigned EncSize;
+      if (!getSizeForEncoding<ELFT>(Enc, EncSize))
+        return false;
+      if (D.size() < EncSize) {
+        error("invalid encoding size");
+        return false;
+      }
       D = D.slice(EncSize);
       break;
     }
     case 'S':
     case 'L':
       // L: Language Specific Data Area (LSDA) encoding
       // S: This CIE represents a stack frame for the invocation of a signal
       //    handler
       break;
     default:
-      fatal("unknown .eh_frame augmentation string value");
+      error("unknown .eh_frame augmentation string value");
+      return false;
     }
   }
-  return dwarf::DW_EH_PE_absptr;
+  Result = dwarf::DW_EH_PE_absptr;
+  return false;
 }
 
 template <class ELFT>
 template <bool IsRela>
 void EHOutputSection<ELFT>::addSectionAux(
     EHInputSection<ELFT> *S,
     iterator_range<const Elf_Rel_Impl<ELFT, IsRela> *> Rels) {
   const endianness E = ELFT::TargetEndianness;
void EHOutputSection<ELFT>::addSectionAux(
   auto RelI = Rels.begin();
   auto RelE = Rels.end();
 
   DenseMap<unsigned, unsigned> OffsetToIndex;
   while (!D.empty()) {
     unsigned Index = S->Offsets.size();
     S->Offsets.push_back(std::make_pair(Offset, -1));
 
-    uintX_t Length = readEntryLength(D);
+    uintX_t Length;
+    if (!readEntryLength(D, Length))
+      return;
     // If CIE/FDE data length is zero then Length is 4, this
     // shall be considered a terminator and processing shall end.
     if (Length == 4)
       break;
     StringRef Entry((const char *)D.data(), Length);
 
     while (RelI != RelE && RelI->r_offset < Offset)
       ++RelI;
     uintX_t NextOffset = Offset + Length;
     bool HasReloc = RelI != RelE && RelI->r_offset < NextOffset;
 
     uint32_t ID = read32<E>(D.data() + 4);
     if (ID == 0) {
       // CIE
       Cie<ELFT> C(S, Index);
       if (Config->EhFrameHdr)
-        C.FdeEncoding = getFdeEncoding(D);
+        if (!getFdeEncoding(D, C.FdeEncoding))
+          return;
 
       StringRef Personality;
       if (HasReloc) {
         uint32_t SymIndex = RelI->getSymbol(Config->Mips64EL);
         SymbolBody &Body = *S->getFile()->getSymbolBody(SymIndex)->repl();
         Personality = Body.getName();
       }
 
       std::pair<StringRef, StringRef> CieInfo(Entry, Personality);
       auto P = CieMap.insert(std::make_pair(CieInfo, Cies.size()));
       if (P.second) {
         Cies.push_back(C);
         this->Header.sh_size += alignTo(Length, sizeof(uintX_t));
       }
       OffsetToIndex[Offset] = P.first->second;
     } else {
-      if (!HasReloc)
-        fatal("FDE doesn't reference another section");
+      if (!HasReloc) {
+        error("FDE doesn't reference another section");
+        return;
+      }
       InputSectionBase<ELFT> *Target = S->getRelocTarget(*RelI);
       if (Target != &InputSection<ELFT>::Discarded && Target->isLive()) {
         uint32_t CieOffset = Offset + 4 - ID;
         auto I = OffsetToIndex.find(CieOffset);
-        if (I == OffsetToIndex.end())
-          fatal("Invalid CIE reference");
+        if (I == OffsetToIndex.end()) {
+          error("Invalid CIE reference");
+          return;
+        }
         Cies[I->second].Fdes.push_back(EHRegion<ELFT>(S, Index));
         Out<ELFT>::EhFrameHdr->reserveFde();
         this->Header.sh_size += alignTo(Length, sizeof(uintX_t));
       }
     }
 
     Offset = NextOffset;
     D = D.slice(Length);
   }
 }
 
 template <class ELFT>
-typename EHOutputSection<ELFT>::uintX_t
-EHOutputSection<ELFT>::readEntryLength(ArrayRef<uint8_t> D) {
+bool EHOutputSection<ELFT>::readEntryLength(ArrayRef<uint8_t> D,
+                                            uintX_t &Result) {
   const endianness E = ELFT::TargetEndianness;
 
-  if (D.size() < 4)
-    fatal("Truncated CIE/FDE length");
+  if (D.size() < 4) {
+    error("Truncated CIE/FDE length");
+    return false;
+  }
   uint64_t Len = read32<E>(D.data());
   if (Len < UINT32_MAX) {
-    if (Len > (UINT32_MAX - 4))
-      fatal("CIE/FIE size is too large");
-    if (Len + 4 > D.size())
-      fatal("CIE/FIE ends past the end of the section");
-    return Len + 4;
+    if (Len > (UINT32_MAX - 4) || Len + 4 > D.size()) {
+      error("CIE/FIE size is invalid");
+      return false;
+    }
+    Result = Len + 4;
+    return true;
   }
 
-  if (D.size() < 12)
-    fatal("Truncated CIE/FDE length");
+  if (D.size() < 12) {
+    error("Truncated CIE/FDE length");
+    return false;
+  }
   Len = read64<E>(D.data() + 4);
-  if (Len > (UINT64_MAX - 12))
-    fatal("CIE/FIE size is too large");
-  if (Len + 12 > D.size())
-    fatal("CIE/FIE ends past the end of the section");
-  return Len + 12;
+  if (Len > (UINT64_MAX - 12) || Len + 12 > D.size()) {
+    error("CIE/FIE size is invalid");
+    return false;
+  }
+  Result = Len + 12;
+  return true;
 }
 
 template <class ELFT>
 void EHOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   auto *S = cast<EHInputSection<ELFT>>(C);
   const Elf_Shdr *RelSec = S->RelocSection;
   if (!RelSec)
     return addSectionAux(
void MergeOutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
   ArrayRef<uint8_t> D = S->getSectionData();
   StringRef Data((const char *)D.data(), D.size());
   uintX_t EntSize = S->getSectionHdr()->sh_entsize;
 
   if (this->Header.sh_flags & SHF_STRINGS) {
     uintX_t Offset = 0;
     while (!Data.empty()) {
       size_t End = findNull(Data, EntSize);
-      if (End == StringRef::npos)
-        fatal("String is not null terminated");
+      if (End == StringRef::npos) {
+        error("String is not null terminated");
+        return;
+      }
       StringRef Entry = Data.substr(0, End + EntSize);
       uintX_t OutputOffset = Builder.add(Entry);
       if (shouldTailMerge())
         OutputOffset = -1;
       S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
       uintX_t Size = End + EntSize;
       Data = Data.substr(Size);
       Offset += Size;

 
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
   // Iterate over all input object files to copy their local symbols
   // to the output symbol table pointed by Buf.
   for (const std::unique_ptr<ObjectFile<ELFT>> &File : Table.getObjectFiles()) {
     for (const Elf_Sym *Sym : File->KeptLocalSyms) {
       ErrorOr<StringRef> SymNameOrErr = Sym->getName(File->getStringTable());
-      fatal(SymNameOrErr);
+      if (error(SymNameOrErr, "getName() failed"))
+        return;
       StringRef SymName = *SymNameOrErr;
 
       auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
       uintX_t VA = 0;
       if (Sym->st_shndx == SHN_ABS) {
         ESym->st_shndx = SHN_ABS;
         VA = Sym->st_value;
       } else {

test/ELF/invalid-cie-length2.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
         .section .eh_frame
         .long 42
 
-// CHECK: CIE/FIE ends past the end of the section
+// CHECK: CIE/FIE size is invalid

test/ELF/invalid-cie-length3.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
  .section .eh_frame
  .long 0xFFFFFFFC
 
-// CHECK: CIE/FIE size is too large
+// CHECK: CIE/FIE size is invalid

test/ELF/invalid-cie-length5.s

 // REQUIRES: x86
 
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
 
  .section .eh_frame
  .long 0xFFFFFFFF
  .quad 0xFFFFFFFFFFFFFFF4
 
-// CHECK: CIE/FIE size is too large
+// CHECK: CIE/FIE size is invalid