Commit | Line | Data |
---|---|---|
3151305a ILT |
1 | // ehframe.h -- handle exception frame sections for gold -*- C++ -*- |
2 | ||
3 | // Copyright 2006, 2007 Free Software Foundation, Inc. | |
4 | // Written by Ian Lance Taylor <iant@google.com>. | |
5 | ||
6 | // This file is part of gold. | |
7 | ||
8 | // This program is free software; you can redistribute it and/or modify | |
9 | // it under the terms of the GNU General Public License as published by | |
10 | // the Free Software Foundation; either version 3 of the License, or | |
11 | // (at your option) any later version. | |
12 | ||
13 | // This program is distributed in the hope that it will be useful, | |
14 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
16 | // GNU General Public License for more details. | |
17 | ||
18 | // You should have received a copy of the GNU General Public License | |
19 | // along with this program; if not, write to the Free Software | |
20 | // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, | |
21 | // MA 02110-1301, USA. | |
22 | ||
23 | #ifndef GOLD_EHFRAME_H | |
24 | #define GOLD_EHFRAME_H | |
25 | ||
26 | #include "output.h" | |
730cdc88 | 27 | #include "merge.h" |
3151305a ILT |
28 | |
29 | namespace gold | |
30 | { | |
31 | ||
730cdc88 ILT |
32 | template<int size, bool big_endian> |
33 | class Track_relocs; | |
34 | ||
35 | class Eh_frame; | |
36 | ||
3151305a ILT |
37 | // This class manages the .eh_frame_hdr section, which holds the data |
38 | // for the PT_GNU_EH_FRAME segment. gcc's unwind support code uses | |
39 | // the PT_GNU_EH_FRAME segment to find the list of FDEs. This saves | |
40 | // the time required to register the exception handlers at startup | |
41 | // time and when a shared object is loaded, and the time required to | |
42 | // deregister the exception handlers when a shared object is unloaded. | |
43 | ||
44 | // FIXME: gcc supports using storing a sorted lookup table for the | |
45 | // FDEs in the PT_GNU_EH_FRAME segment, but we do not yet generate | |
46 | // that. | |
47 | ||
48 | class Eh_frame_hdr : public Output_section_data | |
49 | { | |
50 | public: | |
730cdc88 ILT |
51 | Eh_frame_hdr(Output_section* eh_frame_section, const Eh_frame*); |
52 | ||
53 | // Record that we found an unrecognized .eh_frame section. | |
54 | void | |
55 | found_unrecognized_eh_frame_section() | |
56 | { this->any_unrecognized_eh_frame_sections_ = true; } | |
57 | ||
58 | // Record an FDE. | |
59 | void | |
60 | record_fde(off_t fde_offset, unsigned char fde_encoding) | |
61 | { | |
62 | if (!this->any_unrecognized_eh_frame_sections_) | |
63 | this->fde_offsets_.push_back(std::make_pair(fde_offset, fde_encoding)); | |
64 | } | |
3151305a ILT |
65 | |
66 | // Set the final data size. | |
67 | void | |
27bc2bce | 68 | set_final_data_size(); |
3151305a ILT |
69 | |
70 | // Write the data to the file. | |
71 | void | |
72 | do_write(Output_file*); | |
73 | ||
74 | private: | |
730cdc88 ILT |
75 | // Write the data to the file with the right endianness. |
76 | template<int size, bool big_endian> | |
77 | void | |
78 | do_sized_write(Output_file*); | |
79 | ||
80 | // The data we record for one FDE: the offset of the FDE within the | |
81 | // .eh_frame section, and the FDE encoding. | |
82 | typedef std::pair<off_t, unsigned char> Fde_offset; | |
83 | ||
84 | // The list of information we record for an FDE. | |
85 | typedef std::vector<Fde_offset> Fde_offsets; | |
86 | ||
87 | // When writing out the header, we convert the FDE offsets into FDE | |
88 | // addresses. This is a list of pairs of the offset from the header | |
89 | // to the FDE PC and to the FDE itself. | |
90 | template<int size> | |
91 | class Fde_addresses | |
92 | { | |
93 | public: | |
94 | typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; | |
95 | typedef typename std::pair<Address, Address> Fde_address; | |
96 | typedef typename std::vector<Fde_address> Fde_address_list; | |
97 | typedef typename Fde_address_list::iterator iterator; | |
98 | ||
99 | Fde_addresses(unsigned int reserve) | |
100 | : fde_addresses_() | |
101 | { this->fde_addresses_.reserve(reserve); } | |
102 | ||
103 | void | |
104 | push_back(Address pc_address, Address fde_address) | |
105 | { | |
106 | this->fde_addresses_.push_back(std::make_pair(pc_address, fde_address)); | |
107 | } | |
108 | ||
109 | iterator | |
110 | begin() | |
111 | { return this->fde_addresses_.begin(); } | |
112 | ||
113 | iterator | |
114 | end() | |
115 | { return this->fde_addresses_.end(); } | |
116 | ||
117 | private: | |
118 | Fde_address_list fde_addresses_; | |
119 | }; | |
120 | ||
121 | // Compare Fde_address objects. | |
122 | template<int size> | |
123 | struct Fde_address_compare | |
124 | { | |
125 | bool | |
126 | operator()(const typename Fde_addresses<size>::Fde_address& f1, | |
127 | const typename Fde_addresses<size>::Fde_address& f2) const | |
128 | { return f1.first < f2.first; } | |
129 | }; | |
130 | ||
131 | // Return the PC to which an FDE refers. | |
132 | template<int size, bool big_endian> | |
133 | typename elfcpp::Elf_types<size>::Elf_Addr | |
4117d768 ILT |
134 | get_fde_pc(typename elfcpp::Elf_types<size>::Elf_Addr eh_frame_address, |
135 | const unsigned char* eh_frame_contents, | |
730cdc88 ILT |
136 | off_t fde_offset, unsigned char fde_encoding); |
137 | ||
138 | // Convert Fde_offsets to Fde_addresses. | |
139 | template<int size, bool big_endian> | |
140 | void | |
141 | get_fde_addresses(Output_file* of, | |
142 | const Fde_offsets* fde_offsets, | |
143 | Fde_addresses<size>* fde_addresses); | |
144 | ||
3151305a ILT |
145 | // The .eh_frame section. |
146 | Output_section* eh_frame_section_; | |
730cdc88 ILT |
147 | // The .eh_frame section data. |
148 | const Eh_frame* eh_frame_data_; | |
149 | // Data from the FDEs in the .eh_frame sections. | |
150 | Fde_offsets fde_offsets_; | |
151 | // Whether we found any .eh_frame sections which we could not | |
152 | // process. | |
153 | bool any_unrecognized_eh_frame_sections_; | |
154 | }; | |
155 | ||
156 | // This class holds an FDE. | |
157 | ||
158 | class Fde | |
159 | { | |
160 | public: | |
161 | Fde(Relobj* object, unsigned int shndx, off_t input_offset, | |
162 | const unsigned char* contents, size_t length) | |
163 | : object_(object), shndx_(shndx), input_offset_(input_offset), | |
164 | contents_(reinterpret_cast<const char*>(contents), length) | |
165 | { } | |
166 | ||
167 | // Return the length of this FDE. Add 4 for the length and 4 for | |
168 | // the offset to the CIE. | |
169 | size_t | |
170 | length() const | |
171 | { return this->contents_.length() + 8; } | |
172 | ||
173 | // Add a mapping for this FDE to MERGE_MAP. | |
174 | void | |
175 | add_mapping(off_t output_offset, Merge_map* merge_map) const | |
176 | { | |
177 | merge_map->add_mapping(this->object_, this->shndx_, | |
178 | this->input_offset_, this->length(), | |
179 | output_offset); | |
180 | } | |
181 | ||
182 | // Write the FDE to OVIEW starting at OFFSET. FDE_ENCODING is the | |
183 | // encoding, from the CIE. Record the FDE in EH_FRAME_HDR. Return | |
184 | // the new offset. | |
185 | template<int size, bool big_endian> | |
186 | off_t | |
187 | write(unsigned char* oview, off_t offset, off_t cie_offset, | |
188 | unsigned char fde_encoding, Eh_frame_hdr* eh_frame_hdr); | |
189 | ||
190 | private: | |
191 | // The object in which this FDE was seen. | |
192 | Relobj* object_; | |
193 | // Input section index for this FDE. | |
194 | unsigned int shndx_; | |
195 | // Offset within the input section for this FDE. | |
196 | off_t input_offset_; | |
197 | // FDE data. | |
198 | std::string contents_; | |
199 | }; | |
200 | ||
201 | // This class holds a CIE. | |
202 | ||
203 | class Cie | |
204 | { | |
205 | public: | |
206 | Cie(Relobj* object, unsigned int shndx, off_t input_offset, | |
207 | unsigned char fde_encoding, const char* personality_name, | |
208 | const unsigned char* contents, size_t length) | |
209 | : object_(object), | |
210 | shndx_(shndx), | |
211 | input_offset_(input_offset), | |
212 | fde_encoding_(fde_encoding), | |
213 | personality_name_(personality_name), | |
214 | fdes_(), | |
215 | contents_(reinterpret_cast<const char*>(contents), length) | |
216 | { } | |
217 | ||
218 | ~Cie(); | |
219 | ||
220 | // We permit copying a CIE when there are no FDEs. This is | |
221 | // convenient in the code which creates them. | |
222 | Cie(const Cie& cie) | |
223 | : object_(cie.object_), | |
224 | shndx_(cie.shndx_), | |
225 | input_offset_(cie.input_offset_), | |
226 | fde_encoding_(cie.fde_encoding_), | |
227 | personality_name_(cie.personality_name_), | |
228 | fdes_(), | |
229 | contents_(cie.contents_) | |
230 | { gold_assert(cie.fdes_.empty()); } | |
231 | ||
232 | // Add an FDE associated with this CIE. | |
233 | void | |
234 | add_fde(Fde* fde) | |
235 | { this->fdes_.push_back(fde); } | |
236 | ||
237 | // Return the number of FDEs. | |
238 | unsigned int | |
239 | fde_count() const | |
240 | { return this->fdes_.size(); } | |
241 | ||
242 | // Set the output offset of this CIE to OUTPUT_OFFSET. It will be | |
243 | // followed by all its FDEs. ADDRALIGN is the required address | |
244 | // alignment, typically 4 or 8. This updates MERGE_MAP with the | |
245 | // mapping. It returns the new output offset. | |
246 | off_t | |
247 | set_output_offset(off_t output_offset, unsigned int addralign, Merge_map*); | |
248 | ||
249 | // Write the CIE to OVIEW starting at OFFSET. EH_FRAME_HDR is the | |
250 | // exception frame header for FDE recording. Return the new offset. | |
251 | template<int size, bool big_endian> | |
252 | off_t | |
253 | write(unsigned char* oview, off_t offset, Eh_frame_hdr* eh_frame_hdr); | |
254 | ||
255 | friend bool operator<(const Cie&, const Cie&); | |
256 | friend bool operator==(const Cie&, const Cie&); | |
257 | ||
258 | private: | |
259 | // The class is not assignable. | |
260 | Cie& operator=(const Cie&); | |
261 | ||
262 | // The object in which this CIE was first seen. | |
263 | Relobj* object_; | |
264 | // Input section index for this CIE. | |
265 | unsigned int shndx_; | |
266 | // Offset within the input section for this CIE. | |
267 | off_t input_offset_; | |
268 | // The encoding of the FDE. This is a DW_EH_PE code. | |
269 | unsigned char fde_encoding_; | |
270 | // The name of the personality routine. This will be the name of a | |
271 | // global symbol, or will be the empty string. | |
272 | std::string personality_name_; | |
273 | // List of FDEs. | |
274 | std::vector<Fde*> fdes_; | |
275 | // CIE data. | |
276 | std::string contents_; | |
277 | }; | |
278 | ||
279 | extern bool operator<(const Cie&, const Cie&); | |
280 | extern bool operator==(const Cie&, const Cie&); | |
281 | ||
282 | // This class manages .eh_frame sections. It discards duplicate | |
283 | // exception information. | |
284 | ||
285 | class Eh_frame : public Output_section_data | |
286 | { | |
287 | public: | |
288 | Eh_frame(); | |
289 | ||
290 | // Record the associated Eh_frame_hdr, if any. | |
291 | void | |
292 | set_eh_frame_hdr(Eh_frame_hdr* hdr) | |
293 | { this->eh_frame_hdr_ = hdr; } | |
294 | ||
295 | // Add the input section SHNDX in OBJECT. SYMBOLS is the contents | |
296 | // of the symbol table section (size SYMBOLS_SIZE), SYMBOL_NAMES is | |
297 | // the symbol names section (size SYMBOL_NAMES_SIZE). RELOC_SHNDX | |
298 | // is the relocation section if any (0 for none, -1U for multiple). | |
299 | // RELOC_TYPE is the type of the relocation section if any. This | |
300 | // returns whether the section was incorporated into the .eh_frame | |
301 | // data. | |
302 | template<int size, bool big_endian> | |
303 | bool | |
304 | add_ehframe_input_section(Sized_relobj<size, big_endian>* object, | |
305 | const unsigned char* symbols, | |
306 | off_t symbols_size, | |
307 | const unsigned char* symbol_names, | |
308 | off_t symbol_names_size, | |
309 | unsigned int shndx, unsigned int reloc_shndx, | |
310 | unsigned int reloc_type); | |
311 | ||
312 | // Return the number of FDEs. | |
313 | unsigned int | |
314 | fde_count() const; | |
315 | ||
316 | // Set the final data size. | |
317 | void | |
27bc2bce | 318 | set_final_data_size(); |
730cdc88 ILT |
319 | |
320 | // Return the output address for an input address. | |
321 | bool | |
322 | do_output_offset(const Relobj*, unsigned int shndx, off_t offset, | |
323 | off_t* poutput) const; | |
324 | ||
325 | // Write the data to the file. | |
326 | void | |
327 | do_write(Output_file*); | |
328 | ||
329 | private: | |
330 | // The comparison routine for the CIE map. | |
331 | struct Cie_less | |
332 | { | |
333 | bool | |
334 | operator()(const Cie* cie1, const Cie* cie2) const | |
335 | { return *cie1 < *cie2; } | |
336 | }; | |
337 | ||
338 | // A mapping from unique CIEs to their offset in the output file. | |
339 | typedef std::map<Cie*, uint64_t, Cie_less> Cie_offsets; | |
340 | ||
341 | // A list of unmergeable CIEs with their offsets. | |
342 | typedef std::vector<std::pair<Cie*, uint64_t> > Unmergeable_cie_offsets; | |
343 | ||
344 | // A mapping from offsets to CIEs. This is used while reading an | |
345 | // input section. | |
346 | typedef std::map<uint64_t, Cie*> Offsets_to_cie; | |
347 | ||
348 | // A list of CIEs, and a bool indicating whether the CIE is | |
349 | // mergeable. | |
350 | typedef std::vector<std::pair<Cie*, bool> > New_cies; | |
351 | ||
352 | // Skip an LEB128. | |
353 | static bool | |
354 | skip_leb128(const unsigned char**, const unsigned char*); | |
355 | ||
356 | // The implementation of add_ehframe_input_section. | |
357 | template<int size, bool big_endian> | |
358 | bool | |
359 | do_add_ehframe_input_section(Sized_relobj<size, big_endian>* object, | |
360 | const unsigned char* symbols, | |
361 | off_t symbols_size, | |
362 | const unsigned char* symbol_names, | |
363 | off_t symbol_names_size, | |
364 | unsigned int shndx, | |
365 | unsigned int reloc_shndx, | |
366 | unsigned int reloc_type, | |
367 | const unsigned char* pcontents, | |
368 | off_t contents_len, | |
369 | New_cies*); | |
370 | ||
371 | // Read a CIE. | |
372 | template<int size, bool big_endian> | |
373 | bool | |
374 | read_cie(Sized_relobj<size, big_endian>* object, | |
375 | unsigned int shndx, | |
376 | const unsigned char* symbols, | |
377 | off_t symbols_size, | |
378 | const unsigned char* symbol_names, | |
379 | off_t symbol_names_size, | |
380 | const unsigned char* pcontents, | |
381 | const unsigned char* pcie, | |
382 | const unsigned char *pcieend, | |
383 | Track_relocs<size, big_endian>* relocs, | |
384 | Offsets_to_cie* cies, | |
385 | New_cies* new_cies); | |
386 | ||
387 | // Read an FDE. | |
388 | template<int size, bool big_endian> | |
389 | bool | |
390 | read_fde(Sized_relobj<size, big_endian>* object, | |
391 | unsigned int shndx, | |
392 | const unsigned char* symbols, | |
393 | off_t symbols_size, | |
394 | const unsigned char* pcontents, | |
395 | unsigned int offset, | |
396 | const unsigned char* pfde, | |
397 | const unsigned char *pfdeend, | |
398 | Track_relocs<size, big_endian>* relocs, | |
399 | Offsets_to_cie* cies); | |
400 | ||
401 | // Template version of write function. | |
402 | template<int size, bool big_endian> | |
403 | void | |
404 | do_sized_write(unsigned char* oview); | |
405 | ||
406 | // The exception frame header, if any. | |
407 | Eh_frame_hdr* eh_frame_hdr_; | |
408 | // A mapping from all unique CIEs to their offset in the output | |
409 | // file. | |
410 | Cie_offsets cie_offsets_; | |
411 | // A mapping from unmergeable CIEs to their offset in the output | |
412 | // file. | |
413 | Unmergeable_cie_offsets unmergeable_cie_offsets_; | |
414 | // A mapping from input sections to the output section. | |
415 | Merge_map merge_map_; | |
3151305a ILT |
416 | }; |
417 | ||
418 | } // End namespace gold. | |
419 | ||
420 | #endif // !defined(GOLD_EHFRAME_H) |