lto-plugin/lto-plugin.c

   1 /* LTO plugin for gold and/or GNU ld.
   2    Copyright (C) 2009, 2010 Free Software Foundation, Inc.
   3    Contributed by Rafael Avila de Espindola (espindola@google.com).
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 3, or (at your option)
   8 any later version.
   9
  10 This program is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; see the file COPYING3.  If not see
  17 <http://www.gnu.org/licenses/>.  */
  18
  19 /* The plugin has only one external function: onload. Gold passes it an array of
  20    function that the plugin uses to communicate back to gold.
  21
  22    With the functions provided by gold, the plugin can be notified when
  23    gold first analyzes a file and pass a symbol table back to gold. The plugin
  24    is also notified when all symbols have been read and it is time to generate
  25    machine code for the necessary symbols.
  26
  27    More information at http://gcc.gnu.org/wiki/whopr/driver.
  28
  29    This plugin should be passed the lto-wrapper options and will forward them.
  30    It also has 2 options of its own:
  31    -debug: Print the command line used to run lto-wrapper.
  32    -nop: Instead of running lto-wrapper, pass the original to the plugin. This
  33    only works if the input files are hybrid.  */
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include "config.h"
  37 #endif
  38 #if HAVE_STDINT_H
  39 #include <stdint.h>
  40 #endif
  41 #include <assert.h>
  42 #include <string.h>
  43 #include <stdlib.h>
  44 #include <stdio.h>
  45 #include <inttypes.h>
  46 #include <sys/stat.h>
  47 #include <unistd.h>
  48 #include <fcntl.h>
  49 #include <sys/types.h>
  50 #ifdef HAVE_SYS_WAIT_H
  51 #include <sys/wait.h>
  52 #endif
  53 #ifndef WIFEXITED
  54 #define WIFEXITED(S) (((S) & 0xff) == 0)
  55 #endif
  56 #ifndef WEXITSTATUS
  57 #define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
  58 #endif
  59 #include <libiberty.h>
  60 #include <hashtab.h>
  61 #include "../gcc/lto/common.h"
  62 #include "simple-object.h"
  63 #include "plugin-api.h"
  64
  65 /* Handle opening elf files on hosts, such as Windows, that may use
  66    text file handling that will break binary access.  */
  67 #ifndef O_BINARY
  68 # define O_BINARY 0
  69 #endif
  70
  71 /* Segment name for LTO sections.  This is only used for Mach-O.
  72    FIXME: This needs to be kept in sync with darwin.c.  */
  73
  74 #define LTO_SEGMENT_NAME "__GNU_LTO"
  75
  76 /* LTO magic section name.  */
  77
  78 #define LTO_SECTION_PREFIX      ".gnu.lto_.symtab"
  79 #define LTO_SECTION_PREFIX_LEN  (sizeof (LTO_SECTION_PREFIX) - 1)
  80
  81 /* The part of the symbol table the plugin has to keep track of. Note that we
  82    must keep SYMS until all_symbols_read is called to give the linker time to
  83    copy the symbol information. */
  84
  85 struct sym_aux
  86 {
  87   uint32_t slot;
  88   unsigned id;
  89   unsigned next_conflict;
  90 };
  91
  92 struct plugin_symtab
  93 {
  94   int nsyms;
  95   struct sym_aux *aux;
  96   struct ld_plugin_symbol *syms;
  97   unsigned id;
  98 };
  99
 100 /* Encapsulates object file data during symbol scan.  */
 101 struct plugin_objfile
 102 {
 103   int found;
 104   simple_object_read *objfile;
 105   struct plugin_symtab *out;
 106   const struct ld_plugin_input_file *file;
 107 };
 108
 109 /* All that we have to remember about a file. */
 110
 111 struct plugin_file_info
 112 {
 113   char *name;
 114   void *handle;
 115   struct plugin_symtab symtab;
 116   struct plugin_symtab conflicts;
 117 };
 118
 119 /* Until ASM_OUTPUT_LABELREF can be hookized and decoupled from
 120    stdio file streams, we do simple label translation here.  */
 121
 122 enum symbol_style
 123 {
 124   ss_none,      /* No underscore prefix. */
 125   ss_win32,     /* Underscore prefix any symbol not beginning with '@'.  */
 126   ss_uscore,    /* Underscore prefix all symbols.  */
 127 };
 128
 129 static char *arguments_file_name;
 130 static ld_plugin_register_claim_file register_claim_file;
 131 static ld_plugin_register_all_symbols_read register_all_symbols_read;
 132 static ld_plugin_get_symbols get_symbols;
 133 static ld_plugin_register_cleanup register_cleanup;
 134 static ld_plugin_add_input_file add_input_file;
 135 static ld_plugin_add_input_library add_input_library;
 136 static ld_plugin_message message;
 137 static ld_plugin_add_symbols add_symbols;
 138
 139 static struct plugin_file_info *claimed_files = NULL;
 140 static unsigned int num_claimed_files = 0;
 141
 142 static char **output_files = NULL;
 143 static unsigned int num_output_files = 0;
 144
 145 static char **lto_wrapper_argv;
 146 static int lto_wrapper_num_args;
 147
 148 static char **pass_through_items = NULL;
 149 static unsigned int num_pass_through_items;
 150
 151 static char debug;
 152 static char nop;
 153 static char *resolution_file = NULL;
 154
 155 /* Not used by default, but can be overridden at runtime
 156    by using -plugin-opt=-sym-style={none,win32,underscore|uscore}
 157    (in fact, only first letter of style arg is checked.)  */
 158 static enum symbol_style sym_style = ss_none;
 159
 160 static void
 161 check_1 (int gate, enum ld_plugin_level level, const char *text)
 162 {
 163   if (gate)
 164     return;
 165
 166   if (message)
 167     message (level, text);
 168   else
 169     {
 170       /* If there is no nicer way to inform the user, fallback to stderr. */
 171       fprintf (stderr, "%s\n", text);
 172       if (level == LDPL_FATAL)
 173         abort ();
 174     }
 175 }
 176
 177 /* This little wrapper allows check to be called with a non-integer
 178    first argument, such as a pointer that must be non-NULL.  We can't
 179    use c99 bool type to coerce it into range, so we explicitly test.  */
 180 #define check(GATE, LEVEL, TEXT) check_1 (((GATE) != 0), (LEVEL), (TEXT))
 181
 182 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
 183    by P and the result is written in ENTRY. The slot number is stored in SLOT.
 184    Returns the address of the next entry. */
 185
 186 static char *
 187 parse_table_entry (char *p, struct ld_plugin_symbol *entry,
 188                    struct sym_aux *aux)
 189 {
 190   unsigned char t;
 191   enum ld_plugin_symbol_kind translate_kind[] =
 192     {
 193       LDPK_DEF,
 194       LDPK_WEAKDEF,
 195       LDPK_UNDEF,
 196       LDPK_WEAKUNDEF,
 197       LDPK_COMMON
 198     };
 199
 200   enum ld_plugin_symbol_visibility translate_visibility[] =
 201     {
 202       LDPV_DEFAULT,
 203       LDPV_PROTECTED,
 204       LDPV_INTERNAL,
 205       LDPV_HIDDEN
 206     };
 207
 208   switch (sym_style)
 209     {
 210     case ss_win32:
 211       if (p[0] == '@')
 212         {
 213     /* cf. Duff's device.  */
 214     case ss_none:
 215           entry->name = xstrdup (p);
 216           break;
 217         }
 218     /* FALL-THROUGH.  */
 219     case ss_uscore:
 220       entry->name = concat ("_", p, NULL);
 221       break;
 222     default:
 223       check (0, LDPL_FATAL, "invalid symbol style requested");
 224       break;
 225     }
 226   while (*p)
 227     p++;
 228   p++;
 229
 230   entry->version = NULL;
 231
 232   entry->comdat_key = p;
 233   while (*p)
 234     p++;
 235   p++;
 236
 237   if (strlen (entry->comdat_key) == 0)
 238     entry->comdat_key = NULL;
 239   else
 240     entry->comdat_key = xstrdup (entry->comdat_key);
 241
 242   t = *p;
 243   check (t <= 4, LDPL_FATAL, "invalid symbol kind found");
 244   entry->def = translate_kind[t];
 245   p++;
 246
 247   t = *p;
 248   check (t <= 3, LDPL_FATAL, "invalid symbol visibility found");
 249   entry->visibility = translate_visibility[t];
 250   p++;
 251
 252   memcpy (&entry->size, p, sizeof (uint64_t));
 253   p += 8;
 254
 255   memcpy (&aux->slot, p, sizeof (uint32_t));
 256   p += 4;
 257
 258   entry->resolution = LDPR_UNKNOWN;
 259
 260   aux->next_conflict = -1;
 261
 262   return p;
 263 }
 264
 265 /* Translate the IL symbol table located between DATA and END. Append the
 266    slots and symbols to OUT. */
 267
 268 static void
 269 translate (char *data, char *end, struct plugin_symtab *out)
 270 {
 271   struct sym_aux *aux;
 272   struct ld_plugin_symbol *syms = NULL;
 273   int n, len;
 274
 275   /* This overestimates the output buffer sizes, but at least
 276      the algorithm is O(1) now. */
 277
 278   len = (end - data)/8 + out->nsyms + 1;
 279   syms = xrealloc (out->syms, len * sizeof (struct ld_plugin_symbol));
 280   aux = xrealloc (out->aux, len * sizeof (struct sym_aux));
 281
 282   for (n = out->nsyms; data < end; n++)
 283     {
 284       aux[n].id = out->id;
 285       data = parse_table_entry (data, &syms[n], &aux[n]);
 286     }
 287
 288   assert(n < len);
 289
 290   out->nsyms = n;
 291   out->syms = syms;
 292   out->aux = aux;
 293 }
 294
 295 /* Free all memory that is no longer needed after writing the symbol
 296    resolution. */
 297
 298 static void
 299 free_1 (void)
 300 {
 301   unsigned int i;
 302   for (i = 0; i < num_claimed_files; i++)
 303     {
 304       struct plugin_file_info *info = &claimed_files[i];
 305       struct plugin_symtab *symtab = &info->symtab;
 306       unsigned int j;
 307       for (j = 0; j < symtab->nsyms; j++)
 308         {
 309           struct ld_plugin_symbol *s = &symtab->syms[j];
 310           free (s->name);
 311           if (s->comdat_key)
 312             free (s->comdat_key);
 313         }
 314       free (symtab->syms);
 315       symtab->syms = NULL;
 316     }
 317 }
 318
 319 /* Free all remaining memory. */
 320
 321 static void
 322 free_2 (void)
 323 {
 324   unsigned int i;
 325   for (i = 0; i < num_claimed_files; i++)
 326     {
 327       struct plugin_file_info *info = &claimed_files[i];
 328       struct plugin_symtab *symtab = &info->symtab;
 329       free (symtab->aux);
 330       free (info->name);
 331     }
 332
 333   for (i = 0; i < num_output_files; i++)
 334     free (output_files[i]);
 335   free (output_files);
 336
 337   free (claimed_files);
 338   claimed_files = NULL;
 339   num_claimed_files = 0;
 340
 341   if (arguments_file_name)
 342     free (arguments_file_name);
 343   arguments_file_name = NULL;
 344 }
 345
 346 /* Dump SYMTAB to resolution file F. */
 347
 348 static void
 349 dump_symtab (FILE *f, struct plugin_symtab *symtab)
 350 {
 351   unsigned j;
 352
 353   for (j = 0; j < symtab->nsyms; j++)
 354     {
 355       uint32_t slot = symtab->aux[j].slot;
 356       unsigned int resolution = symtab->syms[j].resolution;
 357
 358       assert (resolution != LDPR_UNKNOWN);
 359
 360       fprintf (f, "%u %x %s %s\n", (unsigned int) slot, symtab->aux[j].id,
 361                lto_resolution_str[resolution],
 362                symtab->syms[j].name);
 363     }
 364 }
 365
 366 /* Finish the conflicts' resolution information after the linker resolved
 367    the original symbols */
 368
 369 static void
 370 finish_conflict_resolution (struct plugin_symtab *symtab,
 371                            struct plugin_symtab *conflicts)
 372 {
 373   int i, j;
 374
 375   if (conflicts->nsyms == 0)
 376     return;
 377
 378   for (i = 0; i < symtab->nsyms; i++)
 379     {
 380       int resolution = LDPR_UNKNOWN;
 381
 382       if (symtab->aux[i].next_conflict == -1)
 383         continue;
 384
 385       switch (symtab->syms[i].def)
 386         {
 387         case LDPK_DEF:
 388         case LDPK_COMMON: /* ??? */
 389           resolution = LDPR_RESOLVED_IR;
 390           break;
 391         case LDPK_WEAKDEF:
 392           resolution = LDPR_PREEMPTED_IR;
 393           break;
 394         case LDPK_UNDEF:
 395         case LDPK_WEAKUNDEF:
 396           resolution = symtab->syms[i].resolution;
 397           break;
 398         default:
 399           assert (0);
 400         }
 401
 402       assert (resolution != LDPR_UNKNOWN);
 403
 404       for (j = symtab->aux[i].next_conflict;
 405            j != -1;
 406            j = conflicts->aux[j].next_conflict)
 407         conflicts->syms[j].resolution = resolution;
 408     }
 409 }
 410
 411 /* Free symbol table SYMTAB. */
 412
 413 static void
 414 free_symtab (struct plugin_symtab *symtab)
 415 {
 416   free (symtab->syms);
 417   symtab->syms = NULL;
 418   free (symtab->aux);
 419   symtab->aux = NULL;
 420 }
 421
 422 /*  Writes the relocations to disk. */
 423
 424 static void
 425 write_resolution (void)
 426 {
 427   unsigned int i;
 428   FILE *f;
 429
 430   check (resolution_file, LDPL_FATAL, "resolution file not specified");
 431   f = fopen (resolution_file, "w");
 432   check (f, LDPL_FATAL, "could not open file");
 433
 434   fprintf (f, "%d\n", num_claimed_files);
 435
 436   for (i = 0; i < num_claimed_files; i++)
 437     {
 438       struct plugin_file_info *info = &claimed_files[i];
 439       struct plugin_symtab *symtab = &info->symtab;
 440       struct ld_plugin_symbol *syms = symtab->syms;
 441
 442       get_symbols (info->handle, symtab->nsyms, syms);
 443
 444       finish_conflict_resolution (symtab, &info->conflicts);
 445
 446       fprintf (f, "%s %d\n", info->name, symtab->nsyms + info->conflicts.nsyms);
 447       dump_symtab (f, symtab);
 448       if (info->conflicts.nsyms)
 449         {
 450           dump_symtab (f, &info->conflicts);
 451           free_symtab (&info->conflicts);
 452         }
 453     }
 454   fclose (f);
 455 }
 456
 457 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
 458    stdout. */
 459
 460 static void
 461 add_output_files (FILE *f)
 462 {
 463   for (;;)
 464     {
 465       const unsigned piece = 32;
 466       char *buf, *s = xmalloc (piece);
 467       size_t len;
 468
 469       buf = s;
 470 cont:
 471       if (!fgets (buf, piece, f))
 472         {
 473           free (s);
 474           break;
 475         }
 476       len = strlen (s);
 477       if (s[len - 1] != '\n')
 478         {
 479           s = xrealloc (s, len + piece);
 480           buf = s + len;
 481           goto cont;
 482         }
 483       s[len - 1] = '\0';
 484
 485       num_output_files++;
 486       output_files
 487         = xrealloc (output_files, num_output_files * sizeof (char *));
 488       output_files[num_output_files - 1] = s;
 489       add_input_file (output_files[num_output_files - 1]);
 490     }
 491 }
 492
 493 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
 494    argument list. */
 495
 496 static void
 497 exec_lto_wrapper (char *argv[])
 498 {
 499   int t, i;
 500   int status;
 501   char *at_args;
 502   FILE *args;
 503   FILE *wrapper_output;
 504   char *new_argv[3];
 505   struct pex_obj *pex;
 506   const char *errmsg;
 507
 508   /* Write argv to a file to avoid a command line that is too long. */
 509   arguments_file_name = make_temp_file ("");
 510   check (arguments_file_name, LDPL_FATAL,
 511          "Failed to generate a temorary file name");
 512
 513   args = fopen (arguments_file_name, "w");
 514   check (args, LDPL_FATAL, "could not open arguments file");
 515
 516   t = writeargv (&argv[1], args);
 517   check (t == 0, LDPL_FATAL, "could not write arguments");
 518   t = fclose (args);
 519   check (t == 0, LDPL_FATAL, "could not close arguments file");
 520
 521   at_args = concat ("@", arguments_file_name, NULL);
 522   check (at_args, LDPL_FATAL, "could not allocate");
 523
 524   for (i = 1; argv[i]; i++)
 525     {
 526       char *a = argv[i];
 527       if (a[0] == '-' && a[1] == 'v' && a[2] == '\0')
 528         {
 529           for (i = 0; argv[i]; i++)
 530             fprintf (stderr, "%s ", argv[i]);
 531           fprintf (stderr, "\n");
 532           break;
 533         }
 534     }
 535
 536   new_argv[0] = argv[0];
 537   new_argv[1] = at_args;
 538   new_argv[2] = NULL;
 539
 540   if (debug)
 541     {
 542       for (i = 0; new_argv[i]; i++)
 543         fprintf (stderr, "%s ", new_argv[i]);
 544       fprintf (stderr, "\n");
 545     }
 546
 547
 548   pex = pex_init (PEX_USE_PIPES, "lto-wrapper", NULL);
 549   check (pex != NULL, LDPL_FATAL, "could not pex_init lto-wrapper");
 550
 551   errmsg = pex_run (pex, 0, new_argv[0], new_argv, NULL, NULL, &t);
 552   check (errmsg == NULL, LDPL_FATAL, "could not run lto-wrapper");
 553   check (t == 0, LDPL_FATAL, "could not run lto-wrapper");
 554
 555   wrapper_output = pex_read_output (pex, 0);
 556   check (wrapper_output, LDPL_FATAL, "could not read lto-wrapper output");
 557
 558   add_output_files (wrapper_output);
 559
 560   t = pex_get_status (pex, 1, &status);
 561   check (t == 1, LDPL_FATAL, "could not get lto-wrapper exit status");
 562   check (WIFEXITED (status) && WEXITSTATUS (status) == 0, LDPL_FATAL,
 563          "lto-wrapper failed");
 564
 565   pex_free (pex);
 566
 567   free (at_args);
 568 }
 569
 570 /* Pass the original files back to the linker. */
 571
 572 static void
 573 use_original_files (void)
 574 {
 575   unsigned i;
 576   for (i = 0; i < num_claimed_files; i++)
 577     {
 578       struct plugin_file_info *info = &claimed_files[i];
 579       add_input_file (info->name);
 580     }
 581 }
 582
 583
 584 /* Called by the linker once all symbols have been read. */
 585
 586 static enum ld_plugin_status
 587 all_symbols_read_handler (void)
 588 {
 589   unsigned i;
 590   unsigned num_lto_args = num_claimed_files + lto_wrapper_num_args + 1;
 591   char **lto_argv;
 592   const char **lto_arg_ptr;
 593   if (num_claimed_files == 0)
 594     return LDPS_OK;
 595
 596   if (nop)
 597     {
 598       use_original_files ();
 599       return LDPS_OK;
 600     }
 601
 602   lto_argv = (char **) xcalloc (sizeof (char *), num_lto_args);
 603   lto_arg_ptr = (const char **) lto_argv;
 604   assert (lto_wrapper_argv);
 605
 606   write_resolution ();
 607
 608   free_1 ();
 609
 610   for (i = 0; i < lto_wrapper_num_args; i++)
 611     *lto_arg_ptr++ = lto_wrapper_argv[i];
 612
 613   for (i = 0; i < num_claimed_files; i++)
 614     {
 615       struct plugin_file_info *info = &claimed_files[i];
 616
 617       *lto_arg_ptr++ = info->name;
 618     }
 619
 620   *lto_arg_ptr++ = NULL;
 621   exec_lto_wrapper (lto_argv);
 622
 623   free (lto_argv);
 624
 625   if (pass_through_items)
 626     {
 627       unsigned int i;
 628       for (i = 0; i < num_pass_through_items; i++)
 629         {
 630           if (strncmp (pass_through_items[i], "-l", 2) == 0)
 631             add_input_library (pass_through_items[i] + 2);
 632           else
 633             add_input_file (pass_through_items[i]);
 634           free (pass_through_items[i]);
 635           pass_through_items[i] = NULL;
 636         }
 637       free (pass_through_items);
 638       pass_through_items = NULL;
 639     }
 640
 641   return LDPS_OK;
 642 }
 643
 644 /* Remove temporary files at the end of the link. */
 645
 646 static enum ld_plugin_status
 647 cleanup_handler (void)
 648 {
 649   unsigned int i;
 650   int t;
 651
 652   if (debug)
 653     return LDPS_OK;
 654
 655   if (arguments_file_name)
 656     {
 657       t = unlink (arguments_file_name);
 658       check (t == 0, LDPL_FATAL, "could not unlink arguments file");
 659     }
 660
 661   for (i = 0; i < num_output_files; i++)
 662     {
 663       t = unlink (output_files[i]);
 664       check (t == 0, LDPL_FATAL, "could not unlink output file");
 665     }
 666
 667   free_2 ();
 668   return LDPS_OK;
 669 }
 670
 671 #define SWAP(type, a, b) \
 672   do { type tmp_; tmp_ = (a); (a) = (b); (b) = tmp_; } while(0)
 673
 674 /* Compare two hash table entries */
 675
 676 static int eq_sym (const void *a, const void *b)
 677 {
 678   const struct ld_plugin_symbol *as = (const struct ld_plugin_symbol *)a;
 679   const struct ld_plugin_symbol *bs = (const struct ld_plugin_symbol *)b;
 680
 681   return !strcmp (as->name, bs->name);
 682 }
 683
 684 /* Hash a symbol */
 685
 686 static hashval_t hash_sym (const void *a)
 687 {
 688   const struct ld_plugin_symbol *as = (const struct ld_plugin_symbol *)a;
 689
 690   return htab_hash_string (as->name);
 691 }
 692
 693 /* Determine how strong a symbol is */
 694
 695 static int symbol_strength (struct ld_plugin_symbol *s)
 696 {
 697   switch (s->def)
 698     {
 699     case LDPK_UNDEF:
 700     case LDPK_WEAKUNDEF:
 701       return 0;
 702     case LDPK_WEAKDEF:
 703       return 1;
 704     default:
 705       return 2;
 706     }
 707 }
 708
 709 /* In the ld -r case we can get dups in the LTO symbol tables, where
 710    the same symbol can have different resolutions (e.g. undefined and defined).
 711
 712    We have to keep that in the LTO symbol tables, but the dups confuse
 713    gold and then finally gcc by supplying incorrect resolutions.
 714
 715    Problem is that the main gold symbol table doesn't know about subids
 716    and does not distingush the same symbols in different states.
 717
 718    So we drop duplicates from the linker visible symbol table
 719    and keep them in a private table. Then later do own symbol
 720    resolution for the duplicated based on the results for the
 721    originals.
 722
 723    Then when writing out the resolution file readd the dropped symbols.
 724
 725    XXX how to handle common? */
 726
 727 static void
 728 resolve_conflicts (struct plugin_symtab *t, struct plugin_symtab *conflicts)
 729 {
 730   htab_t symtab = htab_create (t->nsyms, hash_sym, eq_sym, NULL);
 731   int i;
 732   int out;
 733   int outlen;
 734
 735   outlen = t->nsyms;
 736   conflicts->syms = xmalloc (sizeof (struct ld_plugin_symbol) * outlen);
 737   conflicts->aux = xmalloc (sizeof (struct sym_aux) * outlen);
 738
 739   /* Move all duplicate symbols into the auxillary conflicts table. */
 740   out = 0;
 741   for (i = 0; i < t->nsyms; i++)
 742     {
 743       struct ld_plugin_symbol *s = &t->syms[i];
 744       struct sym_aux *aux = &t->aux[i];
 745       void **slot;
 746
 747       slot = htab_find_slot (symtab, s, INSERT);
 748       if (*slot != NULL)
 749         {
 750           int cnf;
 751           struct ld_plugin_symbol *orig = (struct ld_plugin_symbol *)*slot;
 752           struct sym_aux *orig_aux = &t->aux[orig - t->syms];
 753
 754           /* Always let the linker resolve the strongest symbol */
 755           if (symbol_strength (orig) < symbol_strength (s))
 756             {
 757               SWAP (struct ld_plugin_symbol, *orig, *s);
 758               SWAP (uint32_t, orig_aux->slot, aux->slot);
 759               SWAP (unsigned, orig_aux->id, aux->id);
 760               /* Don't swap conflict chain pointer */
 761             }
 762
 763           /* Move current symbol into the conflicts table */
 764           cnf = conflicts->nsyms++;
 765           conflicts->syms[cnf] = *s;
 766           conflicts->aux[cnf] = *aux;
 767           aux = &conflicts->aux[cnf];
 768
 769           /* Update conflicts chain of the original symbol */
 770           aux->next_conflict = orig_aux->next_conflict;
 771           orig_aux->next_conflict = cnf;
 772
 773           continue;
 774         }
 775
 776       /* Remove previous duplicates in the main table */
 777       if (out < i)
 778         {
 779           t->syms[out] = *s;
 780           t->aux[out] = *aux;
 781         }
 782
 783       /* Put original into the hash table */
 784       *slot = &t->syms[out];
 785       out++;
 786     }
 787
 788   assert (conflicts->nsyms <= outlen);
 789   assert (conflicts->nsyms + out == t->nsyms);
 790
 791   t->nsyms = out;
 792   htab_delete (symtab);
 793 }
 794
 795 /* Process one section of an object file.  */
 796
 797 static int
 798 process_symtab (void *data, const char *name, off_t offset, off_t length)
 799 {
 800   struct plugin_objfile *obj = (struct plugin_objfile *)data;
 801   char *s;
 802   char *secdata;
 803
 804   if (strncmp (name, LTO_SECTION_PREFIX, LTO_SECTION_PREFIX_LEN) != 0)
 805     return 1;
 806
 807   s = strrchr (name, '.');
 808   if (s)
 809     sscanf (s, ".%x", &obj->out->id);
 810   secdata = xmalloc (length);
 811   offset += obj->file->offset;
 812   if (offset != lseek (obj->file->fd, offset, SEEK_SET)
 813         || length != read (obj->file->fd, secdata, length))
 814     {
 815       if (message)
 816         message (LDPL_FATAL, "%s: corrupt object file", obj->file->name);
 817       /* Force claim_file_handler to abandon this file.  */
 818       obj->found = 0;
 819       free (secdata);
 820       return 0;
 821     }
 822
 823   translate (secdata, secdata + length, obj->out);
 824   obj->found++;
 825   free (secdata);
 826   return 1;
 827 }
 828
 829 /* Callback used by gold to check if the plugin will claim FILE. Writes
 830    the result in CLAIMED. */
 831
 832 static enum ld_plugin_status
 833 claim_file_handler (const struct ld_plugin_input_file *file, int *claimed)
 834 {
 835   enum ld_plugin_status status;
 836   struct plugin_objfile obj;
 837   struct plugin_file_info lto_file;
 838   int err;
 839   const char *errmsg;
 840
 841   memset (&lto_file, 0, sizeof (struct plugin_file_info));
 842
 843   if (file->offset != 0)
 844     {
 845       char *objname;
 846       /* We pass the offset of the actual file, not the archive header.
 847          Can't use PRIx64, because that's C99, so we have to print the
 848          64-bit hex int as two 32-bit ones. */
 849       int lo, hi;
 850       lo = file->offset & 0xffffffff;
 851       hi = ((int64_t)file->offset >> 32) & 0xffffffff;
 852       int t = hi ? asprintf (&objname, "%s@0x%x%08x", file->name, lo, hi)
 853                 : asprintf (&objname, "%s@0x%x", file->name, lo);
 854       check (t >= 0, LDPL_FATAL, "asprintf failed");
 855       lto_file.name = objname;
 856     }
 857   else
 858     {
 859       lto_file.name = xstrdup (file->name);
 860     }
 861   lto_file.handle = file->handle;
 862
 863   *claimed = 0;
 864   obj.file = file;
 865   obj.found = 0;
 866   obj.out = &lto_file.symtab;
 867   errmsg = NULL;
 868   obj.objfile = simple_object_start_read (file->fd, file->offset, LTO_SEGMENT_NAME,
 869                         &errmsg, &err);
 870   /* No file, but also no error code means unrecognized format; just skip it.  */
 871   if (!obj.objfile && !err)
 872     goto err;
 873
 874   if (obj.objfile)
 875     errmsg = simple_object_find_sections (obj.objfile, process_symtab, &obj, &err);
 876
 877   if (!obj.objfile || errmsg)
 878     {
 879       if (err && message)
 880         message (LDPL_FATAL, "%s: %s: %s", file->name, errmsg,
 881                 xstrerror (err));
 882       else if (message)
 883         message (LDPL_FATAL, "%s: %s", file->name, errmsg);
 884       goto err;
 885     }
 886
 887   if (obj.found == 0)
 888     goto err;
 889
 890   if (obj.found > 1)
 891     resolve_conflicts (&lto_file.symtab, &lto_file.conflicts);
 892
 893   status = add_symbols (file->handle, lto_file.symtab.nsyms,
 894                         lto_file.symtab.syms);
 895   check (status == LDPS_OK, LDPL_FATAL, "could not add symbols");
 896
 897   *claimed = 1;
 898   num_claimed_files++;
 899   claimed_files =
 900     xrealloc (claimed_files,
 901               num_claimed_files * sizeof (struct plugin_file_info));
 902   claimed_files[num_claimed_files - 1] = lto_file;
 903
 904   goto cleanup;
 905
 906  err:
 907   free (lto_file.name);
 908
 909  cleanup:
 910   if (obj.objfile)
 911     simple_object_release_read (obj.objfile);
 912
 913   return LDPS_OK;
 914 }
 915
 916 /* Parse the plugin options. */
 917
 918 static void
 919 process_option (const char *option)
 920 {
 921   if (strcmp (option, "-debug") == 0)
 922     debug = 1;
 923   else if (strcmp (option, "-nop") == 0)
 924     nop = 1;
 925   else if (!strncmp (option, "-pass-through=", strlen("-pass-through=")))
 926     {
 927       num_pass_through_items++;
 928       pass_through_items = xrealloc (pass_through_items,
 929                                      num_pass_through_items * sizeof (char *));
 930       pass_through_items[num_pass_through_items - 1] =
 931           xstrdup (option + strlen ("-pass-through="));
 932     }
 933   else if (!strncmp (option, "-sym-style=", sizeof ("-sym-style=") - 1))
 934     {
 935       switch (option[sizeof ("-sym-style=") - 1])
 936         {
 937         case 'w':
 938           sym_style = ss_win32;
 939           break;
 940         case 'u':
 941           sym_style = ss_uscore;
 942           break;
 943         default:
 944           sym_style = ss_none;
 945           break;
 946         }
 947     }
 948   else
 949     {
 950       int size;
 951       char *opt = xstrdup (option);
 952       lto_wrapper_num_args += 1;
 953       size = lto_wrapper_num_args * sizeof (char *);
 954       lto_wrapper_argv = (char **) xrealloc (lto_wrapper_argv, size);
 955       lto_wrapper_argv[lto_wrapper_num_args - 1] = opt;
 956       if (strncmp (option, "-fresolution=", sizeof ("-fresolution=") - 1) == 0)
 957         resolution_file = opt + sizeof ("-fresolution=") - 1;
 958     }
 959 }
 960
 961 /* Called by gold after loading the plugin. TV is the transfer vector. */
 962
 963 enum ld_plugin_status
 964 onload (struct ld_plugin_tv *tv)
 965 {
 966   struct ld_plugin_tv *p;
 967   enum ld_plugin_status status;
 968
 969   p = tv;
 970   while (p->tv_tag)
 971     {
 972       switch (p->tv_tag)
 973         {
 974         case LDPT_MESSAGE:
 975           message = p->tv_u.tv_message;
 976           break;
 977         case LDPT_REGISTER_CLAIM_FILE_HOOK:
 978           register_claim_file = p->tv_u.tv_register_claim_file;
 979           break;
 980         case LDPT_ADD_SYMBOLS:
 981           add_symbols = p->tv_u.tv_add_symbols;
 982           break;
 983         case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
 984           register_all_symbols_read = p->tv_u.tv_register_all_symbols_read;
 985           break;
 986         case LDPT_GET_SYMBOLS:
 987           get_symbols = p->tv_u.tv_get_symbols;
 988           break;
 989         case LDPT_REGISTER_CLEANUP_HOOK:
 990           register_cleanup = p->tv_u.tv_register_cleanup;
 991           break;
 992         case LDPT_ADD_INPUT_FILE:
 993           add_input_file = p->tv_u.tv_add_input_file;
 994           break;
 995         case LDPT_ADD_INPUT_LIBRARY:
 996           add_input_library = p->tv_u.tv_add_input_library;
 997           break;
 998         case LDPT_OPTION:
 999           process_option (p->tv_u.tv_string);
1000           break;
1001         default:
1002           break;
1003         }
1004       p++;
1005     }
1006
1007   check (register_claim_file, LDPL_FATAL, "register_claim_file not found");
1008   check (add_symbols, LDPL_FATAL, "add_symbols not found");
1009   status = register_claim_file (claim_file_handler);
1010   check (status == LDPS_OK, LDPL_FATAL,
1011          "could not register the claim_file callback");
1012
1013   if (register_cleanup)
1014     {
1015       status = register_cleanup (cleanup_handler);
1016       check (status == LDPS_OK, LDPL_FATAL,
1017              "could not register the cleanup callback");
1018     }
1019
1020   if (register_all_symbols_read)
1021     {
1022       check (get_symbols, LDPL_FATAL, "get_symbols not found");
1023       status = register_all_symbols_read (all_symbols_read_handler);
1024       check (status == LDPS_OK, LDPL_FATAL,
1025              "could not register the all_symbols_read callback");
1026     }
1027
1028   return LDPS_OK;
1029 }