gold/ehframe.cc

   1 // ehframe.cc -- handle exception frame sections for gold
   2
   3 // Copyright 2006, 2007, 2008, 2010, 2011, 2012 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   Track_relocs<size, big_endian> relocs;
 635
 636   const unsigned char* p = pcontents;
 637   const unsigned char* pend = p + contents_len;
 638
 639   // Get the contents of the reloc section if any.
 640   if (!relocs.initialize(object, reloc_shndx, reloc_type))
 641     return false;
 642
 643   // Keep track of which CIEs are at which offsets.
 644   Offsets_to_cie cies;
 645
 646   while (p < pend)
 647     {
 648       if (pend - p < 4)
 649         return false;
 650
 651       // There shouldn't be any relocations here.
 652       if (relocs.advance(p + 4 - pcontents) > 0)
 653         return false;
 654
 655       unsigned int len = elfcpp::Swap<32, big_endian>::readval(p);
 656       p += 4;
 657       if (len == 0)
 658         {
 659           // We should only find a zero-length entry at the end of the
 660           // section.
 661           if (p < pend)
 662             return false;
 663           break;
 664         }
 665       // We don't support a 64-bit .eh_frame.
 666       if (len == 0xffffffff)
 667         return false;
 668       if (static_cast<unsigned int>(pend - p) < len)
 669         return false;
 670
 671       const unsigned char* const pentend = p + len;
 672
 673       if (pend - p < 4)
 674         return false;
 675       if (relocs.advance(p + 4 - pcontents) > 0)
 676         return false;
 677
 678       unsigned int id = elfcpp::Swap<32, big_endian>::readval(p);
 679       p += 4;
 680
 681       if (id == 0)
 682         {
 683           // CIE.
 684           if (!this->read_cie(object, shndx, symbols, symbols_size,
 685                               symbol_names, symbol_names_size,
 686                               pcontents, p, pentend, &relocs, &cies,
 687                               new_cies))
 688             return false;
 689         }
 690       else
 691         {
 692           // FDE.
 693           if (!this->read_fde(object, shndx, symbols, symbols_size,
 694                               pcontents, id, p, pentend, &relocs, &cies))
 695             return false;
 696         }
 697
 698       p = pentend;
 699     }
 700
 701   return true;
 702 }
 703
 704 // Read a CIE.  Return false if we can't parse the information.
 705
 706 template<int size, bool big_endian>
 707 bool
 708 Eh_frame::read_cie(Sized_relobj_file<size, big_endian>* object,
 709                    unsigned int shndx,
 710                    const unsigned char* symbols,
 711                    section_size_type symbols_size,
 712                    const unsigned char* symbol_names,
 713                    section_size_type symbol_names_size,
 714                    const unsigned char* pcontents,
 715                    const unsigned char* pcie,
 716                    const unsigned char* pcieend,
 717                    Track_relocs<size, big_endian>* relocs,
 718                    Offsets_to_cie* cies,
 719                    New_cies* new_cies)
 720 {
 721   bool mergeable = true;
 722
 723   // We need to find the personality routine if there is one, since we
 724   // can only merge CIEs which use the same routine.  We also need to
 725   // find the FDE encoding if there is one, so that we can read the PC
 726   // from the FDE.
 727
 728   const unsigned char* p = pcie;
 729
 730   if (pcieend - p < 1)
 731     return false;
 732   unsigned char version = *p++;
 733   if (version != 1 && version != 3)
 734     return false;
 735
 736   const unsigned char* paug = p;
 737   const void* paugendv = memchr(p, '\0', pcieend - p);
 738   const unsigned char* paugend = static_cast<const unsigned char*>(paugendv);
 739   if (paugend == NULL)
 740     return false;
 741   p = paugend + 1;
 742
 743   if (paug[0] == 'e' && paug[1] == 'h')
 744     {
 745       // This is a CIE from gcc before version 3.0.  We can't merge
 746       // these.  We can still read the FDEs.
 747       mergeable = false;
 748       paug += 2;
 749       if (*paug != '\0')
 750         return false;
 751       if (pcieend - p < size / 8)
 752         return false;
 753       p += size / 8;
 754     }
 755
 756   // Skip the code alignment.
 757   if (!skip_leb128(&p, pcieend))
 758     return false;
 759
 760   // Skip the data alignment.
 761   if (!skip_leb128(&p, pcieend))
 762     return false;
 763
 764   // Skip the return column.
 765   if (version == 1)
 766     {
 767       if (pcieend - p < 1)
 768         return false;
 769       ++p;
 770     }
 771   else
 772     {
 773       if (!skip_leb128(&p, pcieend))
 774         return false;
 775     }
 776
 777   if (*paug == 'z')
 778     {
 779       ++paug;
 780       // Skip the augmentation size.
 781       if (!skip_leb128(&p, pcieend))
 782         return false;
 783     }
 784
 785   unsigned char fde_encoding = elfcpp::DW_EH_PE_absptr;
 786   int per_offset = -1;
 787   while (*paug != '\0')
 788     {
 789       switch (*paug)
 790         {
 791         case 'L': // LSDA encoding.
 792           if (pcieend - p < 1)
 793             return false;
 794           ++p;
 795           break;
 796
 797         case 'R': // FDE encoding.
 798           if (pcieend - p < 1)
 799             return false;
 800           fde_encoding = *p;
 801           switch (fde_encoding & 7)
 802             {
 803             case elfcpp::DW_EH_PE_absptr:
 804             case elfcpp::DW_EH_PE_udata2:
 805             case elfcpp::DW_EH_PE_udata4:
 806             case elfcpp::DW_EH_PE_udata8:
 807               break;
 808             default:
 809               // We don't expect to see any other cases here, and
 810               // we're not prepared to handle them.
 811               return false;
 812             }
 813           ++p;
 814           break;
 815
 816         case 'S':
 817           break;
 818
 819         case 'P':
 820           // Personality encoding.
 821           {
 822             if (pcieend - p < 1)
 823               return false;
 824             unsigned char per_encoding = *p;
 825             ++p;
 826
 827             if ((per_encoding & 0x60) == 0x60)
 828               return false;
 829             unsigned int per_width;
 830             switch (per_encoding & 7)
 831               {
 832               case elfcpp::DW_EH_PE_udata2:
 833                 per_width = 2;
 834                 break;
 835               case elfcpp::DW_EH_PE_udata4:
 836                 per_width = 4;
 837                 break;
 838               case elfcpp::DW_EH_PE_udata8:
 839                 per_width = 8;
 840                 break;
 841               case elfcpp::DW_EH_PE_absptr:
 842                 per_width = size / 8;
 843                 break;
 844               default:
 845                 return false;
 846               }
 847
 848             if ((per_encoding & 0xf0) == elfcpp::DW_EH_PE_aligned)
 849               {
 850                 unsigned int len = p - pcie;
 851                 len += per_width - 1;
 852                 len &= ~ (per_width - 1);
 853                 if (static_cast<unsigned int>(pcieend - p) < len)
 854                   return false;
 855                 p += len;
 856               }
 857
 858             per_offset = p - pcontents;
 859
 860             if (static_cast<unsigned int>(pcieend - p) < per_width)
 861               return false;
 862             p += per_width;
 863           }
 864           break;
 865
 866         default:
 867           return false;
 868         }
 869
 870       ++paug;
 871     }
 872
 873   const char* personality_name = "";
 874   if (per_offset != -1)
 875     {
 876       if (relocs->advance(per_offset) > 0)
 877         return false;
 878       if (relocs->next_offset() != per_offset)
 879         return false;
 880
 881       unsigned int personality_symndx = relocs->next_symndx();
 882       if (personality_symndx == -1U)
 883         return false;
 884
 885       if (personality_symndx < object->local_symbol_count())
 886         {
 887           // We can only merge this CIE if the personality routine is
 888           // a global symbol.  We can still read the FDEs.
 889           mergeable = false;
 890         }
 891       else
 892         {
 893           const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
 894           if (personality_symndx >= symbols_size / sym_size)
 895             return false;
 896           elfcpp::Sym<size, big_endian> sym(symbols
 897                                             + (personality_symndx * sym_size));
 898           unsigned int name_offset = sym.get_st_name();
 899           if (name_offset >= symbol_names_size)
 900             return false;
 901           personality_name = (reinterpret_cast<const char*>(symbol_names)
 902                               + name_offset);
 903         }
 904
 905       int r = relocs->advance(per_offset + 1);
 906       gold_assert(r == 1);
 907     }
 908
 909   if (relocs->advance(pcieend - pcontents) > 0)
 910     return false;
 911
 912   Cie cie(object, shndx, (pcie - 8) - pcontents, fde_encoding,
 913           personality_name, pcie, pcieend - pcie);
 914   Cie* cie_pointer = NULL;
 915   if (mergeable)
 916     {
 917       Cie_offsets::iterator find_cie = this->cie_offsets_.find(&cie);
 918       if (find_cie != this->cie_offsets_.end())
 919         cie_pointer = *find_cie;
 920       else
 921         {
 922           // See if we already saw this CIE in this object file.
 923           for (New_cies::const_iterator pc = new_cies->begin();
 924                pc != new_cies->end();
 925                ++pc)
 926             {
 927               if (*(pc->first) == cie)
 928                 {
 929                   cie_pointer = pc->first;
 930                   break;
 931                 }
 932             }
 933         }
 934     }
 935
 936   if (cie_pointer == NULL)
 937     {
 938       cie_pointer = new Cie(cie);
 939       new_cies->push_back(std::make_pair(cie_pointer, mergeable));
 940     }
 941   else
 942     {
 943       // We are deleting this CIE.  Record that in our mapping from
 944       // input sections to the output section.  At this point we don't
 945       // know for sure that we are doing a special mapping for this
 946       // input section, but that's OK--if we don't do a special
 947       // mapping, nobody will ever ask for the mapping we add here.
 948       this->merge_map_.add_mapping(object, shndx, (pcie - 8) - pcontents,
 949                                    pcieend - (pcie - 8), -1);
 950     }
 951
 952   // Record this CIE plus the offset in the input section.
 953   cies->insert(std::make_pair(pcie - pcontents, cie_pointer));
 954
 955   return true;
 956 }
 957
 958 // Read an FDE.  Return false if we can't parse the information.
 959
 960 template<int size, bool big_endian>
 961 bool
 962 Eh_frame::read_fde(Sized_relobj_file<size, big_endian>* object,
 963                    unsigned int shndx,
 964                    const unsigned char* symbols,
 965                    section_size_type symbols_size,
 966                    const unsigned char* pcontents,
 967                    unsigned int offset,
 968                    const unsigned char* pfde,
 969                    const unsigned char* pfdeend,
 970                    Track_relocs<size, big_endian>* relocs,
 971                    Offsets_to_cie* cies)
 972 {
 973   // OFFSET is the distance between the 4 bytes before PFDE to the
 974   // start of the CIE.  The offset we recorded for the CIE is 8 bytes
 975   // after the start of the CIE--after the length and the zero tag.
 976   unsigned int cie_offset = (pfde - 4 - pcontents) - offset + 8;
 977   Offsets_to_cie::const_iterator pcie = cies->find(cie_offset);
 978   if (pcie == cies->end())
 979     return false;
 980   Cie* cie = pcie->second;
 981
 982   // The FDE should start with a reloc to the start of the code which
 983   // it describes.
 984   if (relocs->advance(pfde - pcontents) > 0)
 985     return false;
 986
 987   if (relocs->next_offset() != pfde - pcontents)
 988     return false;
 989
 990   unsigned int symndx = relocs->next_symndx();
 991   if (symndx == -1U)
 992     return false;
 993
 994   // There can be another reloc in the FDE, if the CIE specifies an
 995   // LSDA (language specific data area).  We currently don't care.  We
 996   // will care later if we want to optimize the LSDA from an absolute
 997   // pointer to a PC relative offset when generating a shared library.
 998   relocs->advance(pfdeend - pcontents);
 999
1000   unsigned int fde_shndx;
1001   const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
1002   if (symndx >= symbols_size / sym_size)
1003     return false;
1004   elfcpp::Sym<size, big_endian> sym(symbols + symndx * sym_size);
1005   bool is_ordinary;
1006   fde_shndx = object->adjust_sym_shndx(symndx, sym.get_st_shndx(),
1007                                        &is_ordinary);
1008
1009   if (is_ordinary
1010       && fde_shndx != elfcpp::SHN_UNDEF
1011       && fde_shndx < object->shnum()
1012       && !object->is_section_included(fde_shndx))
1013     {
1014       // This FDE applies to a section which we are discarding.  We
1015       // can discard this FDE.
1016       this->merge_map_.add_mapping(object, shndx, (pfde - 8) - pcontents,
1017                                    pfdeend - (pfde - 8), -1);
1018       return true;
1019     }
1020
1021   cie->add_fde(new Fde(object, shndx, (pfde - 8) - pcontents,
1022                        pfde, pfdeend - pfde));
1023
1024   return true;
1025 }
1026
1027 // Add unwind information for a PLT.
1028
1029 void
1030 Eh_frame::add_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data,
1031                               size_t cie_length, const unsigned char* fde_data,
1032                               size_t fde_length)
1033 {
1034   Cie cie(NULL, 0, 0, elfcpp::DW_EH_PE_pcrel | elfcpp::DW_EH_PE_sdata4, "",
1035           cie_data, cie_length);
1036   Cie_offsets::iterator find_cie = this->cie_offsets_.find(&cie);
1037   Cie* pcie;
1038   if (find_cie != this->cie_offsets_.end())
1039     pcie = *find_cie;
1040   else
1041     {
1042       pcie = new Cie(cie);
1043       this->cie_offsets_.insert(pcie);
1044     }
1045
1046   Fde* fde = new Fde(plt, fde_data, fde_length);
1047   pcie->add_fde(fde);
1048 }
1049
1050 // Return the number of FDEs.
1051
1052 unsigned int
1053 Eh_frame::fde_count() const
1054 {
1055   unsigned int ret = 0;
1056   for (Unmergeable_cie_offsets::const_iterator p =
1057          this->unmergeable_cie_offsets_.begin();
1058        p != this->unmergeable_cie_offsets_.end();
1059        ++p)
1060     ret += (*p)->fde_count();
1061   for (Cie_offsets::const_iterator p = this->cie_offsets_.begin();
1062        p != this->cie_offsets_.end();
1063        ++p)
1064     ret += (*p)->fde_count();
1065   return ret;
1066 }
1067
1068 // Set the final data size.
1069
1070 void
1071 Eh_frame::set_final_data_size()
1072 {
1073   // We can be called more than once if Layout::set_segment_offsets
1074   // finds a better mapping.  We don't want to add all the mappings
1075   // again.
1076   if (this->mappings_are_done_)
1077     {
1078       this->set_data_size(this->final_data_size_);
1079       return;
1080     }
1081
1082   section_offset_type output_offset = 0;
1083
1084   for (Unmergeable_cie_offsets::iterator p =
1085          this->unmergeable_cie_offsets_.begin();
1086        p != this->unmergeable_cie_offsets_.end();
1087        ++p)
1088     output_offset = (*p)->set_output_offset(output_offset,
1089                                             this->addralign(),
1090                                             &this->merge_map_);
1091
1092   for (Cie_offsets::iterator p = this->cie_offsets_.begin();
1093        p != this->cie_offsets_.end();
1094        ++p)
1095     output_offset = (*p)->set_output_offset(output_offset,
1096                                             this->addralign(),
1097                                             &this->merge_map_);
1098
1099   this->mappings_are_done_ = true;
1100   this->final_data_size_ = output_offset;
1101
1102   gold_assert((output_offset & (this->addralign() - 1)) == 0);
1103   this->set_data_size(output_offset);
1104 }
1105
1106 // Return an output offset for an input offset.
1107
1108 bool
1109 Eh_frame::do_output_offset(const Relobj* object, unsigned int shndx,
1110                            section_offset_type offset,
1111                            section_offset_type* poutput) const
1112 {
1113   return this->merge_map_.get_output_offset(object, shndx, offset, poutput);
1114 }
1115
1116 // Return whether this is the merge section for an input section.
1117
1118 bool
1119 Eh_frame::do_is_merge_section_for(const Relobj* object,
1120                                   unsigned int shndx) const
1121 {
1122   return this->merge_map_.is_merge_section_for(object, shndx);
1123 }
1124
1125 // Write the data to the output file.
1126
1127 void
1128 Eh_frame::do_write(Output_file* of)
1129 {
1130   const off_t offset = this->offset();
1131   const off_t oview_size = this->data_size();
1132   unsigned char* const oview = of->get_output_view(offset, oview_size);
1133
1134   switch (parameters->size_and_endianness())
1135     {
1136 #ifdef HAVE_TARGET_32_LITTLE
1137     case Parameters::TARGET_32_LITTLE:
1138       this->do_sized_write<32, false>(oview);
1139       break;
1140 #endif
1141 #ifdef HAVE_TARGET_32_BIG
1142     case Parameters::TARGET_32_BIG:
1143       this->do_sized_write<32, true>(oview);
1144       break;
1145 #endif
1146 #ifdef HAVE_TARGET_64_LITTLE
1147     case Parameters::TARGET_64_LITTLE:
1148       this->do_sized_write<64, false>(oview);
1149       break;
1150 #endif
1151 #ifdef HAVE_TARGET_64_BIG
1152     case Parameters::TARGET_64_BIG:
1153       this->do_sized_write<64, true>(oview);
1154       break;
1155 #endif
1156     default:
1157       gold_unreachable();
1158     }
1159
1160   of->write_output_view(offset, oview_size, oview);
1161 }
1162
1163 // Write the data to the output file--template version.
1164
1165 template<int size, bool big_endian>
1166 void
1167 Eh_frame::do_sized_write(unsigned char* oview)
1168 {
1169   uint64_t address = this->address();
1170   unsigned int addralign = this->addralign();
1171   section_offset_type o = 0;
1172   for (Unmergeable_cie_offsets::iterator p =
1173          this->unmergeable_cie_offsets_.begin();
1174        p != this->unmergeable_cie_offsets_.end();
1175        ++p)
1176     o = (*p)->write<size, big_endian>(oview, o, address, addralign,
1177                                       this->eh_frame_hdr_);
1178   for (Cie_offsets::iterator p = this->cie_offsets_.begin();
1179        p != this->cie_offsets_.end();
1180        ++p)
1181     o = (*p)->write<size, big_endian>(oview, o, address, addralign,
1182                                       this->eh_frame_hdr_);
1183 }
1184
1185 #ifdef HAVE_TARGET_32_LITTLE
1186 template
1187 bool
1188 Eh_frame::add_ehframe_input_section<32, false>(
1189     Sized_relobj_file<32, false>* object,
1190     const unsigned char* symbols,
1191     section_size_type symbols_size,
1192     const unsigned char* symbol_names,
1193     section_size_type symbol_names_size,
1194     unsigned int shndx,
1195     unsigned int reloc_shndx,
1196     unsigned int reloc_type);
1197 #endif
1198
1199 #ifdef HAVE_TARGET_32_BIG
1200 template
1201 bool
1202 Eh_frame::add_ehframe_input_section<32, true>(
1203     Sized_relobj_file<32, true>* object,
1204     const unsigned char* symbols,
1205     section_size_type symbols_size,
1206     const unsigned char* symbol_names,
1207     section_size_type symbol_names_size,
1208     unsigned int shndx,
1209     unsigned int reloc_shndx,
1210     unsigned int reloc_type);
1211 #endif
1212
1213 #ifdef HAVE_TARGET_64_LITTLE
1214 template
1215 bool
1216 Eh_frame::add_ehframe_input_section<64, false>(
1217     Sized_relobj_file<64, false>* object,
1218     const unsigned char* symbols,
1219     section_size_type symbols_size,
1220     const unsigned char* symbol_names,
1221     section_size_type symbol_names_size,
1222     unsigned int shndx,
1223     unsigned int reloc_shndx,
1224     unsigned int reloc_type);
1225 #endif
1226
1227 #ifdef HAVE_TARGET_64_BIG
1228 template
1229 bool
1230 Eh_frame::add_ehframe_input_section<64, true>(
1231     Sized_relobj_file<64, true>* object,
1232     const unsigned char* symbols,
1233     section_size_type symbols_size,
1234     const unsigned char* symbol_names,
1235     section_size_type symbol_names_size,
1236     unsigned int shndx,
1237     unsigned int reloc_shndx,
1238     unsigned int reloc_type);
1239 #endif
1240
1241 } // End namespace gold.