1// ehframe.cc -- handle exception frame sections for gold 2 3// Copyright (C) 2006-2017 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 34namespace 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 77const int eh_frame_hdr_size = 4; 78 79// Construct the exception frame header. 80 81Eh_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 93void 94Eh_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 109void 110Eh_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 141template<int size, bool big_endian> 142void 143Eh_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 220template<int size, bool big_endian> 221typename elfcpp::Elf_types<size>::Elf_Addr 222Eh_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 299template<int size, bool big_endian> 300void 301Eh_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. OUTPUT_OFFSET is the offset of the 330// Eh_frame section within the output section. FDE_ENCODING is the 331// encoding, from the CIE. ADDRALIGN is the required alignment. 332// ADDRESS is the virtual address of OVIEW. Record the FDE pc for 333// EH_FRAME_HDR. Return the new offset. 334 335template<int size, bool big_endian> 336section_offset_type 337Fde::write(unsigned char* oview, section_offset_type output_offset, 338 section_offset_type offset, uint64_t address, unsigned int addralign, 339 section_offset_type cie_offset, unsigned char fde_encoding, 340 Eh_frame_hdr* eh_frame_hdr) 341{ 342 gold_assert((offset & (addralign - 1)) == 0); 343 344 size_t length = this->contents_.length(); 345 346 // We add 8 when getting the aligned length to account for the 347 // length word and the CIE offset. 348 size_t aligned_full_length = align_address(length + 8, addralign); 349 350 // Write the length of the FDE as a 32-bit word. The length word 351 // does not include the four bytes of the length word itself, but it 352 // does include the offset to the CIE. 353 elfcpp::Swap<32, big_endian>::writeval(oview + offset, 354 aligned_full_length - 4); 355 356 // Write the offset to the CIE as a 32-bit word. This is the 357 // difference between the address of the offset word itself and the 358 // CIE address. 359 elfcpp::Swap<32, big_endian>::writeval(oview + offset + 4, 360 offset + 4 - cie_offset); 361 362 // Copy the rest of the FDE. Note that this is run before 363 // relocation processing is done on this section, so the relocations 364 // will later be applied to the FDE data. 365 memcpy(oview + offset + 8, this->contents_.data(), length); 366 367 // If this FDE is associated with a PLT, fill in the PLT's address 368 // and size. 369 if (this->object_ == NULL) 370 { 371 gold_assert(memcmp(oview + offset + 8, "\0\0\0\0\0\0\0\0", 8) == 0); 372 uint64_t paddress; 373 off_t psize; 374 parameters->target().plt_fde_location(this->u_.from_linker.plt, 375 oview + offset + 8, 376 &paddress, &psize); 377 uint64_t poffset = paddress - (address + offset + 8); 378 int32_t spoffset = static_cast<int32_t>(poffset); 379 uint32_t upsize = static_cast<uint32_t>(psize); 380 if (static_cast<uint64_t>(static_cast<int64_t>(spoffset)) != poffset 381 || static_cast<off_t>(upsize) != psize) 382 gold_warning(_("overflow in PLT unwind data; " 383 "unwinding through PLT may fail")); 384 elfcpp::Swap<32, big_endian>::writeval(oview + offset + 8, spoffset); 385 elfcpp::Swap<32, big_endian>::writeval(oview + offset + 12, upsize); 386 } 387 388 if (aligned_full_length > length + 8) 389 memset(oview + offset + length + 8, 0, aligned_full_length - (length + 8)); 390 391 // Tell the exception frame header about this FDE. 392 if (eh_frame_hdr != NULL) 393 eh_frame_hdr->record_fde(output_offset + offset, fde_encoding); 394 395 return offset + aligned_full_length; 396} 397 398// Class Cie. 399 400// Destructor. 401 402Cie::~Cie() 403{ 404 for (std::vector<Fde*>::iterator p = this->fdes_.begin(); 405 p != this->fdes_.end(); 406 ++p) 407 delete *p; 408} 409 410// Set the output offset of a CIE. Return the new output offset. 411 412section_offset_type 413Cie::set_output_offset(section_offset_type output_offset, 414 unsigned int addralign, 415 Output_section_data *output_data) 416{ 417 size_t length = this->contents_.length(); 418 419 // Add 4 for length and 4 for zero CIE identifier tag. 420 length += 8; 421 422 if (this->object_ != NULL) 423 { 424 // Add a mapping so that relocations are applied correctly. 425 this->object_->add_merge_mapping(output_data, this->shndx_, 426 this->input_offset_, length, 427 output_offset); 428 } 429 430 length = align_address(length, addralign); 431 432 for (std::vector<Fde*>::const_iterator p = this->fdes_.begin(); 433 p != this->fdes_.end(); 434 ++p) 435 { 436 (*p)->add_mapping(output_offset + length, output_data); 437 438 size_t fde_length = (*p)->length(); 439 fde_length = align_address(fde_length, addralign); 440 length += fde_length; 441 } 442 443 return output_offset + length; 444} 445 446// Write the CIE to OVIEW starting at OFFSET. OUTPUT_OFFSET is the 447// offset of the Eh_frame section within the output section. Round up 448// the bytes to ADDRALIGN. ADDRESS is the virtual address of OVIEW. 449// EH_FRAME_HDR is the exception frame header for FDE recording. 450// POST_FDES stashes FDEs created after mappings were done, for later 451// writing. Return the new offset. 452 453template<int size, bool big_endian> 454section_offset_type 455Cie::write(unsigned char* oview, section_offset_type output_offset, 456 section_offset_type offset, uint64_t address, 457 unsigned int addralign, Eh_frame_hdr* eh_frame_hdr, 458 Post_fdes* post_fdes) 459{ 460 gold_assert((offset & (addralign - 1)) == 0); 461 462 section_offset_type cie_offset = offset; 463 464 size_t length = this->contents_.length(); 465 466 // We add 8 when getting the aligned length to account for the 467 // length word and the CIE tag. 468 size_t aligned_full_length = align_address(length + 8, addralign); 469 470 // Write the length of the CIE as a 32-bit word. The length word 471 // does not include the four bytes of the length word itself. 472 elfcpp::Swap<32, big_endian>::writeval(oview + offset, 473 aligned_full_length - 4); 474 475 // Write the tag which marks this as a CIE: a 32-bit zero. 476 elfcpp::Swap<32, big_endian>::writeval(oview + offset + 4, 0); 477 478 // Write out the CIE data. 479 memcpy(oview + offset + 8, this->contents_.data(), length); 480 481 if (aligned_full_length > length + 8) 482 memset(oview + offset + length + 8, 0, aligned_full_length - (length + 8)); 483 484 offset += aligned_full_length; 485 486 // Write out the associated FDEs. 487 unsigned char fde_encoding = this->fde_encoding_; 488 for (std::vector<Fde*>::const_iterator p = this->fdes_.begin(); 489 p != this->fdes_.end(); 490 ++p) 491 { 492 if ((*p)->post_map()) 493 post_fdes->push_back(Post_fde(*p, cie_offset, fde_encoding)); 494 else 495 offset = (*p)->write<size, big_endian>(oview, output_offset, offset, 496 address, addralign, cie_offset, 497 fde_encoding, eh_frame_hdr); 498 } 499 500 return offset; 501} 502 503// We track all the CIEs we see, and merge them when possible. This 504// works because each FDE holds an offset to the relevant CIE: we 505// rewrite the FDEs to point to the merged CIE. This is worthwhile 506// because in a typical C++ program many FDEs in many different object 507// files will use the same CIE. 508 509// An equality operator for Cie. 510 511bool 512operator==(const Cie& cie1, const Cie& cie2) 513{ 514 return (cie1.personality_name_ == cie2.personality_name_ 515 && cie1.contents_ == cie2.contents_); 516} 517 518// A less-than operator for Cie. 519 520bool 521operator<(const Cie& cie1, const Cie& cie2) 522{ 523 if (cie1.personality_name_ != cie2.personality_name_) 524 return cie1.personality_name_ < cie2.personality_name_; 525 return cie1.contents_ < cie2.contents_; 526} 527 528// Class Eh_frame. 529 530Eh_frame::Eh_frame() 531 : Output_section_data(Output_data::default_alignment()), 532 eh_frame_hdr_(NULL), 533 cie_offsets_(), 534 unmergeable_cie_offsets_(), 535 mappings_are_done_(false), 536 final_data_size_(0) 537{ 538} 539 540// Skip an LEB128, updating *PP to point to the next character. 541// Return false if we ran off the end of the string. 542 543bool 544Eh_frame::skip_leb128(const unsigned char** pp, const unsigned char* pend) 545{ 546 const unsigned char* p; 547 for (p = *pp; p < pend; ++p) 548 { 549 if ((*p & 0x80) == 0) 550 { 551 *pp = p + 1; 552 return true; 553 } 554 } 555 return false; 556} 557 558// Add input section SHNDX in OBJECT to an exception frame section. 559// SYMBOLS is the contents of the symbol table section (size 560// SYMBOLS_SIZE), SYMBOL_NAMES is the symbol names section (size 561// SYMBOL_NAMES_SIZE). RELOC_SHNDX is the index of a relocation 562// section applying to SHNDX, or 0 if none, or -1U if more than one. 563// RELOC_TYPE is the type of the reloc section if there is one, either 564// SHT_REL or SHT_RELA. We try to parse the input exception frame 565// data into our data structures. If we can't do it, we return false 566// to mean that the section should be handled as a normal input 567// section. 568 569template<int size, bool big_endian> 570Eh_frame::Eh_frame_section_disposition 571Eh_frame::add_ehframe_input_section( 572 Sized_relobj_file<size, big_endian>* object, 573 const unsigned char* symbols, 574 section_size_type symbols_size, 575 const unsigned char* symbol_names, 576 section_size_type symbol_names_size, 577 unsigned int shndx, 578 unsigned int reloc_shndx, 579 unsigned int reloc_type) 580{ 581 // Get the section contents. 582 section_size_type contents_len; 583 const unsigned char* pcontents = object->section_contents(shndx, 584 &contents_len, 585 false); 586 if (contents_len == 0) 587 return EH_EMPTY_SECTION; 588 589 // If this is the marker section for the end of the data, then 590 // return false to force it to be handled as an ordinary input 591 // section. If we don't do this, we won't correctly handle the case 592 // of unrecognized .eh_frame sections. 593 if (contents_len == 4 594 && elfcpp::Swap<32, big_endian>::readval(pcontents) == 0) 595 return EH_END_MARKER_SECTION; 596 597 New_cies new_cies; 598 if (!this->do_add_ehframe_input_section(object, symbols, symbols_size, 599 symbol_names, symbol_names_size, 600 shndx, reloc_shndx, 601 reloc_type, pcontents, 602 contents_len, &new_cies)) 603 { 604 if (this->eh_frame_hdr_ != NULL) 605 this->eh_frame_hdr_->found_unrecognized_eh_frame_section(); 606 607 for (New_cies::iterator p = new_cies.begin(); 608 p != new_cies.end(); 609 ++p) 610 delete p->first; 611 612 return EH_UNRECOGNIZED_SECTION; 613 } 614 615 // Now that we know we are using this section, record any new CIEs 616 // that we found. 617 for (New_cies::const_iterator p = new_cies.begin(); 618 p != new_cies.end(); 619 ++p) 620 { 621 if (p->second) 622 this->cie_offsets_.insert(p->first); 623 else 624 this->unmergeable_cie_offsets_.push_back(p->first); 625 } 626 627 return EH_OPTIMIZABLE_SECTION; 628} 629 630// The bulk of the implementation of add_ehframe_input_section. 631 632template<int size, bool big_endian> 633bool 634Eh_frame::do_add_ehframe_input_section( 635 Sized_relobj_file<size, big_endian>* object, 636 const unsigned char* symbols, 637 section_size_type symbols_size, 638 const unsigned char* symbol_names, 639 section_size_type symbol_names_size, 640 unsigned int shndx, 641 unsigned int reloc_shndx, 642 unsigned int reloc_type, 643 const unsigned char* pcontents, 644 section_size_type contents_len, 645 New_cies* new_cies) 646{ 647 Track_relocs<size, big_endian> relocs; 648 649 const unsigned char* p = pcontents; 650 const unsigned char* pend = p + contents_len; 651 652 // Get the contents of the reloc section if any. 653 if (!relocs.initialize(object, reloc_shndx, reloc_type)) 654 return false; 655 656 // Keep track of which CIEs are at which offsets. 657 Offsets_to_cie cies; 658 659 while (p < pend) 660 { 661 if (pend - p < 4) 662 return false; 663 664 // There shouldn't be any relocations here. 665 if (relocs.advance(p + 4 - pcontents) > 0) 666 return false; 667 668 unsigned int len = elfcpp::Swap<32, big_endian>::readval(p); 669 p += 4; 670 if (len == 0) 671 { 672 // We should only find a zero-length entry at the end of the 673 // section. 674 if (p < pend) 675 return false; 676 break; 677 } 678 // We don't support a 64-bit .eh_frame. 679 if (len == 0xffffffff) 680 return false; 681 if (static_cast<unsigned int>(pend - p) < len) 682 return false; 683 684 const unsigned char* const pentend = p + len; 685 686 if (pend - p < 4) 687 return false; 688 if (relocs.advance(p + 4 - pcontents) > 0) 689 return false; 690 691 unsigned int id = elfcpp::Swap<32, big_endian>::readval(p); 692 p += 4; 693 694 if (id == 0) 695 { 696 // CIE. 697 if (!this->read_cie(object, shndx, symbols, symbols_size, 698 symbol_names, symbol_names_size, 699 pcontents, p, pentend, &relocs, &cies, 700 new_cies)) 701 return false; 702 } 703 else 704 { 705 // FDE. 706 if (!this->read_fde(object, shndx, symbols, symbols_size, 707 pcontents, id, p, pentend, &relocs, &cies)) 708 return false; 709 } 710 711 p = pentend; 712 } 713 714 return true; 715} 716 717// Read a CIE. Return false if we can't parse the information. 718 719template<int size, bool big_endian> 720bool 721Eh_frame::read_cie(Sized_relobj_file<size, big_endian>* object, 722 unsigned int shndx, 723 const unsigned char* symbols, 724 section_size_type symbols_size, 725 const unsigned char* symbol_names, 726 section_size_type symbol_names_size, 727 const unsigned char* pcontents, 728 const unsigned char* pcie, 729 const unsigned char* pcieend, 730 Track_relocs<size, big_endian>* relocs, 731 Offsets_to_cie* cies, 732 New_cies* new_cies) 733{ 734 bool mergeable = true; 735 736 // We need to find the personality routine if there is one, since we 737 // can only merge CIEs which use the same routine. We also need to 738 // find the FDE encoding if there is one, so that we can read the PC 739 // from the FDE. 740 741 const unsigned char* p = pcie; 742 743 if (pcieend - p < 1) 744 return false; 745 unsigned char version = *p++; 746 if (version != 1 && version != 3) 747 return false; 748 749 const unsigned char* paug = p; 750 const void* paugendv = memchr(p, '\0', pcieend - p); 751 const unsigned char* paugend = static_cast<const unsigned char*>(paugendv); 752 if (paugend == NULL) 753 return false; 754 p = paugend + 1; 755 756 if (paug[0] == 'e' && paug[1] == 'h') 757 { 758 // This is a CIE from gcc before version 3.0. We can't merge 759 // these. We can still read the FDEs. 760 mergeable = false; 761 paug += 2; 762 if (*paug != '\0') 763 return false; 764 if (pcieend - p < size / 8) 765 return false; 766 p += size / 8; 767 } 768 769 // Skip the code alignment. 770 if (!skip_leb128(&p, pcieend)) 771 return false; 772 773 // Skip the data alignment. 774 if (!skip_leb128(&p, pcieend)) 775 return false; 776 777 // Skip the return column. 778 if (version == 1) 779 { 780 if (pcieend - p < 1) 781 return false; 782 ++p; 783 } 784 else 785 { 786 if (!skip_leb128(&p, pcieend)) 787 return false; 788 } 789 790 if (*paug == 'z') 791 { 792 ++paug; 793 // Skip the augmentation size. 794 if (!skip_leb128(&p, pcieend)) 795 return false; 796 } 797 798 unsigned char fde_encoding = elfcpp::DW_EH_PE_absptr; 799 int per_offset = -1; 800 while (*paug != '\0') 801 { 802 switch (*paug) 803 { 804 case 'L': // LSDA encoding. 805 if (pcieend - p < 1) 806 return false; 807 ++p; 808 break; 809 810 case 'R': // FDE encoding. 811 if (pcieend - p < 1) 812 return false; 813 fde_encoding = *p; 814 switch (fde_encoding & 7) 815 { 816 case elfcpp::DW_EH_PE_absptr: 817 case elfcpp::DW_EH_PE_udata2: 818 case elfcpp::DW_EH_PE_udata4: 819 case elfcpp::DW_EH_PE_udata8: 820 break; 821 default: 822 // We don't expect to see any other cases here, and 823 // we're not prepared to handle them. 824 return false; 825 } 826 ++p; 827 break; 828 829 case 'S': 830 break; 831 832 case 'P': 833 // Personality encoding. 834 { 835 if (pcieend - p < 1) 836 return false; 837 unsigned char per_encoding = *p; 838 ++p; 839 840 if ((per_encoding & 0x60) == 0x60) 841 return false; 842 unsigned int per_width; 843 switch (per_encoding & 7) 844 { 845 case elfcpp::DW_EH_PE_udata2: 846 per_width = 2; 847 break; 848 case elfcpp::DW_EH_PE_udata4: 849 per_width = 4; 850 break; 851 case elfcpp::DW_EH_PE_udata8: 852 per_width = 8; 853 break; 854 case elfcpp::DW_EH_PE_absptr: 855 per_width = size / 8; 856 break; 857 default: 858 return false; 859 } 860 861 if ((per_encoding & 0xf0) == elfcpp::DW_EH_PE_aligned) 862 { 863 unsigned int len = p - pcie; 864 len += per_width - 1; 865 len &= ~ (per_width - 1); 866 if (static_cast<unsigned int>(pcieend - p) < len) 867 return false; 868 p += len; 869 } 870 871 per_offset = p - pcontents; 872 873 if (static_cast<unsigned int>(pcieend - p) < per_width) 874 return false; 875 p += per_width; 876 } 877 break; 878 879 default: 880 return false; 881 } 882 883 ++paug; 884 } 885 886 const char* personality_name = ""; 887 if (per_offset != -1) 888 { 889 if (relocs->advance(per_offset) > 0) 890 return false; 891 if (relocs->next_offset() != per_offset) 892 return false; 893 894 unsigned int personality_symndx = relocs->next_symndx(); 895 if (personality_symndx == -1U) 896 return false; 897 898 if (personality_symndx < object->local_symbol_count()) 899 { 900 // We can only merge this CIE if the personality routine is 901 // a global symbol. We can still read the FDEs. 902 mergeable = false; 903 } 904 else 905 { 906 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 907 if (personality_symndx >= symbols_size / sym_size) 908 return false; 909 elfcpp::Sym<size, big_endian> sym(symbols 910 + (personality_symndx * sym_size)); 911 unsigned int name_offset = sym.get_st_name(); 912 if (name_offset >= symbol_names_size) 913 return false; 914 personality_name = (reinterpret_cast<const char*>(symbol_names) 915 + name_offset); 916 } 917 918 int r = relocs->advance(per_offset + 1); 919 gold_assert(r == 1); 920 } 921 922 if (relocs->advance(pcieend - pcontents) > 0) 923 return false; 924 925 Cie cie(object, shndx, (pcie - 8) - pcontents, fde_encoding, 926 personality_name, pcie, pcieend - pcie); 927 Cie* cie_pointer = NULL; 928 if (mergeable) 929 { 930 Cie_offsets::iterator find_cie = this->cie_offsets_.find(&cie); 931 if (find_cie != this->cie_offsets_.end()) 932 cie_pointer = *find_cie; 933 else 934 { 935 // See if we already saw this CIE in this object file. 936 for (New_cies::const_iterator pc = new_cies->begin(); 937 pc != new_cies->end(); 938 ++pc) 939 { 940 if (*(pc->first) == cie) 941 { 942 cie_pointer = pc->first; 943 break; 944 } 945 } 946 } 947 } 948 949 if (cie_pointer == NULL) 950 { 951 cie_pointer = new Cie(cie); 952 new_cies->push_back(std::make_pair(cie_pointer, mergeable)); 953 } 954 else 955 { 956 // We are deleting this CIE. Record that in our mapping from 957 // input sections to the output section. At this point we don't 958 // know for sure that we are doing a special mapping for this 959 // input section, but that's OK--if we don't do a special 960 // mapping, nobody will ever ask for the mapping we add here. 961 object->add_merge_mapping(this, shndx, (pcie - 8) - pcontents, 962 pcieend - (pcie - 8), -1); 963 } 964 965 // Record this CIE plus the offset in the input section. 966 cies->insert(std::make_pair(pcie - pcontents, cie_pointer)); 967 968 return true; 969} 970 971// Read an FDE. Return false if we can't parse the information. 972 973template<int size, bool big_endian> 974bool 975Eh_frame::read_fde(Sized_relobj_file<size, big_endian>* object, 976 unsigned int shndx, 977 const unsigned char* symbols, 978 section_size_type symbols_size, 979 const unsigned char* pcontents, 980 unsigned int offset, 981 const unsigned char* pfde, 982 const unsigned char* pfdeend, 983 Track_relocs<size, big_endian>* relocs, 984 Offsets_to_cie* cies) 985{ 986 // OFFSET is the distance between the 4 bytes before PFDE to the 987 // start of the CIE. The offset we recorded for the CIE is 8 bytes 988 // after the start of the CIE--after the length and the zero tag. 989 unsigned int cie_offset = (pfde - 4 - pcontents) - offset + 8; 990 Offsets_to_cie::const_iterator pcie = cies->find(cie_offset); 991 if (pcie == cies->end()) 992 return false; 993 Cie* cie = pcie->second; 994 995 int pc_size = 0; 996 switch (cie->fde_encoding() & 7) 997 { 998 case elfcpp::DW_EH_PE_udata2: 999 pc_size = 2; 1000 break; 1001 case elfcpp::DW_EH_PE_udata4: 1002 pc_size = 4; 1003 break; 1004 case elfcpp::DW_EH_PE_udata8: 1005 gold_assert(size == 64); 1006 pc_size = 8; 1007 break; 1008 case elfcpp::DW_EH_PE_absptr: 1009 pc_size = size == 32 ? 4 : 8; 1010 break; 1011 default: 1012 // All other cases were rejected in Eh_frame::read_cie. 1013 gold_unreachable(); 1014 } 1015 1016 // The FDE should start with a reloc to the start of the code which 1017 // it describes. 1018 if (relocs->advance(pfde - pcontents) > 0) 1019 return false; 1020 if (relocs->next_offset() != pfde - pcontents) 1021 { 1022 // In an object produced by a relocatable link, gold may have 1023 // discarded a COMDAT group in the previous link, but not the 1024 // corresponding FDEs. In that case, gold will have discarded 1025 // the relocations, so the FDE will have a non-relocatable zero 1026 // (regardless of whether the PC encoding is absolute, pc-relative, 1027 // or data-relative) instead of a pointer to the start of the code. 1028 1029 uint64_t pc_value = 0; 1030 switch (pc_size) 1031 { 1032 case 2: 1033 pc_value = elfcpp::Swap<16, big_endian>::readval(pfde); 1034 break; 1035 case 4: 1036 pc_value = elfcpp::Swap<32, big_endian>::readval(pfde); 1037 break; 1038 case 8: 1039 pc_value = elfcpp::Swap_unaligned<64, big_endian>::readval(pfde); 1040 break; 1041 default: 1042 gold_unreachable(); 1043 } 1044 1045 if (pc_value == 0) 1046 { 1047 // This FDE applies to a discarded function. We 1048 // can discard this FDE. 1049 object->add_merge_mapping(this, shndx, (pfde - 8) - pcontents, 1050 pfdeend - (pfde - 8), -1); 1051 return true; 1052 } 1053 1054 // Otherwise, reject the FDE. 1055 return false; 1056 } 1057 1058 unsigned int symndx = relocs->next_symndx(); 1059 if (symndx == -1U) 1060 return false; 1061 1062 // There can be another reloc in the FDE, if the CIE specifies an 1063 // LSDA (language specific data area). We currently don't care. We 1064 // will care later if we want to optimize the LSDA from an absolute 1065 // pointer to a PC relative offset when generating a shared library. 1066 relocs->advance(pfdeend - pcontents); 1067 1068 // Find the section index for code that this FDE describes. 1069 // If we have discarded the section, we can also discard the FDE. 1070 unsigned int fde_shndx; 1071 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 1072 if (symndx >= symbols_size / sym_size) 1073 return false; 1074 elfcpp::Sym<size, big_endian> sym(symbols + symndx * sym_size); 1075 bool is_ordinary; 1076 fde_shndx = object->adjust_sym_shndx(symndx, sym.get_st_shndx(), 1077 &is_ordinary); 1078 bool is_discarded = (is_ordinary 1079 && fde_shndx != elfcpp::SHN_UNDEF 1080 && fde_shndx < object->shnum() 1081 && !object->is_section_included(fde_shndx)); 1082 1083 // Fetch the address range field from the FDE. The offset and size 1084 // of the field depends on the PC encoding given in the CIE, but 1085 // it is always an absolute value. If the address range is 0, this 1086 // FDE corresponds to a function that was discarded during optimization 1087 // (too late to discard the corresponding FDE). 1088 uint64_t address_range = 0; 1089 switch (pc_size) 1090 { 1091 case 2: 1092 address_range = elfcpp::Swap<16, big_endian>::readval(pfde + 2); 1093 break; 1094 case 4: 1095 address_range = elfcpp::Swap<32, big_endian>::readval(pfde + 4); 1096 break; 1097 case 8: 1098 address_range = elfcpp::Swap_unaligned<64, big_endian>::readval(pfde + 8); 1099 break; 1100 default: 1101 gold_unreachable(); 1102 } 1103 1104 if (is_discarded || address_range == 0) 1105 { 1106 // This FDE applies to a discarded function. We 1107 // can discard this FDE. 1108 object->add_merge_mapping(this, shndx, (pfde - 8) - pcontents, 1109 pfdeend - (pfde - 8), -1); 1110 return true; 1111 } 1112 1113 cie->add_fde(new Fde(object, shndx, (pfde - 8) - pcontents, 1114 pfde, pfdeend - pfde)); 1115 1116 return true; 1117} 1118 1119// Add unwind information for a PLT. 1120 1121void 1122Eh_frame::add_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data, 1123 size_t cie_length, const unsigned char* fde_data, 1124 size_t fde_length) 1125{ 1126 Cie cie(NULL, 0, 0, elfcpp::DW_EH_PE_pcrel | elfcpp::DW_EH_PE_sdata4, "", 1127 cie_data, cie_length); 1128 Cie_offsets::iterator find_cie = this->cie_offsets_.find(&cie); 1129 Cie* pcie; 1130 if (find_cie != this->cie_offsets_.end()) 1131 pcie = *find_cie; 1132 else 1133 { 1134 gold_assert(!this->mappings_are_done_); 1135 pcie = new Cie(cie); 1136 this->cie_offsets_.insert(pcie); 1137 } 1138 1139 Fde* fde = new Fde(plt, fde_data, fde_length, this->mappings_are_done_); 1140 pcie->add_fde(fde); 1141 1142 if (this->mappings_are_done_) 1143 this->final_data_size_ += align_address(fde_length + 8, this->addralign()); 1144} 1145 1146// Return the number of FDEs. 1147 1148unsigned int 1149Eh_frame::fde_count() const 1150{ 1151 unsigned int ret = 0; 1152 for (Unmergeable_cie_offsets::const_iterator p = 1153 this->unmergeable_cie_offsets_.begin(); 1154 p != this->unmergeable_cie_offsets_.end(); 1155 ++p) 1156 ret += (*p)->fde_count(); 1157 for (Cie_offsets::const_iterator p = this->cie_offsets_.begin(); 1158 p != this->cie_offsets_.end(); 1159 ++p) 1160 ret += (*p)->fde_count(); 1161 return ret; 1162} 1163 1164// Set the final data size. 1165 1166void 1167Eh_frame::set_final_data_size() 1168{ 1169 // We can be called more than once if Layout::set_segment_offsets 1170 // finds a better mapping. We don't want to add all the mappings 1171 // again. 1172 if (this->mappings_are_done_) 1173 { 1174 this->set_data_size(this->final_data_size_); 1175 return; 1176 } 1177 1178 section_offset_type output_start = 0; 1179 if (this->is_offset_valid()) 1180 output_start = this->offset() - this->output_section()->offset(); 1181 section_offset_type output_offset = output_start; 1182 1183 for (Unmergeable_cie_offsets::iterator p = 1184 this->unmergeable_cie_offsets_.begin(); 1185 p != this->unmergeable_cie_offsets_.end(); 1186 ++p) 1187 output_offset = (*p)->set_output_offset(output_offset, 1188 this->addralign(), 1189 this); 1190 1191 for (Cie_offsets::iterator p = this->cie_offsets_.begin(); 1192 p != this->cie_offsets_.end(); 1193 ++p) 1194 output_offset = (*p)->set_output_offset(output_offset, 1195 this->addralign(), 1196 this); 1197 1198 this->mappings_are_done_ = true; 1199 this->final_data_size_ = output_offset - output_start; 1200 1201 gold_assert((output_offset & (this->addralign() - 1)) == 0); 1202 this->set_data_size(this->final_data_size_); 1203} 1204 1205// Return an output offset for an input offset. 1206 1207bool 1208Eh_frame::do_output_offset(const Relobj* object, unsigned int shndx, 1209 section_offset_type offset, 1210 section_offset_type* poutput) const 1211{ 1212 return object->merge_output_offset(shndx, offset, poutput); 1213} 1214 1215// Write the data to the output file. 1216 1217void 1218Eh_frame::do_write(Output_file* of) 1219{ 1220 const off_t offset = this->offset(); 1221 const off_t oview_size = this->data_size(); 1222 unsigned char* const oview = of->get_output_view(offset, oview_size); 1223 1224 switch (parameters->size_and_endianness()) 1225 { 1226#ifdef HAVE_TARGET_32_LITTLE 1227 case Parameters::TARGET_32_LITTLE: 1228 this->do_sized_write<32, false>(oview); 1229 break; 1230#endif 1231#ifdef HAVE_TARGET_32_BIG 1232 case Parameters::TARGET_32_BIG: 1233 this->do_sized_write<32, true>(oview); 1234 break; 1235#endif 1236#ifdef HAVE_TARGET_64_LITTLE 1237 case Parameters::TARGET_64_LITTLE: 1238 this->do_sized_write<64, false>(oview); 1239 break; 1240#endif 1241#ifdef HAVE_TARGET_64_BIG 1242 case Parameters::TARGET_64_BIG: 1243 this->do_sized_write<64, true>(oview); 1244 break; 1245#endif 1246 default: 1247 gold_unreachable(); 1248 } 1249 1250 of->write_output_view(offset, oview_size, oview); 1251} 1252 1253// Write the data to the output file--template version. 1254 1255template<int size, bool big_endian> 1256void 1257Eh_frame::do_sized_write(unsigned char* oview) 1258{ 1259 uint64_t address = this->address(); 1260 unsigned int addralign = this->addralign(); 1261 section_offset_type o = 0; 1262 const off_t output_offset = this->offset() - this->output_section()->offset(); 1263 Post_fdes post_fdes; 1264 for (Unmergeable_cie_offsets::iterator p = 1265 this->unmergeable_cie_offsets_.begin(); 1266 p != this->unmergeable_cie_offsets_.end(); 1267 ++p) 1268 o = (*p)->write<size, big_endian>(oview, output_offset, o, address, 1269 addralign, this->eh_frame_hdr_, 1270 &post_fdes); 1271 for (Cie_offsets::iterator p = this->cie_offsets_.begin(); 1272 p != this->cie_offsets_.end(); 1273 ++p) 1274 o = (*p)->write<size, big_endian>(oview, output_offset, o, address, 1275 addralign, this->eh_frame_hdr_, 1276 &post_fdes); 1277 for (Post_fdes::iterator p = post_fdes.begin(); 1278 p != post_fdes.end(); 1279 ++p) 1280 o = (*p).fde->write<size, big_endian>(oview, output_offset, o, address, 1281 addralign, (*p).cie_offset, 1282 (*p).fde_encoding, 1283 this->eh_frame_hdr_); 1284} 1285 1286#ifdef HAVE_TARGET_32_LITTLE 1287template 1288Eh_frame::Eh_frame_section_disposition 1289Eh_frame::add_ehframe_input_section<32, false>( 1290 Sized_relobj_file<32, false>* object, 1291 const unsigned char* symbols, 1292 section_size_type symbols_size, 1293 const unsigned char* symbol_names, 1294 section_size_type symbol_names_size, 1295 unsigned int shndx, 1296 unsigned int reloc_shndx, 1297 unsigned int reloc_type); 1298#endif 1299 1300#ifdef HAVE_TARGET_32_BIG 1301template 1302Eh_frame::Eh_frame_section_disposition 1303Eh_frame::add_ehframe_input_section<32, true>( 1304 Sized_relobj_file<32, true>* object, 1305 const unsigned char* symbols, 1306 section_size_type symbols_size, 1307 const unsigned char* symbol_names, 1308 section_size_type symbol_names_size, 1309 unsigned int shndx, 1310 unsigned int reloc_shndx, 1311 unsigned int reloc_type); 1312#endif 1313 1314#ifdef HAVE_TARGET_64_LITTLE 1315template 1316Eh_frame::Eh_frame_section_disposition 1317Eh_frame::add_ehframe_input_section<64, false>( 1318 Sized_relobj_file<64, false>* object, 1319 const unsigned char* symbols, 1320 section_size_type symbols_size, 1321 const unsigned char* symbol_names, 1322 section_size_type symbol_names_size, 1323 unsigned int shndx, 1324 unsigned int reloc_shndx, 1325 unsigned int reloc_type); 1326#endif 1327 1328#ifdef HAVE_TARGET_64_BIG 1329template 1330Eh_frame::Eh_frame_section_disposition 1331Eh_frame::add_ehframe_input_section<64, true>( 1332 Sized_relobj_file<64, true>* object, 1333 const unsigned char* symbols, 1334 section_size_type symbols_size, 1335 const unsigned char* symbol_names, 1336 section_size_type symbol_names_size, 1337 unsigned int shndx, 1338 unsigned int reloc_shndx, 1339 unsigned int reloc_type); 1340#endif 1341 1342} // End namespace gold. 1343