OSDN Git Service

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