Commit | Line | Data |
---|---|---|
3151305a ILT |
1 | // ehframe.h -- handle exception frame sections for gold -*- C++ -*- |
2 | ||
b3adc24a | 3 | // Copyright (C) 2006-2020 Free Software Foundation, Inc. |
3151305a ILT |
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 | ||
1cac254c ILT |
26 | #include <map> |
27 | #include <set> | |
28 | #include <vector> | |
29 | ||
3151305a | 30 | #include "output.h" |
730cdc88 | 31 | #include "merge.h" |
3151305a ILT |
32 | |
33 | namespace gold | |
34 | { | |
35 | ||
730cdc88 ILT |
36 | template<int size, bool big_endian> |
37 | class Track_relocs; | |
38 | ||
39 | class Eh_frame; | |
40 | ||
3151305a ILT |
41 | // This class manages the .eh_frame_hdr section, which holds the data |
42 | // for the PT_GNU_EH_FRAME segment. gcc's unwind support code uses | |
43 | // the PT_GNU_EH_FRAME segment to find the list of FDEs. This saves | |
44 | // the time required to register the exception handlers at startup | |
45 | // time and when a shared object is loaded, and the time required to | |
46 | // deregister the exception handlers when a shared object is unloaded. | |
47 | ||
3151305a ILT |
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 | |
8383303e | 60 | record_fde(section_offset_type fde_offset, unsigned char fde_encoding) |
730cdc88 ILT |
61 | { |
62 | if (!this->any_unrecognized_eh_frame_sections_) | |
cafdd569 | 63 | this->fde_offsets_.push_back(std::make_pair(fde_offset, fde_encoding)); |
730cdc88 | 64 | } |
3151305a | 65 | |
7d9e3d98 | 66 | protected: |
3151305a ILT |
67 | // Set the final data size. |
68 | void | |
27bc2bce | 69 | set_final_data_size(); |
3151305a ILT |
70 | |
71 | // Write the data to the file. | |
72 | void | |
73 | do_write(Output_file*); | |
74 | ||
7d9e3d98 ILT |
75 | // Write to a map file. |
76 | void | |
77 | do_print_to_mapfile(Mapfile* mapfile) const | |
78 | { mapfile->print_output_data(this, _("** eh_frame_hdr")); } | |
79 | ||
3151305a | 80 | private: |
730cdc88 ILT |
81 | // Write the data to the file with the right endianness. |
82 | template<int size, bool big_endian> | |
83 | void | |
84 | do_sized_write(Output_file*); | |
85 | ||
86 | // The data we record for one FDE: the offset of the FDE within the | |
87 | // .eh_frame section, and the FDE encoding. | |
8383303e | 88 | typedef std::pair<section_offset_type, unsigned char> Fde_offset; |
730cdc88 ILT |
89 | |
90 | // The list of information we record for an FDE. | |
91 | typedef std::vector<Fde_offset> Fde_offsets; | |
92 | ||
93 | // When writing out the header, we convert the FDE offsets into FDE | |
94 | // addresses. This is a list of pairs of the offset from the header | |
95 | // to the FDE PC and to the FDE itself. | |
96 | template<int size> | |
97 | class Fde_addresses | |
98 | { | |
99 | public: | |
100 | typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; | |
101 | typedef typename std::pair<Address, Address> Fde_address; | |
102 | typedef typename std::vector<Fde_address> Fde_address_list; | |
103 | typedef typename Fde_address_list::iterator iterator; | |
104 | ||
105 | Fde_addresses(unsigned int reserve) | |
106 | : fde_addresses_() | |
107 | { this->fde_addresses_.reserve(reserve); } | |
108 | ||
109 | void | |
110 | push_back(Address pc_address, Address fde_address) | |
111 | { | |
112 | this->fde_addresses_.push_back(std::make_pair(pc_address, fde_address)); | |
113 | } | |
114 | ||
115 | iterator | |
116 | begin() | |
117 | { return this->fde_addresses_.begin(); } | |
118 | ||
119 | iterator | |
120 | end() | |
121 | { return this->fde_addresses_.end(); } | |
122 | ||
123 | private: | |
124 | Fde_address_list fde_addresses_; | |
125 | }; | |
126 | ||
127 | // Compare Fde_address objects. | |
128 | template<int size> | |
129 | struct Fde_address_compare | |
130 | { | |
131 | bool | |
132 | operator()(const typename Fde_addresses<size>::Fde_address& f1, | |
133 | const typename Fde_addresses<size>::Fde_address& f2) const | |
134 | { return f1.first < f2.first; } | |
135 | }; | |
136 | ||
137 | // Return the PC to which an FDE refers. | |
138 | template<int size, bool big_endian> | |
139 | typename elfcpp::Elf_types<size>::Elf_Addr | |
4117d768 ILT |
140 | get_fde_pc(typename elfcpp::Elf_types<size>::Elf_Addr eh_frame_address, |
141 | const unsigned char* eh_frame_contents, | |
8383303e | 142 | section_offset_type fde_offset, unsigned char fde_encoding); |
730cdc88 ILT |
143 | |
144 | // Convert Fde_offsets to Fde_addresses. | |
145 | template<int size, bool big_endian> | |
146 | void | |
147 | get_fde_addresses(Output_file* of, | |
148 | const Fde_offsets* fde_offsets, | |
149 | Fde_addresses<size>* fde_addresses); | |
150 | ||
3151305a ILT |
151 | // The .eh_frame section. |
152 | Output_section* eh_frame_section_; | |
730cdc88 ILT |
153 | // The .eh_frame section data. |
154 | const Eh_frame* eh_frame_data_; | |
155 | // Data from the FDEs in the .eh_frame sections. | |
156 | Fde_offsets fde_offsets_; | |
157 | // Whether we found any .eh_frame sections which we could not | |
158 | // process. | |
159 | bool any_unrecognized_eh_frame_sections_; | |
160 | }; | |
161 | ||
162 | // This class holds an FDE. | |
163 | ||
164 | class Fde | |
165 | { | |
166 | public: | |
8383303e | 167 | Fde(Relobj* object, unsigned int shndx, section_offset_type input_offset, |
2ea97941 | 168 | const unsigned char* contents, size_t length) |
07a60597 | 169 | : object_(object), |
2ea97941 | 170 | contents_(reinterpret_cast<const char*>(contents), length) |
07a60597 ILT |
171 | { |
172 | this->u_.from_object.shndx = shndx; | |
173 | this->u_.from_object.input_offset = input_offset; | |
174 | } | |
175 | ||
176 | // Create an FDE associated with a PLT. | |
9d5781f8 AM |
177 | Fde(Output_data* plt, const unsigned char* contents, size_t length, |
178 | bool post_map) | |
07a60597 ILT |
179 | : object_(NULL), |
180 | contents_(reinterpret_cast<const char*>(contents), length) | |
9d5781f8 AM |
181 | { |
182 | this->u_.from_linker.plt = plt; | |
183 | this->u_.from_linker.post_map = post_map; | |
184 | } | |
730cdc88 ILT |
185 | |
186 | // Return the length of this FDE. Add 4 for the length and 4 for | |
187 | // the offset to the CIE. | |
188 | size_t | |
189 | length() const | |
190 | { return this->contents_.length() + 8; } | |
191 | ||
07a60597 ILT |
192 | // Add a mapping for this FDE to MERGE_MAP, so that relocations |
193 | // against the FDE are applied to right part of the output file. | |
730cdc88 | 194 | void |
dbe40a88 RÁE |
195 | add_mapping(section_offset_type output_offset, |
196 | Output_section_data* output_data) const | |
730cdc88 | 197 | { |
07a60597 | 198 | if (this->object_ != NULL) |
dbe40a88 | 199 | this->object_->add_merge_mapping(output_data, this->u_.from_object.shndx, |
07a60597 ILT |
200 | this->u_.from_object.input_offset, this->length(), |
201 | output_offset); | |
730cdc88 ILT |
202 | } |
203 | ||
9d5781f8 AM |
204 | // Return whether this FDE was added after merge mapping. |
205 | bool | |
220f9906 | 206 | post_map() const |
9d5781f8 AM |
207 | { return this->object_ == NULL && this->u_.from_linker.post_map; } |
208 | ||
220f9906 AM |
209 | // Return whether this FDE was added for the PLT after merge mapping. |
210 | bool | |
211 | post_map(const Output_data* plt) const | |
212 | { return this->post_map() && this->u_.from_linker.plt == plt; } | |
213 | ||
730cdc88 | 214 | // Write the FDE to OVIEW starting at OFFSET. FDE_ENCODING is the |
935e8877 | 215 | // encoding, from the CIE. Round up the bytes to ADDRALIGN if |
07a60597 ILT |
216 | // necessary. ADDRESS is the virtual address of OVIEW. Record the |
217 | // FDE in EH_FRAME_HDR. Return the new offset. | |
730cdc88 | 218 | template<int size, bool big_endian> |
8383303e | 219 | section_offset_type |
9860cbcf CC |
220 | write(unsigned char* oview, section_offset_type output_section_offset, |
221 | section_offset_type offset, uint64_t address, unsigned int addralign, | |
07a60597 ILT |
222 | section_offset_type cie_offset, unsigned char fde_encoding, |
223 | Eh_frame_hdr* eh_frame_hdr); | |
730cdc88 ILT |
224 | |
225 | private: | |
07a60597 ILT |
226 | // The object in which this FDE was seen. This will be NULL for a |
227 | // linker generated FDE. | |
730cdc88 | 228 | Relobj* object_; |
07a60597 ILT |
229 | union |
230 | { | |
231 | // These fields are used if the FDE is from an input object (the | |
232 | // object_ field is not NULL). | |
233 | struct | |
234 | { | |
235 | // Input section index for this FDE. | |
236 | unsigned int shndx; | |
237 | // Offset within the input section for this FDE. | |
238 | section_offset_type input_offset; | |
239 | } from_object; | |
240 | // This field is used if the FDE is generated by the linker (the | |
241 | // object_ field is NULL). | |
242 | struct | |
243 | { | |
244 | // The only linker generated FDEs are for PLT sections, and this | |
245 | // points to the PLT section. | |
246 | Output_data* plt; | |
9d5781f8 AM |
247 | // Set if the FDE was added after merge mapping. |
248 | bool post_map; | |
07a60597 ILT |
249 | } from_linker; |
250 | } u_; | |
730cdc88 ILT |
251 | // FDE data. |
252 | std::string contents_; | |
253 | }; | |
254 | ||
4bead2d5 | 255 | // A FDE plus some info from a CIE to allow later writing of the FDE. |
9d5781f8 | 256 | |
4bead2d5 AM |
257 | struct Post_fde |
258 | { | |
259 | Post_fde(Fde* f, section_offset_type cie_off, unsigned char encoding) | |
260 | : fde(f), cie_offset(cie_off), fde_encoding(encoding) | |
261 | { } | |
262 | ||
263 | Fde* fde; | |
264 | section_offset_type cie_offset; | |
265 | unsigned char fde_encoding; | |
266 | }; | |
267 | ||
268 | typedef std::vector<Post_fde> Post_fdes; | |
9d5781f8 | 269 | |
730cdc88 ILT |
270 | // This class holds a CIE. |
271 | ||
272 | class Cie | |
273 | { | |
274 | public: | |
8383303e | 275 | Cie(Relobj* object, unsigned int shndx, section_offset_type input_offset, |
730cdc88 ILT |
276 | unsigned char fde_encoding, const char* personality_name, |
277 | const unsigned char* contents, size_t length) | |
278 | : object_(object), | |
279 | shndx_(shndx), | |
280 | input_offset_(input_offset), | |
281 | fde_encoding_(fde_encoding), | |
282 | personality_name_(personality_name), | |
283 | fdes_(), | |
284 | contents_(reinterpret_cast<const char*>(contents), length) | |
285 | { } | |
286 | ||
287 | ~Cie(); | |
288 | ||
289 | // We permit copying a CIE when there are no FDEs. This is | |
290 | // convenient in the code which creates them. | |
291 | Cie(const Cie& cie) | |
292 | : object_(cie.object_), | |
293 | shndx_(cie.shndx_), | |
294 | input_offset_(cie.input_offset_), | |
295 | fde_encoding_(cie.fde_encoding_), | |
296 | personality_name_(cie.personality_name_), | |
297 | fdes_(), | |
298 | contents_(cie.contents_) | |
299 | { gold_assert(cie.fdes_.empty()); } | |
300 | ||
301 | // Add an FDE associated with this CIE. | |
302 | void | |
303 | add_fde(Fde* fde) | |
304 | { this->fdes_.push_back(fde); } | |
305 | ||
220f9906 | 306 | // Remove the last FDE associated with this CIE. |
be897fb7 | 307 | void |
220f9906 AM |
308 | remove_fde() |
309 | { this->fdes_.pop_back(); } | |
310 | ||
311 | // Access the last FDE associated with this CIE. | |
312 | const Fde* | |
313 | last_fde() const | |
314 | { return this->fdes_.back(); } | |
be897fb7 | 315 | |
730cdc88 ILT |
316 | // Return the number of FDEs. |
317 | unsigned int | |
318 | fde_count() const | |
319 | { return this->fdes_.size(); } | |
320 | ||
321 | // Set the output offset of this CIE to OUTPUT_OFFSET. It will be | |
322 | // followed by all its FDEs. ADDRALIGN is the required address | |
323 | // alignment, typically 4 or 8. This updates MERGE_MAP with the | |
324 | // mapping. It returns the new output offset. | |
8383303e ILT |
325 | section_offset_type |
326 | set_output_offset(section_offset_type output_offset, unsigned int addralign, | |
dbe40a88 | 327 | Output_section_data*); |
730cdc88 | 328 | |
9d5781f8 AM |
329 | // Write the CIE to OVIEW starting at OFFSET. Round up the bytes to |
330 | // ADDRALIGN. ADDRESS is the virtual address of OVIEW. | |
331 | // EH_FRAME_HDR is the exception frame header for FDE recording. | |
332 | // POST_FDES stashes FDEs created after mappings were done, for later | |
333 | // writing. Return the new offset. | |
730cdc88 | 334 | template<int size, bool big_endian> |
8383303e | 335 | section_offset_type |
9860cbcf CC |
336 | write(unsigned char* oview, section_offset_type output_section_offset, |
337 | section_offset_type offset, uint64_t address, | |
9d5781f8 AM |
338 | unsigned int addralign, Eh_frame_hdr* eh_frame_hdr, |
339 | Post_fdes* post_fdes); | |
730cdc88 | 340 | |
fc5a9bd5 CC |
341 | // Return the FDE encoding. |
342 | unsigned char | |
343 | fde_encoding() const | |
344 | { return this->fde_encoding_; } | |
345 | ||
730cdc88 ILT |
346 | friend bool operator<(const Cie&, const Cie&); |
347 | friend bool operator==(const Cie&, const Cie&); | |
348 | ||
349 | private: | |
350 | // The class is not assignable. | |
351 | Cie& operator=(const Cie&); | |
352 | ||
07a60597 ILT |
353 | // The object in which this CIE was first seen. This will be NULL |
354 | // for a linker generated CIE. | |
730cdc88 | 355 | Relobj* object_; |
07a60597 ILT |
356 | // Input section index for this CIE. This will be 0 for a linker |
357 | // generated CIE. | |
730cdc88 | 358 | unsigned int shndx_; |
07a60597 ILT |
359 | // Offset within the input section for this CIE. This will be 0 for |
360 | // a linker generated CIE. | |
8383303e | 361 | section_offset_type input_offset_; |
730cdc88 ILT |
362 | // The encoding of the FDE. This is a DW_EH_PE code. |
363 | unsigned char fde_encoding_; | |
364 | // The name of the personality routine. This will be the name of a | |
365 | // global symbol, or will be the empty string. | |
366 | std::string personality_name_; | |
367 | // List of FDEs. | |
368 | std::vector<Fde*> fdes_; | |
369 | // CIE data. | |
370 | std::string contents_; | |
371 | }; | |
372 | ||
373 | extern bool operator<(const Cie&, const Cie&); | |
374 | extern bool operator==(const Cie&, const Cie&); | |
375 | ||
376 | // This class manages .eh_frame sections. It discards duplicate | |
377 | // exception information. | |
378 | ||
379 | class Eh_frame : public Output_section_data | |
380 | { | |
381 | public: | |
e1663197 CC |
382 | enum Eh_frame_section_disposition |
383 | { | |
384 | EH_EMPTY_SECTION, | |
385 | EH_UNRECOGNIZED_SECTION, | |
386 | EH_OPTIMIZABLE_SECTION, | |
387 | EH_END_MARKER_SECTION | |
388 | }; | |
389 | ||
730cdc88 ILT |
390 | Eh_frame(); |
391 | ||
392 | // Record the associated Eh_frame_hdr, if any. | |
393 | void | |
394 | set_eh_frame_hdr(Eh_frame_hdr* hdr) | |
395 | { this->eh_frame_hdr_ = hdr; } | |
396 | ||
397 | // Add the input section SHNDX in OBJECT. SYMBOLS is the contents | |
398 | // of the symbol table section (size SYMBOLS_SIZE), SYMBOL_NAMES is | |
399 | // the symbol names section (size SYMBOL_NAMES_SIZE). RELOC_SHNDX | |
400 | // is the relocation section if any (0 for none, -1U for multiple). | |
401 | // RELOC_TYPE is the type of the relocation section if any. This | |
402 | // returns whether the section was incorporated into the .eh_frame | |
403 | // data. | |
404 | template<int size, bool big_endian> | |
e1663197 | 405 | Eh_frame_section_disposition |
6fa2a40b | 406 | add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object, |
730cdc88 | 407 | const unsigned char* symbols, |
8383303e | 408 | section_size_type symbols_size, |
730cdc88 | 409 | const unsigned char* symbol_names, |
8383303e | 410 | section_size_type symbol_names_size, |
730cdc88 ILT |
411 | unsigned int shndx, unsigned int reloc_shndx, |
412 | unsigned int reloc_type); | |
413 | ||
07a60597 ILT |
414 | // Add a CIE and an FDE for a PLT section, to permit unwinding |
415 | // through a PLT. The FDE data should start with 8 bytes of zero, | |
416 | // which will be replaced by a 4 byte PC relative reference to the | |
417 | // address of PLT and a 4 byte size of PLT. | |
418 | void | |
419 | add_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data, | |
420 | size_t cie_length, const unsigned char* fde_data, | |
421 | size_t fde_length); | |
422 | ||
220f9906 | 423 | // Remove all post-map unwind information for a PLT. |
be897fb7 AM |
424 | void |
425 | remove_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data, | |
220f9906 | 426 | size_t cie_length); |
be897fb7 | 427 | |
730cdc88 ILT |
428 | // Return the number of FDEs. |
429 | unsigned int | |
430 | fde_count() const; | |
431 | ||
7d9e3d98 | 432 | protected: |
730cdc88 ILT |
433 | // Set the final data size. |
434 | void | |
27bc2bce | 435 | set_final_data_size(); |
730cdc88 ILT |
436 | |
437 | // Return the output address for an input address. | |
438 | bool | |
8383303e ILT |
439 | do_output_offset(const Relobj*, unsigned int shndx, |
440 | section_offset_type offset, | |
441 | section_offset_type* poutput) const; | |
730cdc88 ILT |
442 | |
443 | // Write the data to the file. | |
444 | void | |
445 | do_write(Output_file*); | |
446 | ||
7d9e3d98 ILT |
447 | // Write to a map file. |
448 | void | |
449 | do_print_to_mapfile(Mapfile* mapfile) const | |
450 | { mapfile->print_output_data(this, _("** eh_frame")); } | |
451 | ||
730cdc88 ILT |
452 | private: |
453 | // The comparison routine for the CIE map. | |
454 | struct Cie_less | |
455 | { | |
456 | bool | |
457 | operator()(const Cie* cie1, const Cie* cie2) const | |
458 | { return *cie1 < *cie2; } | |
459 | }; | |
460 | ||
1cac254c ILT |
461 | // A set of unique CIEs. |
462 | typedef std::set<Cie*, Cie_less> Cie_offsets; | |
730cdc88 | 463 | |
1cac254c ILT |
464 | // A list of unmergeable CIEs. |
465 | typedef std::vector<Cie*> Unmergeable_cie_offsets; | |
730cdc88 ILT |
466 | |
467 | // A mapping from offsets to CIEs. This is used while reading an | |
468 | // input section. | |
469 | typedef std::map<uint64_t, Cie*> Offsets_to_cie; | |
470 | ||
471 | // A list of CIEs, and a bool indicating whether the CIE is | |
472 | // mergeable. | |
473 | typedef std::vector<std::pair<Cie*, bool> > New_cies; | |
474 | ||
475 | // Skip an LEB128. | |
476 | static bool | |
477 | skip_leb128(const unsigned char**, const unsigned char*); | |
478 | ||
479 | // The implementation of add_ehframe_input_section. | |
480 | template<int size, bool big_endian> | |
481 | bool | |
6fa2a40b | 482 | do_add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object, |
730cdc88 | 483 | const unsigned char* symbols, |
8383303e | 484 | section_size_type symbols_size, |
730cdc88 | 485 | const unsigned char* symbol_names, |
8383303e | 486 | section_size_type symbol_names_size, |
730cdc88 ILT |
487 | unsigned int shndx, |
488 | unsigned int reloc_shndx, | |
489 | unsigned int reloc_type, | |
490 | const unsigned char* pcontents, | |
8383303e | 491 | section_size_type contents_len, |
730cdc88 ILT |
492 | New_cies*); |
493 | ||
494 | // Read a CIE. | |
495 | template<int size, bool big_endian> | |
496 | bool | |
6fa2a40b | 497 | read_cie(Sized_relobj_file<size, big_endian>* object, |
730cdc88 ILT |
498 | unsigned int shndx, |
499 | const unsigned char* symbols, | |
8383303e | 500 | section_size_type symbols_size, |
730cdc88 | 501 | const unsigned char* symbol_names, |
8383303e | 502 | section_size_type symbol_names_size, |
730cdc88 ILT |
503 | const unsigned char* pcontents, |
504 | const unsigned char* pcie, | |
ca09d69a | 505 | const unsigned char* pcieend, |
730cdc88 ILT |
506 | Track_relocs<size, big_endian>* relocs, |
507 | Offsets_to_cie* cies, | |
508 | New_cies* new_cies); | |
509 | ||
510 | // Read an FDE. | |
511 | template<int size, bool big_endian> | |
512 | bool | |
6fa2a40b | 513 | read_fde(Sized_relobj_file<size, big_endian>* object, |
730cdc88 ILT |
514 | unsigned int shndx, |
515 | const unsigned char* symbols, | |
8383303e | 516 | section_size_type symbols_size, |
730cdc88 ILT |
517 | const unsigned char* pcontents, |
518 | unsigned int offset, | |
519 | const unsigned char* pfde, | |
ca09d69a | 520 | const unsigned char* pfdeend, |
730cdc88 ILT |
521 | Track_relocs<size, big_endian>* relocs, |
522 | Offsets_to_cie* cies); | |
523 | ||
524 | // Template version of write function. | |
525 | template<int size, bool big_endian> | |
526 | void | |
527 | do_sized_write(unsigned char* oview); | |
528 | ||
529 | // The exception frame header, if any. | |
530 | Eh_frame_hdr* eh_frame_hdr_; | |
531 | // A mapping from all unique CIEs to their offset in the output | |
532 | // file. | |
533 | Cie_offsets cie_offsets_; | |
534 | // A mapping from unmergeable CIEs to their offset in the output | |
535 | // file. | |
536 | Unmergeable_cie_offsets unmergeable_cie_offsets_; | |
1d6531cf ILT |
537 | // Whether we have created the mappings to the output section. |
538 | bool mappings_are_done_; | |
539 | // The final data size. This is only set if mappings_are_done_ is | |
540 | // true. | |
541 | section_size_type final_data_size_; | |
3151305a ILT |
542 | }; |
543 | ||
544 | } // End namespace gold. | |
545 | ||
546 | #endif // !defined(GOLD_EHFRAME_H) |