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