OSDN Git Service

ae484a9efab2271267192677ce95cbbdd7bc653c
[pf3gnuchains/gcc-fork.git] / lto-plugin / lto-plugin.c
1 /* LTO plugin for gold.
2    Copyright (C) 2009 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 #include <assert.h>
36 #include <string.h>
37 #include <stdlib.h>
38 #include <stdio.h>
39 #include <inttypes.h>
40 #include <ar.h>
41 #include <sys/stat.h>
42 #include <unistd.h>
43 #include <fcntl.h>
44 #include <sys/types.h>
45 #include <sys/wait.h>
46 #include <stdbool.h>
47 #include <libiberty.h>
48
49 /* The presence of gelf.h is checked by the toplevel configure script.  */
50 #include <gelf.h>
51
52 #include "plugin-api.h"
53 #include "../gcc/lto/common.h"
54
55 /* The part of the symbol table the plugin has to keep track of. Note that we
56    must keep SYMS until all_symbols_read is called to give the linker time to
57    copy the symbol information. */
58
59 struct plugin_symtab
60 {
61   int nsyms;
62   uint32_t *slots;
63   struct ld_plugin_symbol *syms;
64 };
65
66 /* All that we have to remember about a file. */
67
68 struct plugin_file_info
69 {
70   char *name;
71   void *handle;
72   struct plugin_symtab symtab;
73   unsigned char temp;
74 };
75
76
77 static char *temp_obj_dir_name;
78 static ld_plugin_register_claim_file register_claim_file;
79 static ld_plugin_add_symbols add_symbols;
80 static ld_plugin_register_all_symbols_read register_all_symbols_read;
81 static ld_plugin_get_symbols get_symbols;
82 static ld_plugin_register_cleanup register_cleanup;
83 static ld_plugin_add_input_file add_input_file;
84 static ld_plugin_add_input_library add_input_library;
85
86 static struct plugin_file_info *claimed_files = NULL;
87 static unsigned int num_claimed_files = 0;
88
89 static char **output_files = NULL;
90 static unsigned int num_output_files = 0;
91
92 static char **lto_wrapper_argv;
93 static int lto_wrapper_num_args;
94
95 static char **pass_through_items = NULL;
96 static unsigned int num_pass_through_items;
97
98 static bool debug;
99 static bool nop;
100 static char *resolution_file = NULL;
101
102 /* Parse an entry of the IL symbol table. The data to be parsed is pointed
103    by P and the result is written in ENTRY. The slot number is stored in SLOT.
104    Returns the address of the next entry. */
105
106 static char *
107 parse_table_entry (char *p, struct ld_plugin_symbol *entry, uint32_t *slot)
108 {
109   unsigned char t;
110   enum ld_plugin_symbol_kind translate_kind[] =
111     {
112       LDPK_DEF,
113       LDPK_WEAKDEF,
114       LDPK_UNDEF,
115       LDPK_WEAKUNDEF,
116       LDPK_COMMON
117     };
118
119   enum ld_plugin_symbol_visibility translate_visibility[] =
120     {
121       LDPV_DEFAULT,
122       LDPV_PROTECTED,
123       LDPV_INTERNAL,
124       LDPV_HIDDEN
125     };
126
127   entry->name = strdup (p);
128   while (*p)
129     p++;
130   p++;
131
132   entry->version = NULL;
133
134   entry->comdat_key = p;
135   while (*p)
136     p++;
137   p++;
138
139   if (strlen (entry->comdat_key) == 0)
140     entry->comdat_key = NULL;
141   else
142     entry->comdat_key = strdup (entry->comdat_key);
143
144   t = *p;
145   assert (t <= 4);
146   entry->def = translate_kind[t];
147   p++;
148
149   t = *p;
150   assert (t <= 3);
151   entry->visibility = translate_visibility[t];
152   p++;
153
154   entry->size = *(uint64_t *) p;
155   p += 8;
156
157   *slot = *(uint32_t *) p;
158   p += 4;
159
160   entry->resolution = LDPR_UNKNOWN;
161
162   return p;
163 }
164
165 /* Return the section in ELF that is named NAME. */
166
167 static Elf_Scn *
168 get_section (Elf *elf, const char *name)
169 {
170   Elf_Scn *section = 0;
171   GElf_Ehdr header;
172   GElf_Ehdr *t = gelf_getehdr (elf, &header);
173   if (t == NULL)
174     return NULL;
175   assert (t == &header);
176
177   while ((section = elf_nextscn(elf, section)) != 0)
178     {
179       GElf_Shdr shdr;
180       GElf_Shdr *tshdr = gelf_getshdr (section, &shdr);
181       const char *t;
182       assert (tshdr == &shdr);
183       t = elf_strptr (elf, header.e_shstrndx, shdr.sh_name);
184       assert (t != NULL);
185       if (strcmp (t, name) == 0)
186         return section;
187     }
188   return NULL;
189 }
190
191 /* Returns the IL symbol table of file ELF. */
192
193 static Elf_Data *
194 get_symtab (Elf *elf)
195 {
196   Elf_Data *data = 0;
197   Elf_Scn *section = get_section (elf, ".gnu.lto_.symtab");
198   if (!section)
199     return NULL;
200
201   data = elf_getdata (section, data);
202   assert (data);
203   return data;
204 }
205
206 /* Translate the IL symbol table SYMTAB. Write the slots and symbols in OUT. */
207
208 static void
209 translate (Elf_Data *symtab, struct plugin_symtab *out)
210 {
211   uint32_t *slots = NULL;
212   char *data = symtab->d_buf;
213   char *end = data + symtab->d_size;
214   struct ld_plugin_symbol *syms = NULL;
215   int n = 0;
216
217   while (data < end)
218     {
219       n++;
220       syms = realloc (syms, n * sizeof (struct ld_plugin_symbol));
221       assert (syms);
222       slots = realloc (slots, n * sizeof (uint32_t));
223       assert (slots);
224       data = parse_table_entry (data, &syms[n - 1], &slots[n - 1]);
225     }
226
227   out->nsyms = n;
228   out->syms = syms;
229   out->slots = slots;
230 }
231
232 /* Free all memory that is no longer needed after writing the symbol
233    resolution. */
234
235 static void
236 free_1 (void)
237 {
238   unsigned int i;
239   for (i = 0; i < num_claimed_files; i++)
240     {
241       struct plugin_file_info *info = &claimed_files[i];
242       struct plugin_symtab *symtab = &info->symtab;
243       unsigned int j;
244       for (j = 0; j < symtab->nsyms; j++)
245         {
246           struct ld_plugin_symbol *s = &symtab->syms[j];
247           free (s->name);
248           if (s->comdat_key)
249             free (s->comdat_key);
250         }
251       free (symtab->syms);
252       symtab->syms = NULL;
253     }
254 }
255
256 /* Free all remaining memory. */
257
258 static void
259 free_2 (void)
260 {
261   unsigned int i;
262   for (i = 0; i < num_claimed_files; i++)
263     {
264       struct plugin_file_info *info = &claimed_files[i];
265       struct plugin_symtab *symtab = &info->symtab;
266       free (symtab->slots);
267       free (info->name);
268     }
269
270   for (i = 0; i < num_output_files; i++)
271     free (output_files[i]);
272   free (output_files);
273
274   free (claimed_files);
275   claimed_files = NULL;
276   num_claimed_files = 0;
277
278   free (temp_obj_dir_name);
279   temp_obj_dir_name = NULL;
280
281   if (resolution_file)
282     {
283       free (resolution_file);
284       resolution_file = NULL;
285     }
286 }
287
288 /*  Writes the relocations to disk. */
289
290 static void
291 write_resolution (void)
292 {
293   unsigned int i;
294   FILE *f;
295
296   if (!resolution_file)
297     return;
298
299   f = fopen (resolution_file, "w");
300   assert (f);
301
302   fprintf (f, "%d\n", num_claimed_files);
303
304   for (i = 0; i < num_claimed_files; i++)
305     {
306       struct plugin_file_info *info = &claimed_files[i];
307       struct plugin_symtab *symtab = &info->symtab;
308       struct ld_plugin_symbol *syms = symtab->syms;
309       unsigned j;
310
311       assert (syms);
312       get_symbols (info->handle, symtab->nsyms, syms);
313
314       fprintf (f, "%s %d\n", info->name, info->symtab.nsyms);
315
316       for (j = 0; j < info->symtab.nsyms; j++)
317         {
318           uint32_t slot = symtab->slots[j];
319           unsigned int resolution = syms[j].resolution;
320           fprintf (f, "%d %s\n", slot, lto_resolution_str[resolution]);
321         }
322     }
323   fclose (f);
324 }
325
326 /* Pass files generated by the lto-wrapper to the linker. FD is lto-wrapper's
327    stdout. */
328
329 static void
330 add_output_files (FILE *f)
331 {
332   char fname[1000]; /* FIXME: Is this big enough? */
333
334   for (;;)
335     {
336       size_t len;
337       char *s = fgets (fname, sizeof (fname), f);
338       if (!s)
339         break;
340
341       len = strlen (s);
342       assert (s[len - 1] == '\n');
343       s[len - 1] = '\0';
344
345       num_output_files++;
346       output_files = realloc (output_files, num_output_files * sizeof (char *));
347       output_files[num_output_files - 1] = strdup (s);
348       add_input_file (output_files[num_output_files - 1]);
349     }
350 }
351
352 /* Execute the lto-wrapper. ARGV[0] is the binary. The rest of ARGV is the
353    argument list. */
354
355 static void
356 exec_lto_wrapper (char *argv[])
357 {
358   int t;
359   int status;
360   char *at_args;
361   char *args_name;
362   FILE *args;
363   FILE *wrapper_output;
364   char *new_argv[3];
365   struct pex_obj *pex;
366   const char *errmsg;
367
368   /* Write argv to a file to avoid a command line that is too long. */
369   t = asprintf (&at_args, "@%s/arguments", temp_obj_dir_name);
370   assert (t >= 0);
371
372   args_name = at_args + 1;
373   args = fopen (args_name, "w");
374   assert (args);
375
376   t = writeargv (&argv[1], args);
377   assert (t == 0);
378   t = fclose (args);
379   assert (t == 0);
380
381   new_argv[0] = argv[0];
382   new_argv[1] = at_args;
383   new_argv[2] = NULL;
384
385   if (debug)
386     {
387       int i;
388       for (i = 0; new_argv[i]; i++)
389         fprintf (stderr, "%s ", new_argv[i]);
390       fprintf (stderr, "\n");
391     }
392
393
394   pex = pex_init (PEX_USE_PIPES, "lto-wrapper", NULL);
395   assert (pex != NULL);
396
397   errmsg = pex_run (pex, 0, new_argv[0], new_argv, NULL, NULL, &t);
398   assert (errmsg == NULL);
399   assert (t == 0);
400
401   wrapper_output = pex_read_output (pex, 0);
402   assert (wrapper_output);
403
404   add_output_files (wrapper_output);
405
406   t = pex_get_status (pex, 1, &status);
407   assert (t == 1);
408   assert (WIFEXITED (status) && WEXITSTATUS (status) == 0);
409
410   pex_free (pex);
411
412   t = unlink (args_name);
413   assert (t == 0);
414   free (at_args);
415 }
416
417 /* Pass the original files back to the linker. */
418
419 static void
420 use_original_files (void)
421 {
422   unsigned i;
423   for (i = 0; i < num_claimed_files; i++)
424     {
425       struct plugin_file_info *info = &claimed_files[i];
426       add_input_file (info->name);
427     }
428 }
429
430
431 /* Called by the linker once all symbols have been read. */
432
433 static enum ld_plugin_status
434 all_symbols_read_handler (void)
435 {
436   unsigned i;
437   unsigned num_lto_args = num_claimed_files + lto_wrapper_num_args + 1;
438   char **lto_argv;
439   const char **lto_arg_ptr;
440   if (num_claimed_files == 0)
441     return LDPS_OK;
442
443   if (nop)
444     {
445       use_original_files ();
446       return LDPS_OK;
447     }
448
449   lto_argv = (char **) calloc (sizeof (char *), num_lto_args);
450   lto_arg_ptr = (const char **) lto_argv;
451   assert (lto_wrapper_argv);
452
453   write_resolution ();
454
455   free_1 ();
456
457   for (i = 0; i < lto_wrapper_num_args; i++)
458     *lto_arg_ptr++ = lto_wrapper_argv[i];
459
460   for (i = 0; i < num_claimed_files; i++)
461     {
462       struct plugin_file_info *info = &claimed_files[i];
463
464       *lto_arg_ptr++ = info->name;
465     }
466
467   *lto_arg_ptr++ = NULL;
468   exec_lto_wrapper (lto_argv);
469
470   free (lto_argv);
471
472   if (pass_through_items)
473     {
474       unsigned int i;
475       for (i = 0; i < num_pass_through_items; i++)
476         {
477           if (strncmp (pass_through_items[i], "-l", 2) == 0)
478             add_input_library (pass_through_items[i] + 2);
479           else
480             add_input_file (pass_through_items[i]);
481           free (pass_through_items[i]);
482           pass_through_items[i] = NULL;
483         }
484       free (pass_through_items);
485       pass_through_items = NULL;
486     }
487
488   return LDPS_OK;
489 }
490
491 /* Remove temporary files at the end of the link. */
492
493 static enum ld_plugin_status
494 cleanup_handler (void)
495 {
496   int t;
497   unsigned i;
498
499   for (i = 0; i < num_claimed_files; i++)
500     {
501       struct plugin_file_info *info = &claimed_files[i];
502       if (info->temp)
503         {
504           t = unlink (info->name);
505           assert (t == 0);
506         }
507     }
508   t = rmdir (temp_obj_dir_name);
509   assert (t == 0);
510
511   free_2 ();
512   return LDPS_OK;
513 }
514
515 /* Callback used by gold to check if the plugin will claim FILE. Writes
516    the result in CLAIMED. */
517
518 static enum ld_plugin_status
519 claim_file_handler (const struct ld_plugin_input_file *file, int *claimed)
520 {
521   enum ld_plugin_status status;
522   Elf *elf;
523   struct plugin_file_info lto_file;
524   Elf_Data *symtab;
525   int lto_file_fd;
526
527   if (file->offset != 0)
528     {
529       /* FIXME lto: lto1 should know how to handle archives. */
530       int fd;
531       off_t size = file->filesize;
532       off_t offset;
533
534       static int objnum = 0;
535       char *objname;
536       int t = asprintf (&objname, "%s/obj%d.o",
537                         temp_obj_dir_name, objnum);
538       assert (t >= 0);
539       objnum++;
540
541       fd = open (objname, O_RDWR | O_CREAT, 0666);
542       assert (fd > 0);
543       offset = lseek (file->fd, file->offset, SEEK_SET);
544       assert (offset == file->offset);
545       while (size > 0)
546         {
547           ssize_t r, written;
548           char buf[1000];
549           off_t s = sizeof (buf) < size ? sizeof (buf) : size;
550           r = read (file->fd, buf, s);
551           written = write (fd, buf, r);
552           assert (written = r);
553           size -= r;
554         }
555       lto_file.name = objname;
556       lto_file_fd = fd;
557       lto_file.handle = file->handle;
558       lto_file.temp = 1;
559     }
560   else
561     {
562       lto_file.name = strdup (file->name);
563       lto_file_fd = file->fd;
564       lto_file.handle = file->handle;
565       lto_file.temp = 0;
566     }
567   elf = elf_begin (lto_file_fd, ELF_C_READ, NULL);
568
569   *claimed = 0;
570
571   if (!elf)
572     goto err;
573
574   symtab = get_symtab (elf);
575   if (!symtab)
576     goto err;
577
578   translate (symtab, &lto_file.symtab);
579
580   status = add_symbols (file->handle, lto_file.symtab.nsyms,
581                         lto_file.symtab.syms);
582   assert (status == LDPS_OK);
583
584   *claimed = 1;
585   num_claimed_files++;
586   claimed_files =
587     realloc (claimed_files,
588              num_claimed_files * sizeof (struct plugin_file_info));
589   claimed_files[num_claimed_files - 1] = lto_file;
590
591   goto cleanup;
592
593  err:
594   if (file->offset != 0)
595     {
596       int t = unlink (lto_file.name);
597       assert (t == 0);
598     }
599   free (lto_file.name);
600
601  cleanup:
602   if (elf)
603     elf_end (elf);
604
605   return LDPS_OK;
606 }
607
608 /* Parse the plugin options. */
609
610 static void
611 process_option (const char *option)
612 {
613   if (strcmp (option, "-debug") == 0)
614     debug = 1;
615   else if (strcmp (option, "-nop") == 0)
616     nop = 1;
617   else if (!strncmp (option, "-resolution=", strlen("-resolution=")))
618     {
619       resolution_file = strdup (option + strlen("-resolution="));
620     }
621   else if (!strncmp (option, "-pass-through=", strlen("-pass-through=")))
622     {
623       num_pass_through_items++;
624       pass_through_items = realloc (pass_through_items,
625                                     num_pass_through_items * sizeof (char *));
626       pass_through_items[num_pass_through_items - 1] =
627           strdup (option + strlen ("-pass-through="));
628     }
629   else
630     {
631       int size;
632       lto_wrapper_num_args += 1;
633       size = lto_wrapper_num_args * sizeof (char *);
634       lto_wrapper_argv = (char **) realloc (lto_wrapper_argv, size);
635       lto_wrapper_argv[lto_wrapper_num_args - 1] = strdup(option);
636     }
637 }
638
639 /* Called by gold after loading the plugin. TV is the transfer vector. */
640
641 enum ld_plugin_status
642 onload (struct ld_plugin_tv *tv)
643 {
644   struct ld_plugin_tv *p;
645   enum ld_plugin_status status;
646   char *t;
647
648   unsigned version = elf_version (EV_CURRENT);
649   assert (version != EV_NONE);
650
651   p = tv;
652   while (p->tv_tag)
653     {
654       switch (p->tv_tag)
655         {
656         case LDPT_REGISTER_CLAIM_FILE_HOOK:
657           register_claim_file = p->tv_u.tv_register_claim_file;
658           break;
659         case LDPT_ADD_SYMBOLS:
660           add_symbols = p->tv_u.tv_add_symbols;
661           break;
662         case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK:
663           register_all_symbols_read = p->tv_u.tv_register_all_symbols_read;
664           break;
665         case LDPT_GET_SYMBOLS:
666           get_symbols = p->tv_u.tv_get_symbols;
667           break;
668         case LDPT_REGISTER_CLEANUP_HOOK:
669           register_cleanup = p->tv_u.tv_register_cleanup;
670           break;
671         case LDPT_ADD_INPUT_FILE:
672           add_input_file = p->tv_u.tv_add_input_file;
673           break;
674         case LDPT_ADD_INPUT_LIBRARY:
675           add_input_library = p->tv_u.tv_add_input_library;
676           break;
677         case LDPT_OPTION:
678           process_option (p->tv_u.tv_string);
679           break;
680         default:
681           break;
682         }
683       p++;
684     }
685
686   assert (register_claim_file);
687   assert (add_symbols);
688   status = register_claim_file (claim_file_handler);
689   assert (status == LDPS_OK);
690
691   if (register_cleanup)
692     {
693       status = register_cleanup (cleanup_handler);
694       assert (status == LDPS_OK);
695     }
696
697   if (register_all_symbols_read)
698     {
699       assert (get_symbols);
700       status = register_all_symbols_read (all_symbols_read_handler);
701       assert (status == LDPS_OK);
702     }
703
704   temp_obj_dir_name = strdup ("tmp_objectsXXXXXX");
705   t = mkdtemp (temp_obj_dir_name);
706   assert (t == temp_obj_dir_name);
707   return LDPS_OK;
708 }