1 // plugin.cc -- plugin manager for gold -*- C++ -*- 2 3 // Copyright (C) 2008-2014 Free Software Foundation, Inc. 4 // Written by Cary Coutant <ccoutant (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 <cstdio> 26 #include <cstdarg> 27 #include <cstring> 28 #include <string> 29 #include <vector> 30 31 #ifdef ENABLE_PLUGINS 32 #ifdef HAVE_DLFCN_H 33 #include <dlfcn.h> 34 #elif defined (HAVE_WINDOWS_H) 35 #include <windows.h> 36 #else 37 #error Unknown how to handle dynamic-load-libraries. 38 #endif 39 40 #if !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) 41 42 #define RTLD_NOW 0 /* Dummy value. */ 43 static void * 44 dlopen(const char *file, int mode ATTRIBUTE_UNUSED) 45 { 46 return LoadLibrary(file); 47 } 48 49 static void * 50 dlsym(void *handle, const char *name) 51 { 52 return reinterpret_cast<void *>( 53 GetProcAddress(static_cast<HMODULE>(handle),name)); 54 } 55 56 static const char * 57 dlerror(void) 58 { 59 return "unable to load dll"; 60 } 61 62 #endif /* !defined (HAVE_DLFCN_H) && defined (HAVE_WINDOWS_H) */ 63 #endif /* ENABLE_PLUGINS */ 64 65 #include "parameters.h" 66 #include "errors.h" 67 #include "fileread.h" 68 #include "layout.h" 69 #include "options.h" 70 #include "plugin.h" 71 #include "target.h" 72 #include "readsyms.h" 73 #include "symtab.h" 74 #include "descriptors.h" 75 #include "elfcpp.h" 76 77 namespace gold 78 { 79 80 #ifdef ENABLE_PLUGINS 81 82 // The linker's exported interfaces. 83 84 extern "C" 85 { 86 87 static enum ld_plugin_status 88 register_claim_file(ld_plugin_claim_file_handler handler); 89 90 static enum ld_plugin_status 91 register_all_symbols_read(ld_plugin_all_symbols_read_handler handler); 92 93 static enum ld_plugin_status 94 register_cleanup(ld_plugin_cleanup_handler handler); 95 96 static enum ld_plugin_status 97 add_symbols(void *handle, int nsyms, const struct ld_plugin_symbol *syms); 98 99 static enum ld_plugin_status 100 get_input_file(const void *handle, struct ld_plugin_input_file *file); 101 102 static enum ld_plugin_status 103 get_view(const void *handle, const void **viewp); 104 105 static enum ld_plugin_status 106 release_input_file(const void *handle); 107 108 static enum ld_plugin_status 109 get_symbols(const void *handle, int nsyms, struct ld_plugin_symbol *syms); 110 111 static enum ld_plugin_status 112 get_symbols_v2(const void *handle, int nsyms, struct ld_plugin_symbol *syms); 113 114 static enum ld_plugin_status 115 add_input_file(const char *pathname); 116 117 static enum ld_plugin_status 118 add_input_library(const char *pathname); 119 120 static enum ld_plugin_status 121 set_extra_library_path(const char *path); 122 123 static enum ld_plugin_status 124 message(int level, const char *format, ...); 125 126 static enum ld_plugin_status 127 get_input_section_count(const void* handle, unsigned int* count); 128 129 static enum ld_plugin_status 130 get_input_section_type(const struct ld_plugin_section section, 131 unsigned int* type); 132 133 static enum ld_plugin_status 134 get_input_section_name(const struct ld_plugin_section section, 135 char** section_name_ptr); 136 137 static enum ld_plugin_status 138 get_input_section_contents(const struct ld_plugin_section section, 139 const unsigned char** section_contents, 140 size_t* len); 141 142 static enum ld_plugin_status 143 update_section_order(const struct ld_plugin_section *section_list, 144 unsigned int num_sections); 145 146 static enum ld_plugin_status 147 allow_section_ordering(); 148 149 static enum ld_plugin_status 150 allow_unique_segment_for_sections(); 151 152 static enum ld_plugin_status 153 unique_segment_for_sections(const char* segment_name, 154 uint64_t flags, 155 uint64_t align, 156 const struct ld_plugin_section *section_list, 157 unsigned int num_sections); 158 }; 159 160 #endif // ENABLE_PLUGINS 161 162 static Pluginobj* make_sized_plugin_object(Input_file* input_file, 163 off_t offset, off_t filesize); 164 165 // Plugin methods. 166 167 // Load one plugin library. 168 169 void 170 Plugin::load() 171 { 172 #ifdef ENABLE_PLUGINS 173 // Load the plugin library. 174 // FIXME: Look for the library in standard locations. 175 this->handle_ = dlopen(this->filename_.c_str(), RTLD_NOW); 176 if (this->handle_ == NULL) 177 { 178 gold_error(_("%s: could not load plugin library: %s"), 179 this->filename_.c_str(), dlerror()); 180 return; 181 } 182 183 // Find the plugin's onload entry point. 184 void* ptr = dlsym(this->handle_, "onload"); 185 if (ptr == NULL) 186 { 187 gold_error(_("%s: could not find onload entry point"), 188 this->filename_.c_str()); 189 return; 190 } 191 ld_plugin_onload onload; 192 gold_assert(sizeof(onload) == sizeof(ptr)); 193 memcpy(&onload, &ptr, sizeof(ptr)); 194 195 // Get the linker's version number. 196 const char* ver = get_version_string(); 197 int major = 0; 198 int minor = 0; 199 sscanf(ver, "%d.%d", &major, &minor); 200 201 // Allocate and populate a transfer vector. 202 const int tv_fixed_size = 26; 203 204 int tv_size = this->args_.size() + tv_fixed_size; 205 ld_plugin_tv* tv = new ld_plugin_tv[tv_size]; 206 207 // Put LDPT_MESSAGE at the front of the list so the plugin can use it 208 // while processing subsequent entries. 209 int i = 0; 210 tv[i].tv_tag = LDPT_MESSAGE; 211 tv[i].tv_u.tv_message = message; 212 213 ++i; 214 tv[i].tv_tag = LDPT_API_VERSION; 215 tv[i].tv_u.tv_val = LD_PLUGIN_API_VERSION; 216 217 ++i; 218 tv[i].tv_tag = LDPT_GOLD_VERSION; 219 tv[i].tv_u.tv_val = major * 100 + minor; 220 221 ++i; 222 tv[i].tv_tag = LDPT_LINKER_OUTPUT; 223 if (parameters->options().relocatable()) 224 tv[i].tv_u.tv_val = LDPO_REL; 225 else if (parameters->options().shared()) 226 tv[i].tv_u.tv_val = LDPO_DYN; 227 else if (parameters->options().pie()) 228 tv[i].tv_u.tv_val = LDPO_PIE; 229 else 230 tv[i].tv_u.tv_val = LDPO_EXEC; 231 232 ++i; 233 tv[i].tv_tag = LDPT_OUTPUT_NAME; 234 tv[i].tv_u.tv_string = parameters->options().output(); 235 236 for (unsigned int j = 0; j < this->args_.size(); ++j) 237 { 238 ++i; 239 tv[i].tv_tag = LDPT_OPTION; 240 tv[i].tv_u.tv_string = this->args_[j].c_str(); 241 } 242 243 ++i; 244 tv[i].tv_tag = LDPT_REGISTER_CLAIM_FILE_HOOK; 245 tv[i].tv_u.tv_register_claim_file = register_claim_file; 246 247 ++i; 248 tv[i].tv_tag = LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK; 249 tv[i].tv_u.tv_register_all_symbols_read = register_all_symbols_read; 250 251 ++i; 252 tv[i].tv_tag = LDPT_REGISTER_CLEANUP_HOOK; 253 tv[i].tv_u.tv_register_cleanup = register_cleanup; 254 255 ++i; 256 tv[i].tv_tag = LDPT_ADD_SYMBOLS; 257 tv[i].tv_u.tv_add_symbols = add_symbols; 258 259 ++i; 260 tv[i].tv_tag = LDPT_GET_INPUT_FILE; 261 tv[i].tv_u.tv_get_input_file = get_input_file; 262 263 ++i; 264 tv[i].tv_tag = LDPT_GET_VIEW; 265 tv[i].tv_u.tv_get_view = get_view; 266 267 ++i; 268 tv[i].tv_tag = LDPT_RELEASE_INPUT_FILE; 269 tv[i].tv_u.tv_release_input_file = release_input_file; 270 271 ++i; 272 tv[i].tv_tag = LDPT_GET_SYMBOLS; 273 tv[i].tv_u.tv_get_symbols = get_symbols; 274 275 ++i; 276 tv[i].tv_tag = LDPT_GET_SYMBOLS_V2; 277 tv[i].tv_u.tv_get_symbols = get_symbols_v2; 278 279 ++i; 280 tv[i].tv_tag = LDPT_ADD_INPUT_FILE; 281 tv[i].tv_u.tv_add_input_file = add_input_file; 282 283 ++i; 284 tv[i].tv_tag = LDPT_ADD_INPUT_LIBRARY; 285 tv[i].tv_u.tv_add_input_library = add_input_library; 286 287 ++i; 288 tv[i].tv_tag = LDPT_SET_EXTRA_LIBRARY_PATH; 289 tv[i].tv_u.tv_set_extra_library_path = set_extra_library_path; 290 291 ++i; 292 tv[i].tv_tag = LDPT_GET_INPUT_SECTION_COUNT; 293 tv[i].tv_u.tv_get_input_section_count = get_input_section_count; 294 295 ++i; 296 tv[i].tv_tag = LDPT_GET_INPUT_SECTION_TYPE; 297 tv[i].tv_u.tv_get_input_section_type = get_input_section_type; 298 299 ++i; 300 tv[i].tv_tag = LDPT_GET_INPUT_SECTION_NAME; 301 tv[i].tv_u.tv_get_input_section_name = get_input_section_name; 302 303 ++i; 304 tv[i].tv_tag = LDPT_GET_INPUT_SECTION_CONTENTS; 305 tv[i].tv_u.tv_get_input_section_contents = get_input_section_contents; 306 307 ++i; 308 tv[i].tv_tag = LDPT_UPDATE_SECTION_ORDER; 309 tv[i].tv_u.tv_update_section_order = update_section_order; 310 311 ++i; 312 tv[i].tv_tag = LDPT_ALLOW_SECTION_ORDERING; 313 tv[i].tv_u.tv_allow_section_ordering = allow_section_ordering; 314 315 ++i; 316 tv[i].tv_tag = LDPT_ALLOW_UNIQUE_SEGMENT_FOR_SECTIONS; 317 tv[i].tv_u.tv_allow_unique_segment_for_sections 318 = allow_unique_segment_for_sections; 319 320 ++i; 321 tv[i].tv_tag = LDPT_UNIQUE_SEGMENT_FOR_SECTIONS; 322 tv[i].tv_u.tv_unique_segment_for_sections = unique_segment_for_sections; 323 324 ++i; 325 tv[i].tv_tag = LDPT_NULL; 326 tv[i].tv_u.tv_val = 0; 327 328 gold_assert(i == tv_size - 1); 329 330 // Call the onload entry point. 331 (*onload)(tv); 332 333 delete[] tv; 334 #endif // ENABLE_PLUGINS 335 } 336 337 // Call the plugin claim-file handler. 338 339 inline bool 340 Plugin::claim_file(struct ld_plugin_input_file* plugin_input_file) 341 { 342 int claimed = 0; 343 344 if (this->claim_file_handler_ != NULL) 345 { 346 (*this->claim_file_handler_)(plugin_input_file, &claimed); 347 if (claimed) 348 return true; 349 } 350 return false; 351 } 352 353 // Call the all-symbols-read handler. 354 355 inline void 356 Plugin::all_symbols_read() 357 { 358 if (this->all_symbols_read_handler_ != NULL) 359 (*this->all_symbols_read_handler_)(); 360 } 361 362 // Call the cleanup handler. 363 364 inline void 365 Plugin::cleanup() 366 { 367 if (this->cleanup_handler_ != NULL && !this->cleanup_done_) 368 { 369 // Set this flag before calling to prevent a recursive plunge 370 // in the event that a plugin's cleanup handler issues a 371 // fatal error. 372 this->cleanup_done_ = true; 373 (*this->cleanup_handler_)(); 374 } 375 } 376 377 // This task is used to rescan archives as needed. 378 379 class Plugin_rescan : public Task 380 { 381 public: 382 Plugin_rescan(Task_token* this_blocker, Task_token* next_blocker) 383 : this_blocker_(this_blocker), next_blocker_(next_blocker) 384 { } 385 386 ~Plugin_rescan() 387 { 388 delete this->this_blocker_; 389 } 390 391 Task_token* 392 is_runnable() 393 { 394 if (this->this_blocker_->is_blocked()) 395 return this->this_blocker_; 396 return NULL; 397 } 398 399 void 400 locks(Task_locker* tl) 401 { tl->add(this, this->next_blocker_); } 402 403 void 404 run(Workqueue*) 405 { parameters->options().plugins()->rescan(this); } 406 407 std::string 408 get_name() const 409 { return "Plugin_rescan"; } 410 411 private: 412 Task_token* this_blocker_; 413 Task_token* next_blocker_; 414 }; 415 416 // Plugin_manager methods. 417 418 Plugin_manager::~Plugin_manager() 419 { 420 for (Plugin_list::iterator p = this->plugins_.begin(); 421 p != this->plugins_.end(); 422 ++p) 423 delete *p; 424 this->plugins_.clear(); 425 for (Object_list::iterator obj = this->objects_.begin(); 426 obj != this->objects_.end(); 427 ++obj) 428 delete *obj; 429 this->objects_.clear(); 430 delete this->lock_; 431 } 432 433 // Load all plugin libraries. 434 435 void 436 Plugin_manager::load_plugins(Layout* layout) 437 { 438 this->layout_ = layout; 439 for (this->current_ = this->plugins_.begin(); 440 this->current_ != this->plugins_.end(); 441 ++this->current_) 442 (*this->current_)->load(); 443 } 444 445 // Call the plugin claim-file handlers in turn to see if any claim the file. 446 447 Pluginobj* 448 Plugin_manager::claim_file(Input_file* input_file, off_t offset, 449 off_t filesize, Object* elf_object) 450 { 451 bool lock_initialized = this->initialize_lock_.initialize(); 452 453 gold_assert(lock_initialized); 454 Hold_lock hl(*this->lock_); 455 if (this->in_replacement_phase_) 456 return NULL; 457 458 unsigned int handle = this->objects_.size(); 459 this->input_file_ = input_file; 460 this->plugin_input_file_.name = input_file->filename().c_str(); 461 this->plugin_input_file_.fd = input_file->file().descriptor(); 462 this->plugin_input_file_.offset = offset; 463 this->plugin_input_file_.filesize = filesize; 464 this->plugin_input_file_.handle = reinterpret_cast<void*>(handle); 465 if (elf_object != NULL) 466 this->objects_.push_back(elf_object); 467 this->in_claim_file_handler_ = true; 468 469 for (this->current_ = this->plugins_.begin(); 470 this->current_ != this->plugins_.end(); 471 ++this->current_) 472 { 473 if ((*this->current_)->claim_file(&this->plugin_input_file_)) 474 { 475 this->any_claimed_ = true; 476 this->in_claim_file_handler_ = false; 477 478 if (this->objects_.size() > handle 479 && this->objects_[handle]->pluginobj() != NULL) 480 return this->objects_[handle]->pluginobj(); 481 482 // If the plugin claimed the file but did not call the 483 // add_symbols callback, we need to create the Pluginobj now. 484 Pluginobj* obj = this->make_plugin_object(handle); 485 return obj; 486 } 487 } 488 489 this->in_claim_file_handler_ = false; 490 return NULL; 491 } 492 493 // Save an archive. This is used so that a plugin can add a file 494 // which refers to a symbol which was not previously referenced. In 495 // that case we want to pretend that the symbol was referenced before, 496 // and pull in the archive object. 497 498 void 499 Plugin_manager::save_archive(Archive* archive) 500 { 501 if (this->in_replacement_phase_ || !this->any_claimed_) 502 delete archive; 503 else 504 this->rescannable_.push_back(Rescannable(archive)); 505 } 506 507 // Save an Input_group. This is like save_archive. 508 509 void 510 Plugin_manager::save_input_group(Input_group* input_group) 511 { 512 if (this->in_replacement_phase_ || !this->any_claimed_) 513 delete input_group; 514 else 515 this->rescannable_.push_back(Rescannable(input_group)); 516 } 517 518 // Call the all-symbols-read handlers. 519 520 void 521 Plugin_manager::all_symbols_read(Workqueue* workqueue, Task* task, 522 Input_objects* input_objects, 523 Symbol_table* symtab, 524 Dirsearch* dirpath, Mapfile* mapfile, 525 Task_token** last_blocker) 526 { 527 this->in_replacement_phase_ = true; 528 this->workqueue_ = workqueue; 529 this->task_ = task; 530 this->input_objects_ = input_objects; 531 this->symtab_ = symtab; 532 this->dirpath_ = dirpath; 533 this->mapfile_ = mapfile; 534 this->this_blocker_ = NULL; 535 536 for (this->current_ = this->plugins_.begin(); 537 this->current_ != this->plugins_.end(); 538 ++this->current_) 539 (*this->current_)->all_symbols_read(); 540 541 if (this->any_added_) 542 { 543 Task_token* next_blocker = new Task_token(true); 544 next_blocker->add_blocker(); 545 workqueue->queue(new Plugin_rescan(this->this_blocker_, next_blocker)); 546 this->this_blocker_ = next_blocker; 547 } 548 549 *last_blocker = this->this_blocker_; 550 } 551 552 // This is called when we see a new undefined symbol. If we are in 553 // the replacement phase, this means that we may need to rescan some 554 // archives we have previously seen. 555 556 void 557 Plugin_manager::new_undefined_symbol(Symbol* sym) 558 { 559 if (this->in_replacement_phase_) 560 this->undefined_symbols_.push_back(sym); 561 } 562 563 // Rescan archives as needed. This handles the case where a new 564 // object file added by a plugin has an undefined reference to some 565 // symbol defined in an archive. 566 567 void 568 Plugin_manager::rescan(Task* task) 569 { 570 size_t rescan_pos = 0; 571 size_t rescan_size = this->rescannable_.size(); 572 while (!this->undefined_symbols_.empty()) 573 { 574 if (rescan_pos >= rescan_size) 575 { 576 this->undefined_symbols_.clear(); 577 return; 578 } 579 580 Undefined_symbol_list undefs; 581 undefs.reserve(this->undefined_symbols_.size()); 582 this->undefined_symbols_.swap(undefs); 583 584 size_t min_rescan_pos = rescan_size; 585 586 for (Undefined_symbol_list::const_iterator p = undefs.begin(); 587 p != undefs.end(); 588 ++p) 589 { 590 if (!(*p)->is_undefined()) 591 continue; 592 593 this->undefined_symbols_.push_back(*p); 594 595 // Find the first rescan archive which defines this symbol, 596 // starting at the current rescan position. The rescan position 597 // exists so that given -la -lb -lc we don't look for undefined 598 // symbols in -lb back in -la, but instead get the definition 599 // from -lc. Don't bother to look past the current minimum 600 // rescan position. 601 for (size_t i = rescan_pos; i < min_rescan_pos; ++i) 602 { 603 if (this->rescannable_defines(i, *p)) 604 { 605 min_rescan_pos = i; 606 break; 607 } 608 } 609 } 610 611 if (min_rescan_pos >= rescan_size) 612 { 613 // We didn't find any rescannable archives which define any 614 // undefined symbols. 615 return; 616 } 617 618 const Rescannable& r(this->rescannable_[min_rescan_pos]); 619 if (r.is_archive) 620 { 621 Task_lock_obj<Archive> tl(task, r.u.archive); 622 r.u.archive->add_symbols(this->symtab_, this->layout_, 623 this->input_objects_, this->mapfile_); 624 } 625 else 626 { 627 size_t next_saw_undefined = this->symtab_->saw_undefined(); 628 size_t saw_undefined; 629 do 630 { 631 saw_undefined = next_saw_undefined; 632 633 for (Input_group::const_iterator p = r.u.input_group->begin(); 634 p != r.u.input_group->end(); 635 ++p) 636 { 637 Task_lock_obj<Archive> tl(task, *p); 638 639 (*p)->add_symbols(this->symtab_, this->layout_, 640 this->input_objects_, this->mapfile_); 641 } 642 643 next_saw_undefined = this->symtab_->saw_undefined(); 644 } 645 while (saw_undefined != next_saw_undefined); 646 } 647 648 for (size_t i = rescan_pos; i < min_rescan_pos + 1; ++i) 649 { 650 if (this->rescannable_[i].is_archive) 651 delete this->rescannable_[i].u.archive; 652 else 653 delete this->rescannable_[i].u.input_group; 654 } 655 656 rescan_pos = min_rescan_pos + 1; 657 } 658 } 659 660 // Return whether the rescannable at index I defines SYM. 661 662 bool 663 Plugin_manager::rescannable_defines(size_t i, Symbol* sym) 664 { 665 const Rescannable& r(this->rescannable_[i]); 666 if (r.is_archive) 667 return r.u.archive->defines_symbol(sym); 668 else 669 { 670 for (Input_group::const_iterator p = r.u.input_group->begin(); 671 p != r.u.input_group->end(); 672 ++p) 673 { 674 if ((*p)->defines_symbol(sym)) 675 return true; 676 } 677 return false; 678 } 679 } 680 681 // Layout deferred objects. 682 683 void 684 Plugin_manager::layout_deferred_objects() 685 { 686 Deferred_layout_list::iterator obj; 687 688 for (obj = this->deferred_layout_objects_.begin(); 689 obj != this->deferred_layout_objects_.end(); 690 ++obj) 691 { 692 // Lock the object so we can read from it. This is only called 693 // single-threaded from queue_middle_tasks, so it is OK to lock. 694 // Unfortunately we have no way to pass in a Task token. 695 const Task* dummy_task = reinterpret_cast<const Task*>(-1); 696 Task_lock_obj<Object> tl(dummy_task, *obj); 697 (*obj)->layout_deferred_sections(this->layout_); 698 } 699 } 700 701 // Call the cleanup handlers. 702 703 void 704 Plugin_manager::cleanup() 705 { 706 if (this->any_added_) 707 { 708 // If any input files were added, close all the input files. 709 // This is because the plugin may want to remove them, and on 710 // Windows you are not allowed to remove an open file. 711 close_all_descriptors(); 712 } 713 714 for (this->current_ = this->plugins_.begin(); 715 this->current_ != this->plugins_.end(); 716 ++this->current_) 717 (*this->current_)->cleanup(); 718 } 719 720 // Make a new Pluginobj object. This is called when the plugin calls 721 // the add_symbols API. 722 723 Pluginobj* 724 Plugin_manager::make_plugin_object(unsigned int handle) 725 { 726 // Make sure we aren't asked to make an object for the same handle twice. 727 if (this->objects_.size() != handle 728 && this->objects_[handle]->pluginobj() != NULL) 729 return NULL; 730 731 Pluginobj* obj = make_sized_plugin_object(this->input_file_, 732 this->plugin_input_file_.offset, 733 this->plugin_input_file_.filesize); 734 735 736 // If the elf object for this file was pushed into the objects_ vector, delete 737 // it to make room for the Pluginobj as this file is claimed. 738 if (this->objects_.size() != handle) 739 this->objects_.pop_back(); 740 741 this->objects_.push_back(obj); 742 return obj; 743 } 744 745 // Get the input file information with an open (possibly re-opened) 746 // file descriptor. 747 748 ld_plugin_status 749 Plugin_manager::get_input_file(unsigned int handle, 750 struct ld_plugin_input_file* file) 751 { 752 Pluginobj* obj = this->object(handle)->pluginobj(); 753 if (obj == NULL) 754 return LDPS_BAD_HANDLE; 755 756 obj->lock(this->task_); 757 file->name = obj->filename().c_str(); 758 file->fd = obj->descriptor(); 759 file->offset = obj->offset(); 760 file->filesize = obj->filesize(); 761 file->handle = reinterpret_cast<void*>(handle); 762 return LDPS_OK; 763 } 764 765 // Release the input file. 766 767 ld_plugin_status 768 Plugin_manager::release_input_file(unsigned int handle) 769 { 770 if (this->object(handle) == NULL) 771 return LDPS_BAD_HANDLE; 772 773 Pluginobj* obj = this->object(handle)->pluginobj(); 774 775 if (obj == NULL) 776 return LDPS_BAD_HANDLE; 777 778 obj->unlock(this->task_); 779 return LDPS_OK; 780 } 781 782 // Get the elf object corresponding to the handle. Return NULL if we 783 // found a Pluginobj instead. 784 785 Object* 786 Plugin_manager::get_elf_object(const void* handle) 787 { 788 Object* obj = this->object( 789 static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle))); 790 791 // The object should not be a Pluginobj. 792 if (obj == NULL 793 || obj->pluginobj() != NULL) 794 return NULL; 795 796 return obj; 797 } 798 799 ld_plugin_status 800 Plugin_manager::get_view(unsigned int handle, const void **viewp) 801 { 802 off_t offset; 803 size_t filesize; 804 Input_file *input_file; 805 if (this->in_claim_file_handler_) 806 { 807 // We are being called from the claim_file hook. 808 const struct ld_plugin_input_file &f = this->plugin_input_file_; 809 offset = f.offset; 810 filesize = f.filesize; 811 input_file = this->input_file_; 812 } 813 else 814 { 815 // An already claimed file. 816 if (this->object(handle) == NULL) 817 return LDPS_BAD_HANDLE; 818 Pluginobj* obj = this->object(handle)->pluginobj(); 819 if (obj == NULL) 820 return LDPS_BAD_HANDLE; 821 offset = obj->offset(); 822 filesize = obj->filesize(); 823 input_file = obj->input_file(); 824 } 825 *viewp = (void*) input_file->file().get_view(offset, 0, filesize, false, 826 false); 827 return LDPS_OK; 828 } 829 830 // Add a new library path. 831 832 ld_plugin_status 833 Plugin_manager::set_extra_library_path(const char* path) 834 { 835 this->extra_search_path_ = std::string(path); 836 return LDPS_OK; 837 } 838 839 // Add a new input file. 840 841 ld_plugin_status 842 Plugin_manager::add_input_file(const char* pathname, bool is_lib) 843 { 844 Input_file_argument file(pathname, 845 (is_lib 846 ? Input_file_argument::INPUT_FILE_TYPE_LIBRARY 847 : Input_file_argument::INPUT_FILE_TYPE_FILE), 848 (is_lib 849 ? this->extra_search_path_.c_str() 850 : ""), 851 false, 852 this->options_); 853 Input_argument* input_argument = new Input_argument(file); 854 Task_token* next_blocker = new Task_token(true); 855 next_blocker->add_blocker(); 856 if (parameters->incremental()) 857 gold_error(_("input files added by plug-ins in --incremental mode not " 858 "supported yet")); 859 this->workqueue_->queue_soon(new Read_symbols(this->input_objects_, 860 this->symtab_, 861 this->layout_, 862 this->dirpath_, 863 0, 864 this->mapfile_, 865 input_argument, 866 NULL, 867 NULL, 868 this->this_blocker_, 869 next_blocker)); 870 this->this_blocker_ = next_blocker; 871 this->any_added_ = true; 872 return LDPS_OK; 873 } 874 875 // Class Pluginobj. 876 877 Pluginobj::Pluginobj(const std::string& name, Input_file* input_file, 878 off_t offset, off_t filesize) 879 : Object(name, input_file, false, offset), 880 nsyms_(0), syms_(NULL), symbols_(), filesize_(filesize), comdat_map_() 881 { 882 } 883 884 // Return TRUE if a defined symbol is referenced from outside the 885 // universe of claimed objects. Only references from relocatable, 886 // non-IR (unclaimed) objects count as a reference. References from 887 // dynamic objects count only as "visible". 888 889 static inline bool 890 is_referenced_from_outside(Symbol* lsym) 891 { 892 if (lsym->in_real_elf()) 893 return true; 894 if (parameters->options().relocatable()) 895 return true; 896 if (parameters->options().is_undefined(lsym->name())) 897 return true; 898 return false; 899 } 900 901 // Return TRUE if a defined symbol might be reachable from outside the 902 // load module. 903 904 static inline bool 905 is_visible_from_outside(Symbol* lsym) 906 { 907 if (lsym->in_dyn()) 908 return true; 909 if (parameters->options().export_dynamic() || parameters->options().shared()) 910 return lsym->is_externally_visible(); 911 return false; 912 } 913 914 // Get symbol resolution info. 915 916 ld_plugin_status 917 Pluginobj::get_symbol_resolution_info(Symbol_table* symtab, 918 int nsyms, 919 ld_plugin_symbol* syms, 920 int version) const 921 { 922 // For version 1 of this interface, we cannot use 923 // LDPR_PREVAILING_DEF_IRONLY_EXP, so we return LDPR_PREVAILING_DEF 924 // instead. 925 const ld_plugin_symbol_resolution ldpr_prevailing_def_ironly_exp 926 = (version > 1 927 ? LDPR_PREVAILING_DEF_IRONLY_EXP 928 : LDPR_PREVAILING_DEF); 929 930 if (nsyms > this->nsyms_) 931 return LDPS_NO_SYMS; 932 933 if (static_cast<size_t>(nsyms) > this->symbols_.size()) 934 { 935 // We never decided to include this object. We mark all symbols as 936 // preempted. 937 gold_assert(this->symbols_.size() == 0); 938 for (int i = 0; i < nsyms; i++) 939 syms[i].resolution = LDPR_PREEMPTED_REG; 940 return LDPS_OK; 941 } 942 943 for (int i = 0; i < nsyms; i++) 944 { 945 ld_plugin_symbol* isym = &syms[i]; 946 Symbol* lsym = this->symbols_[i]; 947 if (lsym->is_forwarder()) 948 lsym = symtab->resolve_forwards(lsym); 949 ld_plugin_symbol_resolution res = LDPR_UNKNOWN; 950 951 if (lsym->is_undefined()) 952 // The symbol remains undefined. 953 res = LDPR_UNDEF; 954 else if (isym->def == LDPK_UNDEF 955 || isym->def == LDPK_WEAKUNDEF 956 || isym->def == LDPK_COMMON) 957 { 958 // The original symbol was undefined or common. 959 if (lsym->source() != Symbol::FROM_OBJECT) 960 res = LDPR_RESOLVED_EXEC; 961 else if (lsym->object()->pluginobj() == this) 962 { 963 if (is_referenced_from_outside(lsym)) 964 res = LDPR_PREVAILING_DEF; 965 else if (is_visible_from_outside(lsym)) 966 res = ldpr_prevailing_def_ironly_exp; 967 else 968 res = LDPR_PREVAILING_DEF_IRONLY; 969 } 970 else if (lsym->object()->pluginobj() != NULL) 971 res = LDPR_RESOLVED_IR; 972 else if (lsym->object()->is_dynamic()) 973 res = LDPR_RESOLVED_DYN; 974 else 975 res = LDPR_RESOLVED_EXEC; 976 } 977 else 978 { 979 // The original symbol was a definition. 980 if (lsym->source() != Symbol::FROM_OBJECT) 981 res = LDPR_PREEMPTED_REG; 982 else if (lsym->object() == static_cast<const Object*>(this)) 983 { 984 if (is_referenced_from_outside(lsym)) 985 res = LDPR_PREVAILING_DEF; 986 else if (is_visible_from_outside(lsym)) 987 res = ldpr_prevailing_def_ironly_exp; 988 else 989 res = LDPR_PREVAILING_DEF_IRONLY; 990 } 991 else 992 res = (lsym->object()->pluginobj() != NULL 993 ? LDPR_PREEMPTED_IR 994 : LDPR_PREEMPTED_REG); 995 } 996 isym->resolution = res; 997 } 998 return LDPS_OK; 999 } 1000 1001 // Return TRUE if the comdat group with key COMDAT_KEY from this object 1002 // should be kept. 1003 1004 bool 1005 Pluginobj::include_comdat_group(std::string comdat_key, Layout* layout) 1006 { 1007 std::pair<Comdat_map::iterator, bool> ins = 1008 this->comdat_map_.insert(std::make_pair(comdat_key, false)); 1009 1010 // If this is the first time we've seen this comdat key, ask the 1011 // layout object whether it should be included. 1012 if (ins.second) 1013 ins.first->second = layout->find_or_add_kept_section(comdat_key, 1014 NULL, 0, true, 1015 true, NULL); 1016 1017 return ins.first->second; 1018 } 1019 1020 // Class Sized_pluginobj. 1021 1022 template<int size, bool big_endian> 1023 Sized_pluginobj<size, big_endian>::Sized_pluginobj( 1024 const std::string& name, 1025 Input_file* input_file, 1026 off_t offset, 1027 off_t filesize) 1028 : Pluginobj(name, input_file, offset, filesize) 1029 { 1030 } 1031 1032 // Read the symbols. Not used for plugin objects. 1033 1034 template<int size, bool big_endian> 1035 void 1036 Sized_pluginobj<size, big_endian>::do_read_symbols(Read_symbols_data*) 1037 { 1038 gold_unreachable(); 1039 } 1040 1041 // Lay out the input sections. Not used for plugin objects. 1042 1043 template<int size, bool big_endian> 1044 void 1045 Sized_pluginobj<size, big_endian>::do_layout(Symbol_table*, Layout*, 1046 Read_symbols_data*) 1047 { 1048 gold_unreachable(); 1049 } 1050 1051 // Add the symbols to the symbol table. 1052 1053 template<int size, bool big_endian> 1054 void 1055 Sized_pluginobj<size, big_endian>::do_add_symbols(Symbol_table* symtab, 1056 Read_symbols_data*, 1057 Layout* layout) 1058 { 1059 const int sym_size = elfcpp::Elf_sizes<size>::sym_size; 1060 unsigned char symbuf[sym_size]; 1061 elfcpp::Sym<size, big_endian> sym(symbuf); 1062 elfcpp::Sym_write<size, big_endian> osym(symbuf); 1063 1064 this->symbols_.resize(this->nsyms_); 1065 1066 for (int i = 0; i < this->nsyms_; ++i) 1067 { 1068 const struct ld_plugin_symbol* isym = &this->syms_[i]; 1069 const char* name = isym->name; 1070 const char* ver = isym->version; 1071 elfcpp::Elf_Half shndx; 1072 elfcpp::STB bind; 1073 elfcpp::STV vis; 1074 1075 if (name != NULL && name[0] == '\0') 1076 name = NULL; 1077 if (ver != NULL && ver[0] == '\0') 1078 ver = NULL; 1079 1080 switch (isym->def) 1081 { 1082 case LDPK_WEAKDEF: 1083 case LDPK_WEAKUNDEF: 1084 bind = elfcpp::STB_WEAK; 1085 break; 1086 case LDPK_DEF: 1087 case LDPK_UNDEF: 1088 case LDPK_COMMON: 1089 default: 1090 bind = elfcpp::STB_GLOBAL; 1091 break; 1092 } 1093 1094 switch (isym->def) 1095 { 1096 case LDPK_DEF: 1097 case LDPK_WEAKDEF: 1098 shndx = elfcpp::SHN_ABS; 1099 break; 1100 case LDPK_COMMON: 1101 shndx = elfcpp::SHN_COMMON; 1102 break; 1103 case LDPK_UNDEF: 1104 case LDPK_WEAKUNDEF: 1105 default: 1106 shndx = elfcpp::SHN_UNDEF; 1107 break; 1108 } 1109 1110 switch (isym->visibility) 1111 { 1112 case LDPV_PROTECTED: 1113 vis = elfcpp::STV_PROTECTED; 1114 break; 1115 case LDPV_INTERNAL: 1116 vis = elfcpp::STV_INTERNAL; 1117 break; 1118 case LDPV_HIDDEN: 1119 vis = elfcpp::STV_HIDDEN; 1120 break; 1121 case LDPV_DEFAULT: 1122 default: 1123 vis = elfcpp::STV_DEFAULT; 1124 break; 1125 } 1126 1127 if (isym->comdat_key != NULL 1128 && isym->comdat_key[0] != '\0' 1129 && !this->include_comdat_group(isym->comdat_key, layout)) 1130 shndx = elfcpp::SHN_UNDEF; 1131 1132 osym.put_st_name(0); 1133 osym.put_st_value(0); 1134 osym.put_st_size(0); 1135 osym.put_st_info(bind, elfcpp::STT_NOTYPE); 1136 osym.put_st_other(vis, 0); 1137 osym.put_st_shndx(shndx); 1138 1139 this->symbols_[i] = 1140 symtab->add_from_pluginobj<size, big_endian>(this, name, ver, &sym); 1141 } 1142 } 1143 1144 template<int size, bool big_endian> 1145 Archive::Should_include 1146 Sized_pluginobj<size, big_endian>::do_should_include_member( 1147 Symbol_table* symtab, 1148 Layout* layout, 1149 Read_symbols_data*, 1150 std::string* why) 1151 { 1152 char* tmpbuf = NULL; 1153 size_t tmpbuflen = 0; 1154 1155 for (int i = 0; i < this->nsyms_; ++i) 1156 { 1157 const struct ld_plugin_symbol& sym = this->syms_[i]; 1158 const char* name = sym.name; 1159 Symbol* symbol; 1160 Archive::Should_include t = Archive::should_include_member(symtab, 1161 layout, 1162 name, 1163 &symbol, why, 1164 &tmpbuf, 1165 &tmpbuflen); 1166 if (t == Archive::SHOULD_INCLUDE_YES) 1167 { 1168 if (tmpbuf != NULL) 1169 free(tmpbuf); 1170 return t; 1171 } 1172 } 1173 if (tmpbuf != NULL) 1174 free(tmpbuf); 1175 return Archive::SHOULD_INCLUDE_UNKNOWN; 1176 } 1177 1178 // Iterate over global symbols, calling a visitor class V for each. 1179 1180 template<int size, bool big_endian> 1181 void 1182 Sized_pluginobj<size, big_endian>::do_for_all_global_symbols( 1183 Read_symbols_data*, 1184 Library_base::Symbol_visitor_base* v) 1185 { 1186 for (int i = 0; i < this->nsyms_; ++i) 1187 { 1188 const struct ld_plugin_symbol& sym = this->syms_[i]; 1189 if (sym.def != LDPK_UNDEF) 1190 v->visit(sym.name); 1191 } 1192 } 1193 1194 // Iterate over local symbols, calling a visitor class V for each GOT offset 1195 // associated with a local symbol. 1196 template<int size, bool big_endian> 1197 void 1198 Sized_pluginobj<size, big_endian>::do_for_all_local_got_entries( 1199 Got_offset_list::Visitor*) const 1200 { 1201 gold_unreachable(); 1202 } 1203 1204 // Get the size of a section. Not used for plugin objects. 1205 1206 template<int size, bool big_endian> 1207 uint64_t 1208 Sized_pluginobj<size, big_endian>::do_section_size(unsigned int) 1209 { 1210 gold_unreachable(); 1211 return 0; 1212 } 1213 1214 // Get the name of a section. Not used for plugin objects. 1215 1216 template<int size, bool big_endian> 1217 std::string 1218 Sized_pluginobj<size, big_endian>::do_section_name(unsigned int) const 1219 { 1220 gold_unreachable(); 1221 return std::string(); 1222 } 1223 1224 // Return a view of the contents of a section. Not used for plugin objects. 1225 1226 template<int size, bool big_endian> 1227 const unsigned char* 1228 Sized_pluginobj<size, big_endian>::do_section_contents( 1229 unsigned int, 1230 section_size_type*, 1231 bool) 1232 { 1233 gold_unreachable(); 1234 return NULL; 1235 } 1236 1237 // Return section flags. Not used for plugin objects. 1238 1239 template<int size, bool big_endian> 1240 uint64_t 1241 Sized_pluginobj<size, big_endian>::do_section_flags(unsigned int) 1242 { 1243 gold_unreachable(); 1244 return 0; 1245 } 1246 1247 // Return section entsize. Not used for plugin objects. 1248 1249 template<int size, bool big_endian> 1250 uint64_t 1251 Sized_pluginobj<size, big_endian>::do_section_entsize(unsigned int) 1252 { 1253 gold_unreachable(); 1254 return 0; 1255 } 1256 1257 // Return section address. Not used for plugin objects. 1258 1259 template<int size, bool big_endian> 1260 uint64_t 1261 Sized_pluginobj<size, big_endian>::do_section_address(unsigned int) 1262 { 1263 gold_unreachable(); 1264 return 0; 1265 } 1266 1267 // Return section type. Not used for plugin objects. 1268 1269 template<int size, bool big_endian> 1270 unsigned int 1271 Sized_pluginobj<size, big_endian>::do_section_type(unsigned int) 1272 { 1273 gold_unreachable(); 1274 return 0; 1275 } 1276 1277 // Return the section link field. Not used for plugin objects. 1278 1279 template<int size, bool big_endian> 1280 unsigned int 1281 Sized_pluginobj<size, big_endian>::do_section_link(unsigned int) 1282 { 1283 gold_unreachable(); 1284 return 0; 1285 } 1286 1287 // Return the section link field. Not used for plugin objects. 1288 1289 template<int size, bool big_endian> 1290 unsigned int 1291 Sized_pluginobj<size, big_endian>::do_section_info(unsigned int) 1292 { 1293 gold_unreachable(); 1294 return 0; 1295 } 1296 1297 // Return the section alignment. Not used for plugin objects. 1298 1299 template<int size, bool big_endian> 1300 uint64_t 1301 Sized_pluginobj<size, big_endian>::do_section_addralign(unsigned int) 1302 { 1303 gold_unreachable(); 1304 return 0; 1305 } 1306 1307 // Return the Xindex structure to use. Not used for plugin objects. 1308 1309 template<int size, bool big_endian> 1310 Xindex* 1311 Sized_pluginobj<size, big_endian>::do_initialize_xindex() 1312 { 1313 gold_unreachable(); 1314 return NULL; 1315 } 1316 1317 // Get symbol counts. Don't count plugin objects; the replacement 1318 // files will provide the counts. 1319 1320 template<int size, bool big_endian> 1321 void 1322 Sized_pluginobj<size, big_endian>::do_get_global_symbol_counts( 1323 const Symbol_table*, 1324 size_t* defined, 1325 size_t* used) const 1326 { 1327 *defined = 0; 1328 *used = 0; 1329 } 1330 1331 // Get symbols. Not used for plugin objects. 1332 1333 template<int size, bool big_endian> 1334 const Object::Symbols* 1335 Sized_pluginobj<size, big_endian>::do_get_global_symbols() const 1336 { 1337 gold_unreachable(); 1338 } 1339 1340 // Class Plugin_finish. This task runs after all replacement files have 1341 // been added. For now, it's a placeholder for a possible plugin API 1342 // to allow the plugin to release most of its resources. The cleanup 1343 // handlers must be called later, because they can remove the temporary 1344 // object files that are needed until the end of the link. 1345 1346 class Plugin_finish : public Task 1347 { 1348 public: 1349 Plugin_finish(Task_token* this_blocker, Task_token* next_blocker) 1350 : this_blocker_(this_blocker), next_blocker_(next_blocker) 1351 { } 1352 1353 ~Plugin_finish() 1354 { 1355 if (this->this_blocker_ != NULL) 1356 delete this->this_blocker_; 1357 } 1358 1359 Task_token* 1360 is_runnable() 1361 { 1362 if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) 1363 return this->this_blocker_; 1364 return NULL; 1365 } 1366 1367 void 1368 locks(Task_locker* tl) 1369 { tl->add(this, this->next_blocker_); } 1370 1371 void 1372 run(Workqueue*) 1373 { 1374 // We could call early cleanup handlers here. 1375 } 1376 1377 std::string 1378 get_name() const 1379 { return "Plugin_finish"; } 1380 1381 private: 1382 Task_token* this_blocker_; 1383 Task_token* next_blocker_; 1384 }; 1385 1386 // Class Plugin_hook. 1387 1388 Plugin_hook::~Plugin_hook() 1389 { 1390 } 1391 1392 // Return whether a Plugin_hook task is runnable. 1393 1394 Task_token* 1395 Plugin_hook::is_runnable() 1396 { 1397 if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) 1398 return this->this_blocker_; 1399 return NULL; 1400 } 1401 1402 // Return a Task_locker for a Plugin_hook task. We don't need any 1403 // locks here. 1404 1405 void 1406 Plugin_hook::locks(Task_locker*) 1407 { 1408 } 1409 1410 // Run the "all symbols read" plugin hook. 1411 1412 void 1413 Plugin_hook::run(Workqueue* workqueue) 1414 { 1415 gold_assert(this->options_.has_plugins()); 1416 Symbol* start_sym = this->symtab_->lookup(parameters->entry()); 1417 if (start_sym != NULL) 1418 start_sym->set_in_real_elf(); 1419 1420 this->options_.plugins()->all_symbols_read(workqueue, 1421 this, 1422 this->input_objects_, 1423 this->symtab_, 1424 this->dirpath_, 1425 this->mapfile_, 1426 &this->this_blocker_); 1427 workqueue->queue_soon(new Plugin_finish(this->this_blocker_, 1428 this->next_blocker_)); 1429 } 1430 1431 // The C interface routines called by the plugins. 1432 1433 #ifdef ENABLE_PLUGINS 1434 1435 // Register a claim-file handler. 1436 1437 static enum ld_plugin_status 1438 register_claim_file(ld_plugin_claim_file_handler handler) 1439 { 1440 gold_assert(parameters->options().has_plugins()); 1441 parameters->options().plugins()->set_claim_file_handler(handler); 1442 return LDPS_OK; 1443 } 1444 1445 // Register an all-symbols-read handler. 1446 1447 static enum ld_plugin_status 1448 register_all_symbols_read(ld_plugin_all_symbols_read_handler handler) 1449 { 1450 gold_assert(parameters->options().has_plugins()); 1451 parameters->options().plugins()->set_all_symbols_read_handler(handler); 1452 return LDPS_OK; 1453 } 1454 1455 // Register a cleanup handler. 1456 1457 static enum ld_plugin_status 1458 register_cleanup(ld_plugin_cleanup_handler handler) 1459 { 1460 gold_assert(parameters->options().has_plugins()); 1461 parameters->options().plugins()->set_cleanup_handler(handler); 1462 return LDPS_OK; 1463 } 1464 1465 // Add symbols from a plugin-claimed input file. 1466 1467 static enum ld_plugin_status 1468 add_symbols(void* handle, int nsyms, const ld_plugin_symbol* syms) 1469 { 1470 gold_assert(parameters->options().has_plugins()); 1471 Pluginobj* obj = parameters->options().plugins()->make_plugin_object( 1472 static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle))); 1473 if (obj == NULL) 1474 return LDPS_ERR; 1475 obj->store_incoming_symbols(nsyms, syms); 1476 return LDPS_OK; 1477 } 1478 1479 // Get the input file information with an open (possibly re-opened) 1480 // file descriptor. 1481 1482 static enum ld_plugin_status 1483 get_input_file(const void* handle, struct ld_plugin_input_file* file) 1484 { 1485 gold_assert(parameters->options().has_plugins()); 1486 unsigned int obj_index = 1487 static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle)); 1488 return parameters->options().plugins()->get_input_file(obj_index, file); 1489 } 1490 1491 // Release the input file. 1492 1493 static enum ld_plugin_status 1494 release_input_file(const void* handle) 1495 { 1496 gold_assert(parameters->options().has_plugins()); 1497 unsigned int obj_index = 1498 static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle)); 1499 return parameters->options().plugins()->release_input_file(obj_index); 1500 } 1501 1502 static enum ld_plugin_status 1503 get_view(const void *handle, const void **viewp) 1504 { 1505 gold_assert(parameters->options().has_plugins()); 1506 unsigned int obj_index = 1507 static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle)); 1508 return parameters->options().plugins()->get_view(obj_index, viewp); 1509 } 1510 1511 // Get the symbol resolution info for a plugin-claimed input file. 1512 1513 static enum ld_plugin_status 1514 get_symbols(const void* handle, int nsyms, ld_plugin_symbol* syms) 1515 { 1516 gold_assert(parameters->options().has_plugins()); 1517 Plugin_manager* plugins = parameters->options().plugins(); 1518 Object* obj = plugins->object( 1519 static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle))); 1520 if (obj == NULL) 1521 return LDPS_ERR; 1522 Pluginobj* plugin_obj = obj->pluginobj(); 1523 if (plugin_obj == NULL) 1524 return LDPS_ERR; 1525 Symbol_table* symtab = plugins->symtab(); 1526 return plugin_obj->get_symbol_resolution_info(symtab, nsyms, syms, 1); 1527 } 1528 1529 // Version 2 of the above. The only difference is that this version 1530 // is allowed to return the resolution code LDPR_PREVAILING_DEF_IRONLY_EXP. 1531 1532 static enum ld_plugin_status 1533 get_symbols_v2(const void* handle, int nsyms, ld_plugin_symbol* syms) 1534 { 1535 gold_assert(parameters->options().has_plugins()); 1536 Plugin_manager* plugins = parameters->options().plugins(); 1537 Object* obj = plugins->object( 1538 static_cast<unsigned int>(reinterpret_cast<intptr_t>(handle))); 1539 if (obj == NULL) 1540 return LDPS_ERR; 1541 Pluginobj* plugin_obj = obj->pluginobj(); 1542 if (plugin_obj == NULL) 1543 return LDPS_ERR; 1544 Symbol_table* symtab = plugins->symtab(); 1545 return plugin_obj->get_symbol_resolution_info(symtab, nsyms, syms, 2); 1546 } 1547 1548 // Add a new (real) input file generated by a plugin. 1549 1550 static enum ld_plugin_status 1551 add_input_file(const char* pathname) 1552 { 1553 gold_assert(parameters->options().has_plugins()); 1554 return parameters->options().plugins()->add_input_file(pathname, false); 1555 } 1556 1557 // Add a new (real) library required by a plugin. 1558 1559 static enum ld_plugin_status 1560 add_input_library(const char* pathname) 1561 { 1562 gold_assert(parameters->options().has_plugins()); 1563 return parameters->options().plugins()->add_input_file(pathname, true); 1564 } 1565 1566 // Set the extra library path to be used by libraries added via 1567 // add_input_library 1568 1569 static enum ld_plugin_status 1570 set_extra_library_path(const char* path) 1571 { 1572 gold_assert(parameters->options().has_plugins()); 1573 return parameters->options().plugins()->set_extra_library_path(path); 1574 } 1575 1576 // Issue a diagnostic message from a plugin. 1577 1578 static enum ld_plugin_status 1579 message(int level, const char* format, ...) 1580 { 1581 va_list args; 1582 va_start(args, format); 1583 1584 switch (level) 1585 { 1586 case LDPL_INFO: 1587 parameters->errors()->info(format, args); 1588 break; 1589 case LDPL_WARNING: 1590 parameters->errors()->warning(format, args); 1591 break; 1592 case LDPL_ERROR: 1593 default: 1594 parameters->errors()->error(format, args); 1595 break; 1596 case LDPL_FATAL: 1597 parameters->errors()->fatal(format, args); 1598 break; 1599 } 1600 1601 va_end(args); 1602 return LDPS_OK; 1603 } 1604 1605 // Get the section count of the object corresponding to the handle. This 1606 // plugin interface can only be called in the claim_file handler of the plugin. 1607 1608 static enum ld_plugin_status 1609 get_input_section_count(const void* handle, unsigned int* count) 1610 { 1611 gold_assert(parameters->options().has_plugins()); 1612 1613 if (!parameters->options().plugins()->in_claim_file_handler()) 1614 return LDPS_ERR; 1615 1616 Object* obj = parameters->options().plugins()->get_elf_object(handle); 1617 1618 if (obj == NULL) 1619 return LDPS_ERR; 1620 1621 *count = obj->shnum(); 1622 return LDPS_OK; 1623 } 1624 1625 // Get the type of the specified section in the object corresponding 1626 // to the handle. This plugin interface can only be called in the 1627 // claim_file handler of the plugin. 1628 1629 static enum ld_plugin_status 1630 get_input_section_type(const struct ld_plugin_section section, 1631 unsigned int* type) 1632 { 1633 gold_assert(parameters->options().has_plugins()); 1634 1635 if (!parameters->options().plugins()->in_claim_file_handler()) 1636 return LDPS_ERR; 1637 1638 Object* obj 1639 = parameters->options().plugins()->get_elf_object(section.handle); 1640 1641 if (obj == NULL) 1642 return LDPS_BAD_HANDLE; 1643 1644 *type = obj->section_type(section.shndx); 1645 return LDPS_OK; 1646 } 1647 1648 // Get the name of the specified section in the object corresponding 1649 // to the handle. This plugin interface can only be called in the 1650 // claim_file handler of the plugin. 1651 1652 static enum ld_plugin_status 1653 get_input_section_name(const struct ld_plugin_section section, 1654 char** section_name_ptr) 1655 { 1656 gold_assert(parameters->options().has_plugins()); 1657 1658 if (!parameters->options().plugins()->in_claim_file_handler()) 1659 return LDPS_ERR; 1660 1661 Object* obj 1662 = parameters->options().plugins()->get_elf_object(section.handle); 1663 1664 if (obj == NULL) 1665 return LDPS_BAD_HANDLE; 1666 1667 // Check if the object is locked before getting the section name. 1668 gold_assert(obj->is_locked()); 1669 1670 const std::string section_name = obj->section_name(section.shndx); 1671 *section_name_ptr = static_cast<char*>(malloc(section_name.length() + 1)); 1672 memcpy(*section_name_ptr, section_name.c_str(), section_name.length() + 1); 1673 return LDPS_OK; 1674 } 1675 1676 // Get the contents of the specified section in the object corresponding 1677 // to the handle. This plugin interface can only be called in the 1678 // claim_file handler of the plugin. 1679 1680 static enum ld_plugin_status 1681 get_input_section_contents(const struct ld_plugin_section section, 1682 const unsigned char** section_contents_ptr, 1683 size_t* len) 1684 { 1685 gold_assert(parameters->options().has_plugins()); 1686 1687 if (!parameters->options().plugins()->in_claim_file_handler()) 1688 return LDPS_ERR; 1689 1690 Object* obj 1691 = parameters->options().plugins()->get_elf_object(section.handle); 1692 1693 if (obj == NULL) 1694 return LDPS_BAD_HANDLE; 1695 1696 // Check if the object is locked before getting the section contents. 1697 gold_assert(obj->is_locked()); 1698 1699 section_size_type plen; 1700 *section_contents_ptr 1701 = obj->section_contents(section.shndx, &plen, false); 1702 *len = plen; 1703 return LDPS_OK; 1704 } 1705 1706 // Specify the ordering of sections in the final layout. The sections are 1707 // specified as (handle,shndx) pairs in the two arrays in the order in 1708 // which they should appear in the final layout. 1709 1710 static enum ld_plugin_status 1711 update_section_order(const struct ld_plugin_section* section_list, 1712 unsigned int num_sections) 1713 { 1714 gold_assert(parameters->options().has_plugins()); 1715 1716 if (num_sections == 0) 1717 return LDPS_OK; 1718 1719 if (section_list == NULL) 1720 return LDPS_ERR; 1721 1722 Layout* layout = parameters->options().plugins()->layout(); 1723 gold_assert (layout != NULL); 1724 1725 std::map<Section_id, unsigned int>* order_map 1726 = layout->get_section_order_map(); 1727 1728 /* Store the mapping from Section_id to section position in layout's 1729 order_map to consult after output sections are added. */ 1730 for (unsigned int i = 0; i < num_sections; ++i) 1731 { 1732 Object* obj = parameters->options().plugins()->get_elf_object( 1733 section_list[i].handle); 1734 if (obj == NULL) 1735 return LDPS_BAD_HANDLE; 1736 unsigned int shndx = section_list[i].shndx; 1737 Section_id secn_id(obj, shndx); 1738 (*order_map)[secn_id] = i + 1; 1739 } 1740 1741 return LDPS_OK; 1742 } 1743 1744 // Let the linker know that the sections could be reordered. 1745 1746 static enum ld_plugin_status 1747 allow_section_ordering() 1748 { 1749 gold_assert(parameters->options().has_plugins()); 1750 Layout* layout = parameters->options().plugins()->layout(); 1751 layout->set_section_ordering_specified(); 1752 return LDPS_OK; 1753 } 1754 1755 // Let the linker know that a subset of sections could be mapped 1756 // to a unique segment. 1757 1758 static enum ld_plugin_status 1759 allow_unique_segment_for_sections() 1760 { 1761 gold_assert(parameters->options().has_plugins()); 1762 Layout* layout = parameters->options().plugins()->layout(); 1763 layout->set_unique_segment_for_sections_specified(); 1764 return LDPS_OK; 1765 } 1766 1767 // This function should map the list of sections specified in the 1768 // SECTION_LIST to a unique segment. ELF segments do not have names 1769 // and the NAME is used to identify Output Section which should contain 1770 // the list of sections. This Output Section will then be mapped to 1771 // a unique segment. FLAGS is used to specify if any additional segment 1772 // flags need to be set. For instance, a specific segment flag can be 1773 // set to identify this segment. Unsetting segment flags is not possible. 1774 // ALIGN specifies the alignment of the segment. 1775 1776 static enum ld_plugin_status 1777 unique_segment_for_sections(const char* segment_name, 1778 uint64_t flags, 1779 uint64_t align, 1780 const struct ld_plugin_section* section_list, 1781 unsigned int num_sections) 1782 { 1783 gold_assert(parameters->options().has_plugins()); 1784 1785 if (num_sections == 0) 1786 return LDPS_OK; 1787 1788 if (section_list == NULL) 1789 return LDPS_ERR; 1790 1791 Layout* layout = parameters->options().plugins()->layout(); 1792 gold_assert (layout != NULL); 1793 1794 Layout::Unique_segment_info* s = new Layout::Unique_segment_info; 1795 s->name = segment_name; 1796 s->flags = flags; 1797 s->align = align; 1798 1799 for (unsigned int i = 0; i < num_sections; ++i) 1800 { 1801 Object* obj = parameters->options().plugins()->get_elf_object( 1802 section_list[i].handle); 1803 if (obj == NULL) 1804 return LDPS_BAD_HANDLE; 1805 unsigned int shndx = section_list[i].shndx; 1806 Const_section_id secn_id(obj, shndx); 1807 layout->insert_section_segment_map(secn_id, s); 1808 } 1809 1810 return LDPS_OK; 1811 } 1812 1813 #endif // ENABLE_PLUGINS 1814 1815 // Allocate a Pluginobj object of the appropriate size and endianness. 1816 1817 static Pluginobj* 1818 make_sized_plugin_object(Input_file* input_file, off_t offset, off_t filesize) 1819 { 1820 Pluginobj* obj = NULL; 1821 1822 parameters_force_valid_target(); 1823 const Target& target(parameters->target()); 1824 1825 if (target.get_size() == 32) 1826 { 1827 if (target.is_big_endian()) 1828 #ifdef HAVE_TARGET_32_BIG 1829 obj = new Sized_pluginobj<32, true>(input_file->filename(), 1830 input_file, offset, filesize); 1831 #else 1832 gold_error(_("%s: not configured to support " 1833 "32-bit big-endian object"), 1834 input_file->filename().c_str()); 1835 #endif 1836 else 1837 #ifdef HAVE_TARGET_32_LITTLE 1838 obj = new Sized_pluginobj<32, false>(input_file->filename(), 1839 input_file, offset, filesize); 1840 #else 1841 gold_error(_("%s: not configured to support " 1842 "32-bit little-endian object"), 1843 input_file->filename().c_str()); 1844 #endif 1845 } 1846 else if (target.get_size() == 64) 1847 { 1848 if (target.is_big_endian()) 1849 #ifdef HAVE_TARGET_64_BIG 1850 obj = new Sized_pluginobj<64, true>(input_file->filename(), 1851 input_file, offset, filesize); 1852 #else 1853 gold_error(_("%s: not configured to support " 1854 "64-bit big-endian object"), 1855 input_file->filename().c_str()); 1856 #endif 1857 else 1858 #ifdef HAVE_TARGET_64_LITTLE 1859 obj = new Sized_pluginobj<64, false>(input_file->filename(), 1860 input_file, offset, filesize); 1861 #else 1862 gold_error(_("%s: not configured to support " 1863 "64-bit little-endian object"), 1864 input_file->filename().c_str()); 1865 #endif 1866 } 1867 1868 gold_assert(obj != NULL); 1869 return obj; 1870 } 1871 1872 } // End namespace gold. 1873