OSDN Git Service

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