1 /* LTO routines for ELF object files.
2 Copyright 2009, 2010 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
5 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
28 #include "libiberty.h"
30 #include "lto-streamer.h"
32 /* Cater to hosts with half-backed <elf.h> file like HP-UX. */
37 #ifndef EM_SPARC32PLUS
38 # define EM_SPARC32PLUS 18
42 /* Handle opening elf files on hosts, such as Windows, that may use
43 text file handling that will break binary access. */
49 /* Initialize FILE, an LTO file object for FILENAME. */
51 lto_file_init (lto_file
*file
, const char *filename
, off_t offset
)
53 file
->filename
= filename
;
54 file
->offset
= offset
;
60 /* The base information. */
63 /* The system file descriptor for the file. */
66 /* The libelf descriptor for the file. */
69 /* Section number of string table used for section names. */
72 /* Writable file members. */
74 /* The currently active section. */
77 /* The output stream for section header names. */
78 struct lto_output_stream
*shstrtab_stream
;
80 /* Linked list of data which must be freed *after* the file has been
81 closed. This is an annoying limitation of libelf. */
82 struct lto_char_ptr_base
*data
;
84 typedef struct lto_elf_file lto_elf_file
;
86 /* Stores executable header attributes which must be shared by all ELF files.
87 This is used for validating input files and populating output files. */
92 unsigned char elf_ident
[EI_NIDENT
];
93 Elf64_Half elf_machine
;
97 /* Return the section header for SECTION. The return value is never
98 NULL. Call lto_elf_free_shdr to release the memory allocated. */
101 lto_elf_get_shdr (Elf_Scn
*section
)
105 switch (cached_file_attrs
.bits
)
111 /* Read the 32-bit section header. */
112 shdr32
= elf32_getshdr (section
);
114 fatal_error ("could not read section header: %s", elf_errmsg (0));
116 /* Transform it into a 64-bit section header. */
117 shdr
= XNEW (Elf64_Shdr
);
118 shdr
->sh_name
= shdr32
->sh_name
;
119 shdr
->sh_type
= shdr32
->sh_type
;
120 shdr
->sh_flags
= shdr32
->sh_flags
;
121 shdr
->sh_addr
= shdr32
->sh_addr
;
122 shdr
->sh_offset
= shdr32
->sh_offset
;
123 shdr
->sh_size
= shdr32
->sh_size
;
124 shdr
->sh_link
= shdr32
->sh_link
;
125 shdr
->sh_info
= shdr32
->sh_info
;
126 shdr
->sh_addralign
= shdr32
->sh_addralign
;
127 shdr
->sh_entsize
= shdr32
->sh_entsize
;
133 shdr
= elf64_getshdr (section
);
135 fatal_error ("could not read section header: %s", elf_errmsg (0));
145 /* Free SHDR, previously allocated by lto_elf_get_shdr. */
147 lto_elf_free_shdr (Elf64_Shdr
*shdr
)
149 if (cached_file_attrs
.bits
!= 64)
154 /* Returns a hash code for P. */
157 hash_name (const void *p
)
159 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
160 return (hashval_t
) htab_hash_string (ds
->name
);
164 /* Returns nonzero if P1 and P2 are equal. */
167 eq_name (const void *p1
, const void *p2
)
169 const struct lto_section_slot
*s1
=
170 (const struct lto_section_slot
*) p1
;
171 const struct lto_section_slot
*s2
=
172 (const struct lto_section_slot
*) p2
;
174 return strcmp (s1
->name
, s2
->name
) == 0;
178 /* Build a hash table whose key is the section names and whose data is
179 the start and size of each section in the .o file. */
182 lto_obj_build_section_table (lto_file
*lto_file
)
184 lto_elf_file
*elf_file
= (lto_elf_file
*)lto_file
;
185 htab_t section_hash_table
;
189 section_hash_table
= htab_create (37, hash_name
, eq_name
, free
);
191 base_offset
= elf_getbase (elf_file
->elf
);
192 /* We are reasonably sure that elf_getbase does not fail at this
193 point. So assume that we run into the incompatibility with
194 the FreeBSD libelf implementation that has a non-working
195 elf_getbase for non-archive members in which case the offset
197 if (base_offset
== (size_t)-1)
199 for (section
= elf_getscn (elf_file
->elf
, 0);
201 section
= elf_nextscn (elf_file
->elf
, section
))
208 struct lto_section_slot s_slot
;
210 /* Get the name of this section. */
211 shdr
= lto_elf_get_shdr (section
);
212 offset
= shdr
->sh_name
;
213 name
= elf_strptr (elf_file
->elf
,
214 elf_file
->sec_strtab
,
217 /* Only put lto stuff into the symtab. */
218 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
,
219 strlen (LTO_SECTION_NAME_PREFIX
)) != 0)
221 lto_elf_free_shdr (shdr
);
225 new_name
= XNEWVEC (char, strlen (name
) + 1);
226 strcpy (new_name
, name
);
227 s_slot
.name
= new_name
;
228 slot
= htab_find_slot (section_hash_table
, &s_slot
, INSERT
);
231 struct lto_section_slot
*new_slot
= XNEW (struct lto_section_slot
);
233 new_slot
->name
= new_name
;
234 /* The offset into the file for this section. */
235 new_slot
->start
= base_offset
+ shdr
->sh_offset
;
236 new_slot
->len
= shdr
->sh_size
;
241 error ("two or more sections for %s:", new_name
);
245 lto_elf_free_shdr (shdr
);
248 return section_hash_table
;
252 /* Initialize the section header of section SCN. SH_NAME is the section name
253 as an index into the section header string table. SH_TYPE is the section
254 type, an SHT_* macro from libelf headers. */
256 #define DEFINE_INIT_SHDR(BITS) \
258 init_shdr##BITS (Elf_Scn *scn, size_t sh_name, size_t sh_type) \
260 Elf##BITS##_Shdr *shdr; \
262 shdr = elf##BITS##_getshdr (scn); \
266 fatal_error ("elf32_getshdr() failed: %s", elf_errmsg (-1)); \
268 fatal_error ("elf64_getshdr() failed: %s", elf_errmsg (-1)); \
271 shdr->sh_name = sh_name; \
272 shdr->sh_type = sh_type; \
273 shdr->sh_addralign = POINTER_SIZE / BITS_PER_UNIT; \
274 shdr->sh_flags = 0; \
275 shdr->sh_entsize = 0; \
278 DEFINE_INIT_SHDR (32)
279 DEFINE_INIT_SHDR (64)
281 static bool first_data_block
;
283 /* Begin a new ELF section named NAME with type TYPE in the current output
284 file. TYPE is an SHT_* macro from the libelf headers. */
287 lto_elf_begin_section_with_type (const char *name
, size_t type
)
293 /* Grab the current output file and do some basic assertion checking. */
294 file
= (lto_elf_file
*) lto_get_current_out_file (),
296 gcc_assert (file
->elf
);
297 gcc_assert (!file
->scn
);
299 /* Create a new section. */
300 scn
= elf_newscn (file
->elf
);
302 fatal_error ("could not create a new ELF section: %s", elf_errmsg (-1));
305 /* Add a string table entry and record the offset. */
306 gcc_assert (file
->shstrtab_stream
);
307 sh_name
= file
->shstrtab_stream
->total_size
;
308 lto_output_data_stream (file
->shstrtab_stream
, name
, strlen (name
) + 1);
310 /* Initialize the section header. */
311 switch (cached_file_attrs
.bits
)
314 init_shdr32 (scn
, sh_name
, type
);
318 init_shdr64 (scn
, sh_name
, type
);
325 first_data_block
= true;
329 /* Begin a new ELF section named NAME in the current output file. */
332 lto_obj_begin_section (const char *name
)
334 lto_elf_begin_section_with_type (name
, SHT_PROGBITS
);
338 /* Append DATA of length LEN to the current output section. BASE is a pointer
339 to the output page containing DATA. It is freed once the output file has
343 lto_obj_append_data (const void *data
, size_t len
, void *block
)
347 struct lto_char_ptr_base
*base
= (struct lto_char_ptr_base
*) block
;
349 /* Grab the current output file and do some basic assertion checking. */
350 file
= (lto_elf_file
*) lto_get_current_out_file ();
352 gcc_assert (file
->scn
);
354 elf_data
= elf_newdata (file
->scn
);
356 fatal_error ("could not append data to ELF section: %s", elf_errmsg (-1));
358 if (first_data_block
)
360 elf_data
->d_align
= POINTER_SIZE
/ BITS_PER_UNIT
;
361 first_data_block
= false;
364 elf_data
->d_align
= 1;
365 elf_data
->d_buf
= CONST_CAST (void *, data
);
366 elf_data
->d_off
= 0LL;
367 elf_data
->d_size
= len
;
368 elf_data
->d_type
= ELF_T_BYTE
;
369 elf_data
->d_version
= EV_CURRENT
;
371 base
->ptr
= (char *)file
->data
;
376 /* End the current output section. This just does some assertion checking
377 and sets the current output file's scn member to NULL. */
380 lto_obj_end_section (void)
384 /* Grab the current output file and validate some basic assertions. */
385 file
= (lto_elf_file
*) lto_get_current_out_file ();
387 gcc_assert (file
->scn
);
393 /* Return true if ELF_MACHINE is compatible with the cached value of the
394 architecture and possibly update the latter. Return false otherwise.
396 Note: if you want to add more EM_* cases, you'll need to provide the
397 corresponding definitions at the beginning of the file. */
400 is_compatible_architecture (Elf64_Half elf_machine
)
402 if (cached_file_attrs
.elf_machine
== elf_machine
)
405 switch (cached_file_attrs
.elf_machine
)
408 if (elf_machine
== EM_SPARC32PLUS
)
410 cached_file_attrs
.elf_machine
= elf_machine
;
416 if (elf_machine
== EM_SPARC
)
428 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
429 uninitialized, caches the architecture. */
431 #define DEFINE_VALIDATE_EHDR(BITS) \
433 validate_ehdr##BITS (lto_elf_file *elf_file) \
435 Elf##BITS##_Ehdr *elf_header; \
437 elf_header = elf##BITS##_getehdr (elf_file->elf); \
440 error ("could not read ELF header: %s", elf_errmsg (0)); \
444 if (elf_header->e_type != ET_REL) \
446 error ("not a relocatable ELF object file"); \
450 if (!cached_file_attrs.initialized) \
451 cached_file_attrs.elf_machine = elf_header->e_machine; \
452 else if (!is_compatible_architecture (elf_header->e_machine)) \
454 error ("inconsistent file architecture detected"); \
461 DEFINE_VALIDATE_EHDR (32)
462 DEFINE_VALIDATE_EHDR (64)
465 #ifndef HAVE_ELF_GETSHDRSTRNDX
466 /* elf_getshdrstrndx replacement for systems that lack it, but provide
467 either the gABI conformant or Solaris 2 variant of elf_getshstrndx
471 elf_getshdrstrndx (Elf
*elf
, size_t *dst
)
473 #ifdef HAVE_ELF_GETSHSTRNDX_GABI
474 return elf_getshstrndx (elf
, dst
);
476 return elf_getshstrndx (elf
, dst
) ? 0 : -1;
481 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
482 uninitialized, caches the results. Also records the section header string
483 table's section index. Returns true on success or false on failure. */
486 validate_file (lto_elf_file
*elf_file
)
488 const char *elf_ident
;
490 /* Some aspects of the libelf API are dependent on whether the
491 object file is a 32-bit or 64-bit file. Determine which kind of
493 elf_ident
= elf_getident (elf_file
->elf
, NULL
);
496 error ("could not read ELF identification information: %s",
502 if (!cached_file_attrs
.initialized
)
504 switch (elf_ident
[EI_CLASS
])
507 cached_file_attrs
.bits
= 32;
511 cached_file_attrs
.bits
= 64;
515 error ("unsupported ELF file class");
519 memcpy (cached_file_attrs
.elf_ident
, elf_ident
,
520 sizeof cached_file_attrs
.elf_ident
);
523 if (memcmp (elf_ident
, cached_file_attrs
.elf_ident
,
524 sizeof cached_file_attrs
.elf_ident
))
527 /* Check that the input file is a relocatable object file with the correct
529 switch (cached_file_attrs
.bits
)
532 if (!validate_ehdr32 (elf_file
))
537 if (!validate_ehdr64 (elf_file
))
545 /* Read the string table used for section header names. */
546 if (elf_getshdrstrndx (elf_file
->elf
, &elf_file
->sec_strtab
) == -1)
548 error ("could not locate ELF string table: %s", elf_errmsg (0));
552 cached_file_attrs
.initialized
= true;
557 /* Helper functions used by init_ehdr. Initialize ELF_FILE's executable
558 header using cached data from previously read files. */
560 #define DEFINE_INIT_EHDR(BITS) \
562 init_ehdr##BITS (lto_elf_file *elf_file) \
564 Elf##BITS##_Ehdr *ehdr; \
566 gcc_assert (cached_file_attrs.bits); \
568 ehdr = elf##BITS##_newehdr (elf_file->elf); \
572 fatal_error ("elf32_newehdr() failed: %s", elf_errmsg (-1)); \
574 fatal_error ("elf64_newehdr() failed: %s", elf_errmsg (-1)); \
577 memcpy (ehdr->e_ident, cached_file_attrs.elf_ident, \
578 sizeof cached_file_attrs.elf_ident); \
579 ehdr->e_type = ET_REL; \
580 ehdr->e_version = EV_CURRENT; \
581 ehdr->e_machine = cached_file_attrs.elf_machine; \
584 DEFINE_INIT_EHDR (32)
585 DEFINE_INIT_EHDR (64)
588 /* Initialize ELF_FILE's executable header using cached data from previously
592 init_ehdr (lto_elf_file
*elf_file
)
594 switch (cached_file_attrs
.bits
)
597 init_ehdr32 (elf_file
);
601 init_ehdr64 (elf_file
);
609 /* Open ELF file FILENAME. If WRITABLE is true, the file is opened for write
610 and, if necessary, created. Otherwise, the file is opened for reading.
611 Returns the opened file. */
614 lto_obj_file_open (const char *filename
, bool writable
)
616 lto_elf_file
*elf_file
;
617 lto_file
*result
= NULL
;
621 const char *offset_p
;
625 offset_p
= strrchr (filename
, '@');
627 && offset_p
!= filename
628 && sscanf (offset_p
, "@%li%n", &loffset
, &consumed
) >= 1
629 && strlen (offset_p
) == (unsigned int)consumed
)
631 fname
= (char *) xmalloc (offset_p
- filename
+ 1);
632 memcpy (fname
, filename
, offset_p
- filename
);
633 fname
[offset_p
- filename
] = '\0';
634 offset
= (off_t
)loffset
;
635 /* elf_rand expects the offset to point to the ar header, not the
636 object itself. Subtract the size of the ar header (60 bytes).
637 We don't uses sizeof (struct ar_hd) to avoid including ar.h */
638 header_offset
= offset
- 60;
642 fname
= xstrdup (filename
);
648 elf_file
= XCNEW (lto_elf_file
);
649 result
= (lto_file
*) elf_file
;
650 lto_file_init (result
, fname
, offset
);
654 elf_file
->fd
= open (fname
, writable
? O_WRONLY
|O_CREAT
|O_BINARY
655 : O_RDONLY
|O_BINARY
, 0666);
656 if (elf_file
->fd
== -1)
658 error ("could not open file %s", fname
);
662 /* Initialize the ELF library. */
663 if (elf_version (EV_CURRENT
) == EV_NONE
)
665 error ("ELF library is older than that used when building GCC");
669 /* Open the ELF file descriptor. */
670 elf_file
->elf
= elf_begin (elf_file
->fd
, writable
? ELF_C_WRITE
: ELF_C_READ
,
674 error ("could not open ELF file: %s", elf_errmsg (0));
681 off_t t
= elf_rand (elf_file
->elf
, header_offset
);
682 if (t
!= header_offset
)
684 error ("could not seek in archive");
688 e
= elf_begin (elf_file
->fd
, ELF_C_READ
, elf_file
->elf
);
691 error("could not find archive member");
694 elf_end (elf_file
->elf
);
700 init_ehdr (elf_file
);
701 elf_file
->shstrtab_stream
= XCNEW (struct lto_output_stream
);
702 /* Output an empty string to the section header table. This becomes the
703 name of the initial NULL section. */
704 lto_output_1_stream (elf_file
->shstrtab_stream
, '\0');
707 if (!validate_file (elf_file
))
714 lto_obj_file_close (result
);
719 /* Close ELF file FILE and clean up any associated data structures. If FILE
720 was opened for writing, the file's ELF data is written at this time, and
721 any cached data buffers are freed. */
724 lto_obj_file_close (lto_file
*file
)
726 lto_elf_file
*elf_file
= (lto_elf_file
*) file
;
727 struct lto_char_ptr_base
*cur
, *tmp
;
729 /* Write the ELF section header string table. */
730 if (elf_file
->shstrtab_stream
)
733 GElf_Ehdr
*ehdr_p
, ehdr_buf
;
734 lto_file
*old_file
= lto_set_current_out_file (file
);
736 lto_elf_begin_section_with_type (".shstrtab", SHT_STRTAB
);
737 ehdr_p
= gelf_getehdr (elf_file
->elf
, &ehdr_buf
);
739 fatal_error ("gelf_getehdr() failed: %s", elf_errmsg (-1));
740 strtab
= elf_ndxscn (elf_file
->scn
);
741 if (strtab
< SHN_LORESERVE
)
742 ehdr_p
->e_shstrndx
= strtab
;
745 GElf_Shdr
*shdr_p
, shdr_buf
;
746 Elf_Scn
*scn_p
= elf_getscn (elf_file
->elf
, 0);
748 fatal_error ("elf_getscn() failed: %s", elf_errmsg (-1));
749 shdr_p
= gelf_getshdr (scn_p
, &shdr_buf
);
751 fatal_error ("gelf_getshdr() failed: %s", elf_errmsg (-1));
752 shdr_p
->sh_link
= strtab
;
753 if (gelf_update_shdr (scn_p
, shdr_p
) == 0)
754 fatal_error ("gelf_update_shdr() failed: %s", elf_errmsg (-1));
755 ehdr_p
->e_shstrndx
= SHN_XINDEX
;
757 if (gelf_update_ehdr (elf_file
->elf
, ehdr_p
) == 0)
758 fatal_error ("gelf_update_ehdr() failed: %s", elf_errmsg (-1));
759 lto_write_stream (elf_file
->shstrtab_stream
);
760 lto_obj_end_section ();
762 lto_set_current_out_file (old_file
);
763 free (elf_file
->shstrtab_stream
);
765 if (elf_update (elf_file
->elf
, ELF_C_WRITE
) < 0)
766 fatal_error ("elf_update() failed: %s", elf_errmsg (-1));
770 elf_end (elf_file
->elf
);
771 if (elf_file
->fd
!= -1)
772 close (elf_file
->fd
);
774 /* Free any ELF data buffers. */
775 cur
= elf_file
->data
;
779 cur
= (struct lto_char_ptr_base
*) cur
->ptr
;
787 /* The current output file. */
788 static lto_file
*current_out_file
;
791 /* Sets the current output file to FILE. Returns the old output file or
795 lto_set_current_out_file (lto_file
*file
)
797 lto_file
*old_file
= current_out_file
;
798 current_out_file
= file
;
803 /* Returns the current output file. */
806 lto_get_current_out_file (void)
808 return current_out_file
;