vendor/lld/lld-trunk-r290819

1 files changed, 97 insertions, 50 deletions

diff --git a/ELF/EhFrame.cpp b/ELF/EhFrame.cpp
index b130ac1ca22d..2428473d9012 100644
--- a/ELF/EhFrame.cpp
+++ b/ELF/EhFrame.cpp
@@ -18,6 +18,9 @@
 
 #include "EhFrame.h"
 #include "Error.h"
+#include "InputSection.h"
+#include "Relocations.h"
+#include "Strings.h"
 
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Dwarf.h"
@@ -29,49 +32,93 @@ using namespace llvm::dwarf;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
-namespace lld {
-namespace elf {
+using namespace lld;
+using namespace lld::elf;
 
+namespace {
+template <class ELFT> class EhReader {
+public:
+  EhReader(InputSectionBase<ELFT> *S, ArrayRef<uint8_t> D) : IS(S), D(D) {}
+  size_t readEhRecordSize();
+  uint8_t getFdeEncoding();
+
+private:
+  template <class P> void failOn(const P *Loc, const Twine &Msg) {
+    fatal(IS->getLocation((const uint8_t *)Loc - IS->Data.data()) + ": " + Msg);
+  }
+
+  uint8_t readByte();
+  void skipBytes(size_t Count);
+  StringRef readString();
+  void skipLeb128();
+  void skipAugP();
+
+  InputSectionBase<ELFT> *IS;
+  ArrayRef<uint8_t> D;
+};
+}
+
+template <class ELFT>
+size_t elf::readEhRecordSize(InputSectionBase<ELFT> *S, size_t Off) {
+  return EhReader<ELFT>(S, S->Data.slice(Off)).readEhRecordSize();
+}
 // .eh_frame section is a sequence of records. Each record starts with
 // a 4 byte length field. This function reads the length.
-template <class ELFT> size_t readEhRecordSize(ArrayRef<uint8_t> D) {
+template <class ELFT> size_t EhReader<ELFT>::readEhRecordSize() {
   const endianness E = ELFT::TargetEndianness;
   if (D.size() < 4)
-    fatal("CIE/FDE too small");
+    failOn(D.data(), "CIE/FDE too small");
 
   // First 4 bytes of CIE/FDE is the size of the record.
   // If it is 0xFFFFFFFF, the next 8 bytes contain the size instead,
   // but we do not support that format yet.
   uint64_t V = read32<E>(D.data());
   if (V == UINT32_MAX)
-    fatal("CIE/FDE too large");
+    failOn(D.data(), "CIE/FDE too large");
   uint64_t Size = V + 4;
   if (Size > D.size())
-    fatal("CIE/FIE ends past the end of the section");
+    failOn(D.data(), "CIE/FDE ends past the end of the section");
   return Size;
 }
 
 // Read a byte and advance D by one byte.
-static uint8_t readByte(ArrayRef<uint8_t> &D) {
+template <class ELFT> uint8_t EhReader<ELFT>::readByte() {
   if (D.empty())
-    fatal("corrupted or unsupported CIE information");
+    failOn(D.data(), "unexpected end of CIE");
   uint8_t B = D.front();
   D = D.slice(1);
   return B;
 }
 
+template <class ELFT> void EhReader<ELFT>::skipBytes(size_t Count) {
+  if (D.size() < Count)
+    failOn(D.data(), "CIE is too small");
+  D = D.slice(Count);
+}
+
+// Read a null-terminated string.
+template <class ELFT> StringRef EhReader<ELFT>::readString() {
+  const uint8_t *End = std::find(D.begin(), D.end(), '\0');
+  if (End == D.end())
+    failOn(D.data(), "corrupted CIE (failed to read string)");
+  StringRef S = toStringRef(D.slice(0, End - D.begin()));
+  D = D.slice(S.size() + 1);
+  return S;
+}
+
 // Skip an integer encoded in the LEB128 format.
 // Actual number is not of interest because only the runtime needs it.
 // But we need to be at least able to skip it so that we can read
 // the field that follows a LEB128 number.
-static void skipLeb128(ArrayRef<uint8_t> &D) {
+template <class ELFT> void EhReader<ELFT>::skipLeb128() {
+  const uint8_t *ErrPos = D.data();
   while (!D.empty()) {
     uint8_t Val = D.front();
     D = D.slice(1);
     if ((Val & 0x80) == 0)
       return;
   }
-  fatal("corrupted or unsupported CIE information");
+  failOn(ErrPos, "corrupted CIE (failed to read LEB128)");
 }
 
 template <class ELFT> static size_t getAugPSize(unsigned Enc) {
@@ -89,79 +136,79 @@ template <class ELFT> static size_t getAugPSize(unsigned Enc) {
   case DW_EH_PE_sdata8:
     return 8;
   }
-  fatal("unknown FDE encoding");
+  return 0;
 }
 
-template <class ELFT> static void skipAugP(ArrayRef<uint8_t> &D) {
-  uint8_t Enc = readByte(D);
+template <class ELFT> void EhReader<ELFT>::skipAugP() {
+  uint8_t Enc = readByte();
   if ((Enc & 0xf0) == DW_EH_PE_aligned)
-    fatal("DW_EH_PE_aligned encoding is not supported");
+    failOn(D.data() - 1, "DW_EH_PE_aligned encoding is not supported");
   size_t Size = getAugPSize<ELFT>(Enc);
+  if (Size == 0)
+    failOn(D.data() - 1, "unknown FDE encoding");
   if (Size >= D.size())
-    fatal("corrupted CIE");
+    failOn(D.data() - 1, "corrupted CIE");
   D = D.slice(Size);
 }
 
-template <class ELFT> uint8_t getFdeEncoding(ArrayRef<uint8_t> D) {
-  if (D.size() < 8)
-    fatal("CIE too small");
-  D = D.slice(8);
+template <class ELFT> uint8_t elf::getFdeEncoding(EhSectionPiece *P) {
+  auto *IS = static_cast<InputSectionBase<ELFT> *>(P->ID);
+  return EhReader<ELFT>(IS, P->data()).getFdeEncoding();
+}
 
-  uint8_t Version = readByte(D);
+template <class ELFT> uint8_t EhReader<ELFT>::getFdeEncoding() {
+  skipBytes(8);
+  int Version = readByte();
   if (Version != 1 && Version != 3)
-    fatal("FDE version 1 or 3 expected, but got " + Twine((unsigned)Version));
+    failOn(D.data() - 1,
+           "FDE version 1 or 3 expected, but got " + Twine(Version));
 
-  const unsigned char *AugEnd = std::find(D.begin(), D.end(), '\0');
-  if (AugEnd == D.end())
-    fatal("corrupted CIE");
-  StringRef Aug(reinterpret_cast<const char *>(D.begin()), AugEnd - D.begin());
-  D = D.slice(Aug.size() + 1);
+  StringRef Aug = readString();
 
-  // Code alignment factor should always be 1 for .eh_frame.
-  if (readByte(D) != 1)
-    fatal("CIE code alignment must be 1");
-
-  // Skip data alignment factor.
-  skipLeb128(D);
+  // Skip code and data alignment factors.
+  skipLeb128();
+  skipLeb128();
 
   // 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);
+    readByte();
   else
-    skipLeb128(D);
+    skipLeb128();
 
   // We only care about an 'R' value, but other records may precede an 'R'
   // record. Unfortunately records are not in TLV (type-length-value) format,
   // so we need to teach the linker how to skip records for each type.
   for (char C : Aug) {
     if (C == 'R')
-      return readByte(D);
+      return readByte();
     if (C == 'z') {
-      skipLeb128(D);
+      skipLeb128();
       continue;
     }
     if (C == 'P') {
-      skipAugP<ELFT>(D);
+      skipAugP();
       continue;
     }
     if (C == 'L') {
-      readByte(D);
+      readByte();
       continue;
     }
-    fatal("unknown .eh_frame augmentation string: " + Aug);
+    failOn(Aug.data(), "unknown .eh_frame augmentation string: " + Aug);
   }
   return DW_EH_PE_absptr;
 }
 
-template size_t readEhRecordSize<ELF32LE>(ArrayRef<uint8_t>);
-template size_t readEhRecordSize<ELF32BE>(ArrayRef<uint8_t>);
-template size_t readEhRecordSize<ELF64LE>(ArrayRef<uint8_t>);
-template size_t readEhRecordSize<ELF64BE>(ArrayRef<uint8_t>);
-
-template uint8_t getFdeEncoding<ELF32LE>(ArrayRef<uint8_t>);
-template uint8_t getFdeEncoding<ELF32BE>(ArrayRef<uint8_t>);
-template uint8_t getFdeEncoding<ELF64LE>(ArrayRef<uint8_t>);
-template uint8_t getFdeEncoding<ELF64BE>(ArrayRef<uint8_t>);
-}
-}
+template size_t elf::readEhRecordSize<ELF32LE>(InputSectionBase<ELF32LE> *S,
+                                               size_t Off);
+template size_t elf::readEhRecordSize<ELF32BE>(InputSectionBase<ELF32BE> *S,
+                                               size_t Off);
+template size_t elf::readEhRecordSize<ELF64LE>(InputSectionBase<ELF64LE> *S,
+                                               size_t Off);
+template size_t elf::readEhRecordSize<ELF64BE>(InputSectionBase<ELF64BE> *S,
+                                               size_t Off);
+
+template uint8_t elf::getFdeEncoding<ELF32LE>(EhSectionPiece *P);
+template uint8_t elf::getFdeEncoding<ELF32BE>(EhSectionPiece *P);
+template uint8_t elf::getFdeEncoding<ELF64LE>(EhSectionPiece *P);
+template uint8_t elf::getFdeEncoding<ELF64BE>(EhSectionPiece *P);