Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.22 / gold / ehframe.cc
1 // ehframe.cc -- handle exception frame sections for gold
2
3 // Copyright 2006, 2007, 2008, 2010, 2011 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 #include "gold.h"
24
25 #include <cstring>
26 #include <algorithm>
27
28 #include "elfcpp.h"
29 #include "dwarf.h"
30 #include "symtab.h"
31 #include "reloc.h"
32 #include "ehframe.h"
33
34 namespace gold
35 {
36
37 // This file handles generation of the exception frame header that
38 // gcc's runtime support libraries use to find unwind information at
39 // runtime.  This file also handles discarding duplicate exception
40 // frame information.
41
42 // The exception frame header starts with four bytes:
43
44 // 0: The version number, currently 1.
45
46 // 1: The encoding of the pointer to the exception frames.  This can
47 //    be any DWARF unwind encoding (DW_EH_PE_*).  It is normally a 4
48 //    byte PC relative offset (DW_EH_PE_pcrel | DW_EH_PE_sdata4).
49
50 // 2: The encoding of the count of the number of FDE pointers in the
51 //    lookup table.  This can be any DWARF unwind encoding, and in
52 //    particular can be DW_EH_PE_omit if the count is omitted.  It is
53 //    normally a 4 byte unsigned count (DW_EH_PE_udata4).
54
55 // 3: The encoding of the lookup table entries.  Currently gcc's
56 //    libraries will only support DW_EH_PE_datarel | DW_EH_PE_sdata4,
57 //    which means that the values are 4 byte offsets from the start of
58 //    the table.
59
60 // The exception frame header is followed by a pointer to the contents
61 // of the exception frame section (.eh_frame).  This pointer is
62 // encoded as specified in the byte at offset 1 of the header (i.e.,
63 // it is normally a 4 byte PC relative offset).
64
65 // If there is a lookup table, this is followed by the count of the
66 // number of FDE pointers, encoded as specified in the byte at offset
67 // 2 of the header (i.e., normally a 4 byte unsigned integer).
68
69 // This is followed by the table, which should start at an 4-byte
70 // aligned address in memory.  Each entry in the table is 8 bytes.
71 // Each entry represents an FDE.  The first four bytes of each entry
72 // are an offset to the starting PC for the FDE.  The last four bytes
73 // of each entry are an offset to the FDE data.  The offsets are from
74 // the start of the exception frame header information.  The entries
75 // are in sorted order by starting PC.
76
77 const int eh_frame_hdr_size = 4;
78
79 // Construct the exception frame header.
80
81 Eh_frame_hdr::Eh_frame_hdr(Output_section* eh_frame_section,
82                            const Eh_frame* eh_frame_data)
83   : Output_section_data(4),
84     eh_frame_section_(eh_frame_section),
85     eh_frame_data_(eh_frame_data),
86     fde_offsets_(),
87     any_unrecognized_eh_frame_sections_(false)
88 {
89 }
90
91 // Set the size of the exception frame header.
92
93 void
94 Eh_frame_hdr::set_final_data_size()
95 {
96   unsigned int data_size = eh_frame_hdr_size + 4;
97   if (!this->any_unrecognized_eh_frame_sections_)
98     {
99       unsigned int fde_count = this->eh_frame_data_->fde_count();
100       if (fde_count != 0)
101         data_size += 4 + 8 * fde_count;
102       this->fde_offsets_.reserve(fde_count);
103     }
104   this->set_data_size(data_size);
105 }
106
107 // Write the data to the file.
108
109 void
110 Eh_frame_hdr::do_write(Output_file* of)
111 {
112   switch (parameters->size_and_endianness())
113     {
114 #ifdef HAVE_TARGET_32_LITTLE
115     case Parameters::TARGET_32_LITTLE:
116       this->do_sized_write<32, false>(of);
117       break;
118 #endif
119 #ifdef HAVE_TARGET_32_BIG
120     case Parameters::TARGET_32_BIG:
121       this->do_sized_write<32, true>(of);
122       break;
123 #endif
124 #ifdef HAVE_TARGET_64_LITTLE
125     case Parameters::TARGET_64_LITTLE:
126       this->do_sized_write<64, false>(of);
127       break;
128 #endif
129 #ifdef HAVE_TARGET_64_BIG
130     case Parameters::TARGET_64_BIG:
131       this->do_sized_write<64, true>(of);
132       break;
133 #endif
134     default:
135       gold_unreachable();
136     }
137 }
138
139 // Write the data to the file with the right endianness.
140
141 template<int size, bool big_endian>
142 void
143 Eh_frame_hdr::do_sized_write(Output_file* of)
144 {
145   const off_t off = this->offset();
146   const off_t oview_size = this->data_size();
147   unsigned char* const oview = of->get_output_view(off, oview_size);
148
149   // Version number.
150   oview[0] = 1;
151
152   // Write out a 4 byte PC relative offset to the address of the
153   // .eh_frame section.
154   oview[1] = elfcpp::DW_EH_PE_pcrel | elfcpp::DW_EH_PE_sdata4;
155   uint64_t eh_frame_address = this->eh_frame_section_->address();
156   uint64_t eh_frame_hdr_address = this->address();
157   uint64_t eh_frame_offset = (eh_frame_address -
158                               (eh_frame_hdr_address + 4));
159   elfcpp::Swap<32, big_endian>::writeval(oview + 4, eh_frame_offset);
160
161   if (this->any_unrecognized_eh_frame_sections_
162       || this->fde_offsets_.empty())
163     {
164       // There are no FDEs, or we didn't recognize the format of the
165       // some of the .eh_frame sections, so we can't write out the
166       // sorted table.
167       oview[2] = elfcpp::DW_EH_PE_omit;
168       oview[3] = elfcpp::DW_EH_PE_omit;
169
170       gold_assert(oview_size == 8);
171     }
172   else
173     {
174       oview[2] = elfcpp::DW_EH_PE_udata4;
175       oview[3] = elfcpp::DW_EH_PE_datarel | elfcpp::DW_EH_PE_sdata4;
176
177       elfcpp::Swap<32, big_endian>::writeval(oview + 8,
178                                              this->fde_offsets_.size());
179
180       // We have the offsets of the FDEs in the .eh_frame section.  We
181       // couldn't easily get the PC values before, as they depend on
182       // relocations which are, of course, target specific.  This code
183       // is run after all those relocations have been applied to the
184       // output file.  Here we read the output file again to find the
185       // PC values.  Then we sort the list and write it out.
186
187       Fde_addresses<size> fde_addresses(this->fde_offsets_.size());
188       this->get_fde_addresses<size, big_endian>(of, &this->fde_offsets_,
189                                                 &fde_addresses);
190
191       std::sort(fde_addresses.begin(), fde_addresses.end(),
192                 Fde_address_compare<size>());
193
194       typename elfcpp::Elf_types<size>::Elf_Addr output_address;
195       output_address = this->address();
196
197       unsigned char* pfde = oview + 12;
198       for (typename Fde_addresses<size>::iterator p = fde_addresses.begin();
199            p != fde_addresses.end();
200            ++p)
201         {
202           elfcpp::Swap<32, big_endian>::writeval(pfde,
203                                                  p->first - output_address);
204           elfcpp::Swap<32, big_endian>::writeval(pfde + 4,
205                                                  p->second - output_address);
206           pfde += 8;
207         }
208
209       gold_assert(pfde - oview == oview_size);
210     }
211
212   of->write_output_view(off, oview_size, oview);
213 }
214
215 // Given the offset FDE_OFFSET of an FDE in the .eh_frame section, and
216 // the contents of the .eh_frame section EH_FRAME_CONTENTS, where the
217 // FDE's encoding is FDE_ENCODING, return the output address of the
218 // FDE's PC.
219
220 template<int size, bool big_endian>
221 typename elfcpp::Elf_types<size>::Elf_Addr
222 Eh_frame_hdr::get_fde_pc(
223     typename elfcpp::Elf_types<size>::Elf_Addr eh_frame_address,
224     const unsigned char* eh_frame_contents,
225     section_offset_type fde_offset,
226     unsigned char fde_encoding)
227 {
228   // The FDE starts with a 4 byte length and a 4 byte offset to the
229   // CIE.  The PC follows.
230   const unsigned char* p = eh_frame_contents + fde_offset + 8;
231
232   typename elfcpp::Elf_types<size>::Elf_Addr pc;
233   bool is_signed = (fde_encoding & elfcpp::DW_EH_PE_signed) != 0;
234   int pc_size = fde_encoding & 7;
235   if (pc_size == elfcpp::DW_EH_PE_absptr)
236     {
237       if (size == 32)
238         pc_size = elfcpp::DW_EH_PE_udata4;
239       else if (size == 64)
240         pc_size = elfcpp::DW_EH_PE_udata8;
241       else
242         gold_unreachable();
243     }
244
245   switch (pc_size)
246     {
247     case elfcpp::DW_EH_PE_udata2:
248       pc = elfcpp::Swap<16, big_endian>::readval(p);
249       if (is_signed)
250         pc = (pc ^ 0x8000) - 0x8000;
251       break;
252
253     case elfcpp::DW_EH_PE_udata4:
254       pc = elfcpp::Swap<32, big_endian>::readval(p);
255       if (size > 32 && is_signed)
256         pc = (pc ^ 0x80000000) - 0x80000000;
257       break;
258
259     case elfcpp::DW_EH_PE_udata8:
260       gold_assert(size == 64);
261       pc = elfcpp::Swap_unaligned<64, big_endian>::readval(p);
262       break;
263
264     default:
265       // All other cases were rejected in Eh_frame::read_cie.
266       gold_unreachable();
267     }
268
269   switch (fde_encoding & 0x70)
270     {
271     case 0:
272       break;
273
274     case elfcpp::DW_EH_PE_pcrel:
275       pc += eh_frame_address + fde_offset + 8;
276       break;
277
278     case elfcpp::DW_EH_PE_datarel:
279       pc += parameters->target().ehframe_datarel_base();
280       break;
281
282     default:
283       // If other cases arise, then we have to handle them, or we have
284       // to reject them by returning false in Eh_frame::read_cie.
285       gold_unreachable();
286     }
287
288   gold_assert((fde_encoding & elfcpp::DW_EH_PE_indirect) == 0);
289
290   return pc;
291 }
292
293 // Given an array of FDE offsets in the .eh_frame section, return an
294 // array of offsets from the exception frame header to the FDE's
295 // output PC and to the output address of the FDE itself.  We get the
296 // FDE's PC by actually looking in the .eh_frame section we just wrote
297 // to the output file.
298
299 template<int size, bool big_endian>
300 void
301 Eh_frame_hdr::get_fde_addresses(Output_file* of,
302                                 const Fde_offsets* fde_offsets,
303                                 Fde_addresses<size>* fde_addresses)
304 {
305   typename elfcpp::Elf_types<size>::Elf_Addr eh_frame_address;
306   eh_frame_address = this->eh_frame_section_->address();
307   off_t eh_frame_offset = this->eh_frame_section_->offset();
308   off_t eh_frame_size = this->eh_frame_section_->data_size();
309   const unsigned char* eh_frame_contents = of->get_input_view(eh_frame_offset,
310                                                               eh_frame_size);
311
312   for (Fde_offsets::const_iterator p = fde_offsets->begin();
313        p != fde_offsets->end();
314        ++p)
315     {
316       typename elfcpp::Elf_types<size>::Elf_Addr fde_pc;
317       fde_pc = this->get_fde_pc<size, big_endian>(eh_frame_address,
318                                                   eh_frame_contents,
319                                                   p->first, p->second);
320       fde_addresses->push_back(fde_pc, eh_frame_address + p->first);
321     }
322
323   of->free_input_view(eh_frame_offset, eh_frame_size, eh_frame_contents);
324 }
325
326 // Class Fde.
327
328 // Write the FDE to OVIEW starting at OFFSET.  CIE_OFFSET is the
329 // offset of the CIE in OVIEW.  FDE_ENCODING is the encoding, from the
330 // CIE.  ADDRALIGN is the required alignment.  ADDRESS is the virtual
331 // address of OVIEW.  Record the FDE pc for EH_FRAME_HDR.  Return the
332 // new offset.
333
334 template<int size, bool big_endian>
335 section_offset_type
336 Fde::write(unsigned char* oview, section_offset_type offset,
337            uint64_t address, unsigned int addralign,
338            section_offset_type cie_offset, unsigned char fde_encoding,
339            Eh_frame_hdr* eh_frame_hdr)
340 {
341   gold_assert((offset & (addralign - 1)) == 0);
342
343   size_t length = this->contents_.length();
344
345   // We add 8 when getting the aligned length to account for the
346   // length word and the CIE offset.
347   size_t aligned_full_length = align_address(length + 8, addralign);
348
349   // Write the length of the FDE as a 32-bit word.  The length word
350   // does not include the four bytes of the length word itself, but it
351   // does include the offset to the CIE.
352   elfcpp::Swap<32, big_endian>::writeval(oview + offset,
353                                          aligned_full_length - 4);
354
355   // Write the offset to the CIE as a 32-bit word.  This is the
356   // difference between the address of the offset word itself and the
357   // CIE address.
358   elfcpp::Swap<32, big_endian>::writeval(oview + offset + 4,
359                                          offset + 4 - cie_offset);
360
361   // Copy the rest of the FDE.  Note that this is run before
362   // relocation processing is done on this section, so the relocations
363   // will later be applied to the FDE data.
364   memcpy(oview + offset + 8, this->contents_.data(), length);
365
366   // If this FDE is associated with a PLT, fill in the PLT's address
367   // and size.
368   if (this->object_ == NULL)
369     {
370       gold_assert(memcmp(oview + offset + 8, "\0\0\0\0\0\0\0\0", 8) == 0);
371       Output_data* plt = this->u_.from_linker.plt;
372       uint64_t poffset = plt->address() - (address + offset + 8);
373       int32_t spoffset = static_cast<int32_t>(poffset);
374       off_t psize = plt->data_size();
375       uint32_t upsize = static_cast<uint32_t>(psize);
376       if (static_cast<uint64_t>(static_cast<int64_t>(spoffset)) != poffset
377           || static_cast<off_t>(upsize) != psize)
378         gold_warning(_("overflow in PLT unwind data; "
379                        "unwinding through PLT may fail"));
380       elfcpp::Swap<32, big_endian>::writeval(oview + offset + 8, spoffset);
381       elfcpp::Swap<32, big_endian>::writeval(oview + offset + 12, upsize);
382     }
383
384   if (aligned_full_length > length + 8)
385     memset(oview + offset + length + 8, 0, aligned_full_length - (length + 8));
386
387   // Tell the exception frame header about this FDE.
388   if (eh_frame_hdr != NULL)
389     eh_frame_hdr->record_fde(offset, fde_encoding);
390
391   return offset + aligned_full_length;
392 }
393
394 // Class Cie.
395
396 // Destructor.
397
398 Cie::~Cie()
399 {
400   for (std::vector<Fde*>::iterator p = this->fdes_.begin();
401        p != this->fdes_.end();
402        ++p)
403     delete *p;
404 }
405
406 // Set the output offset of a CIE.  Return the new output offset.
407
408 section_offset_type
409 Cie::set_output_offset(section_offset_type output_offset,
410                        unsigned int addralign,
411                        Merge_map* merge_map)
412 {
413   size_t length = this->contents_.length();
414
415   // Add 4 for length and 4 for zero CIE identifier tag.
416   length += 8;
417
418   if (this->object_ != NULL)
419     {
420       // Add a mapping so that relocations are applied correctly.
421       merge_map->add_mapping(this->object_, this->shndx_, this->input_offset_,
422                              length, output_offset);
423     }
424
425   length = align_address(length, addralign);
426
427   for (std::vector<Fde*>::const_iterator p = this->fdes_.begin();
428        p != this->fdes_.end();
429        ++p)
430     {
431       (*p)->add_mapping(output_offset + length, merge_map);
432
433       size_t fde_length = (*p)->length();
434       fde_length = align_address(fde_length, addralign);
435       length += fde_length;
436     }
437
438   return output_offset + length;
439 }
440
441 // Write the CIE to OVIEW starting at OFFSET.  EH_FRAME_HDR is for FDE
442 // recording.  Round up the bytes to ADDRALIGN.  Return the new
443 // offset.
444
445 template<int size, bool big_endian>
446 section_offset_type
447 Cie::write(unsigned char* oview, section_offset_type offset,
448            uint64_t address, unsigned int addralign,
449            Eh_frame_hdr* eh_frame_hdr)
450 {
451   gold_assert((offset & (addralign - 1)) == 0);
452
453   section_offset_type cie_offset = offset;
454
455   size_t length = this->contents_.length();
456
457   // We add 8 when getting the aligned length to account for the
458   // length word and the CIE tag.
459   size_t aligned_full_length = align_address(length + 8, addralign);
460
461   // Write the length of the CIE as a 32-bit word.  The length word
462   // does not include the four bytes of the length word itself.
463   elfcpp::Swap<32, big_endian>::writeval(oview + offset,
464                                          aligned_full_length - 4);
465
466   // Write the tag which marks this as a CIE: a 32-bit zero.
467   elfcpp::Swap<32, big_endian>::writeval(oview + offset + 4, 0);
468
469   // Write out the CIE data.
470   memcpy(oview + offset + 8, this->contents_.data(), length);
471
472   if (aligned_full_length > length + 8)
473     memset(oview + offset + length + 8, 0, aligned_full_length - (length + 8));
474
475   offset += aligned_full_length;
476
477   // Write out the associated FDEs.
478   unsigned char fde_encoding = this->fde_encoding_;
479   for (std::vector<Fde*>::const_iterator p = this->fdes_.begin();
480        p != this->fdes_.end();
481        ++p)
482     offset = (*p)->write<size, big_endian>(oview, offset, address, addralign,
483                                            cie_offset, fde_encoding,
484                                            eh_frame_hdr);
485
486   return offset;
487 }
488
489 // We track all the CIEs we see, and merge them when possible.  This
490 // works because each FDE holds an offset to the relevant CIE: we
491 // rewrite the FDEs to point to the merged CIE.  This is worthwhile
492 // because in a typical C++ program many FDEs in many different object
493 // files will use the same CIE.
494
495 // An equality operator for Cie.
496
497 bool
498 operator==(const Cie& cie1, const Cie& cie2)
499 {
500   return (cie1.personality_name_ == cie2.personality_name_
501           && cie1.contents_ == cie2.contents_);
502 }
503
504 // A less-than operator for Cie.
505
506 bool
507 operator<(const Cie& cie1, const Cie& cie2)
508 {
509   if (cie1.personality_name_ != cie2.personality_name_)
510     return cie1.personality_name_ < cie2.personality_name_;
511   return cie1.contents_ < cie2.contents_;
512 }
513
514 // Class Eh_frame.
515
516 Eh_frame::Eh_frame()
517   : Output_section_data(Output_data::default_alignment()),
518     eh_frame_hdr_(NULL),
519     cie_offsets_(),
520     unmergeable_cie_offsets_(),
521     merge_map_(),
522     mappings_are_done_(false),
523     final_data_size_(0)
524 {
525 }
526
527 // Skip an LEB128, updating *PP to point to the next character.
528 // Return false if we ran off the end of the string.
529
530 bool
531 Eh_frame::skip_leb128(const unsigned char** pp, const unsigned char* pend)
532 {
533   const unsigned char* p;
534   for (p = *pp; p < pend; ++p)
535     {
536       if ((*p & 0x80) == 0)
537         {
538           *pp = p + 1;
539           return true;
540         }
541     }
542   return false;
543 }
544
545 // Add input section SHNDX in OBJECT to an exception frame section.
546 // SYMBOLS is the contents of the symbol table section (size
547 // SYMBOLS_SIZE), SYMBOL_NAMES is the symbol names section (size
548 // SYMBOL_NAMES_SIZE).  RELOC_SHNDX is the index of a relocation
549 // section applying to SHNDX, or 0 if none, or -1U if more than one.
550 // RELOC_TYPE is the type of the reloc section if there is one, either
551 // SHT_REL or SHT_RELA.  We try to parse the input exception frame
552 // data into our data structures.  If we can't do it, we return false
553 // to mean that the section should be handled as a normal input
554 // section.
555
556 template<int size, bool big_endian>
557 bool
558 Eh_frame::add_ehframe_input_section(
559     Sized_relobj_file<size, big_endian>* object,
560     const unsigned char* symbols,
561     section_size_type symbols_size,
562     const unsigned char* symbol_names,
563     section_size_type symbol_names_size,
564     unsigned int shndx,
565     unsigned int reloc_shndx,
566     unsigned int reloc_type)
567 {
568   // Get the section contents.
569   section_size_type contents_len;
570   const unsigned char* pcontents = object->section_contents(shndx,
571                                                             &contents_len,
572                                                             false);
573   if (contents_len == 0)
574     return false;
575
576   // If this is the marker section for the end of the data, then
577   // return false to force it to be handled as an ordinary input
578   // section.  If we don't do this, we won't correctly handle the case
579   // of unrecognized .eh_frame sections.
580   if (contents_len == 4
581       && elfcpp::Swap<32, big_endian>::readval(pcontents) == 0)
582     return false;
583
584   New_cies new_cies;
585   if (!this->do_add_ehframe_input_section(object, symbols, symbols_size,
586                                           symbol_names, symbol_names_size,
587                                           shndx, reloc_shndx,
588                                           reloc_type, pcontents,
589                                           contents_len, &new_cies))
590     {
591       if (this->eh_frame_hdr_ != NULL)
592         this->eh_frame_hdr_->found_unrecognized_eh_frame_section();
593
594       for (New_cies::iterator p = new_cies.begin();
595            p != new_cies.end();
596            ++p)
597         delete p->first;
598
599       return false;
600     }
601
602   // Now that we know we are using this section, record any new CIEs
603   // that we found.
604   for (New_cies::const_iterator p = new_cies.begin();
605        p != new_cies.end();
606        ++p)
607     {
608       if (p->second)
609         this->cie_offsets_.insert(p->first);
610       else
611         this->unmergeable_cie_offsets_.push_back(p->first);
612     }
613
614   return true;
615 }
616
617 // The bulk of the implementation of add_ehframe_input_section.
618
619 template<int size, bool big_endian>
620 bool
621 Eh_frame::do_add_ehframe_input_section(
622     Sized_relobj_file<size, big_endian>* object,
623     const unsigned char* symbols,
624     section_size_type symbols_size,
625     const unsigned char* symbol_names,
626     section_size_type symbol_names_size,
627     unsigned int shndx,
628     unsigned int reloc_shndx,
629     unsigned int reloc_type,
630     const unsigned char* pcontents,
631     section_size_type contents_len,
632     New_cies* new_cies)
633 {
634   typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
635   Track_relocs<size, big_endian> relocs;
636
637   const unsigned char* p = pcontents;
638   const unsigned char* pend = p + contents_len;
639
640   // Get the contents of the reloc section if any.
641   if (!relocs.initialize(object, reloc_shndx, reloc_type))
642     return false;
643
644   // Keep track of which CIEs are at which offsets.
645   Offsets_to_cie cies;
646
647   while (p < pend)
648     {
649       if (pend - p < 4)
650         return false;
651
652       // There shouldn't be any relocations here.
653       if (relocs.advance(p + 4 - pcontents) > 0)
654         return false;
655
656       unsigned int len = elfcpp::Swap<32, big_endian>::readval(p);
657       p += 4;
658       if (len == 0)
659         {
660           // We should only find a zero-length entry at the end of the
661           // section.
662           if (p < pend)
663             return false;
664           break;
665         }
666       // We don't support a 64-bit .eh_frame.
667       if (len == 0xffffffff)
668         return false;
669       if (static_cast<unsigned int>(pend - p) < len)
670         return false;
671
672       const unsigned char* const pentend = p + len;
673
674       if (pend - p < 4)
675         return false;
676       if (relocs.advance(p + 4 - pcontents) > 0)
677         return false;
678
679       unsigned int id = elfcpp::Swap<32, big_endian>::readval(p);
680       p += 4;
681
682       if (id == 0)
683         {
684           // CIE.
685           if (!this->read_cie(object, shndx, symbols, symbols_size,
686                               symbol_names, symbol_names_size,
687                               pcontents, p, pentend, &relocs, &cies,
688                               new_cies))
689             return false;
690         }
691       else
692         {
693           // FDE.
694           if (!this->read_fde(object, shndx, symbols, symbols_size,
695                               pcontents, id, p, pentend, &relocs, &cies))
696             return false;
697         }
698
699       p = pentend;
700     }
701
702   return true;
703 }
704
705 // Read a CIE.  Return false if we can't parse the information.
706
707 template<int size, bool big_endian>
708 bool
709 Eh_frame::read_cie(Sized_relobj_file<size, big_endian>* object,
710                    unsigned int shndx,
711                    const unsigned char* symbols,
712                    section_size_type symbols_size,
713                    const unsigned char* symbol_names,
714                    section_size_type symbol_names_size,
715                    const unsigned char* pcontents,
716                    const unsigned char* pcie,
717                    const unsigned char* pcieend,
718                    Track_relocs<size, big_endian>* relocs,
719                    Offsets_to_cie* cies,
720                    New_cies* new_cies)
721 {
722   bool mergeable = true;
723
724   // We need to find the personality routine if there is one, since we
725   // can only merge CIEs which use the same routine.  We also need to
726   // find the FDE encoding if there is one, so that we can read the PC
727   // from the FDE.
728
729   const unsigned char* p = pcie;
730
731   if (pcieend - p < 1)
732     return false;
733   unsigned char version = *p++;
734   if (version != 1 && version != 3)
735     return false;
736
737   const unsigned char* paug = p;
738   const void* paugendv = memchr(p, '\0', pcieend - p);
739   const unsigned char* paugend = static_cast<const unsigned char*>(paugendv);
740   if (paugend == NULL)
741     return false;
742   p = paugend + 1;
743
744   if (paug[0] == 'e' && paug[1] == 'h')
745     {
746       // This is a CIE from gcc before version 3.0.  We can't merge
747       // these.  We can still read the FDEs.
748       mergeable = false;
749       paug += 2;
750       if (*paug != '\0')
751         return false;
752       if (pcieend - p < size / 8)
753         return false;
754       p += size / 8;
755     }
756
757   // Skip the code alignment.
758   if (!skip_leb128(&p, pcieend))
759     return false;
760
761   // Skip the data alignment.
762   if (!skip_leb128(&p, pcieend))
763     return false;
764
765   // Skip the return column.
766   if (version == 1)
767     {
768       if (pcieend - p < 1)
769         return false;
770       ++p;
771     }
772   else
773     {
774       if (!skip_leb128(&p, pcieend))
775         return false;
776     }
777
778   if (*paug == 'z')
779     {
780       ++paug;
781       // Skip the augmentation size.
782       if (!skip_leb128(&p, pcieend))
783         return false;
784     }
785
786   unsigned char fde_encoding = elfcpp::DW_EH_PE_absptr;
787   int per_offset = -1;
788   while (*paug != '\0')
789     {
790       switch (*paug)
791         {
792         case 'L': // LSDA encoding.
793           if (pcieend - p < 1)
794             return false;
795           ++p;
796           break;
797
798         case 'R': // FDE encoding.
799           if (pcieend - p < 1)
800             return false;
801           fde_encoding = *p;
802           switch (fde_encoding & 7)
803             {
804             case elfcpp::DW_EH_PE_absptr:
805             case elfcpp::DW_EH_PE_udata2:
806             case elfcpp::DW_EH_PE_udata4:
807             case elfcpp::DW_EH_PE_udata8:
808               break;
809             default:
810               // We don't expect to see any other cases here, and
811               // we're not prepared to handle them.
812               return false;
813             }
814           ++p;
815           break;
816
817         case 'S':
818           break;
819
820         case 'P':
821           // Personality encoding.
822           {
823             if (pcieend - p < 1)
824               return false;
825             unsigned char per_encoding = *p;
826             ++p;
827
828             if ((per_encoding & 0x60) == 0x60)
829               return false;
830             unsigned int per_width;
831             switch (per_encoding & 7)
832               {
833               case elfcpp::DW_EH_PE_udata2:
834                 per_width = 2;
835                 break;
836               case elfcpp::DW_EH_PE_udata4:
837                 per_width = 4;
838                 break;
839               case elfcpp::DW_EH_PE_udata8:
840                 per_width = 8;
841                 break;
842               case elfcpp::DW_EH_PE_absptr:
843                 per_width = size / 8;
844                 break;
845               default:
846                 return false;
847               }
848
849             if ((per_encoding & 0xf0) == elfcpp::DW_EH_PE_aligned)
850               {
851                 unsigned int len = p - pcie;
852                 len += per_width - 1;
853                 len &= ~ (per_width - 1);
854                 if (static_cast<unsigned int>(pcieend - p) < len)
855                   return false;
856                 p += len;
857               }
858
859             per_offset = p - pcontents;
860
861             if (static_cast<unsigned int>(pcieend - p) < per_width)
862               return false;
863             p += per_width;
864           }
865           break;
866
867         default:
868           return false;
869         }
870
871       ++paug;
872     }
873
874   const char* personality_name = "";
875   if (per_offset != -1)
876     {
877       if (relocs->advance(per_offset) > 0)
878         return false;
879       if (relocs->next_offset() != per_offset)
880         return false;
881
882       unsigned int personality_symndx = relocs->next_symndx();
883       if (personality_symndx == -1U)
884         return false;
885
886       if (personality_symndx < object->local_symbol_count())
887         {
888           // We can only merge this CIE if the personality routine is
889           // a global symbol.  We can still read the FDEs.
890           mergeable = false;
891         }
892       else
893         {
894           const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
895           if (personality_symndx >= symbols_size / sym_size)
896             return false;
897           elfcpp::Sym<size, big_endian> sym(symbols
898                                             + (personality_symndx * sym_size));
899           unsigned int name_offset = sym.get_st_name();
900           if (name_offset >= symbol_names_size)
901             return false;
902           personality_name = (reinterpret_cast<const char*>(symbol_names)
903                               + name_offset);
904         }
905
906       int r = relocs->advance(per_offset + 1);
907       gold_assert(r == 1);
908     }
909
910   if (relocs->advance(pcieend - pcontents) > 0)
911     return false;
912
913   Cie cie(object, shndx, (pcie - 8) - pcontents, fde_encoding, 
914           personality_name, pcie, pcieend - pcie);
915   Cie* cie_pointer = NULL;
916   if (mergeable)
917     {
918       Cie_offsets::iterator find_cie = this->cie_offsets_.find(&cie);
919       if (find_cie != this->cie_offsets_.end())
920         cie_pointer = *find_cie;
921       else
922         {
923           // See if we already saw this CIE in this object file.
924           for (New_cies::const_iterator pc = new_cies->begin();
925                pc != new_cies->end();
926                ++pc)
927             {
928               if (*(pc->first) == cie)
929                 {
930                   cie_pointer = pc->first;
931                   break;
932                 }
933             }
934         }
935     }
936
937   if (cie_pointer == NULL)
938     {
939       cie_pointer = new Cie(cie);
940       new_cies->push_back(std::make_pair(cie_pointer, mergeable));
941     }
942   else
943     {
944       // We are deleting this CIE.  Record that in our mapping from
945       // input sections to the output section.  At this point we don't
946       // know for sure that we are doing a special mapping for this
947       // input section, but that's OK--if we don't do a special
948       // mapping, nobody will ever ask for the mapping we add here.
949       this->merge_map_.add_mapping(object, shndx, (pcie - 8) - pcontents,
950                                    pcieend - (pcie - 8), -1);
951     }
952
953   // Record this CIE plus the offset in the input section.
954   cies->insert(std::make_pair(pcie - pcontents, cie_pointer));
955
956   return true;
957 }
958
959 // Read an FDE.  Return false if we can't parse the information.
960
961 template<int size, bool big_endian>
962 bool
963 Eh_frame::read_fde(Sized_relobj_file<size, big_endian>* object,
964                    unsigned int shndx,
965                    const unsigned char* symbols,
966                    section_size_type symbols_size,
967                    const unsigned char* pcontents,
968                    unsigned int offset,
969                    const unsigned char* pfde,
970                    const unsigned char* pfdeend,
971                    Track_relocs<size, big_endian>* relocs,
972                    Offsets_to_cie* cies)
973 {
974   // OFFSET is the distance between the 4 bytes before PFDE to the
975   // start of the CIE.  The offset we recorded for the CIE is 8 bytes
976   // after the start of the CIE--after the length and the zero tag.
977   unsigned int cie_offset = (pfde - 4 - pcontents) - offset + 8;
978   Offsets_to_cie::const_iterator pcie = cies->find(cie_offset);
979   if (pcie == cies->end())
980     return false;
981   Cie* cie = pcie->second;
982
983   // The FDE should start with a reloc to the start of the code which
984   // it describes.
985   if (relocs->advance(pfde - pcontents) > 0)
986     return false;
987
988   if (relocs->next_offset() != pfde - pcontents)
989     return false;
990
991   unsigned int symndx = relocs->next_symndx();
992   if (symndx == -1U)
993     return false;
994
995   // There can be another reloc in the FDE, if the CIE specifies an
996   // LSDA (language specific data area).  We currently don't care.  We
997   // will care later if we want to optimize the LSDA from an absolute
998   // pointer to a PC relative offset when generating a shared library.
999   relocs->advance(pfdeend - pcontents);
1000
1001   unsigned int fde_shndx;
1002   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1003   if (symndx >= symbols_size / sym_size)
1004     return false;
1005   elfcpp::Sym<size, big_endian> sym(symbols + symndx * sym_size);
1006   bool is_ordinary;
1007   fde_shndx = object->adjust_sym_shndx(symndx, sym.get_st_shndx(),
1008                                        &is_ordinary);
1009
1010   if (is_ordinary
1011       && fde_shndx != elfcpp::SHN_UNDEF
1012       && fde_shndx < object->shnum()
1013       && !object->is_section_included(fde_shndx))
1014     {
1015       // This FDE applies to a section which we are discarding.  We
1016       // can discard this FDE.
1017       this->merge_map_.add_mapping(object, shndx, (pfde - 8) - pcontents,
1018                                    pfdeend - (pfde - 8), -1);
1019       return true;
1020     }
1021
1022   cie->add_fde(new Fde(object, shndx, (pfde - 8) - pcontents,
1023                        pfde, pfdeend - pfde));
1024
1025   return true;
1026 }
1027
1028 // Add unwind information for a PLT.
1029
1030 void
1031 Eh_frame::add_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data,
1032                               size_t cie_length, const unsigned char* fde_data,
1033                               size_t fde_length)
1034 {
1035   Cie cie(NULL, 0, 0, elfcpp::DW_EH_PE_pcrel | elfcpp::DW_EH_PE_sdata4, "",
1036           cie_data, cie_length);
1037   Cie_offsets::iterator find_cie = this->cie_offsets_.find(&cie);
1038   Cie* pcie;
1039   if (find_cie != this->cie_offsets_.end())
1040     pcie = *find_cie;
1041   else
1042     {
1043       pcie = new Cie(cie);
1044       this->cie_offsets_.insert(pcie);
1045     }
1046
1047   Fde* fde = new Fde(plt, fde_data, fde_length);
1048   pcie->add_fde(fde);
1049 }
1050
1051 // Return the number of FDEs.
1052
1053 unsigned int
1054 Eh_frame::fde_count() const
1055 {
1056   unsigned int ret = 0;
1057   for (Unmergeable_cie_offsets::const_iterator p =
1058          this->unmergeable_cie_offsets_.begin();
1059        p != this->unmergeable_cie_offsets_.end();
1060        ++p)
1061     ret += (*p)->fde_count();
1062   for (Cie_offsets::const_iterator p = this->cie_offsets_.begin();
1063        p != this->cie_offsets_.end();
1064        ++p)
1065     ret += (*p)->fde_count();
1066   return ret;
1067 }
1068
1069 // Set the final data size.
1070
1071 void
1072 Eh_frame::set_final_data_size()
1073 {
1074   // We can be called more than once if Layout::set_segment_offsets
1075   // finds a better mapping.  We don't want to add all the mappings
1076   // again.
1077   if (this->mappings_are_done_)
1078     {
1079       this->set_data_size(this->final_data_size_);
1080       return;
1081     }
1082
1083   section_offset_type output_offset = 0;
1084
1085   for (Unmergeable_cie_offsets::iterator p =
1086          this->unmergeable_cie_offsets_.begin();
1087        p != this->unmergeable_cie_offsets_.end();
1088        ++p)
1089     output_offset = (*p)->set_output_offset(output_offset,
1090                                             this->addralign(),
1091                                             &this->merge_map_);
1092
1093   for (Cie_offsets::iterator p = this->cie_offsets_.begin();
1094        p != this->cie_offsets_.end();
1095        ++p)
1096     output_offset = (*p)->set_output_offset(output_offset,
1097                                             this->addralign(),
1098                                             &this->merge_map_);
1099
1100   this->mappings_are_done_ = true;
1101   this->final_data_size_ = output_offset;
1102
1103   gold_assert((output_offset & (this->addralign() - 1)) == 0);
1104   this->set_data_size(output_offset);
1105 }
1106
1107 // Return an output offset for an input offset.
1108
1109 bool
1110 Eh_frame::do_output_offset(const Relobj* object, unsigned int shndx,
1111                            section_offset_type offset,
1112                            section_offset_type* poutput) const
1113 {
1114   return this->merge_map_.get_output_offset(object, shndx, offset, poutput);
1115 }
1116
1117 // Return whether this is the merge section for an input section.
1118
1119 bool
1120 Eh_frame::do_is_merge_section_for(const Relobj* object,
1121                                   unsigned int shndx) const
1122 {
1123   return this->merge_map_.is_merge_section_for(object, shndx);
1124 }
1125
1126 // Write the data to the output file.
1127
1128 void
1129 Eh_frame::do_write(Output_file* of)
1130 {
1131   const off_t offset = this->offset();
1132   const off_t oview_size = this->data_size();
1133   unsigned char* const oview = of->get_output_view(offset, oview_size);
1134
1135   switch (parameters->size_and_endianness())
1136     {
1137 #ifdef HAVE_TARGET_32_LITTLE
1138     case Parameters::TARGET_32_LITTLE:
1139       this->do_sized_write<32, false>(oview);
1140       break;
1141 #endif
1142 #ifdef HAVE_TARGET_32_BIG
1143     case Parameters::TARGET_32_BIG:
1144       this->do_sized_write<32, true>(oview);
1145       break;
1146 #endif
1147 #ifdef HAVE_TARGET_64_LITTLE
1148     case Parameters::TARGET_64_LITTLE:
1149       this->do_sized_write<64, false>(oview);
1150       break;
1151 #endif
1152 #ifdef HAVE_TARGET_64_BIG
1153     case Parameters::TARGET_64_BIG:
1154       this->do_sized_write<64, true>(oview);
1155       break;
1156 #endif
1157     default:
1158       gold_unreachable();
1159     }
1160
1161   of->write_output_view(offset, oview_size, oview);
1162 }
1163
1164 // Write the data to the output file--template version.
1165
1166 template<int size, bool big_endian>
1167 void
1168 Eh_frame::do_sized_write(unsigned char* oview)
1169 {
1170   uint64_t address = this->address();
1171   unsigned int addralign = this->addralign();
1172   section_offset_type o = 0;
1173   for (Unmergeable_cie_offsets::iterator p =
1174          this->unmergeable_cie_offsets_.begin();
1175        p != this->unmergeable_cie_offsets_.end();
1176        ++p)
1177     o = (*p)->write<size, big_endian>(oview, o, address, addralign,
1178                                       this->eh_frame_hdr_);
1179   for (Cie_offsets::iterator p = this->cie_offsets_.begin();
1180        p != this->cie_offsets_.end();
1181        ++p)
1182     o = (*p)->write<size, big_endian>(oview, o, address, addralign,
1183                                       this->eh_frame_hdr_);
1184 }
1185
1186 #ifdef HAVE_TARGET_32_LITTLE
1187 template
1188 bool
1189 Eh_frame::add_ehframe_input_section<32, false>(
1190     Sized_relobj_file<32, false>* object,
1191     const unsigned char* symbols,
1192     section_size_type symbols_size,
1193     const unsigned char* symbol_names,
1194     section_size_type symbol_names_size,
1195     unsigned int shndx,
1196     unsigned int reloc_shndx,
1197     unsigned int reloc_type);
1198 #endif
1199
1200 #ifdef HAVE_TARGET_32_BIG
1201 template
1202 bool
1203 Eh_frame::add_ehframe_input_section<32, true>(
1204     Sized_relobj_file<32, true>* object,
1205     const unsigned char* symbols,
1206     section_size_type symbols_size,
1207     const unsigned char* symbol_names,
1208     section_size_type symbol_names_size,
1209     unsigned int shndx,
1210     unsigned int reloc_shndx,
1211     unsigned int reloc_type);
1212 #endif
1213
1214 #ifdef HAVE_TARGET_64_LITTLE
1215 template
1216 bool
1217 Eh_frame::add_ehframe_input_section<64, false>(
1218     Sized_relobj_file<64, false>* object,
1219     const unsigned char* symbols,
1220     section_size_type symbols_size,
1221     const unsigned char* symbol_names,
1222     section_size_type symbol_names_size,
1223     unsigned int shndx,
1224     unsigned int reloc_shndx,
1225     unsigned int reloc_type);
1226 #endif
1227
1228 #ifdef HAVE_TARGET_64_BIG
1229 template
1230 bool
1231 Eh_frame::add_ehframe_input_section<64, true>(
1232     Sized_relobj_file<64, true>* object,
1233     const unsigned char* symbols,
1234     section_size_type symbols_size,
1235     const unsigned char* symbol_names,
1236     section_size_type symbol_names_size,
1237     unsigned int shndx,
1238     unsigned int reloc_shndx,
1239     unsigned int reloc_type);
1240 #endif
1241
1242 } // End namespace gold.