OSDN Git Service

2009-11-04 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / lto / lto-elf.c
1 /* LTO routines for ELF object files.
2    Copyright 2009 Free Software Foundation, Inc.
3    Contributed by CodeSourcery, Inc.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "toplev.h"
25 #include <gelf.h>
26 #include "lto.h"
27 #include "tm.h"
28 #include "libiberty.h"
29 #include "ggc.h"
30 #include "lto-streamer.h"
31
32
33 /* Initialize FILE, an LTO file object for FILENAME.  */
34 static void
35 lto_file_init (lto_file *file, const char *filename)
36 {
37   file->filename = filename;
38 }
39
40 /* An ELF file.  */
41 struct lto_elf_file 
42 {
43   /* The base information.  */
44   lto_file base;
45
46   /* The system file descriptor for the file.  */
47   int fd;
48
49   /* The libelf descriptor for the file.  */
50   Elf *elf;
51
52   /* Section number of string table used for section names.  */
53   size_t sec_strtab;
54
55   /* Writable file members.  */
56
57   /* The currently active section.  */
58   Elf_Scn *scn;
59
60   /* The output stream for section header names.  */
61   struct lto_output_stream *shstrtab_stream;
62
63   /* Linked list of data which must be freed *after* the file has been
64      closed.  This is an annoying limitation of libelf.  */
65   struct lto_char_ptr_base *data;
66 };
67 typedef struct lto_elf_file lto_elf_file;
68
69 /* Stores executable header attributes which must be shared by all ELF files.
70    This is used for validating input files and populating output files.  */
71 static struct {
72   bool initialized;
73   /* 32 or 64 bits?  */
74   size_t bits;
75   unsigned char elf_ident[EI_NIDENT];
76   Elf64_Half elf_machine;
77 } cached_file_attrs;
78
79
80 /* Return the section header for SECTION.  The return value is never
81    NULL.  Call lto_elf_free_shdr to release the memory allocated.  */
82
83 static Elf64_Shdr *
84 lto_elf_get_shdr (Elf_Scn *section)
85 {
86   Elf64_Shdr *shdr;
87
88   switch (cached_file_attrs.bits)
89     {
90     case 32:
91       {
92         Elf32_Shdr *shdr32;
93
94         /* Read the 32-bit section header.  */
95         shdr32 = elf32_getshdr (section);
96         if (!shdr32)
97           fatal_error ("could not read section header: %s", elf_errmsg (0));
98
99         /* Transform it into a 64-bit section header.  */
100         shdr = XNEW (Elf64_Shdr);
101         shdr->sh_name = shdr32->sh_name;
102         shdr->sh_type = shdr32->sh_type;
103         shdr->sh_flags = shdr32->sh_flags;
104         shdr->sh_addr = shdr32->sh_addr;
105         shdr->sh_offset = shdr32->sh_offset;
106         shdr->sh_size = shdr32->sh_size;
107         shdr->sh_link = shdr32->sh_link;
108         shdr->sh_info = shdr32->sh_info;
109         shdr->sh_addralign = shdr32->sh_addralign;
110         shdr->sh_entsize  = shdr32->sh_entsize;
111         break;
112       }
113       break;
114
115     case 64:
116       shdr = elf64_getshdr (section);
117       if (!shdr)
118         fatal_error ("could not read section header: %s", elf_errmsg (0));
119       break;
120
121     default:
122       gcc_unreachable ();
123     }
124
125   return shdr;
126 }
127
128 /* Free SHDR, previously allocated by lto_elf_get_shdr.  */
129 static void
130 lto_elf_free_shdr (Elf64_Shdr *shdr)
131 {
132   if (cached_file_attrs.bits != 64)
133     free (shdr);
134 }
135
136
137 /* Returns a hash code for P.  */
138
139 static hashval_t
140 hash_name (const void *p)
141 {
142   const struct lto_section_slot *ds = (const struct lto_section_slot *) p;
143   return (hashval_t) htab_hash_string (ds->name);
144 }
145
146
147 /* Returns nonzero if P1 and P2 are equal.  */
148
149 static int
150 eq_name (const void *p1, const void *p2)
151 {
152   const struct lto_section_slot *s1 =
153     (const struct lto_section_slot *) p1;
154   const struct lto_section_slot *s2 =
155     (const struct lto_section_slot *) p2;
156
157   return strcmp (s1->name, s2->name) == 0;
158 }
159
160
161 /* Build a hash table whose key is the section names and whose data is
162    the start and size of each section in the .o file.  */
163
164 htab_t
165 lto_elf_build_section_table (lto_file *lto_file) 
166 {
167   lto_elf_file *elf_file = (lto_elf_file *)lto_file;
168   htab_t section_hash_table;
169   Elf_Scn *section;
170   size_t base_offset;
171
172   section_hash_table = htab_create (37, hash_name, eq_name, free);
173
174   base_offset = elf_getbase (elf_file->elf);
175   for (section = elf_getscn (elf_file->elf, 0);
176        section;
177        section = elf_nextscn (elf_file->elf, section)) 
178     {
179       Elf64_Shdr *shdr;
180       const char *name;
181       size_t offset;
182       char *new_name;
183       void **slot;
184       struct lto_section_slot s_slot;
185
186       /* Get the name of this section.  */
187       shdr = lto_elf_get_shdr (section);
188       offset = shdr->sh_name;
189       name = elf_strptr (elf_file->elf, 
190                          elf_file->sec_strtab,
191                          offset);
192
193       /* Only put lto stuff into the symtab.  */
194       if (strncmp (name, LTO_SECTION_NAME_PREFIX, 
195                    strlen (LTO_SECTION_NAME_PREFIX)) != 0)
196         {
197           lto_elf_free_shdr (shdr);
198           continue;
199         }
200
201       new_name = XNEWVEC (char, strlen (name) + 1);
202       strcpy (new_name, name);
203       s_slot.name = new_name;
204       slot = htab_find_slot (section_hash_table, &s_slot, INSERT);
205       if (*slot == NULL)
206         {
207           struct lto_section_slot *new_slot = XNEW (struct lto_section_slot);
208
209           new_slot->name = new_name;
210           /* The offset into the file for this section.  */
211           new_slot->start = base_offset + shdr->sh_offset;
212           new_slot->len = shdr->sh_size;
213           *slot = new_slot;
214         }
215       else
216         {
217           error ("two or more sections for %s:", new_name);
218           return NULL;
219         }
220
221       lto_elf_free_shdr (shdr);
222     }
223
224   return section_hash_table;
225 }
226
227
228 /* Initialize the section header of section SCN.  SH_NAME is the section name
229    as an index into the section header string table.  SH_TYPE is the section
230    type, an SHT_* macro from libelf headers.  */
231
232 #define DEFINE_INIT_SHDR(BITS)                                        \
233 static void                                                           \
234 init_shdr##BITS (Elf_Scn *scn, size_t sh_name, size_t sh_type)        \
235 {                                                                     \
236   Elf##BITS##_Shdr *shdr;                                             \
237                                                                       \
238   shdr = elf##BITS##_getshdr (scn);                                   \
239   if (!shdr)                                                          \
240     {                                                                 \
241       if (BITS == 32)                                                 \
242         fatal_error ("elf32_getshdr() failed: %s", elf_errmsg (-1));  \
243       else                                                            \
244         fatal_error ("elf64_getshdr() failed: %s", elf_errmsg (-1));  \
245     }                                                                 \
246                                                                       \
247   shdr->sh_name = sh_name;                                            \
248   shdr->sh_type = sh_type;                                            \
249   shdr->sh_addralign = POINTER_SIZE / BITS_PER_UNIT;                  \
250   shdr->sh_flags = 0;                                                 \
251   shdr->sh_entsize = 0;                                               \
252 }
253
254 DEFINE_INIT_SHDR (32)
255 DEFINE_INIT_SHDR (64)
256
257 static bool first_data_block;
258
259 /* Begin a new ELF section named NAME with type TYPE in the current output
260    file.  TYPE is an SHT_* macro from the libelf headers.  */
261
262 static void
263 lto_elf_begin_section_with_type (const char *name, size_t type)
264 {
265   lto_elf_file *file;
266   Elf_Scn *scn;
267   size_t sh_name;
268
269   /* Grab the current output file and do some basic assertion checking.  */
270   file = (lto_elf_file *) lto_get_current_out_file (),
271   gcc_assert (file);
272   gcc_assert (file->elf);
273   gcc_assert (!file->scn);
274
275   /* Create a new section.  */
276   scn = elf_newscn (file->elf);
277   if (!scn)
278     fatal_error ("could not create a new ELF section: %s", elf_errmsg (-1));
279   file->scn = scn;
280
281   /* Add a string table entry and record the offset.  */
282   gcc_assert (file->shstrtab_stream);
283   sh_name = file->shstrtab_stream->total_size;
284   lto_output_data_stream (file->shstrtab_stream, name, strlen (name) + 1);
285
286   /* Initialize the section header.  */
287   switch (cached_file_attrs.bits)
288     {
289     case 32:
290       init_shdr32 (scn, sh_name, type);
291       break;
292
293     case 64:
294       init_shdr64 (scn, sh_name, type);
295       break;
296
297     default:
298       gcc_unreachable ();
299     }
300
301   first_data_block = true;
302 }
303
304
305 /* Begin a new ELF section named NAME in the current output file.  */
306
307 void
308 lto_elf_begin_section (const char *name)
309 {
310   lto_elf_begin_section_with_type (name, SHT_PROGBITS);
311 }
312
313
314 /* Append DATA of length LEN to the current output section.  BASE is a pointer
315    to the output page containing DATA.  It is freed once the output file has
316    been written.  */
317
318 void
319 lto_elf_append_data (const void *data, size_t len, void *block)
320 {
321   lto_elf_file *file;
322   Elf_Data *elf_data;
323   struct lto_char_ptr_base *base = (struct lto_char_ptr_base *) block;
324
325   /* Grab the current output file and do some basic assertion checking.  */
326   file = (lto_elf_file *) lto_get_current_out_file ();
327   gcc_assert (file);
328   gcc_assert (file->scn);
329
330   elf_data = elf_newdata (file->scn);
331   if (!elf_data)
332     fatal_error ("could not append data to ELF section: %s", elf_errmsg (-1));
333
334   if (first_data_block)
335     {
336       elf_data->d_align = POINTER_SIZE / BITS_PER_UNIT;
337       first_data_block = false;
338     }
339   else
340     elf_data->d_align = 1;
341   elf_data->d_buf = CONST_CAST (void *, data);
342   elf_data->d_off = 0LL;
343   elf_data->d_size = len;
344   elf_data->d_type = ELF_T_BYTE;
345   elf_data->d_version = EV_CURRENT;
346
347   base->ptr = (char *)file->data;
348   file->data = base;
349 }
350
351
352 /* End the current output section.  This just does some assertion checking
353    and sets the current output file's scn member to NULL.  */
354
355 void
356 lto_elf_end_section (void)
357 {
358   lto_elf_file *file;
359
360   /* Grab the current output file and validate some basic assertions.  */
361   file = (lto_elf_file *) lto_get_current_out_file ();
362   gcc_assert (file);
363   gcc_assert (file->scn);
364
365   file->scn = NULL;
366 }
367
368
369 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
370    uninitialized, caches the architecture.  */
371
372 #define DEFINE_VALIDATE_EHDR(BITS)                              \
373 static bool                                                     \
374 validate_ehdr##BITS (lto_elf_file *elf_file)                    \
375 {                                                               \
376   Elf##BITS##_Ehdr *elf_header;                                 \
377                                                                 \
378   elf_header = elf##BITS##_getehdr (elf_file->elf);             \
379   if (!elf_header)                                              \
380     {                                                           \
381       error ("could not read ELF header: %s", elf_errmsg (0));  \
382       return false;                                             \
383     }                                                           \
384                                                                 \
385   if (elf_header->e_type != ET_REL)                             \
386     {                                                           \
387       error ("not a relocatable ELF object file");              \
388       return false;                                             \
389     }                                                           \
390                                                                 \
391   if (!cached_file_attrs.initialized)                           \
392     cached_file_attrs.elf_machine = elf_header->e_machine;      \
393                                                                 \
394   if (cached_file_attrs.elf_machine != elf_header->e_machine)   \
395     {                                                           \
396       error ("inconsistent file architecture detected");        \
397       return false;                                             \
398     }                                                           \
399                                                                 \
400   return true;                                                  \
401 }
402
403 DEFINE_VALIDATE_EHDR (32)
404 DEFINE_VALIDATE_EHDR (64)
405
406
407 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
408    uninitialized, caches the results.  Also records the section header string
409    table's section index.  Returns true on success or false on failure.  */
410
411 static bool
412 validate_file (lto_elf_file *elf_file)
413 {
414   const char *elf_ident;
415
416   /* Some aspects of the libelf API are dependent on whether the
417      object file is a 32-bit or 64-bit file.  Determine which kind of
418      file this is now.  */
419   elf_ident = elf_getident (elf_file->elf, NULL);
420   if (!elf_ident)
421     {
422       error ("could not read ELF identification information: %s",
423               elf_errmsg (0));
424       return false;
425              
426     }
427
428   if (!cached_file_attrs.initialized)
429     {
430       switch (elf_ident[EI_CLASS])
431         {
432         case ELFCLASS32:
433           cached_file_attrs.bits = 32;
434           break;
435
436         case ELFCLASS64:
437           cached_file_attrs.bits = 64;
438           break;
439
440         default:
441           error ("unsupported ELF file class");
442           return false;
443         }
444
445       memcpy (cached_file_attrs.elf_ident, elf_ident,
446               sizeof cached_file_attrs.elf_ident);
447     }
448
449   if (memcmp (elf_ident, cached_file_attrs.elf_ident,
450               sizeof cached_file_attrs.elf_ident))
451     return false;
452
453   /* Check that the input file is a relocatable object file with the correct
454      architecture.  */
455   switch (cached_file_attrs.bits)
456     {
457     case 32:
458       if (!validate_ehdr32 (elf_file))
459         return false;
460       break;
461
462     case 64:
463       if (!validate_ehdr64 (elf_file))
464         return false;
465       break;
466
467     default:
468       gcc_unreachable ();
469     }
470
471   /* Read the string table used for section header names.  */
472   if (elf_getshdrstrndx (elf_file->elf, &elf_file->sec_strtab) == -1)
473     {
474       error ("could not locate ELF string table: %s", elf_errmsg (0));
475       return false;
476     }
477
478   cached_file_attrs.initialized = true;
479   return true;
480 }
481
482
483 /* Helper functions used by init_ehdr.  Initialize ELF_FILE's executable
484    header using cached data from previously read files.  */
485
486 #define DEFINE_INIT_EHDR(BITS)                                        \
487 static void                                                           \
488 init_ehdr##BITS (lto_elf_file *elf_file)                              \
489 {                                                                     \
490   Elf##BITS##_Ehdr *ehdr;                                             \
491                                                                       \
492   gcc_assert (cached_file_attrs.bits);                                \
493                                                                       \
494   ehdr = elf##BITS##_newehdr (elf_file->elf);                         \
495   if (!ehdr)                                                          \
496     {                                                                 \
497       if (BITS == 32)                                                 \
498         fatal_error ("elf32_newehdr() failed: %s", elf_errmsg (-1));  \
499       else                                                            \
500         fatal_error ("elf64_newehdr() failed: %s", elf_errmsg (-1));  \
501     }                                                                 \
502                                                                       \
503   memcpy (ehdr->e_ident, cached_file_attrs.elf_ident,                 \
504           sizeof cached_file_attrs.elf_ident);                        \
505   ehdr->e_type = ET_REL;                                              \
506   ehdr->e_version = EV_CURRENT;                                       \
507   ehdr->e_machine = cached_file_attrs.elf_machine;                    \
508 }
509
510 DEFINE_INIT_EHDR (32)
511 DEFINE_INIT_EHDR (64)
512
513
514 /* Initialize ELF_FILE's executable header using cached data from previously
515    read files.  */
516
517 static void
518 init_ehdr (lto_elf_file *elf_file)
519 {
520   switch (cached_file_attrs.bits)
521     {
522     case 32:
523       init_ehdr32 (elf_file);
524       break;
525
526     case 64:
527       init_ehdr64 (elf_file);
528       break;
529
530     default:
531       gcc_unreachable ();
532     }
533 }
534
535 /* Open ELF file FILENAME.  If WRITABLE is true, the file is opened for write
536    and, if necessary, created.  Otherwise, the file is opened for reading.
537    Returns the opened file.  */
538
539 lto_file *
540 lto_elf_file_open (const char *filename, bool writable)
541 {
542   lto_elf_file *elf_file;
543   lto_file *result;
544   off_t offset;
545   const char *offset_p;
546   char *fname;
547
548   offset_p = strchr (filename, '@');
549   if (!offset_p)
550     {
551       fname = xstrdup (filename);
552       offset = 0;
553     }
554   else
555     {
556       int64_t t;
557       fname = (char *) xmalloc (offset_p - filename + 1);
558       memcpy (fname, filename, offset_p - filename);
559       fname[offset_p - filename] = '\0';
560       offset_p++;
561       sscanf(offset_p, "%" PRId64 , &t);
562       offset = t;
563       /* elf_rand expects the offset to point to the ar header, not the
564          object itself. Subtract the size of the ar header (60 bytes).
565          We don't uses sizeof (struct ar_hd) to avoid including ar.h */
566       offset -= 60;
567     }
568
569   /* Set up.  */
570   elf_file = XCNEW (lto_elf_file);
571   result = (lto_file *) elf_file;
572   lto_file_init (result, fname);
573   elf_file->fd = -1;
574
575   /* Open the file.  */
576   elf_file->fd = open (fname, writable ? O_WRONLY|O_CREAT : O_RDONLY, 0666);
577   if (elf_file->fd == -1)
578     {
579       error ("could not open file %s", fname);
580       goto fail;
581     }
582
583   /* Initialize the ELF library.  */
584   if (elf_version (EV_CURRENT) == EV_NONE)
585     {
586       error ("ELF library is older than that used when building GCC");
587       goto fail;
588     }
589
590   /* Open the ELF file descriptor.  */
591   elf_file->elf = elf_begin (elf_file->fd, writable ? ELF_C_WRITE : ELF_C_READ,
592                              NULL);
593   if (!elf_file->elf)
594     {
595       error ("could not open ELF file: %s", elf_errmsg (0));
596       goto fail;
597     }
598
599   if (offset != 0)
600     {
601       Elf *e;
602       off_t t = elf_rand (elf_file->elf, offset);
603       if (t != offset)
604         {
605           error ("could not seek in archive");
606           goto fail;
607         }
608
609       e = elf_begin (elf_file->fd, ELF_C_READ, elf_file->elf);
610       if (e == NULL)
611         {
612           error("could not find archive member");
613           goto fail;
614         }
615       elf_end (elf_file->elf);
616       elf_file->elf = e;
617     }
618
619   if (writable)
620     {
621       init_ehdr (elf_file);
622       elf_file->shstrtab_stream = XCNEW (struct lto_output_stream);
623       /* Output an empty string to the section header table.  This becomes the
624          name of the initial NULL section.  */
625       lto_output_1_stream (elf_file->shstrtab_stream, '\0');
626     }
627   else
628     if (!validate_file (elf_file))
629       goto fail;
630
631   return result;
632
633  fail:
634   lto_elf_file_close (result);
635   return NULL;
636 }
637
638
639 /* Close ELF file FILE and clean up any associated data structures.  If FILE
640    was opened for writing, the file's ELF data is written at this time, and
641    any cached data buffers are freed.  */
642
643 void
644 lto_elf_file_close (lto_file *file)
645 {
646   lto_elf_file *elf_file = (lto_elf_file *) file;
647   struct lto_char_ptr_base *cur, *tmp;
648
649   /* Write the ELF section header string table.  */
650   if (elf_file->shstrtab_stream)
651     {
652       size_t strtab;
653       GElf_Ehdr *ehdr_p, ehdr_buf;
654       lto_file *old_file = lto_set_current_out_file (file);
655
656       lto_elf_begin_section_with_type (".shstrtab", SHT_STRTAB);
657       ehdr_p = gelf_getehdr (elf_file->elf, &ehdr_buf);
658       if (ehdr_p == NULL)
659         fatal_error ("gelf_getehdr() failed: %s", elf_errmsg (-1));
660       strtab = elf_ndxscn (elf_file->scn);
661       if (strtab < SHN_LORESERVE)
662         ehdr_p->e_shstrndx = strtab;
663       else
664         {
665           GElf_Shdr *shdr_p, shdr_buf;
666           Elf_Scn *scn_p = elf_getscn (elf_file->elf, 0);
667           if (scn_p == NULL)
668             fatal_error ("elf_getscn() failed: %s", elf_errmsg (-1));
669           shdr_p = gelf_getshdr (scn_p, &shdr_buf);
670           if (shdr_p == NULL)
671             fatal_error ("gelf_getshdr() failed: %s", elf_errmsg (-1));
672           shdr_p->sh_link = strtab;
673           if (gelf_update_shdr (scn_p, shdr_p) == 0)
674             fatal_error ("gelf_update_shdr() failed: %s", elf_errmsg (-1));
675           ehdr_p->e_shstrndx = SHN_XINDEX;
676         }
677       if (gelf_update_ehdr (elf_file->elf, ehdr_p) == 0)
678         fatal_error ("gelf_update_ehdr() failed: %s", elf_errmsg (-1));
679       lto_write_stream (elf_file->shstrtab_stream);
680       lto_elf_end_section ();
681
682       lto_set_current_out_file (old_file);
683       free (elf_file->shstrtab_stream);
684
685       if (elf_update (elf_file->elf, ELF_C_WRITE) < 0)
686         fatal_error ("elf_update() failed: %s", elf_errmsg (-1));
687     }
688
689   if (elf_file->elf)
690     elf_end (elf_file->elf);
691   if (elf_file->fd != -1)
692     close (elf_file->fd);
693
694   /* Free any ELF data buffers.  */
695   cur = elf_file->data;
696   while (cur)
697     {
698       tmp = cur;
699       cur = (struct lto_char_ptr_base *) cur->ptr;
700       free (tmp);
701     }
702
703   free (file);
704 }
705
706
707 /* The current output file.  */
708 static lto_file *current_out_file;
709
710
711 /* Sets the current output file to FILE.  Returns the old output file or
712    NULL.  */
713
714 lto_file *
715 lto_set_current_out_file (lto_file *file)
716 {
717   lto_file *old_file = current_out_file;
718   current_out_file = file;
719   return old_file;
720 }
721
722
723 /* Returns the current output file.  */
724
725 lto_file *
726 lto_get_current_out_file (void)
727 {
728   return current_out_file;
729 }