gold/plugin.cc

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