OSDN Git Service

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