1 // ehframe.cc -- handle exception frame sections for gold 2 3 // Copyright (C) 2006-2020 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. 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 335 template<int size, bool big_endian> 336 section_offset_type 337 Fde::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 402 Cie::~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 412 section_offset_type 413 Cie::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 453 template<int size, bool big_endian> 454 section_offset_type 455 Cie::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 511 bool 512 operator==(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 520 bool 521 operator<(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 530 Eh_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 543 bool 544 Eh_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 569 template<int size, bool big_endian> 570 Eh_frame::Eh_frame_section_disposition 571 Eh_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 632 template<int size, bool big_endian> 633 bool 634 Eh_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 719 template<int size, bool big_endian> 720 bool 721 Eh_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 973 template<int size, bool big_endian> 974 bool 975 Eh_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 1121 void 1122 Eh_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 // Remove all post-map unwind information for a PLT. 1147 1148 void 1149 Eh_frame::remove_ehframe_for_plt(Output_data* plt, 1150 const unsigned char* cie_data, 1151 size_t cie_length) 1152 { 1153 if (!this->mappings_are_done_) 1154 return; 1155 1156 Cie cie(NULL, 0, 0, elfcpp::DW_EH_PE_pcrel | elfcpp::DW_EH_PE_sdata4, "", 1157 cie_data, cie_length); 1158 Cie_offsets::iterator find_cie = this->cie_offsets_.find(&cie); 1159 gold_assert (find_cie != this->cie_offsets_.end()); 1160 Cie* pcie = *find_cie; 1161 1162 while (pcie->fde_count() != 0) 1163 { 1164 const Fde* fde = pcie->last_fde(); 1165 if (!fde->post_map(plt)) 1166 break; 1167 size_t length = fde->length(); 1168 this->final_data_size_ -= align_address(length + 8, this->addralign()); 1169 pcie->remove_fde(); 1170 } 1171 } 1172 1173 // Return the number of FDEs. 1174 1175 unsigned int 1176 Eh_frame::fde_count() const 1177 { 1178 unsigned int ret = 0; 1179 for (Unmergeable_cie_offsets::const_iterator p = 1180 this->unmergeable_cie_offsets_.begin(); 1181 p != this->unmergeable_cie_offsets_.end(); 1182 ++p) 1183 ret += (*p)->fde_count(); 1184 for (Cie_offsets::const_iterator p = this->cie_offsets_.begin(); 1185 p != this->cie_offsets_.end(); 1186 ++p) 1187 ret += (*p)->fde_count(); 1188 return ret; 1189 } 1190 1191 // Set the final data size. 1192 1193 void 1194 Eh_frame::set_final_data_size() 1195 { 1196 // We can be called more than once if Layout::set_segment_offsets 1197 // finds a better mapping. We don't want to add all the mappings 1198 // again. 1199 if (this->mappings_are_done_) 1200 { 1201 this->set_data_size(this->final_data_size_); 1202 return; 1203 } 1204 1205 section_offset_type output_start = 0; 1206 if (this->is_offset_valid()) 1207 output_start = this->offset() - this->output_section()->offset(); 1208 section_offset_type output_offset = output_start; 1209 1210 for (Unmergeable_cie_offsets::iterator p = 1211 this->unmergeable_cie_offsets_.begin(); 1212 p != this->unmergeable_cie_offsets_.end(); 1213 ++p) 1214 output_offset = (*p)->set_output_offset(output_offset, 1215 this->addralign(), 1216 this); 1217 1218 for (Cie_offsets::iterator p = this->cie_offsets_.begin(); 1219 p != this->cie_offsets_.end(); 1220 ++p) 1221 output_offset = (*p)->set_output_offset(output_offset, 1222 this->addralign(), 1223 this); 1224 1225 this->mappings_are_done_ = true; 1226 this->final_data_size_ = output_offset - output_start; 1227 1228 gold_assert((output_offset & (this->addralign() - 1)) == 0); 1229 this->set_data_size(this->final_data_size_); 1230 } 1231 1232 // Return an output offset for an input offset. 1233 1234 bool 1235 Eh_frame::do_output_offset(const Relobj* object, unsigned int shndx, 1236 section_offset_type offset, 1237 section_offset_type* poutput) const 1238 { 1239 return object->merge_output_offset(shndx, offset, poutput); 1240 } 1241 1242 // Write the data to the output file. 1243 1244 void 1245 Eh_frame::do_write(Output_file* of) 1246 { 1247 const off_t offset = this->offset(); 1248 const off_t oview_size = this->data_size(); 1249 unsigned char* const oview = of->get_output_view(offset, oview_size); 1250 1251 switch (parameters->size_and_endianness()) 1252 { 1253 #ifdef HAVE_TARGET_32_LITTLE 1254 case Parameters::TARGET_32_LITTLE: 1255 this->do_sized_write<32, false>(oview); 1256 break; 1257 #endif 1258 #ifdef HAVE_TARGET_32_BIG 1259 case Parameters::TARGET_32_BIG: 1260 this->do_sized_write<32, true>(oview); 1261 break; 1262 #endif 1263 #ifdef HAVE_TARGET_64_LITTLE 1264 case Parameters::TARGET_64_LITTLE: 1265 this->do_sized_write<64, false>(oview); 1266 break; 1267 #endif 1268 #ifdef HAVE_TARGET_64_BIG 1269 case Parameters::TARGET_64_BIG: 1270 this->do_sized_write<64, true>(oview); 1271 break; 1272 #endif 1273 default: 1274 gold_unreachable(); 1275 } 1276 1277 of->write_output_view(offset, oview_size, oview); 1278 } 1279 1280 // Write the data to the output file--template version. 1281 1282 template<int size, bool big_endian> 1283 void 1284 Eh_frame::do_sized_write(unsigned char* oview) 1285 { 1286 uint64_t address = this->address(); 1287 unsigned int addralign = this->addralign(); 1288 section_offset_type o = 0; 1289 const off_t output_offset = this->offset() - this->output_section()->offset(); 1290 Post_fdes post_fdes; 1291 for (Unmergeable_cie_offsets::iterator p = 1292 this->unmergeable_cie_offsets_.begin(); 1293 p != this->unmergeable_cie_offsets_.end(); 1294 ++p) 1295 o = (*p)->write<size, big_endian>(oview, output_offset, o, address, 1296 addralign, this->eh_frame_hdr_, 1297 &post_fdes); 1298 for (Cie_offsets::iterator p = this->cie_offsets_.begin(); 1299 p != this->cie_offsets_.end(); 1300 ++p) 1301 o = (*p)->write<size, big_endian>(oview, output_offset, o, address, 1302 addralign, this->eh_frame_hdr_, 1303 &post_fdes); 1304 for (Post_fdes::iterator p = post_fdes.begin(); 1305 p != post_fdes.end(); 1306 ++p) 1307 o = (*p).fde->write<size, big_endian>(oview, output_offset, o, address, 1308 addralign, (*p).cie_offset, 1309 (*p).fde_encoding, 1310 this->eh_frame_hdr_); 1311 } 1312 1313 #ifdef HAVE_TARGET_32_LITTLE 1314 template 1315 Eh_frame::Eh_frame_section_disposition 1316 Eh_frame::add_ehframe_input_section<32, false>( 1317 Sized_relobj_file<32, false>* object, 1318 const unsigned char* symbols, 1319 section_size_type symbols_size, 1320 const unsigned char* symbol_names, 1321 section_size_type symbol_names_size, 1322 unsigned int shndx, 1323 unsigned int reloc_shndx, 1324 unsigned int reloc_type); 1325 #endif 1326 1327 #ifdef HAVE_TARGET_32_BIG 1328 template 1329 Eh_frame::Eh_frame_section_disposition 1330 Eh_frame::add_ehframe_input_section<32, true>( 1331 Sized_relobj_file<32, true>* object, 1332 const unsigned char* symbols, 1333 section_size_type symbols_size, 1334 const unsigned char* symbol_names, 1335 section_size_type symbol_names_size, 1336 unsigned int shndx, 1337 unsigned int reloc_shndx, 1338 unsigned int reloc_type); 1339 #endif 1340 1341 #ifdef HAVE_TARGET_64_LITTLE 1342 template 1343 Eh_frame::Eh_frame_section_disposition 1344 Eh_frame::add_ehframe_input_section<64, false>( 1345 Sized_relobj_file<64, false>* object, 1346 const unsigned char* symbols, 1347 section_size_type symbols_size, 1348 const unsigned char* symbol_names, 1349 section_size_type symbol_names_size, 1350 unsigned int shndx, 1351 unsigned int reloc_shndx, 1352 unsigned int reloc_type); 1353 #endif 1354 1355 #ifdef HAVE_TARGET_64_BIG 1356 template 1357 Eh_frame::Eh_frame_section_disposition 1358 Eh_frame::add_ehframe_input_section<64, true>( 1359 Sized_relobj_file<64, true>* object, 1360 const unsigned char* symbols, 1361 section_size_type symbols_size, 1362 const unsigned char* symbol_names, 1363 section_size_type symbol_names_size, 1364 unsigned int shndx, 1365 unsigned int reloc_shndx, 1366 unsigned int reloc_type); 1367 #endif 1368 1369 } // End namespace gold. 1370