OSDN Git Service

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