1 //===- EhFrame.cpp -------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // .eh_frame section contains information on how to unwind the stack when
10 // an exception is thrown. The section consists of sequence of CIE and FDE
11 // records. The linker needs to merge CIEs and associate FDEs to CIEs.
12 // That means the linker has to understand the format of the section.
13 //
14 // This file contains a few utility functions to read .eh_frame contents.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #include "EhFrame.h"
19 #include "Config.h"
20 #include "InputSection.h"
21 #include "Relocations.h"
22 #include "Target.h"
23 #include "lld/Common/ErrorHandler.h"
24 #include "lld/Common/Strings.h"
25 #include "llvm/BinaryFormat/Dwarf.h"
26 #include "llvm/Object/ELF.h"
27 
28 using namespace llvm;
29 using namespace llvm::ELF;
30 using namespace llvm::dwarf;
31 using namespace llvm::object;
32 using namespace lld;
33 using namespace lld::elf;
34 
35 namespace {
36 class EhReader {
37 public:
38   EhReader(InputSectionBase *s, ArrayRef<uint8_t> d) : isec(s), d(d) {}
39   uint8_t getFdeEncoding();
40   bool hasLSDA();
41 
42 private:
43   template <class P> void failOn(const P *loc, const Twine &msg) {
44     fatal("corrupted .eh_frame: " + msg + "\n>>> defined in " +
45           isec->getObjMsg((const uint8_t *)loc - isec->data().data()));
46   }
47 
48   uint8_t readByte();
49   void skipBytes(size_t count);
50   StringRef readString();
51   void skipLeb128();
52   void skipAugP();
53   StringRef getAugmentation();
54 
55   InputSectionBase *isec;
56   ArrayRef<uint8_t> d;
57 };
58 }
59 
60 // Read a byte and advance D by one byte.
61 uint8_t EhReader::readByte() {
62   if (d.empty())
63     failOn(d.data(), "unexpected end of CIE");
64   uint8_t b = d.front();
65   d = d.slice(1);
66   return b;
67 }
68 
69 void EhReader::skipBytes(size_t count) {
70   if (d.size() < count)
71     failOn(d.data(), "CIE is too small");
72   d = d.slice(count);
73 }
74 
75 // Read a null-terminated string.
76 StringRef EhReader::readString() {
77   const uint8_t *end = llvm::find(d, '\0');
78   if (end == d.end())
79     failOn(d.data(), "corrupted CIE (failed to read string)");
80   StringRef s = toStringRef(d.slice(0, end - d.begin()));
81   d = d.slice(s.size() + 1);
82   return s;
83 }
84 
85 // Skip an integer encoded in the LEB128 format.
86 // Actual number is not of interest because only the runtime needs it.
87 // But we need to be at least able to skip it so that we can read
88 // the field that follows a LEB128 number.
89 void EhReader::skipLeb128() {
90   const uint8_t *errPos = d.data();
91   while (!d.empty()) {
92     uint8_t val = d.front();
93     d = d.slice(1);
94     if ((val & 0x80) == 0)
95       return;
96   }
97   failOn(errPos, "corrupted CIE (failed to read LEB128)");
98 }
99 
100 static size_t getAugPSize(unsigned enc) {
101   switch (enc & 0x0f) {
102   case DW_EH_PE_absptr:
103   case DW_EH_PE_signed:
104     return config->wordsize;
105   case DW_EH_PE_udata2:
106   case DW_EH_PE_sdata2:
107     return 2;
108   case DW_EH_PE_udata4:
109   case DW_EH_PE_sdata4:
110     return 4;
111   case DW_EH_PE_udata8:
112   case DW_EH_PE_sdata8:
113     return 8;
114   }
115   return 0;
116 }
117 
118 void EhReader::skipAugP() {
119   uint8_t enc = readByte();
120   if ((enc & 0xf0) == DW_EH_PE_aligned)
121     failOn(d.data() - 1, "DW_EH_PE_aligned encoding is not supported");
122   size_t size = getAugPSize(enc);
123   if (size == 0)
124     failOn(d.data() - 1, "unknown FDE encoding");
125   if (size >= d.size())
126     failOn(d.data() - 1, "corrupted CIE");
127   d = d.slice(size);
128 }
129 
130 uint8_t elf::getFdeEncoding(EhSectionPiece *p) {
131   return EhReader(p->sec, p->data()).getFdeEncoding();
132 }
133 
134 bool elf::hasLSDA(const EhSectionPiece &p) {
135   return EhReader(p.sec, p.data()).hasLSDA();
136 }
137 
138 StringRef EhReader::getAugmentation() {
139   skipBytes(8);
140   int version = readByte();
141   if (version != 1 && version != 3)
142     failOn(d.data() - 1,
143            "FDE version 1 or 3 expected, but got " + Twine(version));
144 
145   StringRef aug = readString();
146 
147   // Skip code and data alignment factors.
148   skipLeb128();
149   skipLeb128();
150 
151   // Skip the return address register. In CIE version 1 this is a single
152   // byte. In CIE version 3 this is an unsigned LEB128.
153   if (version == 1)
154     readByte();
155   else
156     skipLeb128();
157   return aug;
158 }
159 
160 uint8_t EhReader::getFdeEncoding() {
161   // We only care about an 'R' value, but other records may precede an 'R'
162   // record. Unfortunately records are not in TLV (type-length-value) format,
163   // so we need to teach the linker how to skip records for each type.
164   StringRef aug = getAugmentation();
165   for (char c : aug) {
166     if (c == 'R')
167       return readByte();
168     if (c == 'z')
169       skipLeb128();
170     else if (c == 'L')
171       readByte();
172     else if (c == 'P')
173       skipAugP();
174     else if (c != 'B' && c != 'S')
175       failOn(aug.data(), "unknown .eh_frame augmentation string: " + aug);
176   }
177   return DW_EH_PE_absptr;
178 }
179 
180 bool EhReader::hasLSDA() {
181   StringRef aug = getAugmentation();
182   for (char c : aug) {
183     if (c == 'L')
184       return true;
185     if (c == 'z')
186       skipLeb128();
187     else if (c == 'P')
188       skipAugP();
189     else if (c == 'R')
190       readByte();
191     else if (c != 'B' && c != 'S')
192       failOn(aug.data(), "unknown .eh_frame augmentation string: " + aug);
193   }
194   return false;
195 }
196