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