contrib/llvm/tools/lld/ELF/EhFrame.cpp

   1 //===- EhFrame.cpp -------------------------------------------------------===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // .eh_frame section contains information on how to unwind the stack when
  11 // an exception is thrown. The section consists of sequence of CIE and FDE
  12 // records. The linker needs to merge CIEs and associate FDEs to CIEs.
  13 // That means the linker has to understand the format of the section.
  14 //
  15 // This file contains a few utility functions to read .eh_frame contents.
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "EhFrame.h"
  20 #include "Error.h"
  21
  22 #include "llvm/Object/ELF.h"
  23 #include "llvm/Support/Dwarf.h"
  24 #include "llvm/Support/Endian.h"
  25
  26 using namespace llvm;
  27 using namespace llvm::ELF;
  28 using namespace llvm::dwarf;
  29 using namespace llvm::object;
  30 using namespace llvm::support::endian;
  31
  32 namespace lld {
  33 namespace elf {
  34
  35 // .eh_frame section is a sequence of records. Each record starts with
  36 // a 4 byte length field. This function reads the length.
  37 template <class ELFT> size_t readEhRecordSize(ArrayRef<uint8_t> D) {
  38   const endianness E = ELFT::TargetEndianness;
  39   if (D.size() < 4)
  40     fatal("CIE/FDE too small");
  41
  42   // First 4 bytes of CIE/FDE is the size of the record.
  43   // If it is 0xFFFFFFFF, the next 8 bytes contain the size instead,
  44   // but we do not support that format yet.
  45   uint64_t V = read32<E>(D.data());
  46   if (V == UINT32_MAX)
  47     fatal("CIE/FDE too large");
  48   uint64_t Size = V + 4;
  49   if (Size > D.size())
  50     fatal("CIE/FIE ends past the end of the section");
  51   return Size;
  52 }
  53
  54 // Read a byte and advance D by one byte.
  55 static uint8_t readByte(ArrayRef<uint8_t> &D) {
  56   if (D.empty())
  57     fatal("corrupted or unsupported CIE information");
  58   uint8_t B = D.front();
  59   D = D.slice(1);
  60   return B;
  61 }
  62
  63 // Skip an integer encoded in the LEB128 format.
  64 // Actual number is not of interest because only the runtime needs it.
  65 // But we need to be at least able to skip it so that we can read
  66 // the field that follows a LEB128 number.
  67 static void skipLeb128(ArrayRef<uint8_t> &D) {
  68   while (!D.empty()) {
  69     uint8_t Val = D.front();
  70     D = D.slice(1);
  71     if ((Val & 0x80) == 0)
  72       return;
  73   }
  74   fatal("corrupted or unsupported CIE information");
  75 }
  76
  77 template <class ELFT> static size_t getAugPSize(unsigned Enc) {
  78   switch (Enc & 0x0f) {
  79   case DW_EH_PE_absptr:
  80   case DW_EH_PE_signed:
  81     return ELFT::Is64Bits ? 8 : 4;
  82   case DW_EH_PE_udata2:
  83   case DW_EH_PE_sdata2:
  84     return 2;
  85   case DW_EH_PE_udata4:
  86   case DW_EH_PE_sdata4:
  87     return 4;
  88   case DW_EH_PE_udata8:
  89   case DW_EH_PE_sdata8:
  90     return 8;
  91   }
  92   fatal("unknown FDE encoding");
  93 }
  94
  95 template <class ELFT> static void skipAugP(ArrayRef<uint8_t> &D) {
  96   uint8_t Enc = readByte(D);
  97   if ((Enc & 0xf0) == DW_EH_PE_aligned)
  98     fatal("DW_EH_PE_aligned encoding is not supported");
  99   size_t Size = getAugPSize<ELFT>(Enc);
 100   if (Size >= D.size())
 101     fatal("corrupted CIE");
 102   D = D.slice(Size);
 103 }
 104
 105 template <class ELFT> uint8_t getFdeEncoding(ArrayRef<uint8_t> D) {
 106   if (D.size() < 8)
 107     fatal("CIE too small");
 108   D = D.slice(8);
 109
 110   uint8_t Version = readByte(D);
 111   if (Version != 1 && Version != 3)
 112     fatal("FDE version 1 or 3 expected, but got " + Twine((unsigned)Version));
 113
 114   const unsigned char *AugEnd = std::find(D.begin(), D.end(), '\0');
 115   if (AugEnd == D.end())
 116     fatal("corrupted CIE");
 117   StringRef Aug(reinterpret_cast<const char *>(D.begin()), AugEnd - D.begin());
 118   D = D.slice(Aug.size() + 1);
 119
 120   // Code alignment factor should always be 1 for .eh_frame.
 121   if (readByte(D) != 1)
 122     fatal("CIE code alignment must be 1");
 123
 124   // Skip data alignment factor.
 125   skipLeb128(D);
 126
 127   // Skip the return address register. In CIE version 1 this is a single
 128   // byte. In CIE version 3 this is an unsigned LEB128.
 129   if (Version == 1)
 130     readByte(D);
 131   else
 132     skipLeb128(D);
 133
 134   // We only care about an 'R' value, but other records may precede an 'R'
 135   // record. Unfortunately records are not in TLV (type-length-value) format,
 136   // so we need to teach the linker how to skip records for each type.
 137   for (char C : Aug) {
 138     if (C == 'R')
 139       return readByte(D);
 140     if (C == 'z') {
 141       skipLeb128(D);
 142       continue;
 143     }
 144     if (C == 'P') {
 145       skipAugP<ELFT>(D);
 146       continue;
 147     }
 148     if (C == 'L') {
 149       readByte(D);
 150       continue;
 151     }
 152     fatal("unknown .eh_frame augmentation string: " + Aug);
 153   }
 154   return DW_EH_PE_absptr;
 155 }
 156
 157 template size_t readEhRecordSize<ELF32LE>(ArrayRef<uint8_t>);
 158 template size_t readEhRecordSize<ELF32BE>(ArrayRef<uint8_t>);
 159 template size_t readEhRecordSize<ELF64LE>(ArrayRef<uint8_t>);
 160 template size_t readEhRecordSize<ELF64BE>(ArrayRef<uint8_t>);
 161
 162 template uint8_t getFdeEncoding<ELF32LE>(ArrayRef<uint8_t>);
 163 template uint8_t getFdeEncoding<ELF32BE>(ArrayRef<uint8_t>);
 164 template uint8_t getFdeEncoding<ELF64LE>(ArrayRef<uint8_t>);
 165 template uint8_t getFdeEncoding<ELF64BE>(ArrayRef<uint8_t>);
 166 }
 167 }