1 // inremental.cc -- incremental linking support for gold 2 3 // Copyright (C) 2009-2014 Free Software Foundation, Inc. 4 // Written by Mikolaj Zalewski <mikolajz (at) 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 <set> 26 #include <cstdarg> 27 #include "libiberty.h" 28 29 #include "elfcpp.h" 30 #include "options.h" 31 #include "output.h" 32 #include "symtab.h" 33 #include "incremental.h" 34 #include "archive.h" 35 #include "object.h" 36 #include "target-select.h" 37 #include "target.h" 38 #include "fileread.h" 39 #include "script.h" 40 41 namespace gold { 42 43 // Version number for the .gnu_incremental_inputs section. 44 // Version 1 was the initial checkin. 45 // Version 2 adds some padding to ensure 8-byte alignment where necessary. 46 const unsigned int INCREMENTAL_LINK_VERSION = 2; 47 48 // This class manages the .gnu_incremental_inputs section, which holds 49 // the header information, a directory of input files, and separate 50 // entries for each input file. 51 52 template<int size, bool big_endian> 53 class Output_section_incremental_inputs : public Output_section_data 54 { 55 public: 56 Output_section_incremental_inputs(const Incremental_inputs* inputs, 57 const Symbol_table* symtab) 58 : Output_section_data(size / 8), inputs_(inputs), symtab_(symtab) 59 { } 60 61 protected: 62 // This is called to update the section size prior to assigning 63 // the address and file offset. 64 void 65 update_data_size() 66 { this->set_final_data_size(); } 67 68 // Set the final data size. 69 void 70 set_final_data_size(); 71 72 // Write the data to the file. 73 void 74 do_write(Output_file*); 75 76 // Write to a map file. 77 void 78 do_print_to_mapfile(Mapfile* mapfile) const 79 { mapfile->print_output_data(this, _("** incremental_inputs")); } 80 81 private: 82 // Write the section header. 83 unsigned char* 84 write_header(unsigned char* pov, unsigned int input_file_count, 85 section_offset_type command_line_offset); 86 87 // Write the input file entries. 88 unsigned char* 89 write_input_files(unsigned char* oview, unsigned char* pov, 90 Stringpool* strtab); 91 92 // Write the supplemental information blocks. 93 unsigned char* 94 write_info_blocks(unsigned char* oview, unsigned char* pov, 95 Stringpool* strtab, unsigned int* global_syms, 96 unsigned int global_sym_count); 97 98 // Write the contents of the .gnu_incremental_symtab section. 99 void 100 write_symtab(unsigned char* pov, unsigned int* global_syms, 101 unsigned int global_sym_count); 102 103 // Write the contents of the .gnu_incremental_got_plt section. 104 void 105 write_got_plt(unsigned char* pov, off_t view_size); 106 107 // Typedefs for writing the data to the output sections. 108 typedef elfcpp::Swap<size, big_endian> Swap; 109 typedef elfcpp::Swap<16, big_endian> Swap16; 110 typedef elfcpp::Swap<32, big_endian> Swap32; 111 typedef elfcpp::Swap<64, big_endian> Swap64; 112 113 // Sizes of various structures. 114 static const int sizeof_addr = size / 8; 115 static const int header_size = 116 Incremental_inputs_reader<size, big_endian>::header_size; 117 static const int input_entry_size = 118 Incremental_inputs_reader<size, big_endian>::input_entry_size; 119 static const unsigned int object_info_size = 120 Incremental_inputs_reader<size, big_endian>::object_info_size; 121 static const unsigned int input_section_entry_size = 122 Incremental_inputs_reader<size, big_endian>::input_section_entry_size; 123 static const unsigned int global_sym_entry_size = 124 Incremental_inputs_reader<size, big_endian>::global_sym_entry_size; 125 static const unsigned int incr_reloc_size = 126 Incremental_relocs_reader<size, big_endian>::reloc_size; 127 128 // The Incremental_inputs object. 129 const Incremental_inputs* inputs_; 130 131 // The symbol table. 132 const Symbol_table* symtab_; 133 }; 134 135 // Inform the user why we don't do an incremental link. Not called in 136 // the obvious case of missing output file. TODO: Is this helpful? 137 138 void 139 vexplain_no_incremental(const char* format, va_list args) 140 { 141 char* buf = NULL; 142 if (vasprintf(&buf, format, args) < 0) 143 gold_nomem(); 144 gold_info(_("the link might take longer: " 145 "cannot perform incremental link: %s"), buf); 146 free(buf); 147 } 148 149 void 150 explain_no_incremental(const char* format, ...) 151 { 152 va_list args; 153 va_start(args, format); 154 vexplain_no_incremental(format, args); 155 va_end(args); 156 } 157 158 // Report an error. 159 160 void 161 Incremental_binary::error(const char* format, ...) const 162 { 163 va_list args; 164 va_start(args, format); 165 // Current code only checks if the file can be used for incremental linking, 166 // so errors shouldn't fail the build, but only result in a fallback to a 167 // full build. 168 // TODO: when we implement incremental editing of the file, we may need a 169 // flag that will cause errors to be treated seriously. 170 vexplain_no_incremental(format, args); 171 va_end(args); 172 } 173 174 // Return TRUE if a section of type SH_TYPE can be updated in place 175 // during an incremental update. We can update sections of type PROGBITS, 176 // NOBITS, INIT_ARRAY, FINI_ARRAY, PREINIT_ARRAY, and NOTE. All others 177 // will be regenerated. 178 179 bool 180 can_incremental_update(unsigned int sh_type) 181 { 182 return (sh_type == elfcpp::SHT_PROGBITS 183 || sh_type == elfcpp::SHT_NOBITS 184 || sh_type == elfcpp::SHT_INIT_ARRAY 185 || sh_type == elfcpp::SHT_FINI_ARRAY 186 || sh_type == elfcpp::SHT_PREINIT_ARRAY 187 || sh_type == elfcpp::SHT_NOTE); 188 } 189 190 // Find the .gnu_incremental_inputs section and related sections. 191 192 template<int size, bool big_endian> 193 bool 194 Sized_incremental_binary<size, big_endian>::find_incremental_inputs_sections( 195 unsigned int* p_inputs_shndx, 196 unsigned int* p_symtab_shndx, 197 unsigned int* p_relocs_shndx, 198 unsigned int* p_got_plt_shndx, 199 unsigned int* p_strtab_shndx) 200 { 201 unsigned int inputs_shndx = 202 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_INPUTS); 203 if (inputs_shndx == elfcpp::SHN_UNDEF) // Not found. 204 return false; 205 206 unsigned int symtab_shndx = 207 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_SYMTAB); 208 if (symtab_shndx == elfcpp::SHN_UNDEF) // Not found. 209 return false; 210 if (this->elf_file_.section_link(symtab_shndx) != inputs_shndx) 211 return false; 212 213 unsigned int relocs_shndx = 214 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_RELOCS); 215 if (relocs_shndx == elfcpp::SHN_UNDEF) // Not found. 216 return false; 217 if (this->elf_file_.section_link(relocs_shndx) != inputs_shndx) 218 return false; 219 220 unsigned int got_plt_shndx = 221 this->elf_file_.find_section_by_type(elfcpp::SHT_GNU_INCREMENTAL_GOT_PLT); 222 if (got_plt_shndx == elfcpp::SHN_UNDEF) // Not found. 223 return false; 224 if (this->elf_file_.section_link(got_plt_shndx) != inputs_shndx) 225 return false; 226 227 unsigned int strtab_shndx = this->elf_file_.section_link(inputs_shndx); 228 if (strtab_shndx == elfcpp::SHN_UNDEF 229 || strtab_shndx > this->elf_file_.shnum() 230 || this->elf_file_.section_type(strtab_shndx) != elfcpp::SHT_STRTAB) 231 return false; 232 233 if (p_inputs_shndx != NULL) 234 *p_inputs_shndx = inputs_shndx; 235 if (p_symtab_shndx != NULL) 236 *p_symtab_shndx = symtab_shndx; 237 if (p_relocs_shndx != NULL) 238 *p_relocs_shndx = relocs_shndx; 239 if (p_got_plt_shndx != NULL) 240 *p_got_plt_shndx = got_plt_shndx; 241 if (p_strtab_shndx != NULL) 242 *p_strtab_shndx = strtab_shndx; 243 return true; 244 } 245 246 // Set up the readers into the incremental info sections. 247 248 template<int size, bool big_endian> 249 void 250 Sized_incremental_binary<size, big_endian>::setup_readers() 251 { 252 unsigned int inputs_shndx; 253 unsigned int symtab_shndx; 254 unsigned int relocs_shndx; 255 unsigned int got_plt_shndx; 256 unsigned int strtab_shndx; 257 258 if (!this->find_incremental_inputs_sections(&inputs_shndx, &symtab_shndx, 259 &relocs_shndx, &got_plt_shndx, 260 &strtab_shndx)) 261 return; 262 263 Location inputs_location(this->elf_file_.section_contents(inputs_shndx)); 264 Location symtab_location(this->elf_file_.section_contents(symtab_shndx)); 265 Location relocs_location(this->elf_file_.section_contents(relocs_shndx)); 266 Location got_plt_location(this->elf_file_.section_contents(got_plt_shndx)); 267 Location strtab_location(this->elf_file_.section_contents(strtab_shndx)); 268 269 View inputs_view = this->view(inputs_location); 270 View symtab_view = this->view(symtab_location); 271 View relocs_view = this->view(relocs_location); 272 View got_plt_view = this->view(got_plt_location); 273 View strtab_view = this->view(strtab_location); 274 275 elfcpp::Elf_strtab strtab(strtab_view.data(), strtab_location.data_size); 276 277 this->inputs_reader_ = 278 Incremental_inputs_reader<size, big_endian>(inputs_view.data(), strtab); 279 this->symtab_reader_ = 280 Incremental_symtab_reader<big_endian>(symtab_view.data(), 281 symtab_location.data_size); 282 this->relocs_reader_ = 283 Incremental_relocs_reader<size, big_endian>(relocs_view.data(), 284 relocs_location.data_size); 285 this->got_plt_reader_ = 286 Incremental_got_plt_reader<big_endian>(got_plt_view.data()); 287 288 // Find the main symbol table. 289 unsigned int main_symtab_shndx = 290 this->elf_file_.find_section_by_type(elfcpp::SHT_SYMTAB); 291 gold_assert(main_symtab_shndx != elfcpp::SHN_UNDEF); 292 this->main_symtab_loc_ = this->elf_file_.section_contents(main_symtab_shndx); 293 294 // Find the main symbol string table. 295 unsigned int main_strtab_shndx = 296 this->elf_file_.section_link(main_symtab_shndx); 297 gold_assert(main_strtab_shndx != elfcpp::SHN_UNDEF 298 && main_strtab_shndx < this->elf_file_.shnum()); 299 this->main_strtab_loc_ = this->elf_file_.section_contents(main_strtab_shndx); 300 301 // Walk the list of input files (a) to setup an Input_reader for each 302 // input file, and (b) to record maps of files added from archive 303 // libraries and scripts. 304 Incremental_inputs_reader<size, big_endian>& inputs = this->inputs_reader_; 305 unsigned int count = inputs.input_file_count(); 306 this->input_objects_.resize(count); 307 this->input_entry_readers_.reserve(count); 308 this->library_map_.resize(count); 309 this->script_map_.resize(count); 310 for (unsigned int i = 0; i < count; i++) 311 { 312 Input_entry_reader input_file = inputs.input_file(i); 313 this->input_entry_readers_.push_back(Sized_input_reader(input_file)); 314 switch (input_file.type()) 315 { 316 case INCREMENTAL_INPUT_OBJECT: 317 case INCREMENTAL_INPUT_ARCHIVE_MEMBER: 318 case INCREMENTAL_INPUT_SHARED_LIBRARY: 319 // No special treatment necessary. 320 break; 321 case INCREMENTAL_INPUT_ARCHIVE: 322 { 323 Incremental_library* lib = 324 new Incremental_library(input_file.filename(), i, 325 &this->input_entry_readers_[i]); 326 this->library_map_[i] = lib; 327 unsigned int member_count = input_file.get_member_count(); 328 for (unsigned int j = 0; j < member_count; j++) 329 { 330 int member_offset = input_file.get_member_offset(j); 331 int member_index = inputs.input_file_index(member_offset); 332 this->library_map_[member_index] = lib; 333 } 334 } 335 break; 336 case INCREMENTAL_INPUT_SCRIPT: 337 { 338 Script_info* script = new Script_info(input_file.filename(), i); 339 this->script_map_[i] = script; 340 unsigned int object_count = input_file.get_object_count(); 341 for (unsigned int j = 0; j < object_count; j++) 342 { 343 int object_offset = input_file.get_object_offset(j); 344 int object_index = inputs.input_file_index(object_offset); 345 this->script_map_[object_index] = script; 346 } 347 } 348 break; 349 default: 350 gold_unreachable(); 351 } 352 } 353 354 // Initialize the map of global symbols. 355 unsigned int nglobals = this->symtab_reader_.symbol_count(); 356 this->symbol_map_.resize(nglobals); 357 358 this->has_incremental_info_ = true; 359 } 360 361 // Walk the list of input files given on the command line, and build 362 // a direct map of file index to the corresponding input argument. 363 364 void 365 check_input_args(std::vector<const Input_argument*>& input_args_map, 366 Input_arguments::const_iterator begin, 367 Input_arguments::const_iterator end) 368 { 369 for (Input_arguments::const_iterator p = begin; 370 p != end; 371 ++p) 372 { 373 if (p->is_group()) 374 { 375 const Input_file_group* group = p->group(); 376 check_input_args(input_args_map, group->begin(), group->end()); 377 } 378 else if (p->is_lib()) 379 { 380 const Input_file_lib* lib = p->lib(); 381 check_input_args(input_args_map, lib->begin(), lib->end()); 382 } 383 else 384 { 385 gold_assert(p->is_file()); 386 unsigned int arg_serial = p->file().arg_serial(); 387 if (arg_serial > 0) 388 { 389 gold_assert(arg_serial <= input_args_map.size()); 390 gold_assert(input_args_map[arg_serial - 1] == 0); 391 input_args_map[arg_serial - 1] = &*p; 392 } 393 } 394 } 395 } 396 397 // Determine whether an incremental link based on the existing output file 398 // can be done. 399 400 template<int size, bool big_endian> 401 bool 402 Sized_incremental_binary<size, big_endian>::do_check_inputs( 403 const Command_line& cmdline, 404 Incremental_inputs* incremental_inputs) 405 { 406 Incremental_inputs_reader<size, big_endian>& inputs = this->inputs_reader_; 407 408 if (!this->has_incremental_info_) 409 { 410 explain_no_incremental(_("no incremental data from previous build")); 411 return false; 412 } 413 414 if (inputs.version() != INCREMENTAL_LINK_VERSION) 415 { 416 explain_no_incremental(_("different version of incremental build data")); 417 return false; 418 } 419 420 if (incremental_inputs->command_line() != inputs.command_line()) 421 { 422 gold_debug(DEBUG_INCREMENTAL, 423 "old command line: %s", 424 inputs.command_line()); 425 gold_debug(DEBUG_INCREMENTAL, 426 "new command line: %s", 427 incremental_inputs->command_line().c_str()); 428 explain_no_incremental(_("command line changed")); 429 return false; 430 } 431 432 // Walk the list of input files given on the command line, and build 433 // a direct map of argument serial numbers to the corresponding input 434 // arguments. 435 this->input_args_map_.resize(cmdline.number_of_input_files()); 436 check_input_args(this->input_args_map_, cmdline.begin(), cmdline.end()); 437 438 // Walk the list of input files to check for conditions that prevent 439 // an incremental update link. 440 unsigned int count = inputs.input_file_count(); 441 for (unsigned int i = 0; i < count; i++) 442 { 443 Input_entry_reader input_file = inputs.input_file(i); 444 switch (input_file.type()) 445 { 446 case INCREMENTAL_INPUT_OBJECT: 447 case INCREMENTAL_INPUT_ARCHIVE_MEMBER: 448 case INCREMENTAL_INPUT_SHARED_LIBRARY: 449 case INCREMENTAL_INPUT_ARCHIVE: 450 // No special treatment necessary. 451 break; 452 case INCREMENTAL_INPUT_SCRIPT: 453 if (this->do_file_has_changed(i)) 454 { 455 explain_no_incremental(_("%s: script file changed"), 456 input_file.filename()); 457 return false; 458 } 459 break; 460 default: 461 gold_unreachable(); 462 } 463 } 464 465 return true; 466 } 467 468 // Return TRUE if input file N has changed since the last incremental link. 469 470 template<int size, bool big_endian> 471 bool 472 Sized_incremental_binary<size, big_endian>::do_file_has_changed( 473 unsigned int n) const 474 { 475 Input_entry_reader input_file = this->inputs_reader_.input_file(n); 476 Incremental_disposition disp = INCREMENTAL_CHECK; 477 478 // For files named in scripts, find the file that was actually named 479 // on the command line, so that we can get the incremental disposition 480 // flag. 481 Script_info* script = this->get_script_info(n); 482 if (script != NULL) 483 n = script->input_file_index(); 484 485 const Input_argument* input_argument = this->get_input_argument(n); 486 if (input_argument != NULL) 487 disp = input_argument->file().options().incremental_disposition(); 488 489 // For files at the beginning of the command line (i.e., those added 490 // implicitly by gcc), check whether the --incremental-startup-unchanged 491 // option was used. 492 if (disp == INCREMENTAL_STARTUP) 493 disp = parameters->options().incremental_startup_disposition(); 494 495 if (disp != INCREMENTAL_CHECK) 496 return disp == INCREMENTAL_CHANGED; 497 498 const char* filename = input_file.filename(); 499 Timespec old_mtime = input_file.get_mtime(); 500 Timespec new_mtime; 501 if (!get_mtime(filename, &new_mtime)) 502 { 503 // If we can't open get the current modification time, assume it has 504 // changed. If the file doesn't exist, we'll issue an error when we 505 // try to open it later. 506 return true; 507 } 508 509 if (new_mtime.seconds > old_mtime.seconds) 510 return true; 511 if (new_mtime.seconds == old_mtime.seconds 512 && new_mtime.nanoseconds > old_mtime.nanoseconds) 513 return true; 514 return false; 515 } 516 517 // Initialize the layout of the output file based on the existing 518 // output file. 519 520 template<int size, bool big_endian> 521 void 522 Sized_incremental_binary<size, big_endian>::do_init_layout(Layout* layout) 523 { 524 typedef elfcpp::Shdr<size, big_endian> Shdr; 525 const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; 526 527 // Get views of the section headers and the section string table. 528 const off_t shoff = this->elf_file_.shoff(); 529 const unsigned int shnum = this->elf_file_.shnum(); 530 const unsigned int shstrndx = this->elf_file_.shstrndx(); 531 Location shdrs_location(shoff, shnum * shdr_size); 532 Location shstrndx_location(this->elf_file_.section_contents(shstrndx)); 533 View shdrs_view = this->view(shdrs_location); 534 View shstrndx_view = this->view(shstrndx_location); 535 elfcpp::Elf_strtab shstrtab(shstrndx_view.data(), 536 shstrndx_location.data_size); 537 538 layout->set_incremental_base(this); 539 540 // Initialize the layout. 541 this->section_map_.resize(shnum); 542 const unsigned char* pshdr = shdrs_view.data() + shdr_size; 543 for (unsigned int i = 1; i < shnum; i++) 544 { 545 Shdr shdr(pshdr); 546 const char* name; 547 if (!shstrtab.get_c_string(shdr.get_sh_name(), &name)) 548 name = NULL; 549 gold_debug(DEBUG_INCREMENTAL, 550 "Output section: %2d %08lx %08lx %08lx %3d %s", 551 i, 552 static_cast<long>(shdr.get_sh_addr()), 553 static_cast<long>(shdr.get_sh_offset()), 554 static_cast<long>(shdr.get_sh_size()), 555 shdr.get_sh_type(), name ? name : "<null>"); 556 this->section_map_[i] = layout->init_fixed_output_section(name, shdr); 557 pshdr += shdr_size; 558 } 559 } 560 561 // Mark regions of the input file that must be kept unchanged. 562 563 template<int size, bool big_endian> 564 void 565 Sized_incremental_binary<size, big_endian>::do_reserve_layout( 566 unsigned int input_file_index) 567 { 568 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 569 570 Input_entry_reader input_file = 571 this->inputs_reader_.input_file(input_file_index); 572 573 if (input_file.type() == INCREMENTAL_INPUT_SHARED_LIBRARY) 574 { 575 // Reserve the BSS space used for COPY relocations. 576 unsigned int nsyms = input_file.get_global_symbol_count(); 577 Incremental_binary::View symtab_view(NULL); 578 unsigned int symtab_count; 579 elfcpp::Elf_strtab strtab(NULL, 0); 580 this->get_symtab_view(&symtab_view, &symtab_count, &strtab); 581 for (unsigned int i = 0; i < nsyms; ++i) 582 { 583 bool is_def; 584 bool is_copy; 585 unsigned int output_symndx = 586 input_file.get_output_symbol_index(i, &is_def, &is_copy); 587 if (is_copy) 588 { 589 const unsigned char* sym_p = (symtab_view.data() 590 + output_symndx * sym_size); 591 elfcpp::Sym<size, big_endian> gsym(sym_p); 592 unsigned int shndx = gsym.get_st_shndx(); 593 if (shndx < 1 || shndx >= this->section_map_.size()) 594 continue; 595 Output_section* os = this->section_map_[shndx]; 596 off_t offset = gsym.get_st_value() - os->address(); 597 os->reserve(offset, gsym.get_st_size()); 598 gold_debug(DEBUG_INCREMENTAL, 599 "Reserve for COPY reloc: %s, off %d, size %d", 600 os->name(), 601 static_cast<int>(offset), 602 static_cast<int>(gsym.get_st_size())); 603 } 604 } 605 return; 606 } 607 608 unsigned int shnum = input_file.get_input_section_count(); 609 for (unsigned int i = 0; i < shnum; i++) 610 { 611 typename Input_entry_reader::Input_section_info sect = 612 input_file.get_input_section(i); 613 if (sect.output_shndx == 0 || sect.sh_offset == -1) 614 continue; 615 Output_section* os = this->section_map_[sect.output_shndx]; 616 gold_assert(os != NULL); 617 os->reserve(sect.sh_offset, sect.sh_size); 618 } 619 } 620 621 // Process the GOT and PLT entries from the existing output file. 622 623 template<int size, bool big_endian> 624 void 625 Sized_incremental_binary<size, big_endian>::do_process_got_plt( 626 Symbol_table* symtab, 627 Layout* layout) 628 { 629 Incremental_got_plt_reader<big_endian> got_plt_reader(this->got_plt_reader()); 630 Sized_target<size, big_endian>* target = 631 parameters->sized_target<size, big_endian>(); 632 633 // Get the number of symbols in the main symbol table and in the 634 // incremental symbol table. The difference between the two counts 635 // is the index of the first forced-local or global symbol in the 636 // main symbol table. 637 unsigned int symtab_count = 638 this->main_symtab_loc_.data_size / elfcpp::Elf_sizes<size>::sym_size; 639 unsigned int isym_count = this->symtab_reader_.symbol_count(); 640 unsigned int first_global = symtab_count - isym_count; 641 642 // Tell the target how big the GOT and PLT sections are. 643 unsigned int got_count = got_plt_reader.get_got_entry_count(); 644 unsigned int plt_count = got_plt_reader.get_plt_entry_count(); 645 Output_data_got_base* got = 646 target->init_got_plt_for_update(symtab, layout, got_count, plt_count); 647 648 // Read the GOT entries from the base file and build the outgoing GOT. 649 for (unsigned int i = 0; i < got_count; ++i) 650 { 651 unsigned int got_type = got_plt_reader.get_got_type(i); 652 if ((got_type & 0x7f) == 0x7f) 653 { 654 // This is the second entry of a pair. 655 got->reserve_slot(i); 656 continue; 657 } 658 unsigned int symndx = got_plt_reader.get_got_symndx(i); 659 if (got_type & 0x80) 660 { 661 // This is an entry for a local symbol. Ignore this entry if 662 // the object file was replaced. 663 unsigned int input_index = got_plt_reader.get_got_input_index(i); 664 gold_debug(DEBUG_INCREMENTAL, 665 "GOT entry %d, type %02x: (local symbol)", 666 i, got_type & 0x7f); 667 Sized_relobj_incr<size, big_endian>* obj = 668 this->input_object(input_index); 669 if (obj != NULL) 670 target->reserve_local_got_entry(i, obj, symndx, got_type & 0x7f); 671 } 672 else 673 { 674 // This is an entry for a global symbol. GOT_DESC is the symbol 675 // table index. 676 // FIXME: This should really be a fatal error (corrupt input). 677 gold_assert(symndx >= first_global && symndx < symtab_count); 678 Symbol* sym = this->global_symbol(symndx - first_global); 679 // Add the GOT entry only if the symbol is still referenced. 680 if (sym != NULL && sym->in_reg()) 681 { 682 gold_debug(DEBUG_INCREMENTAL, 683 "GOT entry %d, type %02x: %s", 684 i, got_type, sym->name()); 685 target->reserve_global_got_entry(i, sym, got_type); 686 } 687 } 688 } 689 690 // Read the PLT entries from the base file and pass each to the target. 691 for (unsigned int i = 0; i < plt_count; ++i) 692 { 693 unsigned int plt_desc = got_plt_reader.get_plt_desc(i); 694 // FIXME: This should really be a fatal error (corrupt input). 695 gold_assert(plt_desc >= first_global && plt_desc < symtab_count); 696 Symbol* sym = this->global_symbol(plt_desc - first_global); 697 // Add the PLT entry only if the symbol is still referenced. 698 if (sym != NULL && sym->in_reg()) 699 { 700 gold_debug(DEBUG_INCREMENTAL, 701 "PLT entry %d: %s", 702 i, sym->name()); 703 target->register_global_plt_entry(symtab, layout, i, sym); 704 } 705 } 706 } 707 708 // Emit COPY relocations from the existing output file. 709 710 template<int size, bool big_endian> 711 void 712 Sized_incremental_binary<size, big_endian>::do_emit_copy_relocs( 713 Symbol_table* symtab) 714 { 715 Sized_target<size, big_endian>* target = 716 parameters->sized_target<size, big_endian>(); 717 718 for (typename Copy_relocs::iterator p = this->copy_relocs_.begin(); 719 p != this->copy_relocs_.end(); 720 ++p) 721 { 722 if (!(*p).symbol->is_copied_from_dynobj()) 723 target->emit_copy_reloc(symtab, (*p).symbol, (*p).output_section, 724 (*p).offset); 725 } 726 } 727 728 // Apply incremental relocations for symbols whose values have changed. 729 730 template<int size, bool big_endian> 731 void 732 Sized_incremental_binary<size, big_endian>::do_apply_incremental_relocs( 733 const Symbol_table* symtab, 734 Layout* layout, 735 Output_file* of) 736 { 737 typedef typename elfcpp::Elf_types<size>::Elf_Addr Address; 738 typedef typename elfcpp::Elf_types<size>::Elf_Swxword Addend; 739 Incremental_symtab_reader<big_endian> isymtab(this->symtab_reader()); 740 Incremental_relocs_reader<size, big_endian> irelocs(this->relocs_reader()); 741 unsigned int nglobals = isymtab.symbol_count(); 742 const unsigned int incr_reloc_size = irelocs.reloc_size; 743 744 Relocate_info<size, big_endian> relinfo; 745 relinfo.symtab = symtab; 746 relinfo.layout = layout; 747 relinfo.object = NULL; 748 relinfo.reloc_shndx = 0; 749 relinfo.reloc_shdr = NULL; 750 relinfo.data_shndx = 0; 751 relinfo.data_shdr = NULL; 752 753 Sized_target<size, big_endian>* target = 754 parameters->sized_target<size, big_endian>(); 755 756 for (unsigned int i = 0; i < nglobals; i++) 757 { 758 const Symbol* gsym = this->global_symbol(i); 759 760 // If the symbol is not referenced from any unchanged input files, 761 // we do not need to reapply any of its relocations. 762 if (gsym == NULL) 763 continue; 764 765 // If the symbol is defined in an unchanged file, we do not need to 766 // reapply any of its relocations. 767 if (gsym->source() == Symbol::FROM_OBJECT 768 && gsym->object()->is_incremental()) 769 continue; 770 771 gold_debug(DEBUG_INCREMENTAL, 772 "Applying incremental relocations for global symbol %s [%d]", 773 gsym->name(), i); 774 775 // Follow the linked list of input symbol table entries for this symbol. 776 // We don't bother to figure out whether the symbol table entry belongs 777 // to a changed or unchanged file because it's easier just to apply all 778 // the relocations -- although we might scribble over an area that has 779 // been reallocated, we do this before copying any new data into the 780 // output file. 781 unsigned int offset = isymtab.get_list_head(i); 782 while (offset > 0) 783 { 784 Incremental_global_symbol_reader<big_endian> sym_info = 785 this->inputs_reader().global_symbol_reader_at_offset(offset); 786 unsigned int r_base = sym_info.reloc_offset(); 787 unsigned int r_count = sym_info.reloc_count(); 788 789 // Apply each relocation for this symbol table entry. 790 for (unsigned int j = 0; j < r_count; 791 ++j, r_base += incr_reloc_size) 792 { 793 unsigned int r_type = irelocs.get_r_type(r_base); 794 unsigned int r_shndx = irelocs.get_r_shndx(r_base); 795 Address r_offset = irelocs.get_r_offset(r_base); 796 Addend r_addend = irelocs.get_r_addend(r_base); 797 Output_section* os = this->output_section(r_shndx); 798 Address address = os->address(); 799 off_t section_offset = os->offset(); 800 size_t view_size = os->data_size(); 801 unsigned char* const view = of->get_output_view(section_offset, 802 view_size); 803 804 gold_debug(DEBUG_INCREMENTAL, 805 " %08lx: %s + %d: type %d addend %ld", 806 (long)(section_offset + r_offset), 807 os->name(), 808 (int)r_offset, 809 r_type, 810 (long)r_addend); 811 812 target->apply_relocation(&relinfo, r_offset, r_type, r_addend, 813 gsym, view, address, view_size); 814 815 // FIXME: Do something more efficient if write_output_view 816 // ever becomes more than a no-op. 817 of->write_output_view(section_offset, view_size, view); 818 } 819 offset = sym_info.next_offset(); 820 } 821 } 822 } 823 824 // Get a view of the main symbol table and the symbol string table. 825 826 template<int size, bool big_endian> 827 void 828 Sized_incremental_binary<size, big_endian>::get_symtab_view( 829 View* symtab_view, 830 unsigned int* nsyms, 831 elfcpp::Elf_strtab* strtab) 832 { 833 *symtab_view = this->view(this->main_symtab_loc_); 834 *nsyms = this->main_symtab_loc_.data_size / elfcpp::Elf_sizes<size>::sym_size; 835 836 View strtab_view(this->view(this->main_strtab_loc_)); 837 *strtab = elfcpp::Elf_strtab(strtab_view.data(), 838 this->main_strtab_loc_.data_size); 839 } 840 841 namespace 842 { 843 844 // Create a Sized_incremental_binary object of the specified size and 845 // endianness. Fails if the target architecture is not supported. 846 847 template<int size, bool big_endian> 848 Incremental_binary* 849 make_sized_incremental_binary(Output_file* file, 850 const elfcpp::Ehdr<size, big_endian>& ehdr) 851 { 852 Target* target = select_target(NULL, 0, // XXX 853 ehdr.get_e_machine(), size, big_endian, 854 ehdr.get_e_ident()[elfcpp::EI_OSABI], 855 ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]); 856 if (target == NULL) 857 { 858 explain_no_incremental(_("unsupported ELF machine number %d"), 859 ehdr.get_e_machine()); 860 return NULL; 861 } 862 863 if (!parameters->target_valid()) 864 set_parameters_target(target); 865 else if (target != ¶meters->target()) 866 gold_error(_("%s: incompatible target"), file->filename()); 867 868 return new Sized_incremental_binary<size, big_endian>(file, ehdr, target); 869 } 870 871 } // End of anonymous namespace. 872 873 // Create an Incremental_binary object for FILE. Returns NULL is this is not 874 // possible, e.g. FILE is not an ELF file or has an unsupported target. FILE 875 // should be opened. 876 877 Incremental_binary* 878 open_incremental_binary(Output_file* file) 879 { 880 off_t filesize = file->filesize(); 881 int want = elfcpp::Elf_recognizer::max_header_size; 882 if (filesize < want) 883 want = filesize; 884 885 const unsigned char* p = file->get_input_view(0, want); 886 if (!elfcpp::Elf_recognizer::is_elf_file(p, want)) 887 { 888 explain_no_incremental(_("output is not an ELF file.")); 889 return NULL; 890 } 891 892 int size = 0; 893 bool big_endian = false; 894 std::string error; 895 if (!elfcpp::Elf_recognizer::is_valid_header(p, want, &size, &big_endian, 896 &error)) 897 { 898 explain_no_incremental(error.c_str()); 899 return NULL; 900 } 901 902 Incremental_binary* result = NULL; 903 if (size == 32) 904 { 905 if (big_endian) 906 { 907 #ifdef HAVE_TARGET_32_BIG 908 result = make_sized_incremental_binary<32, true>( 909 file, elfcpp::Ehdr<32, true>(p)); 910 #else 911 explain_no_incremental(_("unsupported file: 32-bit, big-endian")); 912 #endif 913 } 914 else 915 { 916 #ifdef HAVE_TARGET_32_LITTLE 917 result = make_sized_incremental_binary<32, false>( 918 file, elfcpp::Ehdr<32, false>(p)); 919 #else 920 explain_no_incremental(_("unsupported file: 32-bit, little-endian")); 921 #endif 922 } 923 } 924 else if (size == 64) 925 { 926 if (big_endian) 927 { 928 #ifdef HAVE_TARGET_64_BIG 929 result = make_sized_incremental_binary<64, true>( 930 file, elfcpp::Ehdr<64, true>(p)); 931 #else 932 explain_no_incremental(_("unsupported file: 64-bit, big-endian")); 933 #endif 934 } 935 else 936 { 937 #ifdef HAVE_TARGET_64_LITTLE 938 result = make_sized_incremental_binary<64, false>( 939 file, elfcpp::Ehdr<64, false>(p)); 940 #else 941 explain_no_incremental(_("unsupported file: 64-bit, little-endian")); 942 #endif 943 } 944 } 945 else 946 gold_unreachable(); 947 948 return result; 949 } 950 951 // Class Incremental_inputs. 952 953 // Add the command line to the string table, setting 954 // command_line_key_. In incremental builds, the command line is 955 // stored in .gnu_incremental_inputs so that the next linker run can 956 // check if the command line options didn't change. 957 958 void 959 Incremental_inputs::report_command_line(int argc, const char* const* argv) 960 { 961 // Always store 'gold' as argv[0] to avoid a full relink if the user used a 962 // different path to the linker. 963 std::string args("gold"); 964 // Copied from collect_argv in main.cc. 965 for (int i = 1; i < argc; ++i) 966 { 967 // Adding/removing these options should not result in a full relink. 968 if (strcmp(argv[i], "--incremental") == 0 969 || strcmp(argv[i], "--incremental-full") == 0 970 || strcmp(argv[i], "--incremental-update") == 0 971 || strcmp(argv[i], "--incremental-changed") == 0 972 || strcmp(argv[i], "--incremental-unchanged") == 0 973 || strcmp(argv[i], "--incremental-unknown") == 0 974 || strcmp(argv[i], "--incremental-startup-unchanged") == 0 975 || is_prefix_of("--incremental-base=", argv[i]) 976 || is_prefix_of("--incremental-patch=", argv[i]) 977 || is_prefix_of("--debug=", argv[i])) 978 continue; 979 if (strcmp(argv[i], "--incremental-base") == 0 980 || strcmp(argv[i], "--incremental-patch") == 0 981 || strcmp(argv[i], "--debug") == 0) 982 { 983 // When these options are used without the '=', skip the 984 // following parameter as well. 985 ++i; 986 continue; 987 } 988 989 args.append(" '"); 990 // Now append argv[i], but with all single-quotes escaped 991 const char* argpos = argv[i]; 992 while (1) 993 { 994 const int len = strcspn(argpos, "'"); 995 args.append(argpos, len); 996 if (argpos[len] == '\0') 997 break; 998 args.append("'\"'\"'"); 999 argpos += len + 1; 1000 } 1001 args.append("'"); 1002 } 1003 1004 this->command_line_ = args; 1005 this->strtab_->add(this->command_line_.c_str(), false, 1006 &this->command_line_key_); 1007 } 1008 1009 // Record the input archive file ARCHIVE. This is called by the 1010 // Add_archive_symbols task before determining which archive members 1011 // to include. We create the Incremental_archive_entry here and 1012 // attach it to the Archive, but we do not add it to the list of 1013 // input objects until report_archive_end is called. 1014 1015 void 1016 Incremental_inputs::report_archive_begin(Library_base* arch, 1017 unsigned int arg_serial, 1018 Script_info* script_info) 1019 { 1020 Stringpool::Key filename_key; 1021 Timespec mtime = arch->get_mtime(); 1022 1023 // For a file loaded from a script, don't record its argument serial number. 1024 if (script_info != NULL) 1025 arg_serial = 0; 1026 1027 this->strtab_->add(arch->filename().c_str(), false, &filename_key); 1028 Incremental_archive_entry* entry = 1029 new Incremental_archive_entry(filename_key, arg_serial, mtime); 1030 arch->set_incremental_info(entry); 1031 1032 if (script_info != NULL) 1033 { 1034 Incremental_script_entry* script_entry = script_info->incremental_info(); 1035 gold_assert(script_entry != NULL); 1036 script_entry->add_object(entry); 1037 } 1038 } 1039 1040 // Visitor class for processing the unused global symbols in a library. 1041 // An instance of this class is passed to the library's 1042 // for_all_unused_symbols() iterator, which will call the visit() 1043 // function for each global symbol defined in each unused library 1044 // member. We add those symbol names to the incremental info for the 1045 // library. 1046 1047 class Unused_symbol_visitor : public Library_base::Symbol_visitor_base 1048 { 1049 public: 1050 Unused_symbol_visitor(Incremental_archive_entry* entry, Stringpool* strtab) 1051 : entry_(entry), strtab_(strtab) 1052 { } 1053 1054 void 1055 visit(const char* sym) 1056 { 1057 Stringpool::Key symbol_key; 1058 this->strtab_->add(sym, true, &symbol_key); 1059 this->entry_->add_unused_global_symbol(symbol_key); 1060 } 1061 1062 private: 1063 Incremental_archive_entry* entry_; 1064 Stringpool* strtab_; 1065 }; 1066 1067 // Finish recording the input archive file ARCHIVE. This is called by the 1068 // Add_archive_symbols task after determining which archive members 1069 // to include. 1070 1071 void 1072 Incremental_inputs::report_archive_end(Library_base* arch) 1073 { 1074 Incremental_archive_entry* entry = arch->incremental_info(); 1075 1076 gold_assert(entry != NULL); 1077 this->inputs_.push_back(entry); 1078 1079 // Collect unused global symbols. 1080 Unused_symbol_visitor v(entry, this->strtab_); 1081 arch->for_all_unused_symbols(&v); 1082 } 1083 1084 // Record the input object file OBJ. If ARCH is not NULL, attach 1085 // the object file to the archive. This is called by the 1086 // Add_symbols task after finding out the type of the file. 1087 1088 void 1089 Incremental_inputs::report_object(Object* obj, unsigned int arg_serial, 1090 Library_base* arch, Script_info* script_info) 1091 { 1092 Stringpool::Key filename_key; 1093 Timespec mtime = obj->get_mtime(); 1094 1095 // For a file loaded from a script, don't record its argument serial number. 1096 if (script_info != NULL) 1097 arg_serial = 0; 1098 1099 this->strtab_->add(obj->name().c_str(), false, &filename_key); 1100 1101 Incremental_input_entry* input_entry; 1102 1103 this->current_object_ = obj; 1104 1105 if (!obj->is_dynamic()) 1106 { 1107 this->current_object_entry_ = 1108 new Incremental_object_entry(filename_key, obj, arg_serial, mtime); 1109 input_entry = this->current_object_entry_; 1110 if (arch != NULL) 1111 { 1112 Incremental_archive_entry* arch_entry = arch->incremental_info(); 1113 gold_assert(arch_entry != NULL); 1114 arch_entry->add_object(this->current_object_entry_); 1115 } 1116 } 1117 else 1118 { 1119 this->current_object_entry_ = NULL; 1120 Stringpool::Key soname_key; 1121 Dynobj* dynobj = obj->dynobj(); 1122 gold_assert(dynobj != NULL); 1123 this->strtab_->add(dynobj->soname(), false, &soname_key); 1124 input_entry = new Incremental_dynobj_entry(filename_key, soname_key, obj, 1125 arg_serial, mtime); 1126 } 1127 1128 if (obj->is_in_system_directory()) 1129 input_entry->set_is_in_system_directory(); 1130 1131 if (obj->as_needed()) 1132 input_entry->set_as_needed(); 1133 1134 this->inputs_.push_back(input_entry); 1135 1136 if (script_info != NULL) 1137 { 1138 Incremental_script_entry* script_entry = script_info->incremental_info(); 1139 gold_assert(script_entry != NULL); 1140 script_entry->add_object(input_entry); 1141 } 1142 } 1143 1144 // Record an input section SHNDX from object file OBJ. 1145 1146 void 1147 Incremental_inputs::report_input_section(Object* obj, unsigned int shndx, 1148 const char* name, off_t sh_size) 1149 { 1150 Stringpool::Key key = 0; 1151 1152 if (name != NULL) 1153 this->strtab_->add(name, true, &key); 1154 1155 gold_assert(obj == this->current_object_); 1156 gold_assert(this->current_object_entry_ != NULL); 1157 this->current_object_entry_->add_input_section(shndx, key, sh_size); 1158 } 1159 1160 // Record a kept COMDAT group belonging to object file OBJ. 1161 1162 void 1163 Incremental_inputs::report_comdat_group(Object* obj, const char* name) 1164 { 1165 Stringpool::Key key = 0; 1166 1167 if (name != NULL) 1168 this->strtab_->add(name, true, &key); 1169 gold_assert(obj == this->current_object_); 1170 gold_assert(this->current_object_entry_ != NULL); 1171 this->current_object_entry_->add_comdat_group(key); 1172 } 1173 1174 // Record that the input argument INPUT is a script SCRIPT. This is 1175 // called by read_script after parsing the script and reading the list 1176 // of inputs added by this script. 1177 1178 void 1179 Incremental_inputs::report_script(Script_info* script, 1180 unsigned int arg_serial, 1181 Timespec mtime) 1182 { 1183 Stringpool::Key filename_key; 1184 1185 this->strtab_->add(script->filename().c_str(), false, &filename_key); 1186 Incremental_script_entry* entry = 1187 new Incremental_script_entry(filename_key, arg_serial, script, mtime); 1188 this->inputs_.push_back(entry); 1189 script->set_incremental_info(entry); 1190 } 1191 1192 // Finalize the incremental link information. Called from 1193 // Layout::finalize. 1194 1195 void 1196 Incremental_inputs::finalize() 1197 { 1198 // Finalize the string table. 1199 this->strtab_->set_string_offsets(); 1200 } 1201 1202 // Create the .gnu_incremental_inputs, _symtab, and _relocs input sections. 1203 1204 void 1205 Incremental_inputs::create_data_sections(Symbol_table* symtab) 1206 { 1207 int reloc_align = 4; 1208 1209 switch (parameters->size_and_endianness()) 1210 { 1211 #ifdef HAVE_TARGET_32_LITTLE 1212 case Parameters::TARGET_32_LITTLE: 1213 this->inputs_section_ = 1214 new Output_section_incremental_inputs<32, false>(this, symtab); 1215 reloc_align = 4; 1216 break; 1217 #endif 1218 #ifdef HAVE_TARGET_32_BIG 1219 case Parameters::TARGET_32_BIG: 1220 this->inputs_section_ = 1221 new Output_section_incremental_inputs<32, true>(this, symtab); 1222 reloc_align = 4; 1223 break; 1224 #endif 1225 #ifdef HAVE_TARGET_64_LITTLE 1226 case Parameters::TARGET_64_LITTLE: 1227 this->inputs_section_ = 1228 new Output_section_incremental_inputs<64, false>(this, symtab); 1229 reloc_align = 8; 1230 break; 1231 #endif 1232 #ifdef HAVE_TARGET_64_BIG 1233 case Parameters::TARGET_64_BIG: 1234 this->inputs_section_ = 1235 new Output_section_incremental_inputs<64, true>(this, symtab); 1236 reloc_align = 8; 1237 break; 1238 #endif 1239 default: 1240 gold_unreachable(); 1241 } 1242 this->symtab_section_ = new Output_data_space(4, "** incremental_symtab"); 1243 this->relocs_section_ = new Output_data_space(reloc_align, 1244 "** incremental_relocs"); 1245 this->got_plt_section_ = new Output_data_space(4, "** incremental_got_plt"); 1246 } 1247 1248 // Return the sh_entsize value for the .gnu_incremental_relocs section. 1249 unsigned int 1250 Incremental_inputs::relocs_entsize() const 1251 { 1252 return 8 + 2 * parameters->target().get_size() / 8; 1253 } 1254 1255 // Class Output_section_incremental_inputs. 1256 1257 // Finalize the offsets for each input section and supplemental info block, 1258 // and set the final data size of the incremental output sections. 1259 1260 template<int size, bool big_endian> 1261 void 1262 Output_section_incremental_inputs<size, big_endian>::set_final_data_size() 1263 { 1264 const Incremental_inputs* inputs = this->inputs_; 1265 1266 // Offset of each input entry. 1267 unsigned int input_offset = this->header_size; 1268 1269 // Offset of each supplemental info block. 1270 unsigned int file_index = 0; 1271 unsigned int info_offset = this->header_size; 1272 info_offset += this->input_entry_size * inputs->input_file_count(); 1273 1274 // Count each input file and its supplemental information block. 1275 for (Incremental_inputs::Input_list::const_iterator p = 1276 inputs->input_files().begin(); 1277 p != inputs->input_files().end(); 1278 ++p) 1279 { 1280 // Set the index and offset of the input file entry. 1281 (*p)->set_offset(file_index, input_offset); 1282 ++file_index; 1283 input_offset += this->input_entry_size; 1284 1285 // Set the offset of the supplemental info block. 1286 switch ((*p)->type()) 1287 { 1288 case INCREMENTAL_INPUT_SCRIPT: 1289 { 1290 Incremental_script_entry *entry = (*p)->script_entry(); 1291 gold_assert(entry != NULL); 1292 (*p)->set_info_offset(info_offset); 1293 // Object count. 1294 info_offset += 4; 1295 // Each member. 1296 info_offset += (entry->get_object_count() * 4); 1297 } 1298 break; 1299 case INCREMENTAL_INPUT_OBJECT: 1300 case INCREMENTAL_INPUT_ARCHIVE_MEMBER: 1301 { 1302 Incremental_object_entry* entry = (*p)->object_entry(); 1303 gold_assert(entry != NULL); 1304 (*p)->set_info_offset(info_offset); 1305 // Input section count, global symbol count, local symbol offset, 1306 // local symbol count, first dynamic reloc, dynamic reloc count, 1307 // comdat group count. 1308 info_offset += this->object_info_size; 1309 // Each input section. 1310 info_offset += (entry->get_input_section_count() 1311 * this->input_section_entry_size); 1312 // Each global symbol. 1313 const Object::Symbols* syms = entry->object()->get_global_symbols(); 1314 info_offset += syms->size() * this->global_sym_entry_size; 1315 // Each comdat group. 1316 info_offset += entry->get_comdat_group_count() * 4; 1317 } 1318 break; 1319 case INCREMENTAL_INPUT_SHARED_LIBRARY: 1320 { 1321 Incremental_dynobj_entry* entry = (*p)->dynobj_entry(); 1322 gold_assert(entry != NULL); 1323 (*p)->set_info_offset(info_offset); 1324 // Global symbol count, soname index. 1325 info_offset += 8; 1326 // Each global symbol. 1327 const Object::Symbols* syms = entry->object()->get_global_symbols(); 1328 gold_assert(syms != NULL); 1329 unsigned int nsyms = syms->size(); 1330 unsigned int nsyms_out = 0; 1331 for (unsigned int i = 0; i < nsyms; ++i) 1332 { 1333 const Symbol* sym = (*syms)[i]; 1334 if (sym == NULL) 1335 continue; 1336 if (sym->is_forwarder()) 1337 sym = this->symtab_->resolve_forwards(sym); 1338 if (sym->symtab_index() != -1U) 1339 ++nsyms_out; 1340 } 1341 info_offset += nsyms_out * 4; 1342 } 1343 break; 1344 case INCREMENTAL_INPUT_ARCHIVE: 1345 { 1346 Incremental_archive_entry* entry = (*p)->archive_entry(); 1347 gold_assert(entry != NULL); 1348 (*p)->set_info_offset(info_offset); 1349 // Member count + unused global symbol count. 1350 info_offset += 8; 1351 // Each member. 1352 info_offset += (entry->get_member_count() * 4); 1353 // Each global symbol. 1354 info_offset += (entry->get_unused_global_symbol_count() * 4); 1355 } 1356 break; 1357 default: 1358 gold_unreachable(); 1359 } 1360 1361 // Pad so each supplemental info block begins at an 8-byte boundary. 1362 if (info_offset & 4) 1363 info_offset += 4; 1364 } 1365 1366 this->set_data_size(info_offset); 1367 1368 // Set the size of the .gnu_incremental_symtab section. 1369 inputs->symtab_section()->set_current_data_size(this->symtab_->output_count() 1370 * sizeof(unsigned int)); 1371 1372 // Set the size of the .gnu_incremental_relocs section. 1373 inputs->relocs_section()->set_current_data_size(inputs->get_reloc_count() 1374 * this->incr_reloc_size); 1375 1376 // Set the size of the .gnu_incremental_got_plt section. 1377 Sized_target<size, big_endian>* target = 1378 parameters->sized_target<size, big_endian>(); 1379 unsigned int got_count = target->got_entry_count(); 1380 unsigned int plt_count = target->plt_entry_count(); 1381 unsigned int got_plt_size = 8; // GOT entry count, PLT entry count. 1382 got_plt_size = (got_plt_size + got_count + 3) & ~3; // GOT type array. 1383 got_plt_size += got_count * 8 + plt_count * 4; // GOT array, PLT array. 1384 inputs->got_plt_section()->set_current_data_size(got_plt_size); 1385 } 1386 1387 // Write the contents of the .gnu_incremental_inputs and 1388 // .gnu_incremental_symtab sections. 1389 1390 template<int size, bool big_endian> 1391 void 1392 Output_section_incremental_inputs<size, big_endian>::do_write(Output_file* of) 1393 { 1394 const Incremental_inputs* inputs = this->inputs_; 1395 Stringpool* strtab = inputs->get_stringpool(); 1396 1397 // Get a view into the .gnu_incremental_inputs section. 1398 const off_t off = this->offset(); 1399 const off_t oview_size = this->data_size(); 1400 unsigned char* const oview = of->get_output_view(off, oview_size); 1401 unsigned char* pov = oview; 1402 1403 // Get a view into the .gnu_incremental_symtab section. 1404 const off_t symtab_off = inputs->symtab_section()->offset(); 1405 const off_t symtab_size = inputs->symtab_section()->data_size(); 1406 unsigned char* const symtab_view = of->get_output_view(symtab_off, 1407 symtab_size); 1408 1409 // Allocate an array of linked list heads for the .gnu_incremental_symtab 1410 // section. Each element corresponds to a global symbol in the output 1411 // symbol table, and points to the head of the linked list that threads 1412 // through the object file input entries. The value of each element 1413 // is the section-relative offset to a global symbol entry in a 1414 // supplemental information block. 1415 unsigned int global_sym_count = this->symtab_->output_count(); 1416 unsigned int* global_syms = new unsigned int[global_sym_count]; 1417 memset(global_syms, 0, global_sym_count * sizeof(unsigned int)); 1418 1419 // Write the section header. 1420 Stringpool::Key command_line_key = inputs->command_line_key(); 1421 pov = this->write_header(pov, inputs->input_file_count(), 1422 strtab->get_offset_from_key(command_line_key)); 1423 1424 // Write the list of input files. 1425 pov = this->write_input_files(oview, pov, strtab); 1426 1427 // Write the supplemental information blocks for each input file. 1428 pov = this->write_info_blocks(oview, pov, strtab, global_syms, 1429 global_sym_count); 1430 1431 gold_assert(pov - oview == oview_size); 1432 1433 // Write the .gnu_incremental_symtab section. 1434 gold_assert(static_cast<off_t>(global_sym_count) * 4 == symtab_size); 1435 this->write_symtab(symtab_view, global_syms, global_sym_count); 1436 1437 delete[] global_syms; 1438 1439 // Write the .gnu_incremental_got_plt section. 1440 const off_t got_plt_off = inputs->got_plt_section()->offset(); 1441 const off_t got_plt_size = inputs->got_plt_section()->data_size(); 1442 unsigned char* const got_plt_view = of->get_output_view(got_plt_off, 1443 got_plt_size); 1444 this->write_got_plt(got_plt_view, got_plt_size); 1445 1446 of->write_output_view(off, oview_size, oview); 1447 of->write_output_view(symtab_off, symtab_size, symtab_view); 1448 of->write_output_view(got_plt_off, got_plt_size, got_plt_view); 1449 } 1450 1451 // Write the section header: version, input file count, offset of command line 1452 // in the string table, and 4 bytes of padding. 1453 1454 template<int size, bool big_endian> 1455 unsigned char* 1456 Output_section_incremental_inputs<size, big_endian>::write_header( 1457 unsigned char* pov, 1458 unsigned int input_file_count, 1459 section_offset_type command_line_offset) 1460 { 1461 Swap32::writeval(pov, INCREMENTAL_LINK_VERSION); 1462 Swap32::writeval(pov + 4, input_file_count); 1463 Swap32::writeval(pov + 8, command_line_offset); 1464 Swap32::writeval(pov + 12, 0); 1465 gold_assert(this->header_size == 16); 1466 return pov + this->header_size; 1467 } 1468 1469 // Write the input file entries. 1470 1471 template<int size, bool big_endian> 1472 unsigned char* 1473 Output_section_incremental_inputs<size, big_endian>::write_input_files( 1474 unsigned char* oview, 1475 unsigned char* pov, 1476 Stringpool* strtab) 1477 { 1478 const Incremental_inputs* inputs = this->inputs_; 1479 1480 for (Incremental_inputs::Input_list::const_iterator p = 1481 inputs->input_files().begin(); 1482 p != inputs->input_files().end(); 1483 ++p) 1484 { 1485 gold_assert(static_cast<unsigned int>(pov - oview) == (*p)->get_offset()); 1486 section_offset_type filename_offset = 1487 strtab->get_offset_from_key((*p)->get_filename_key()); 1488 const Timespec& mtime = (*p)->get_mtime(); 1489 unsigned int flags = (*p)->type(); 1490 if ((*p)->is_in_system_directory()) 1491 flags |= INCREMENTAL_INPUT_IN_SYSTEM_DIR; 1492 if ((*p)->as_needed()) 1493 flags |= INCREMENTAL_INPUT_AS_NEEDED; 1494 Swap32::writeval(pov, filename_offset); 1495 Swap32::writeval(pov + 4, (*p)->get_info_offset()); 1496 Swap64::writeval(pov + 8, mtime.seconds); 1497 Swap32::writeval(pov + 16, mtime.nanoseconds); 1498 Swap16::writeval(pov + 20, flags); 1499 Swap16::writeval(pov + 22, (*p)->arg_serial()); 1500 gold_assert(this->input_entry_size == 24); 1501 pov += this->input_entry_size; 1502 } 1503 return pov; 1504 } 1505 1506 // Write the supplemental information blocks. 1507 1508 template<int size, bool big_endian> 1509 unsigned char* 1510 Output_section_incremental_inputs<size, big_endian>::write_info_blocks( 1511 unsigned char* oview, 1512 unsigned char* pov, 1513 Stringpool* strtab, 1514 unsigned int* global_syms, 1515 unsigned int global_sym_count) 1516 { 1517 const Incremental_inputs* inputs = this->inputs_; 1518 unsigned int first_global_index = this->symtab_->first_global_index(); 1519 1520 for (Incremental_inputs::Input_list::const_iterator p = 1521 inputs->input_files().begin(); 1522 p != inputs->input_files().end(); 1523 ++p) 1524 { 1525 switch ((*p)->type()) 1526 { 1527 case INCREMENTAL_INPUT_SCRIPT: 1528 { 1529 gold_assert(static_cast<unsigned int>(pov - oview) 1530 == (*p)->get_info_offset()); 1531 Incremental_script_entry* entry = (*p)->script_entry(); 1532 gold_assert(entry != NULL); 1533 1534 // Write the object count. 1535 unsigned int nobjects = entry->get_object_count(); 1536 Swap32::writeval(pov, nobjects); 1537 pov += 4; 1538 1539 // For each object, write the offset to its input file entry. 1540 for (unsigned int i = 0; i < nobjects; ++i) 1541 { 1542 Incremental_input_entry* obj = entry->get_object(i); 1543 Swap32::writeval(pov, obj->get_offset()); 1544 pov += 4; 1545 } 1546 } 1547 break; 1548 1549 case INCREMENTAL_INPUT_OBJECT: 1550 case INCREMENTAL_INPUT_ARCHIVE_MEMBER: 1551 { 1552 gold_assert(static_cast<unsigned int>(pov - oview) 1553 == (*p)->get_info_offset()); 1554 Incremental_object_entry* entry = (*p)->object_entry(); 1555 gold_assert(entry != NULL); 1556 const Object* obj = entry->object(); 1557 const Relobj* relobj = static_cast<const Relobj*>(obj); 1558 const Object::Symbols* syms = obj->get_global_symbols(); 1559 // Write the input section count and global symbol count. 1560 unsigned int nsections = entry->get_input_section_count(); 1561 unsigned int nsyms = syms->size(); 1562 off_t locals_offset = relobj->local_symbol_offset(); 1563 unsigned int nlocals = relobj->output_local_symbol_count(); 1564 unsigned int first_dynrel = relobj->first_dyn_reloc(); 1565 unsigned int ndynrel = relobj->dyn_reloc_count(); 1566 unsigned int ncomdat = entry->get_comdat_group_count(); 1567 Swap32::writeval(pov, nsections); 1568 Swap32::writeval(pov + 4, nsyms); 1569 Swap32::writeval(pov + 8, static_cast<unsigned int>(locals_offset)); 1570 Swap32::writeval(pov + 12, nlocals); 1571 Swap32::writeval(pov + 16, first_dynrel); 1572 Swap32::writeval(pov + 20, ndynrel); 1573 Swap32::writeval(pov + 24, ncomdat); 1574 Swap32::writeval(pov + 28, 0); 1575 gold_assert(this->object_info_size == 32); 1576 pov += this->object_info_size; 1577 1578 // Build a temporary array to map input section indexes 1579 // from the original object file index to the index in the 1580 // incremental info table. 1581 unsigned int* index_map = new unsigned int[obj->shnum()]; 1582 memset(index_map, 0, obj->shnum() * sizeof(unsigned int)); 1583 1584 // For each input section, write the name, output section index, 1585 // offset within output section, and input section size. 1586 for (unsigned int i = 0; i < nsections; i++) 1587 { 1588 unsigned int shndx = entry->get_input_section_index(i); 1589 index_map[shndx] = i + 1; 1590 Stringpool::Key key = entry->get_input_section_name_key(i); 1591 off_t name_offset = 0; 1592 if (key != 0) 1593 name_offset = strtab->get_offset_from_key(key); 1594 int out_shndx = 0; 1595 off_t out_offset = 0; 1596 off_t sh_size = 0; 1597 Output_section* os = obj->output_section(shndx); 1598 if (os != NULL) 1599 { 1600 out_shndx = os->out_shndx(); 1601 out_offset = obj->output_section_offset(shndx); 1602 sh_size = entry->get_input_section_size(i); 1603 } 1604 Swap32::writeval(pov, name_offset); 1605 Swap32::writeval(pov + 4, out_shndx); 1606 Swap::writeval(pov + 8, out_offset); 1607 Swap::writeval(pov + 8 + sizeof_addr, sh_size); 1608 gold_assert(this->input_section_entry_size 1609 == 8 + 2 * sizeof_addr); 1610 pov += this->input_section_entry_size; 1611 } 1612 1613 // For each global symbol, write its associated relocations, 1614 // add it to the linked list of globals, then write the 1615 // supplemental information: global symbol table index, 1616 // input section index, linked list chain pointer, relocation 1617 // count, and offset to the relocations. 1618 for (unsigned int i = 0; i < nsyms; i++) 1619 { 1620 const Symbol* sym = (*syms)[i]; 1621 if (sym->is_forwarder()) 1622 sym = this->symtab_->resolve_forwards(sym); 1623 unsigned int shndx = 0; 1624 if (sym->source() != Symbol::FROM_OBJECT) 1625 { 1626 // The symbol was defined by the linker (e.g., common). 1627 // We mark these symbols with a special SHNDX of -1, 1628 // but exclude linker-predefined symbols and symbols 1629 // copied from shared objects. 1630 if (!sym->is_predefined() 1631 && !sym->is_copied_from_dynobj()) 1632 shndx = -1U; 1633 } 1634 else if (sym->object() == obj && sym->is_defined()) 1635 { 1636 bool is_ordinary; 1637 unsigned int orig_shndx = sym->shndx(&is_ordinary); 1638 if (is_ordinary) 1639 shndx = index_map[orig_shndx]; 1640 else 1641 shndx = 1; 1642 } 1643 unsigned int symtab_index = sym->symtab_index(); 1644 unsigned int chain = 0; 1645 unsigned int first_reloc = 0; 1646 unsigned int nrelocs = obj->get_incremental_reloc_count(i); 1647 if (nrelocs > 0) 1648 { 1649 gold_assert(symtab_index != -1U 1650 && (symtab_index - first_global_index 1651 < global_sym_count)); 1652 first_reloc = obj->get_incremental_reloc_base(i); 1653 chain = global_syms[symtab_index - first_global_index]; 1654 global_syms[symtab_index - first_global_index] = 1655 pov - oview; 1656 } 1657 Swap32::writeval(pov, symtab_index); 1658 Swap32::writeval(pov + 4, shndx); 1659 Swap32::writeval(pov + 8, chain); 1660 Swap32::writeval(pov + 12, nrelocs); 1661 Swap32::writeval(pov + 16, 1662 first_reloc * (8 + 2 * sizeof_addr)); 1663 gold_assert(this->global_sym_entry_size == 20); 1664 pov += this->global_sym_entry_size; 1665 } 1666 1667 // For each kept COMDAT group, write the group signature. 1668 for (unsigned int i = 0; i < ncomdat; i++) 1669 { 1670 Stringpool::Key key = entry->get_comdat_signature_key(i); 1671 off_t name_offset = 0; 1672 if (key != 0) 1673 name_offset = strtab->get_offset_from_key(key); 1674 Swap32::writeval(pov, name_offset); 1675 pov += 4; 1676 } 1677 1678 delete[] index_map; 1679 } 1680 break; 1681 1682 case INCREMENTAL_INPUT_SHARED_LIBRARY: 1683 { 1684 gold_assert(static_cast<unsigned int>(pov - oview) 1685 == (*p)->get_info_offset()); 1686 Incremental_dynobj_entry* entry = (*p)->dynobj_entry(); 1687 gold_assert(entry != NULL); 1688 Object* obj = entry->object(); 1689 Dynobj* dynobj = obj->dynobj(); 1690 gold_assert(dynobj != NULL); 1691 const Object::Symbols* syms = obj->get_global_symbols(); 1692 1693 // Write the soname string table index. 1694 section_offset_type soname_offset = 1695 strtab->get_offset_from_key(entry->get_soname_key()); 1696 Swap32::writeval(pov, soname_offset); 1697 pov += 4; 1698 1699 // Skip the global symbol count for now. 1700 unsigned char* orig_pov = pov; 1701 pov += 4; 1702 1703 // For each global symbol, write the global symbol table index. 1704 unsigned int nsyms = syms->size(); 1705 unsigned int nsyms_out = 0; 1706 for (unsigned int i = 0; i < nsyms; i++) 1707 { 1708 const Symbol* sym = (*syms)[i]; 1709 if (sym == NULL) 1710 continue; 1711 if (sym->is_forwarder()) 1712 sym = this->symtab_->resolve_forwards(sym); 1713 if (sym->symtab_index() == -1U) 1714 continue; 1715 unsigned int flags = 0; 1716 // If the symbol has hidden or internal visibility, we 1717 // mark it as defined in the shared object so we don't 1718 // try to resolve it during an incremental update. 1719 if (sym->visibility() == elfcpp::STV_HIDDEN 1720 || sym->visibility() == elfcpp::STV_INTERNAL) 1721 flags = INCREMENTAL_SHLIB_SYM_DEF; 1722 else if (sym->source() == Symbol::FROM_OBJECT 1723 && sym->object() == obj 1724 && sym->is_defined()) 1725 flags = INCREMENTAL_SHLIB_SYM_DEF; 1726 else if (sym->is_copied_from_dynobj() 1727 && this->symtab_->get_copy_source(sym) == dynobj) 1728 flags = INCREMENTAL_SHLIB_SYM_COPY; 1729 flags <<= INCREMENTAL_SHLIB_SYM_FLAGS_SHIFT; 1730 Swap32::writeval(pov, sym->symtab_index() | flags); 1731 pov += 4; 1732 ++nsyms_out; 1733 } 1734 1735 // Now write the global symbol count. 1736 Swap32::writeval(orig_pov, nsyms_out); 1737 } 1738 break; 1739 1740 case INCREMENTAL_INPUT_ARCHIVE: 1741 { 1742 gold_assert(static_cast<unsigned int>(pov - oview) 1743 == (*p)->get_info_offset()); 1744 Incremental_archive_entry* entry = (*p)->archive_entry(); 1745 gold_assert(entry != NULL); 1746 1747 // Write the member count and unused global symbol count. 1748 unsigned int nmembers = entry->get_member_count(); 1749 unsigned int nsyms = entry->get_unused_global_symbol_count(); 1750 Swap32::writeval(pov, nmembers); 1751 Swap32::writeval(pov + 4, nsyms); 1752 pov += 8; 1753 1754 // For each member, write the offset to its input file entry. 1755 for (unsigned int i = 0; i < nmembers; ++i) 1756 { 1757 Incremental_object_entry* member = entry->get_member(i); 1758 Swap32::writeval(pov, member->get_offset()); 1759 pov += 4; 1760 } 1761 1762 // For each global symbol, write the name offset. 1763 for (unsigned int i = 0; i < nsyms; ++i) 1764 { 1765 Stringpool::Key key = entry->get_unused_global_symbol(i); 1766 Swap32::writeval(pov, strtab->get_offset_from_key(key)); 1767 pov += 4; 1768 } 1769 } 1770 break; 1771 1772 default: 1773 gold_unreachable(); 1774 } 1775 1776 // Pad the info block to a multiple of 8 bytes. 1777 if (static_cast<unsigned int>(pov - oview) & 4) 1778 { 1779 Swap32::writeval(pov, 0); 1780 pov += 4; 1781 } 1782 } 1783 return pov; 1784 } 1785 1786 // Write the contents of the .gnu_incremental_symtab section. 1787 1788 template<int size, bool big_endian> 1789 void 1790 Output_section_incremental_inputs<size, big_endian>::write_symtab( 1791 unsigned char* pov, 1792 unsigned int* global_syms, 1793 unsigned int global_sym_count) 1794 { 1795 for (unsigned int i = 0; i < global_sym_count; ++i) 1796 { 1797 Swap32::writeval(pov, global_syms[i]); 1798 pov += 4; 1799 } 1800 } 1801 1802 // This struct holds the view information needed to write the 1803 // .gnu_incremental_got_plt section. 1804 1805 struct Got_plt_view_info 1806 { 1807 // Start of the GOT type array in the output view. 1808 unsigned char* got_type_p; 1809 // Start of the GOT descriptor array in the output view. 1810 unsigned char* got_desc_p; 1811 // Start of the PLT descriptor array in the output view. 1812 unsigned char* plt_desc_p; 1813 // Number of GOT entries. 1814 unsigned int got_count; 1815 // Number of PLT entries. 1816 unsigned int plt_count; 1817 // Offset of the first non-reserved PLT entry (this is a target-dependent value). 1818 unsigned int first_plt_entry_offset; 1819 // Size of a PLT entry (this is a target-dependent value). 1820 unsigned int plt_entry_size; 1821 // Symbol index to write in the GOT descriptor array. For global symbols, 1822 // this is the global symbol table index; for local symbols, it is the 1823 // local symbol table index. 1824 unsigned int sym_index; 1825 // Input file index to write in the GOT descriptor array. For global 1826 // symbols, this is 0; for local symbols, it is the index of the input 1827 // file entry in the .gnu_incremental_inputs section. 1828 unsigned int input_index; 1829 }; 1830 1831 // Functor class for processing a GOT offset list for local symbols. 1832 // Writes the GOT type and symbol index into the GOT type and descriptor 1833 // arrays in the output section. 1834 1835 template<int size, bool big_endian> 1836 class Local_got_offset_visitor : public Got_offset_list::Visitor 1837 { 1838 public: 1839 Local_got_offset_visitor(struct Got_plt_view_info& info) 1840 : info_(info) 1841 { } 1842 1843 void 1844 visit(unsigned int got_type, unsigned int got_offset) 1845 { 1846 unsigned int got_index = got_offset / this->got_entry_size_; 1847 gold_assert(got_index < this->info_.got_count); 1848 // We can only handle GOT entry types in the range 0..0x7e 1849 // because we use a byte array to store them, and we use the 1850 // high bit to flag a local symbol. 1851 gold_assert(got_type < 0x7f); 1852 this->info_.got_type_p[got_index] = got_type | 0x80; 1853 unsigned char* pov = this->info_.got_desc_p + got_index * 8; 1854 elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.sym_index); 1855 elfcpp::Swap<32, big_endian>::writeval(pov + 4, this->info_.input_index); 1856 } 1857 1858 private: 1859 static const unsigned int got_entry_size_ = size / 8; 1860 struct Got_plt_view_info& info_; 1861 }; 1862 1863 // Functor class for processing a GOT offset list. Writes the GOT type 1864 // and symbol index into the GOT type and descriptor arrays in the output 1865 // section. 1866 1867 template<int size, bool big_endian> 1868 class Global_got_offset_visitor : public Got_offset_list::Visitor 1869 { 1870 public: 1871 Global_got_offset_visitor(struct Got_plt_view_info& info) 1872 : info_(info) 1873 { } 1874 1875 void 1876 visit(unsigned int got_type, unsigned int got_offset) 1877 { 1878 unsigned int got_index = got_offset / this->got_entry_size_; 1879 gold_assert(got_index < this->info_.got_count); 1880 // We can only handle GOT entry types in the range 0..0x7e 1881 // because we use a byte array to store them, and we use the 1882 // high bit to flag a local symbol. 1883 gold_assert(got_type < 0x7f); 1884 this->info_.got_type_p[got_index] = got_type; 1885 unsigned char* pov = this->info_.got_desc_p + got_index * 8; 1886 elfcpp::Swap<32, big_endian>::writeval(pov, this->info_.sym_index); 1887 elfcpp::Swap<32, big_endian>::writeval(pov + 4, 0); 1888 } 1889 1890 private: 1891 static const unsigned int got_entry_size_ = size / 8; 1892 struct Got_plt_view_info& info_; 1893 }; 1894 1895 // Functor class for processing the global symbol table. Processes the 1896 // GOT offset list for the symbol, and writes the symbol table index 1897 // into the PLT descriptor array in the output section. 1898 1899 template<int size, bool big_endian> 1900 class Global_symbol_visitor_got_plt 1901 { 1902 public: 1903 Global_symbol_visitor_got_plt(struct Got_plt_view_info& info) 1904 : info_(info) 1905 { } 1906 1907 void 1908 operator()(const Sized_symbol<size>* sym) 1909 { 1910 typedef Global_got_offset_visitor<size, big_endian> Got_visitor; 1911 const Got_offset_list* got_offsets = sym->got_offset_list(); 1912 if (got_offsets != NULL) 1913 { 1914 this->info_.sym_index = sym->symtab_index(); 1915 this->info_.input_index = 0; 1916 Got_visitor v(this->info_); 1917 got_offsets->for_all_got_offsets(&v); 1918 } 1919 if (sym->has_plt_offset()) 1920 { 1921 unsigned int plt_index = 1922 ((sym->plt_offset() - this->info_.first_plt_entry_offset) 1923 / this->info_.plt_entry_size); 1924 gold_assert(plt_index < this->info_.plt_count); 1925 unsigned char* pov = this->info_.plt_desc_p + plt_index * 4; 1926 elfcpp::Swap<32, big_endian>::writeval(pov, sym->symtab_index()); 1927 } 1928 } 1929 1930 private: 1931 struct Got_plt_view_info& info_; 1932 }; 1933 1934 // Write the contents of the .gnu_incremental_got_plt section. 1935 1936 template<int size, bool big_endian> 1937 void 1938 Output_section_incremental_inputs<size, big_endian>::write_got_plt( 1939 unsigned char* pov, 1940 off_t view_size) 1941 { 1942 Sized_target<size, big_endian>* target = 1943 parameters->sized_target<size, big_endian>(); 1944 1945 // Set up the view information for the functors. 1946 struct Got_plt_view_info view_info; 1947 view_info.got_count = target->got_entry_count(); 1948 view_info.plt_count = target->plt_entry_count(); 1949 view_info.first_plt_entry_offset = target->first_plt_entry_offset(); 1950 view_info.plt_entry_size = target->plt_entry_size(); 1951 view_info.got_type_p = pov + 8; 1952 view_info.got_desc_p = (view_info.got_type_p 1953 + ((view_info.got_count + 3) & ~3)); 1954 view_info.plt_desc_p = view_info.got_desc_p + view_info.got_count * 8; 1955 1956 gold_assert(pov + view_size == 1957 view_info.plt_desc_p + view_info.plt_count * 4); 1958 1959 // Write the section header. 1960 Swap32::writeval(pov, view_info.got_count); 1961 Swap32::writeval(pov + 4, view_info.plt_count); 1962 1963 // Initialize the GOT type array to 0xff (reserved). 1964 memset(view_info.got_type_p, 0xff, view_info.got_count); 1965 1966 // Write the incremental GOT descriptors for local symbols. 1967 typedef Local_got_offset_visitor<size, big_endian> Got_visitor; 1968 for (Incremental_inputs::Input_list::const_iterator p = 1969 this->inputs_->input_files().begin(); 1970 p != this->inputs_->input_files().end(); 1971 ++p) 1972 { 1973 if ((*p)->type() != INCREMENTAL_INPUT_OBJECT 1974 && (*p)->type() != INCREMENTAL_INPUT_ARCHIVE_MEMBER) 1975 continue; 1976 Incremental_object_entry* entry = (*p)->object_entry(); 1977 gold_assert(entry != NULL); 1978 const Object* obj = entry->object(); 1979 gold_assert(obj != NULL); 1980 view_info.input_index = (*p)->get_file_index(); 1981 Got_visitor v(view_info); 1982 obj->for_all_local_got_entries(&v); 1983 } 1984 1985 // Write the incremental GOT and PLT descriptors for global symbols. 1986 typedef Global_symbol_visitor_got_plt<size, big_endian> Symbol_visitor; 1987 symtab_->for_all_symbols<size, Symbol_visitor>(Symbol_visitor(view_info)); 1988 } 1989 1990 // Class Sized_relobj_incr. Most of these methods are not used for 1991 // Incremental objects, but are required to be implemented by the 1992 // base class Object. 1993 1994 template<int size, bool big_endian> 1995 Sized_relobj_incr<size, big_endian>::Sized_relobj_incr( 1996 const std::string& name, 1997 Sized_incremental_binary<size, big_endian>* ibase, 1998 unsigned int input_file_index) 1999 : Sized_relobj<size, big_endian>(name, NULL), ibase_(ibase), 2000 input_file_index_(input_file_index), 2001 input_reader_(ibase->inputs_reader().input_file(input_file_index)), 2002 local_symbol_count_(0), output_local_dynsym_count_(0), 2003 local_symbol_index_(0), local_symbol_offset_(0), local_dynsym_offset_(0), 2004 symbols_(), defined_count_(0), incr_reloc_offset_(-1U), 2005 incr_reloc_count_(0), incr_reloc_output_index_(0), incr_relocs_(NULL), 2006 local_symbols_() 2007 { 2008 if (this->input_reader_.is_in_system_directory()) 2009 this->set_is_in_system_directory(); 2010 const unsigned int shnum = this->input_reader_.get_input_section_count() + 1; 2011 this->set_shnum(shnum); 2012 ibase->set_input_object(input_file_index, this); 2013 } 2014 2015 // Read the symbols. 2016 2017 template<int size, bool big_endian> 2018 void 2019 Sized_relobj_incr<size, big_endian>::do_read_symbols(Read_symbols_data*) 2020 { 2021 gold_unreachable(); 2022 } 2023 2024 // Lay out the input sections. 2025 2026 template<int size, bool big_endian> 2027 void 2028 Sized_relobj_incr<size, big_endian>::do_layout( 2029 Symbol_table*, 2030 Layout* layout, 2031 Read_symbols_data*) 2032 { 2033 const unsigned int shnum = this->shnum(); 2034 Incremental_inputs* incremental_inputs = layout->incremental_inputs(); 2035 gold_assert(incremental_inputs != NULL); 2036 Output_sections& out_sections(this->output_sections()); 2037 out_sections.resize(shnum); 2038 this->section_offsets().resize(shnum); 2039 2040 // Keep track of .debug_info and .debug_types sections. 2041 std::vector<unsigned int> debug_info_sections; 2042 std::vector<unsigned int> debug_types_sections; 2043 2044 for (unsigned int i = 1; i < shnum; i++) 2045 { 2046 typename Input_entry_reader::Input_section_info sect = 2047 this->input_reader_.get_input_section(i - 1); 2048 // Add the section to the incremental inputs layout. 2049 incremental_inputs->report_input_section(this, i, sect.name, 2050 sect.sh_size); 2051 if (sect.output_shndx == 0 || sect.sh_offset == -1) 2052 continue; 2053 Output_section* os = this->ibase_->output_section(sect.output_shndx); 2054 gold_assert(os != NULL); 2055 out_sections[i] = os; 2056 this->section_offsets()[i] = static_cast<Address>(sect.sh_offset); 2057 2058 // When generating a .gdb_index section, we do additional 2059 // processing of .debug_info and .debug_types sections after all 2060 // the other sections. 2061 if (parameters->options().gdb_index()) 2062 { 2063 const char* name = os->name(); 2064 if (strcmp(name, ".debug_info") == 0) 2065 debug_info_sections.push_back(i); 2066 else if (strcmp(name, ".debug_types") == 0) 2067 debug_types_sections.push_back(i); 2068 } 2069 } 2070 2071 // Process the COMDAT groups. 2072 unsigned int ncomdat = this->input_reader_.get_comdat_group_count(); 2073 for (unsigned int i = 0; i < ncomdat; i++) 2074 { 2075 const char* signature = this->input_reader_.get_comdat_group_signature(i); 2076 if (signature == NULL || signature[0] == '\0') 2077 this->error(_("COMDAT group has no signature")); 2078 bool keep = layout->find_or_add_kept_section(signature, this, i, true, 2079 true, NULL); 2080 if (keep) 2081 incremental_inputs->report_comdat_group(this, signature); 2082 else 2083 this->error(_("COMDAT group %s included twice in incremental link"), 2084 signature); 2085 } 2086 2087 // When building a .gdb_index section, scan the .debug_info and 2088 // .debug_types sections. 2089 for (std::vector<unsigned int>::const_iterator p 2090 = debug_info_sections.begin(); 2091 p != debug_info_sections.end(); 2092 ++p) 2093 { 2094 unsigned int i = *p; 2095 layout->add_to_gdb_index(false, this, NULL, 0, i, 0, 0); 2096 } 2097 for (std::vector<unsigned int>::const_iterator p 2098 = debug_types_sections.begin(); 2099 p != debug_types_sections.end(); 2100 ++p) 2101 { 2102 unsigned int i = *p; 2103 layout->add_to_gdb_index(true, this, 0, 0, i, 0, 0); 2104 } 2105 } 2106 2107 // Layout sections whose layout was deferred while waiting for 2108 // input files from a plugin. 2109 template<int size, bool big_endian> 2110 void 2111 Sized_relobj_incr<size, big_endian>::do_layout_deferred_sections(Layout*) 2112 { 2113 } 2114 2115 // Add the symbols to the symbol table. 2116 2117 template<int size, bool big_endian> 2118 void 2119 Sized_relobj_incr<size, big_endian>::do_add_symbols( 2120 Symbol_table* symtab, 2121 Read_symbols_data*, 2122 Layout*) 2123 { 2124 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 2125 unsigned char symbuf[sym_size]; 2126 elfcpp::Sym<size, big_endian> sym(symbuf); 2127 elfcpp::Sym_write<size, big_endian> osym(symbuf); 2128 2129 typedef typename elfcpp::Elf_types<size>::Elf_WXword Elf_size_type; 2130 2131 unsigned int nsyms = this->input_reader_.get_global_symbol_count(); 2132 this->symbols_.resize(nsyms); 2133 2134 Incremental_binary::View symtab_view(NULL); 2135 unsigned int symtab_count; 2136 elfcpp::Elf_strtab strtab(NULL, 0); 2137 this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab); 2138 2139 Incremental_symtab_reader<big_endian> isymtab(this->ibase_->symtab_reader()); 2140 unsigned int isym_count = isymtab.symbol_count(); 2141 unsigned int first_global = symtab_count - isym_count; 2142 2143 const unsigned char* sym_p; 2144 for (unsigned int i = 0; i < nsyms; ++i) 2145 { 2146 Incremental_global_symbol_reader<big_endian> info = 2147 this->input_reader_.get_global_symbol_reader(i); 2148 unsigned int output_symndx = info.output_symndx(); 2149 sym_p = symtab_view.data() + output_symndx * sym_size; 2150 elfcpp::Sym<size, big_endian> gsym(sym_p); 2151 const char* name; 2152 if (!strtab.get_c_string(gsym.get_st_name(), &name)) 2153 name = ""; 2154 2155 typename elfcpp::Elf_types<size>::Elf_Addr v = gsym.get_st_value(); 2156 unsigned int shndx = gsym.get_st_shndx(); 2157 elfcpp::STB st_bind = gsym.get_st_bind(); 2158 elfcpp::STT st_type = gsym.get_st_type(); 2159 2160 // Local hidden symbols start out as globals, but get converted to 2161 // to local during output. 2162 if (st_bind == elfcpp::STB_LOCAL) 2163 st_bind = elfcpp::STB_GLOBAL; 2164 2165 unsigned int input_shndx = info.shndx(); 2166 if (input_shndx == 0 || input_shndx == -1U) 2167 { 2168 shndx = elfcpp::SHN_UNDEF; 2169 v = 0; 2170 } 2171 else if (shndx != elfcpp::SHN_ABS) 2172 { 2173 // Find the input section and calculate the section-relative value. 2174 gold_assert(shndx != elfcpp::SHN_UNDEF); 2175 Output_section* os = this->ibase_->output_section(shndx); 2176 gold_assert(os != NULL && os->has_fixed_layout()); 2177 typename Input_entry_reader::Input_section_info sect = 2178 this->input_reader_.get_input_section(input_shndx - 1); 2179 gold_assert(sect.output_shndx == shndx); 2180 if (st_type != elfcpp::STT_TLS) 2181 v -= os->address(); 2182 v -= sect.sh_offset; 2183 shndx = input_shndx; 2184 } 2185 2186 osym.put_st_name(0); 2187 osym.put_st_value(v); 2188 osym.put_st_size(gsym.get_st_size()); 2189 osym.put_st_info(st_bind, st_type); 2190 osym.put_st_other(gsym.get_st_other()); 2191 osym.put_st_shndx(shndx); 2192 2193 Symbol* res = symtab->add_from_incrobj(this, name, NULL, &sym); 2194 2195 if (shndx != elfcpp::SHN_UNDEF) 2196 ++this->defined_count_; 2197 2198 // If this is a linker-defined symbol that hasn't yet been defined, 2199 // define it now. 2200 if (input_shndx == -1U && !res->is_defined()) 2201 { 2202 shndx = gsym.get_st_shndx(); 2203 v = gsym.get_st_value(); 2204 Elf_size_type symsize = gsym.get_st_size(); 2205 if (shndx == elfcpp::SHN_ABS) 2206 { 2207 symtab->define_as_constant(name, NULL, 2208 Symbol_table::INCREMENTAL_BASE, 2209 v, symsize, st_type, st_bind, 2210 gsym.get_st_visibility(), 0, 2211 false, false); 2212 } 2213 else 2214 { 2215 Output_section* os = this->ibase_->output_section(shndx); 2216 gold_assert(os != NULL && os->has_fixed_layout()); 2217 v -= os->address(); 2218 if (symsize > 0) 2219 os->reserve(v, symsize); 2220 symtab->define_in_output_data(name, NULL, 2221 Symbol_table::INCREMENTAL_BASE, 2222 os, v, symsize, st_type, st_bind, 2223 gsym.get_st_visibility(), 0, 2224 false, false); 2225 } 2226 } 2227 2228 this->symbols_[i] = res; 2229 this->ibase_->add_global_symbol(output_symndx - first_global, res); 2230 } 2231 } 2232 2233 // Return TRUE if we should include this object from an archive library. 2234 2235 template<int size, bool big_endian> 2236 Archive::Should_include 2237 Sized_relobj_incr<size, big_endian>::do_should_include_member( 2238 Symbol_table*, 2239 Layout*, 2240 Read_symbols_data*, 2241 std::string*) 2242 { 2243 gold_unreachable(); 2244 } 2245 2246 // Iterate over global symbols, calling a visitor class V for each. 2247 2248 template<int size, bool big_endian> 2249 void 2250 Sized_relobj_incr<size, big_endian>::do_for_all_global_symbols( 2251 Read_symbols_data*, 2252 Library_base::Symbol_visitor_base*) 2253 { 2254 // This routine is not used for incremental objects. 2255 } 2256 2257 // Get the size of a section. 2258 2259 template<int size, bool big_endian> 2260 uint64_t 2261 Sized_relobj_incr<size, big_endian>::do_section_size(unsigned int) 2262 { 2263 gold_unreachable(); 2264 } 2265 2266 // Get the name of a section. This returns the name of the output 2267 // section, because we don't usually track the names of the input 2268 // sections. 2269 2270 template<int size, bool big_endian> 2271 std::string 2272 Sized_relobj_incr<size, big_endian>::do_section_name(unsigned int shndx) const 2273 { 2274 const Output_sections& out_sections(this->output_sections()); 2275 const Output_section* os = out_sections[shndx]; 2276 if (os == NULL) 2277 return NULL; 2278 return os->name(); 2279 } 2280 2281 // Return a view of the contents of a section. 2282 2283 template<int size, bool big_endian> 2284 const unsigned char* 2285 Sized_relobj_incr<size, big_endian>::do_section_contents( 2286 unsigned int shndx, 2287 section_size_type* plen, 2288 bool) 2289 { 2290 Output_sections& out_sections(this->output_sections()); 2291 Output_section* os = out_sections[shndx]; 2292 gold_assert(os != NULL); 2293 off_t section_offset = os->offset(); 2294 typename Input_entry_reader::Input_section_info sect = 2295 this->input_reader_.get_input_section(shndx - 1); 2296 section_offset += sect.sh_offset; 2297 *plen = sect.sh_size; 2298 return this->ibase_->view(section_offset, sect.sh_size).data(); 2299 } 2300 2301 // Return section flags. 2302 2303 template<int size, bool big_endian> 2304 uint64_t 2305 Sized_relobj_incr<size, big_endian>::do_section_flags(unsigned int) 2306 { 2307 gold_unreachable(); 2308 } 2309 2310 // Return section entsize. 2311 2312 template<int size, bool big_endian> 2313 uint64_t 2314 Sized_relobj_incr<size, big_endian>::do_section_entsize(unsigned int) 2315 { 2316 gold_unreachable(); 2317 } 2318 2319 // Return section address. 2320 2321 template<int size, bool big_endian> 2322 uint64_t 2323 Sized_relobj_incr<size, big_endian>::do_section_address(unsigned int) 2324 { 2325 gold_unreachable(); 2326 } 2327 2328 // Return section type. 2329 2330 template<int size, bool big_endian> 2331 unsigned int 2332 Sized_relobj_incr<size, big_endian>::do_section_type(unsigned int) 2333 { 2334 gold_unreachable(); 2335 } 2336 2337 // Return the section link field. 2338 2339 template<int size, bool big_endian> 2340 unsigned int 2341 Sized_relobj_incr<size, big_endian>::do_section_link(unsigned int) 2342 { 2343 gold_unreachable(); 2344 } 2345 2346 // Return the section link field. 2347 2348 template<int size, bool big_endian> 2349 unsigned int 2350 Sized_relobj_incr<size, big_endian>::do_section_info(unsigned int) 2351 { 2352 gold_unreachable(); 2353 } 2354 2355 // Return the section alignment. 2356 2357 template<int size, bool big_endian> 2358 uint64_t 2359 Sized_relobj_incr<size, big_endian>::do_section_addralign(unsigned int) 2360 { 2361 gold_unreachable(); 2362 } 2363 2364 // Return the Xindex structure to use. 2365 2366 template<int size, bool big_endian> 2367 Xindex* 2368 Sized_relobj_incr<size, big_endian>::do_initialize_xindex() 2369 { 2370 gold_unreachable(); 2371 } 2372 2373 // Get symbol counts. 2374 2375 template<int size, bool big_endian> 2376 void 2377 Sized_relobj_incr<size, big_endian>::do_get_global_symbol_counts( 2378 const Symbol_table*, 2379 size_t* defined, 2380 size_t* used) const 2381 { 2382 *defined = this->defined_count_; 2383 size_t count = 0; 2384 for (typename Symbols::const_iterator p = this->symbols_.begin(); 2385 p != this->symbols_.end(); 2386 ++p) 2387 if (*p != NULL 2388 && (*p)->source() == Symbol::FROM_OBJECT 2389 && (*p)->object() == this 2390 && (*p)->is_defined()) 2391 ++count; 2392 *used = count; 2393 } 2394 2395 // Read the relocs. 2396 2397 template<int size, bool big_endian> 2398 void 2399 Sized_relobj_incr<size, big_endian>::do_read_relocs(Read_relocs_data*) 2400 { 2401 } 2402 2403 // Process the relocs to find list of referenced sections. Used only 2404 // during garbage collection. 2405 2406 template<int size, bool big_endian> 2407 void 2408 Sized_relobj_incr<size, big_endian>::do_gc_process_relocs(Symbol_table*, 2409 Layout*, 2410 Read_relocs_data*) 2411 { 2412 gold_unreachable(); 2413 } 2414 2415 // Scan the relocs and adjust the symbol table. 2416 2417 template<int size, bool big_endian> 2418 void 2419 Sized_relobj_incr<size, big_endian>::do_scan_relocs(Symbol_table*, 2420 Layout* layout, 2421 Read_relocs_data*) 2422 { 2423 // Count the incremental relocations for this object. 2424 unsigned int nsyms = this->input_reader_.get_global_symbol_count(); 2425 this->allocate_incremental_reloc_counts(); 2426 for (unsigned int i = 0; i < nsyms; i++) 2427 { 2428 Incremental_global_symbol_reader<big_endian> sym = 2429 this->input_reader_.get_global_symbol_reader(i); 2430 unsigned int reloc_count = sym.reloc_count(); 2431 if (reloc_count > 0 && this->incr_reloc_offset_ == -1U) 2432 this->incr_reloc_offset_ = sym.reloc_offset(); 2433 this->incr_reloc_count_ += reloc_count; 2434 for (unsigned int j = 0; j < reloc_count; j++) 2435 this->count_incremental_reloc(i); 2436 } 2437 this->incr_reloc_output_index_ = 2438 layout->incremental_inputs()->get_reloc_count(); 2439 this->finalize_incremental_relocs(layout, false); 2440 2441 // The incoming incremental relocations may not end up in the same 2442 // location after the incremental update, because the incremental info 2443 // is regenerated in each link. Because the new location may overlap 2444 // with other data in the updated output file, we need to copy the 2445 // relocations into a buffer so that we can still read them safely 2446 // after we start writing updates to the output file. 2447 if (this->incr_reloc_count_ > 0) 2448 { 2449 const Incremental_relocs_reader<size, big_endian>& relocs_reader = 2450 this->ibase_->relocs_reader(); 2451 const unsigned int incr_reloc_size = relocs_reader.reloc_size; 2452 unsigned int len = this->incr_reloc_count_ * incr_reloc_size; 2453 this->incr_relocs_ = new unsigned char[len]; 2454 memcpy(this->incr_relocs_, 2455 relocs_reader.data(this->incr_reloc_offset_), 2456 len); 2457 } 2458 } 2459 2460 // Count the local symbols. 2461 2462 template<int size, bool big_endian> 2463 void 2464 Sized_relobj_incr<size, big_endian>::do_count_local_symbols( 2465 Stringpool_template<char>* pool, 2466 Stringpool_template<char>*) 2467 { 2468 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 2469 2470 // Set the count of local symbols based on the incremental info. 2471 unsigned int nlocals = this->input_reader_.get_local_symbol_count(); 2472 this->local_symbol_count_ = nlocals; 2473 this->local_symbols_.reserve(nlocals); 2474 2475 // Get views of the base file's symbol table and string table. 2476 Incremental_binary::View symtab_view(NULL); 2477 unsigned int symtab_count; 2478 elfcpp::Elf_strtab strtab(NULL, 0); 2479 this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab); 2480 2481 // Read the local symbols from the base file's symbol table. 2482 off_t off = this->input_reader_.get_local_symbol_offset(); 2483 const unsigned char* symp = symtab_view.data() + off; 2484 for (unsigned int i = 0; i < nlocals; ++i, symp += sym_size) 2485 { 2486 elfcpp::Sym<size, big_endian> sym(symp); 2487 const char* name; 2488 if (!strtab.get_c_string(sym.get_st_name(), &name)) 2489 name = ""; 2490 gold_debug(DEBUG_INCREMENTAL, "Local symbol %d: %s", i, name); 2491 name = pool->add(name, true, NULL); 2492 this->local_symbols_.push_back(Local_symbol(name, 2493 sym.get_st_value(), 2494 sym.get_st_size(), 2495 sym.get_st_shndx(), 2496 sym.get_st_type(), 2497 false)); 2498 } 2499 } 2500 2501 // Finalize the local symbols. 2502 2503 template<int size, bool big_endian> 2504 unsigned int 2505 Sized_relobj_incr<size, big_endian>::do_finalize_local_symbols( 2506 unsigned int index, 2507 off_t off, 2508 Symbol_table*) 2509 { 2510 this->local_symbol_index_ = index; 2511 this->local_symbol_offset_ = off; 2512 return index + this->local_symbol_count_; 2513 } 2514 2515 // Set the offset where local dynamic symbol information will be stored. 2516 2517 template<int size, bool big_endian> 2518 unsigned int 2519 Sized_relobj_incr<size, big_endian>::do_set_local_dynsym_indexes( 2520 unsigned int index) 2521 { 2522 // FIXME: set local dynsym indexes. 2523 return index; 2524 } 2525 2526 // Set the offset where local dynamic symbol information will be stored. 2527 2528 template<int size, bool big_endian> 2529 unsigned int 2530 Sized_relobj_incr<size, big_endian>::do_set_local_dynsym_offset(off_t) 2531 { 2532 return 0; 2533 } 2534 2535 // Relocate the input sections and write out the local symbols. 2536 // We don't actually do any relocation here. For unchanged input files, 2537 // we reapply relocations only for symbols that have changed; that happens 2538 // in queue_final_tasks. We do need to rewrite the incremental relocations 2539 // for this object. 2540 2541 template<int size, bool big_endian> 2542 void 2543 Sized_relobj_incr<size, big_endian>::do_relocate(const Symbol_table*, 2544 const Layout* layout, 2545 Output_file* of) 2546 { 2547 if (this->incr_reloc_count_ == 0) 2548 return; 2549 2550 const unsigned int incr_reloc_size = 2551 Incremental_relocs_reader<size, big_endian>::reloc_size; 2552 2553 // Get a view for the .gnu_incremental_relocs section. 2554 Incremental_inputs* inputs = layout->incremental_inputs(); 2555 gold_assert(inputs != NULL); 2556 const off_t relocs_off = inputs->relocs_section()->offset(); 2557 const off_t relocs_size = inputs->relocs_section()->data_size(); 2558 unsigned char* const view = of->get_output_view(relocs_off, relocs_size); 2559 2560 // Copy the relocations from the buffer. 2561 off_t off = this->incr_reloc_output_index_ * incr_reloc_size; 2562 unsigned int len = this->incr_reloc_count_ * incr_reloc_size; 2563 memcpy(view + off, this->incr_relocs_, len); 2564 2565 // The output section table may have changed, so we need to map 2566 // the old section index to the new section index for each relocation. 2567 for (unsigned int i = 0; i < this->incr_reloc_count_; ++i) 2568 { 2569 unsigned char* pov = view + off + i * incr_reloc_size; 2570 unsigned int shndx = elfcpp::Swap<32, big_endian>::readval(pov + 4); 2571 Output_section* os = this->ibase_->output_section(shndx); 2572 gold_assert(os != NULL); 2573 shndx = os->out_shndx(); 2574 elfcpp::Swap<32, big_endian>::writeval(pov + 4, shndx); 2575 } 2576 2577 of->write_output_view(off, len, view); 2578 2579 // Get views into the output file for the portions of the symbol table 2580 // and the dynamic symbol table that we will be writing. 2581 off_t symtab_off = layout->symtab_section()->offset(); 2582 off_t output_size = this->local_symbol_count_ * This::sym_size; 2583 unsigned char* oview = NULL; 2584 if (output_size > 0) 2585 oview = of->get_output_view(symtab_off + this->local_symbol_offset_, 2586 output_size); 2587 2588 off_t dyn_output_size = this->output_local_dynsym_count_ * sym_size; 2589 unsigned char* dyn_oview = NULL; 2590 if (dyn_output_size > 0) 2591 dyn_oview = of->get_output_view(this->local_dynsym_offset_, 2592 dyn_output_size); 2593 2594 // Write the local symbols. 2595 unsigned char* ov = oview; 2596 unsigned char* dyn_ov = dyn_oview; 2597 const Stringpool* sympool = layout->sympool(); 2598 const Stringpool* dynpool = layout->dynpool(); 2599 Output_symtab_xindex* symtab_xindex = layout->symtab_xindex(); 2600 Output_symtab_xindex* dynsym_xindex = layout->dynsym_xindex(); 2601 for (unsigned int i = 0; i < this->local_symbol_count_; ++i) 2602 { 2603 Local_symbol& lsym(this->local_symbols_[i]); 2604 2605 bool is_ordinary; 2606 unsigned int st_shndx = this->adjust_sym_shndx(i, lsym.st_shndx, 2607 &is_ordinary); 2608 if (is_ordinary) 2609 { 2610 Output_section* os = this->ibase_->output_section(st_shndx); 2611 st_shndx = os->out_shndx(); 2612 if (st_shndx >= elfcpp::SHN_LORESERVE) 2613 { 2614 symtab_xindex->add(this->local_symbol_index_ + i, st_shndx); 2615 if (lsym.needs_dynsym_entry) 2616 dynsym_xindex->add(lsym.output_dynsym_index, st_shndx); 2617 st_shndx = elfcpp::SHN_XINDEX; 2618 } 2619 } 2620 2621 // Write the symbol to the output symbol table. 2622 { 2623 elfcpp::Sym_write<size, big_endian> osym(ov); 2624 osym.put_st_name(sympool->get_offset(lsym.name)); 2625 osym.put_st_value(lsym.st_value); 2626 osym.put_st_size(lsym.st_size); 2627 osym.put_st_info(elfcpp::STB_LOCAL, 2628 static_cast<elfcpp::STT>(lsym.st_type)); 2629 osym.put_st_other(0); 2630 osym.put_st_shndx(st_shndx); 2631 ov += sym_size; 2632 } 2633 2634 // Write the symbol to the output dynamic symbol table. 2635 if (lsym.needs_dynsym_entry) 2636 { 2637 gold_assert(dyn_ov < dyn_oview + dyn_output_size); 2638 elfcpp::Sym_write<size, big_endian> osym(dyn_ov); 2639 osym.put_st_name(dynpool->get_offset(lsym.name)); 2640 osym.put_st_value(lsym.st_value); 2641 osym.put_st_size(lsym.st_size); 2642 osym.put_st_info(elfcpp::STB_LOCAL, 2643 static_cast<elfcpp::STT>(lsym.st_type)); 2644 osym.put_st_other(0); 2645 osym.put_st_shndx(st_shndx); 2646 dyn_ov += sym_size; 2647 } 2648 } 2649 2650 if (output_size > 0) 2651 { 2652 gold_assert(ov - oview == output_size); 2653 of->write_output_view(symtab_off + this->local_symbol_offset_, 2654 output_size, oview); 2655 } 2656 2657 if (dyn_output_size > 0) 2658 { 2659 gold_assert(dyn_ov - dyn_oview == dyn_output_size); 2660 of->write_output_view(this->local_dynsym_offset_, dyn_output_size, 2661 dyn_oview); 2662 } 2663 } 2664 2665 // Set the offset of a section. 2666 2667 template<int size, bool big_endian> 2668 void 2669 Sized_relobj_incr<size, big_endian>::do_set_section_offset(unsigned int, 2670 uint64_t) 2671 { 2672 } 2673 2674 // Class Sized_incr_dynobj. Most of these methods are not used for 2675 // Incremental objects, but are required to be implemented by the 2676 // base class Object. 2677 2678 template<int size, bool big_endian> 2679 Sized_incr_dynobj<size, big_endian>::Sized_incr_dynobj( 2680 const std::string& name, 2681 Sized_incremental_binary<size, big_endian>* ibase, 2682 unsigned int input_file_index) 2683 : Dynobj(name, NULL), ibase_(ibase), 2684 input_file_index_(input_file_index), 2685 input_reader_(ibase->inputs_reader().input_file(input_file_index)), 2686 symbols_(), defined_count_(0) 2687 { 2688 if (this->input_reader_.is_in_system_directory()) 2689 this->set_is_in_system_directory(); 2690 if (this->input_reader_.as_needed()) 2691 this->set_as_needed(); 2692 this->set_soname_string(this->input_reader_.get_soname()); 2693 this->set_shnum(0); 2694 } 2695 2696 // Read the symbols. 2697 2698 template<int size, bool big_endian> 2699 void 2700 Sized_incr_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data*) 2701 { 2702 gold_unreachable(); 2703 } 2704 2705 // Lay out the input sections. 2706 2707 template<int size, bool big_endian> 2708 void 2709 Sized_incr_dynobj<size, big_endian>::do_layout( 2710 Symbol_table*, 2711 Layout*, 2712 Read_symbols_data*) 2713 { 2714 } 2715 2716 // Add the symbols to the symbol table. 2717 2718 template<int size, bool big_endian> 2719 void 2720 Sized_incr_dynobj<size, big_endian>::do_add_symbols( 2721 Symbol_table* symtab, 2722 Read_symbols_data*, 2723 Layout*) 2724 { 2725 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 2726 unsigned char symbuf[sym_size]; 2727 elfcpp::Sym<size, big_endian> sym(symbuf); 2728 elfcpp::Sym_write<size, big_endian> osym(symbuf); 2729 2730 unsigned int nsyms = this->input_reader_.get_global_symbol_count(); 2731 this->symbols_.resize(nsyms); 2732 2733 Incremental_binary::View symtab_view(NULL); 2734 unsigned int symtab_count; 2735 elfcpp::Elf_strtab strtab(NULL, 0); 2736 this->ibase_->get_symtab_view(&symtab_view, &symtab_count, &strtab); 2737 2738 Incremental_symtab_reader<big_endian> isymtab(this->ibase_->symtab_reader()); 2739 unsigned int isym_count = isymtab.symbol_count(); 2740 unsigned int first_global = symtab_count - isym_count; 2741 2742 // We keep a set of symbols that we have generated COPY relocations 2743 // for, indexed by the symbol value. We do not need more than one 2744 // COPY relocation per address. 2745 typedef typename std::set<Address> Copied_symbols; 2746 Copied_symbols copied_symbols; 2747 2748 const unsigned char* sym_p; 2749 for (unsigned int i = 0; i < nsyms; ++i) 2750 { 2751 bool is_def; 2752 bool is_copy; 2753 unsigned int output_symndx = 2754 this->input_reader_.get_output_symbol_index(i, &is_def, &is_copy); 2755 sym_p = symtab_view.data() + output_symndx * sym_size; 2756 elfcpp::Sym<size, big_endian> gsym(sym_p); 2757 const char* name; 2758 if (!strtab.get_c_string(gsym.get_st_name(), &name)) 2759 name = ""; 2760 2761 Address v; 2762 unsigned int shndx; 2763 elfcpp::STB st_bind = gsym.get_st_bind(); 2764 elfcpp::STT st_type = gsym.get_st_type(); 2765 2766 // Local hidden symbols start out as globals, but get converted to 2767 // to local during output. 2768 if (st_bind == elfcpp::STB_LOCAL) 2769 st_bind = elfcpp::STB_GLOBAL; 2770 2771 if (!is_def) 2772 { 2773 shndx = elfcpp::SHN_UNDEF; 2774 v = 0; 2775 } 2776 else 2777 { 2778 // For a symbol defined in a shared object, the section index 2779 // is meaningless, as long as it's not SHN_UNDEF. 2780 shndx = 1; 2781 v = gsym.get_st_value(); 2782 ++this->defined_count_; 2783 } 2784 2785 osym.put_st_name(0); 2786 osym.put_st_value(v); 2787 osym.put_st_size(gsym.get_st_size()); 2788 osym.put_st_info(st_bind, st_type); 2789 osym.put_st_other(gsym.get_st_other()); 2790 osym.put_st_shndx(shndx); 2791 2792 Sized_symbol<size>* res = 2793 symtab->add_from_incrobj<size, big_endian>(this, name, NULL, &sym); 2794 this->symbols_[i] = res; 2795 this->ibase_->add_global_symbol(output_symndx - first_global, 2796 this->symbols_[i]); 2797 2798 if (is_copy) 2799 { 2800 std::pair<typename Copied_symbols::iterator, bool> ins = 2801 copied_symbols.insert(v); 2802 if (ins.second) 2803 { 2804 unsigned int shndx = gsym.get_st_shndx(); 2805 Output_section* os = this->ibase_->output_section(shndx); 2806 off_t offset = v - os->address(); 2807 this->ibase_->add_copy_reloc(this->symbols_[i], os, offset); 2808 } 2809 } 2810 } 2811 } 2812 2813 // Return TRUE if we should include this object from an archive library. 2814 2815 template<int size, bool big_endian> 2816 Archive::Should_include 2817 Sized_incr_dynobj<size, big_endian>::do_should_include_member( 2818 Symbol_table*, 2819 Layout*, 2820 Read_symbols_data*, 2821 std::string*) 2822 { 2823 gold_unreachable(); 2824 } 2825 2826 // Iterate over global symbols, calling a visitor class V for each. 2827 2828 template<int size, bool big_endian> 2829 void 2830 Sized_incr_dynobj<size, big_endian>::do_for_all_global_symbols( 2831 Read_symbols_data*, 2832 Library_base::Symbol_visitor_base*) 2833 { 2834 // This routine is not used for dynamic libraries. 2835 } 2836 2837 // Iterate over local symbols, calling a visitor class V for each GOT offset 2838 // associated with a local symbol. 2839 2840 template<int size, bool big_endian> 2841 void 2842 Sized_incr_dynobj<size, big_endian>::do_for_all_local_got_entries( 2843 Got_offset_list::Visitor*) const 2844 { 2845 } 2846 2847 // Get the size of a section. 2848 2849 template<int size, bool big_endian> 2850 uint64_t 2851 Sized_incr_dynobj<size, big_endian>::do_section_size(unsigned int) 2852 { 2853 gold_unreachable(); 2854 } 2855 2856 // Get the name of a section. 2857 2858 template<int size, bool big_endian> 2859 std::string 2860 Sized_incr_dynobj<size, big_endian>::do_section_name(unsigned int) const 2861 { 2862 gold_unreachable(); 2863 } 2864 2865 // Return a view of the contents of a section. 2866 2867 template<int size, bool big_endian> 2868 const unsigned char* 2869 Sized_incr_dynobj<size, big_endian>::do_section_contents( 2870 unsigned int, 2871 section_size_type*, 2872 bool) 2873 { 2874 gold_unreachable(); 2875 } 2876 2877 // Return section flags. 2878 2879 template<int size, bool big_endian> 2880 uint64_t 2881 Sized_incr_dynobj<size, big_endian>::do_section_flags(unsigned int) 2882 { 2883 gold_unreachable(); 2884 } 2885 2886 // Return section entsize. 2887 2888 template<int size, bool big_endian> 2889 uint64_t 2890 Sized_incr_dynobj<size, big_endian>::do_section_entsize(unsigned int) 2891 { 2892 gold_unreachable(); 2893 } 2894 2895 // Return section address. 2896 2897 template<int size, bool big_endian> 2898 uint64_t 2899 Sized_incr_dynobj<size, big_endian>::do_section_address(unsigned int) 2900 { 2901 gold_unreachable(); 2902 } 2903 2904 // Return section type. 2905 2906 template<int size, bool big_endian> 2907 unsigned int 2908 Sized_incr_dynobj<size, big_endian>::do_section_type(unsigned int) 2909 { 2910 gold_unreachable(); 2911 } 2912 2913 // Return the section link field. 2914 2915 template<int size, bool big_endian> 2916 unsigned int 2917 Sized_incr_dynobj<size, big_endian>::do_section_link(unsigned int) 2918 { 2919 gold_unreachable(); 2920 } 2921 2922 // Return the section link field. 2923 2924 template<int size, bool big_endian> 2925 unsigned int 2926 Sized_incr_dynobj<size, big_endian>::do_section_info(unsigned int) 2927 { 2928 gold_unreachable(); 2929 } 2930 2931 // Return the section alignment. 2932 2933 template<int size, bool big_endian> 2934 uint64_t 2935 Sized_incr_dynobj<size, big_endian>::do_section_addralign(unsigned int) 2936 { 2937 gold_unreachable(); 2938 } 2939 2940 // Return the Xindex structure to use. 2941 2942 template<int size, bool big_endian> 2943 Xindex* 2944 Sized_incr_dynobj<size, big_endian>::do_initialize_xindex() 2945 { 2946 gold_unreachable(); 2947 } 2948 2949 // Get symbol counts. 2950 2951 template<int size, bool big_endian> 2952 void 2953 Sized_incr_dynobj<size, big_endian>::do_get_global_symbol_counts( 2954 const Symbol_table*, 2955 size_t* defined, 2956 size_t* used) const 2957 { 2958 *defined = this->defined_count_; 2959 size_t count = 0; 2960 for (typename Symbols::const_iterator p = this->symbols_.begin(); 2961 p != this->symbols_.end(); 2962 ++p) 2963 if (*p != NULL 2964 && (*p)->source() == Symbol::FROM_OBJECT 2965 && (*p)->object() == this 2966 && (*p)->is_defined() 2967 && (*p)->dynsym_index() != -1U) 2968 ++count; 2969 *used = count; 2970 } 2971 2972 // Allocate an incremental object of the appropriate size and endianness. 2973 2974 Object* 2975 make_sized_incremental_object( 2976 Incremental_binary* ibase, 2977 unsigned int input_file_index, 2978 Incremental_input_type input_type, 2979 const Incremental_binary::Input_reader* input_reader) 2980 { 2981 Object* obj = NULL; 2982 std::string name(input_reader->filename()); 2983 2984 switch (parameters->size_and_endianness()) 2985 { 2986 #ifdef HAVE_TARGET_32_LITTLE 2987 case Parameters::TARGET_32_LITTLE: 2988 { 2989 Sized_incremental_binary<32, false>* sized_ibase = 2990 static_cast<Sized_incremental_binary<32, false>*>(ibase); 2991 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY) 2992 obj = new Sized_incr_dynobj<32, false>(name, sized_ibase, 2993 input_file_index); 2994 else 2995 obj = new Sized_relobj_incr<32, false>(name, sized_ibase, 2996 input_file_index); 2997 } 2998 break; 2999 #endif 3000 #ifdef HAVE_TARGET_32_BIG 3001 case Parameters::TARGET_32_BIG: 3002 { 3003 Sized_incremental_binary<32, true>* sized_ibase = 3004 static_cast<Sized_incremental_binary<32, true>*>(ibase); 3005 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY) 3006 obj = new Sized_incr_dynobj<32, true>(name, sized_ibase, 3007 input_file_index); 3008 else 3009 obj = new Sized_relobj_incr<32, true>(name, sized_ibase, 3010 input_file_index); 3011 } 3012 break; 3013 #endif 3014 #ifdef HAVE_TARGET_64_LITTLE 3015 case Parameters::TARGET_64_LITTLE: 3016 { 3017 Sized_incremental_binary<64, false>* sized_ibase = 3018 static_cast<Sized_incremental_binary<64, false>*>(ibase); 3019 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY) 3020 obj = new Sized_incr_dynobj<64, false>(name, sized_ibase, 3021 input_file_index); 3022 else 3023 obj = new Sized_relobj_incr<64, false>(name, sized_ibase, 3024 input_file_index); 3025 } 3026 break; 3027 #endif 3028 #ifdef HAVE_TARGET_64_BIG 3029 case Parameters::TARGET_64_BIG: 3030 { 3031 Sized_incremental_binary<64, true>* sized_ibase = 3032 static_cast<Sized_incremental_binary<64, true>*>(ibase); 3033 if (input_type == INCREMENTAL_INPUT_SHARED_LIBRARY) 3034 obj = new Sized_incr_dynobj<64, true>(name, sized_ibase, 3035 input_file_index); 3036 else 3037 obj = new Sized_relobj_incr<64, true>(name, sized_ibase, 3038 input_file_index); 3039 } 3040 break; 3041 #endif 3042 default: 3043 gold_unreachable(); 3044 } 3045 3046 gold_assert(obj != NULL); 3047 return obj; 3048 } 3049 3050 // Copy the unused symbols from the incremental input info. 3051 // We need to do this because we may be overwriting the incremental 3052 // input info in the base file before we write the new incremental 3053 // info. 3054 void 3055 Incremental_library::copy_unused_symbols() 3056 { 3057 unsigned int symcount = this->input_reader_->get_unused_symbol_count(); 3058 this->unused_symbols_.reserve(symcount); 3059 for (unsigned int i = 0; i < symcount; ++i) 3060 { 3061 std::string name(this->input_reader_->get_unused_symbol(i)); 3062 this->unused_symbols_.push_back(name); 3063 } 3064 } 3065 3066 // Iterator for unused global symbols in the library. 3067 void 3068 Incremental_library::do_for_all_unused_symbols(Symbol_visitor_base* v) const 3069 { 3070 for (Symbol_list::const_iterator p = this->unused_symbols_.begin(); 3071 p != this->unused_symbols_.end(); 3072 ++p) 3073 v->visit(p->c_str()); 3074 } 3075 3076 // Instantiate the templates we need. 3077 3078 #ifdef HAVE_TARGET_32_LITTLE 3079 template 3080 class Sized_incremental_binary<32, false>; 3081 3082 template 3083 class Sized_relobj_incr<32, false>; 3084 3085 template 3086 class Sized_incr_dynobj<32, false>; 3087 #endif 3088 3089 #ifdef HAVE_TARGET_32_BIG 3090 template 3091 class Sized_incremental_binary<32, true>; 3092 3093 template 3094 class Sized_relobj_incr<32, true>; 3095 3096 template 3097 class Sized_incr_dynobj<32, true>; 3098 #endif 3099 3100 #ifdef HAVE_TARGET_64_LITTLE 3101 template 3102 class Sized_incremental_binary<64, false>; 3103 3104 template 3105 class Sized_relobj_incr<64, false>; 3106 3107 template 3108 class Sized_incr_dynobj<64, false>; 3109 #endif 3110 3111 #ifdef HAVE_TARGET_64_BIG 3112 template 3113 class Sized_incremental_binary<64, true>; 3114 3115 template 3116 class Sized_relobj_incr<64, true>; 3117 3118 template 3119 class Sized_incr_dynobj<64, true>; 3120 #endif 3121 3122 } // End namespace gold. 3123