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
 171   section_hash_table = htab_create (37, hash_name, eq_name, free);
 172
 173   for (section = elf_getscn (elf_file->elf, 0);
 174        section;
 175        section = elf_nextscn (elf_file->elf, section))
 176     {
 177       Elf64_Shdr *shdr;
 178       const char *name;
 179       size_t offset;
 180       char *new_name;
 181       void **slot;
 182       struct lto_section_slot s_slot;
 183
 184       /* Get the name of this section.  */
 185       shdr = lto_elf_get_shdr (section);
 186       offset = shdr->sh_name;
 187       name = elf_strptr (elf_file->elf,
 188                          elf_file->sec_strtab,
 189                          offset);
 190
 191       /* Only put lto stuff into the symtab.  */
 192       if (strncmp (name, LTO_SECTION_NAME_PREFIX,
 193                    strlen (LTO_SECTION_NAME_PREFIX)) != 0)
 194         {
 195           lto_elf_free_shdr (shdr);
 196           continue;
 197         }
 198
 199       new_name = XNEWVEC (char, strlen (name) + 1);
 200       strcpy (new_name, name);
 201       s_slot.name = new_name;
 202       slot = htab_find_slot (section_hash_table, &s_slot, INSERT);
 203       if (*slot == NULL)
 204         {
 205           struct lto_section_slot *new_slot = XNEW (struct lto_section_slot);
 206
 207           new_slot->name = new_name;
 208           /* The offset into the file for this section.  */
 209           new_slot->start = shdr->sh_offset;
 210           new_slot->len = shdr->sh_size;
 211           *slot = new_slot;
 212         }
 213       else
 214         {
 215           error ("two or more sections for %s:", new_name);
 216           return NULL;
 217         }
 218
 219       lto_elf_free_shdr (shdr);
 220     }
 221
 222   return section_hash_table;
 223 }
 224
 225
 226 /* Initialize the section header of section SCN.  SH_NAME is the section name
 227    as an index into the section header string table.  SH_TYPE is the section
 228    type, an SHT_* macro from libelf headers.  */
 229
 230 #define DEFINE_INIT_SHDR(BITS)                                        \
 231 static void                                                           \
 232 init_shdr##BITS (Elf_Scn *scn, size_t sh_name, size_t sh_type)        \
 233 {                                                                     \
 234   Elf##BITS##_Shdr *shdr;                                             \
 235                                                                       \
 236   shdr = elf##BITS##_getshdr (scn);                                   \
 237   if (!shdr)                                                          \
 238     fatal_error ("elf"#BITS"_getshdr() failed: %s", elf_errmsg (-1));\
 239                                                                       \
 240   shdr->sh_name = sh_name;                                            \
 241   shdr->sh_type = sh_type;                                            \
 242   shdr->sh_addralign = POINTER_SIZE / BITS_PER_UNIT;                  \
 243   shdr->sh_flags = 0;                                                 \
 244   shdr->sh_entsize = 0;                                               \
 245 }
 246
 247 DEFINE_INIT_SHDR (32)
 248 DEFINE_INIT_SHDR (64)
 249
 250 static bool first_data_block;
 251
 252 /* Begin a new ELF section named NAME with type TYPE in the current output
 253    file.  TYPE is an SHT_* macro from the libelf headers.  */
 254
 255 static void
 256 lto_elf_begin_section_with_type (const char *name, size_t type)
 257 {
 258   lto_elf_file *file;
 259   Elf_Scn *scn;
 260   size_t sh_name;
 261
 262   /* Grab the current output file and do some basic assertion checking.  */
 263   file = (lto_elf_file *) lto_get_current_out_file (),
 264   gcc_assert (file);
 265   gcc_assert (file->elf);
 266   gcc_assert (!file->scn);
 267
 268   /* Create a new section.  */
 269   scn = elf_newscn (file->elf);
 270   if (!scn)
 271     fatal_error ("could not create a new ELF section: %s", elf_errmsg (-1));
 272   file->scn = scn;
 273
 274   /* Add a string table entry and record the offset.  */
 275   gcc_assert (file->shstrtab_stream);
 276   sh_name = file->shstrtab_stream->total_size;
 277   lto_output_data_stream (file->shstrtab_stream, name, strlen (name) + 1);
 278
 279   /* Initialize the section header.  */
 280   switch (cached_file_attrs.bits)
 281     {
 282     case 32:
 283       init_shdr32 (scn, sh_name, type);
 284       break;
 285
 286     case 64:
 287       init_shdr64 (scn, sh_name, type);
 288       break;
 289
 290     default:
 291       gcc_unreachable ();
 292     }
 293
 294   first_data_block = true;
 295 }
 296
 297
 298 /* Begin a new ELF section named NAME in the current output file.  */
 299
 300 void
 301 lto_elf_begin_section (const char *name)
 302 {
 303   lto_elf_begin_section_with_type (name, SHT_PROGBITS);
 304 }
 305
 306
 307 /* Append DATA of length LEN to the current output section.  BASE is a pointer
 308    to the output page containing DATA.  It is freed once the output file has
 309    been written.  */
 310
 311 void
 312 lto_elf_append_data (const void *data, size_t len, void *block)
 313 {
 314   lto_elf_file *file;
 315   Elf_Data *elf_data;
 316   struct lto_char_ptr_base *base = (struct lto_char_ptr_base *) block;
 317
 318   /* Grab the current output file and do some basic assertion checking.  */
 319   file = (lto_elf_file *) lto_get_current_out_file ();
 320   gcc_assert (file);
 321   gcc_assert (file->scn);
 322
 323   elf_data = elf_newdata (file->scn);
 324   if (!elf_data)
 325     fatal_error ("could not append data to ELF section: %s", elf_errmsg (-1));
 326
 327   if (first_data_block)
 328     {
 329       elf_data->d_align = POINTER_SIZE / BITS_PER_UNIT;
 330       first_data_block = false;
 331     }
 332   else
 333     elf_data->d_align = 1;
 334   elf_data->d_buf = CONST_CAST (void *, data);
 335   elf_data->d_off = 0LL;
 336   elf_data->d_size = len;
 337   elf_data->d_type = ELF_T_BYTE;
 338   elf_data->d_version = EV_CURRENT;
 339
 340   base->ptr = (char *)file->data;
 341   file->data = base;
 342 }
 343
 344
 345 /* End the current output section.  This just does some assertion checking
 346    and sets the current output file's scn member to NULL.  */
 347
 348 void
 349 lto_elf_end_section (void)
 350 {
 351   lto_elf_file *file;
 352
 353   /* Grab the current output file and validate some basic assertions.  */
 354   file = (lto_elf_file *) lto_get_current_out_file ();
 355   gcc_assert (file);
 356   gcc_assert (file->scn);
 357
 358   file->scn = NULL;
 359 }
 360
 361
 362 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
 363    uninitialized, caches the architecture.  */
 364
 365 #define DEFINE_VALIDATE_EHDR(BITS)                              \
 366 static bool                                                     \
 367 validate_ehdr##BITS (lto_elf_file *elf_file)                    \
 368 {                                                               \
 369   Elf##BITS##_Ehdr *elf_header;                                 \
 370                                                                 \
 371   elf_header = elf##BITS##_getehdr (elf_file->elf);             \
 372   if (!elf_header)                                              \
 373     {                                                           \
 374       error ("could not read ELF header: %s", elf_errmsg (0));  \
 375       return false;                                             \
 376     }                                                           \
 377                                                                 \
 378   if (elf_header->e_type != ET_REL)                             \
 379     {                                                           \
 380       error ("not a relocatable ELF object file");              \
 381       return false;                                             \
 382     }                                                           \
 383                                                                 \
 384   if (!cached_file_attrs.initialized)                           \
 385     cached_file_attrs.elf_machine = elf_header->e_machine;      \
 386                                                                 \
 387   if (cached_file_attrs.elf_machine != elf_header->e_machine)   \
 388     {                                                           \
 389       error ("inconsistent file architecture detected");        \
 390       return false;                                             \
 391     }                                                           \
 392                                                                 \
 393   return true;                                                  \
 394 }
 395
 396 DEFINE_VALIDATE_EHDR (32)
 397 DEFINE_VALIDATE_EHDR (64)
 398
 399
 400 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
 401    uninitialized, caches the results.  Also records the section header string
 402    table's section index.  Returns true on success or false on failure.  */
 403
 404 static bool
 405 validate_file (lto_elf_file *elf_file)
 406 {
 407   const char *elf_ident;
 408
 409   /* Some aspects of the libelf API are dependent on whether the
 410      object file is a 32-bit or 64-bit file.  Determine which kind of
 411      file this is now.  */
 412   elf_ident = elf_getident (elf_file->elf, NULL);
 413   if (!elf_ident)
 414     {
 415       error ("could not read ELF identification information: %s",
 416               elf_errmsg (0));
 417       return false;
 418
 419     }
 420
 421   if (!cached_file_attrs.initialized)
 422     {
 423       switch (elf_ident[EI_CLASS])
 424         {
 425         case ELFCLASS32:
 426           cached_file_attrs.bits = 32;
 427           break;
 428
 429         case ELFCLASS64:
 430           cached_file_attrs.bits = 64;
 431           break;
 432
 433         default:
 434           error ("unsupported ELF file class");
 435           return false;
 436         }
 437
 438       memcpy (cached_file_attrs.elf_ident, elf_ident,
 439               sizeof cached_file_attrs.elf_ident);
 440     }
 441
 442   if (memcmp (elf_ident, cached_file_attrs.elf_ident,
 443               sizeof cached_file_attrs.elf_ident))
 444     return false;
 445
 446   /* Check that the input file is a relocatable object file with the correct
 447      architecture.  */
 448   switch (cached_file_attrs.bits)
 449     {
 450     case 32:
 451       if (!validate_ehdr32 (elf_file))
 452         return false;
 453       break;
 454
 455     case 64:
 456       if (!validate_ehdr64 (elf_file))
 457         return false;
 458       break;
 459
 460     default:
 461       gcc_unreachable ();
 462     }
 463
 464   /* Read the string table used for section header names.  */
 465   if (elf_getshdrstrndx (elf_file->elf, &elf_file->sec_strtab) == -1)
 466     {
 467       error ("could not locate ELF string table: %s", elf_errmsg (0));
 468       return false;
 469     }
 470
 471   cached_file_attrs.initialized = true;
 472   return true;
 473 }
 474
 475
 476 /* Helper functions used by init_ehdr.  Initialize ELF_FILE's executable
 477    header using cached data from previously read files.  */
 478
 479 #define DEFINE_INIT_EHDR(BITS)                                        \
 480 static void                                                           \
 481 init_ehdr##BITS (lto_elf_file *elf_file)                              \
 482 {                                                                     \
 483   Elf##BITS##_Ehdr *ehdr;                                             \
 484                                                                       \
 485   gcc_assert (cached_file_attrs.bits);                                \
 486                                                                       \
 487   ehdr = elf##BITS##_newehdr (elf_file->elf);                         \
 488   if (!ehdr)                                                          \
 489     fatal_error ("elf"#BITS"_newehdr() failed: %s", elf_errmsg (-1));\
 490                                                                       \
 491   memcpy (ehdr->e_ident, cached_file_attrs.elf_ident,                 \
 492           sizeof cached_file_attrs.elf_ident);                        \
 493   ehdr->e_type = ET_REL;                                              \
 494   ehdr->e_version = EV_CURRENT;                                       \
 495   ehdr->e_machine = cached_file_attrs.elf_machine;                    \
 496 }
 497
 498 DEFINE_INIT_EHDR (32)
 499 DEFINE_INIT_EHDR (64)
 500
 501
 502 /* Initialize ELF_FILE's executable header using cached data from previously
 503    read files.  */
 504
 505 static void
 506 init_ehdr (lto_elf_file *elf_file)
 507 {
 508   switch (cached_file_attrs.bits)
 509     {
 510     case 32:
 511       init_ehdr32 (elf_file);
 512       break;
 513
 514     case 64:
 515       init_ehdr64 (elf_file);
 516       break;
 517
 518     default:
 519       gcc_unreachable ();
 520     }
 521 }
 522
 523
 524 /* Open ELF file FILENAME.  If WRITABLE is true, the file is opened for write
 525    and, if necessary, created.  Otherwise, the file is opened for reading.
 526    Returns the opened file.  */
 527
 528 lto_file *
 529 lto_elf_file_open (const char *filename, bool writable)
 530 {
 531   lto_elf_file *elf_file;
 532   lto_file *result;
 533
 534   /* Set up.  */
 535   elf_file = XCNEW (lto_elf_file);
 536   result = (lto_file *) elf_file;
 537   lto_file_init (result, filename);
 538   elf_file->fd = -1;
 539
 540   /* Open the file.  */
 541   elf_file->fd = open (filename, writable ? O_WRONLY|O_CREAT : O_RDONLY, 0666);
 542   if (elf_file->fd == -1)
 543     {
 544       error ("could not open file %s", filename);
 545       goto fail;
 546     }
 547
 548   /* Initialize the ELF library.  */
 549   if (elf_version (EV_CURRENT) == EV_NONE)
 550     {
 551       error ("ELF library is older than that used when building GCC");
 552       goto fail;
 553     }
 554
 555   /* Open the ELF file descriptor.  */
 556   elf_file->elf = elf_begin (elf_file->fd, writable ? ELF_C_WRITE : ELF_C_READ,
 557                              NULL);
 558   if (!elf_file->elf)
 559     {
 560       error ("could not open ELF file: %s", elf_errmsg (0));
 561       goto fail;
 562     }
 563
 564   if (writable)
 565     {
 566       init_ehdr (elf_file);
 567       elf_file->shstrtab_stream = XCNEW (struct lto_output_stream);
 568       /* Output an empty string to the section header table.  This becomes the
 569          name of the initial NULL section.  */
 570       lto_output_1_stream (elf_file->shstrtab_stream, '\0');
 571     }
 572   else
 573     if (!validate_file (elf_file))
 574       goto fail;
 575
 576   return result;
 577
 578  fail:
 579   lto_elf_file_close (result);
 580   return NULL;
 581 }
 582
 583
 584 /* Close ELF file FILE and clean up any associated data structures.  If FILE
 585    was opened for writing, the file's ELF data is written at this time, and
 586    any cached data buffers are freed.  */
 587
 588 void
 589 lto_elf_file_close (lto_file *file)
 590 {
 591   lto_elf_file *elf_file = (lto_elf_file *) file;
 592   struct lto_char_ptr_base *cur, *tmp;
 593
 594   /* Write the ELF section header string table.  */
 595   if (elf_file->shstrtab_stream)
 596     {
 597       size_t strtab;
 598       GElf_Ehdr *ehdr_p, ehdr_buf;
 599       lto_file *old_file = lto_set_current_out_file (file);
 600
 601       lto_elf_begin_section_with_type (".shstrtab", SHT_STRTAB);
 602       ehdr_p = gelf_getehdr (elf_file->elf, &ehdr_buf);
 603       if (ehdr_p == NULL)
 604         fatal_error ("gelf_getehdr() failed: %s", elf_errmsg (-1));
 605       strtab = elf_ndxscn (elf_file->scn);
 606       if (strtab < SHN_LORESERVE)
 607         ehdr_p->e_shstrndx = strtab;
 608       else
 609         {
 610           GElf_Shdr *shdr_p, shdr_buf;
 611           Elf_Scn *scn_p = elf_getscn (elf_file->elf, 0);
 612           if (scn_p == NULL)
 613             fatal_error ("elf_getscn() failed: %s", elf_errmsg (-1));
 614           shdr_p = gelf_getshdr (scn_p, &shdr_buf);
 615           if (shdr_p == NULL)
 616             fatal_error ("gelf_getshdr() failed: %s", elf_errmsg (-1));
 617           shdr_p->sh_link = strtab;
 618           if (gelf_update_shdr (scn_p, shdr_p) == 0)
 619             fatal_error ("gelf_update_shdr() failed: %s", elf_errmsg (-1));
 620           ehdr_p->e_shstrndx = SHN_XINDEX;
 621         }
 622       if (gelf_update_ehdr (elf_file->elf, ehdr_p) == 0)
 623         fatal_error ("gelf_update_ehdr() failed: %s", elf_errmsg (-1));
 624       lto_write_stream (elf_file->shstrtab_stream);
 625       lto_elf_end_section ();
 626
 627       lto_set_current_out_file (old_file);
 628       free (elf_file->shstrtab_stream);
 629
 630       if (elf_update (elf_file->elf, ELF_C_WRITE) < 0)
 631         fatal_error ("elf_update() failed: %s", elf_errmsg (-1));
 632     }
 633
 634   if (elf_file->elf)
 635     elf_end (elf_file->elf);
 636   if (elf_file->fd != -1)
 637     close (elf_file->fd);
 638
 639   /* Free any ELF data buffers.  */
 640   cur = elf_file->data;
 641   while (cur)
 642     {
 643       tmp = cur;
 644       cur = (struct lto_char_ptr_base *) cur->ptr;
 645       free (tmp);
 646     }
 647
 648   free (file);
 649 }
 650
 651
 652 /* The current output file.  */
 653 static lto_file *current_out_file;
 654
 655
 656 /* Sets the current output file to FILE.  Returns the old output file or
 657    NULL.  */
 658
 659 lto_file *
 660 lto_set_current_out_file (lto_file *file)
 661 {
 662   lto_file *old_file = current_out_file;
 663   current_out_file = file;
 664   return old_file;
 665 }
 666
 667
 668 /* Returns the current output file.  */
 669
 670 lto_file *
 671 lto_get_current_out_file (void)
 672 {
 673   return current_out_file;
 674 }