gcc/lto/lto-elf.c

   1 /* LTO routines for ELF object files.
   2    Copyright 2009, 2010 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 "diagnostic-core.h"
  25 #include "toplev.h"
  26 #include <gelf.h>
  27 #include "lto.h"
  28 #include "tm.h"
  29 #include "libiberty.h"
  30 #include "ggc.h"
  31 #include "lto-streamer.h"
  32
  33 /* Cater to hosts with half-backed <elf.h> file like HP-UX.  */
  34 #ifndef EM_SPARC
  35 # define EM_SPARC 2
  36 #endif
  37
  38 #ifndef EM_SPARC32PLUS
  39 # define EM_SPARC32PLUS 18
  40 #endif
  41
  42 #ifndef ELFOSABI_NONE
  43 # define ELFOSABI_NONE 0
  44 #endif
  45 #ifndef ELFOSABI_LINUX
  46 # define ELFOSABI_LINUX 3
  47 #endif
  48
  49
  50 /* Handle opening elf files on hosts, such as Windows, that may use
  51    text file handling that will break binary access.  */
  52 #ifndef O_BINARY
  53 # define O_BINARY 0
  54 #endif
  55
  56
  57 /* Initialize FILE, an LTO file object for FILENAME.  */
  58 static void
  59 lto_file_init (lto_file *file, const char *filename, off_t offset)
  60 {
  61   file->filename = filename;
  62   file->offset = offset;
  63 }
  64
  65 /* An ELF file.  */
  66 struct lto_elf_file
  67 {
  68   /* The base information.  */
  69   lto_file base;
  70
  71   /* The system file descriptor for the file.  */
  72   int fd;
  73
  74   /* The libelf descriptor for the file.  */
  75   Elf *elf;
  76
  77   /* Section number of string table used for section names.  */
  78   size_t sec_strtab;
  79
  80   /* Writable file members.  */
  81
  82   /* The currently active section.  */
  83   Elf_Scn *scn;
  84
  85   /* The output stream for section header names.  */
  86   struct lto_output_stream *shstrtab_stream;
  87
  88   /* Linked list of data which must be freed *after* the file has been
  89      closed.  This is an annoying limitation of libelf.  */
  90   struct lto_char_ptr_base *data;
  91 };
  92 typedef struct lto_elf_file lto_elf_file;
  93
  94 /* Stores executable header attributes which must be shared by all ELF files.
  95    This is used for validating input files and populating output files.  */
  96 static struct {
  97   bool initialized;
  98   /* 32 or 64 bits?  */
  99   size_t bits;
 100   unsigned char elf_ident[EI_NIDENT];
 101   Elf64_Half elf_machine;
 102 } cached_file_attrs;
 103
 104
 105 /* Return the section header for SECTION.  The return value is never
 106    NULL.  Call lto_elf_free_shdr to release the memory allocated.  */
 107
 108 static Elf64_Shdr *
 109 lto_elf_get_shdr (Elf_Scn *section)
 110 {
 111   Elf64_Shdr *shdr;
 112
 113   switch (cached_file_attrs.bits)
 114     {
 115     case 32:
 116       {
 117         Elf32_Shdr *shdr32;
 118
 119         /* Read the 32-bit section header.  */
 120         shdr32 = elf32_getshdr (section);
 121         if (!shdr32)
 122           fatal_error ("could not read section header: %s", elf_errmsg (0));
 123
 124         /* Transform it into a 64-bit section header.  */
 125         shdr = XNEW (Elf64_Shdr);
 126         shdr->sh_name = shdr32->sh_name;
 127         shdr->sh_type = shdr32->sh_type;
 128         shdr->sh_flags = shdr32->sh_flags;
 129         shdr->sh_addr = shdr32->sh_addr;
 130         shdr->sh_offset = shdr32->sh_offset;
 131         shdr->sh_size = shdr32->sh_size;
 132         shdr->sh_link = shdr32->sh_link;
 133         shdr->sh_info = shdr32->sh_info;
 134         shdr->sh_addralign = shdr32->sh_addralign;
 135         shdr->sh_entsize  = shdr32->sh_entsize;
 136         break;
 137       }
 138       break;
 139
 140     case 64:
 141       shdr = elf64_getshdr (section);
 142       if (!shdr)
 143         fatal_error ("could not read section header: %s", elf_errmsg (0));
 144       break;
 145
 146     default:
 147       gcc_unreachable ();
 148     }
 149
 150   return shdr;
 151 }
 152
 153 /* Free SHDR, previously allocated by lto_elf_get_shdr.  */
 154 static void
 155 lto_elf_free_shdr (Elf64_Shdr *shdr)
 156 {
 157   if (cached_file_attrs.bits != 64)
 158     free (shdr);
 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_obj_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 = lto_obj_create_section_hash_table ();
 173
 174   base_offset = elf_getbase (elf_file->elf);
 175   /* We are reasonably sure that elf_getbase does not fail at this
 176      point.  So assume that we run into the incompatibility with
 177      the FreeBSD libelf implementation that has a non-working
 178      elf_getbase for non-archive members in which case the offset
 179      should be zero.  */
 180   if (base_offset == (size_t)-1)
 181     base_offset = 0;
 182   for (section = elf_getscn (elf_file->elf, 0);
 183        section;
 184        section = elf_nextscn (elf_file->elf, section))
 185     {
 186       Elf64_Shdr *shdr;
 187       const char *name;
 188       size_t offset;
 189       char *new_name;
 190       void **slot;
 191       struct lto_section_slot s_slot;
 192
 193       /* Get the name of this section.  */
 194       shdr = lto_elf_get_shdr (section);
 195       offset = shdr->sh_name;
 196       name = elf_strptr (elf_file->elf,
 197                          elf_file->sec_strtab,
 198                          offset);
 199
 200       /* Only put lto stuff into the symtab.  */
 201       if (strncmp (name, LTO_SECTION_NAME_PREFIX,
 202                    strlen (LTO_SECTION_NAME_PREFIX)) != 0)
 203         {
 204           lto_elf_free_shdr (shdr);
 205           continue;
 206         }
 207
 208       new_name = XNEWVEC (char, strlen (name) + 1);
 209       strcpy (new_name, name);
 210       s_slot.name = new_name;
 211       slot = htab_find_slot (section_hash_table, &s_slot, INSERT);
 212       if (*slot == NULL)
 213         {
 214           struct lto_section_slot *new_slot = XNEW (struct lto_section_slot);
 215
 216           new_slot->name = new_name;
 217           /* The offset into the file for this section.  */
 218           new_slot->start = base_offset + shdr->sh_offset;
 219           new_slot->len = shdr->sh_size;
 220           *slot = new_slot;
 221         }
 222       else
 223         {
 224           error ("two or more sections for %s:", new_name);
 225           return NULL;
 226         }
 227
 228       lto_elf_free_shdr (shdr);
 229     }
 230
 231   return section_hash_table;
 232 }
 233
 234
 235 /* Initialize the section header of section SCN.  SH_NAME is the section name
 236    as an index into the section header string table.  SH_TYPE is the section
 237    type, an SHT_* macro from libelf headers.  */
 238
 239 #define DEFINE_INIT_SHDR(BITS)                                        \
 240 static void                                                           \
 241 init_shdr##BITS (Elf_Scn *scn, size_t sh_name, size_t sh_type)        \
 242 {                                                                     \
 243   Elf##BITS##_Shdr *shdr;                                             \
 244                                                                       \
 245   shdr = elf##BITS##_getshdr (scn);                                   \
 246   if (!shdr)                                                          \
 247     {                                                                 \
 248       if (BITS == 32)                                                 \
 249         fatal_error ("elf32_getshdr() failed: %s", elf_errmsg (-1));  \
 250       else                                                            \
 251         fatal_error ("elf64_getshdr() failed: %s", elf_errmsg (-1));  \
 252     }                                                                 \
 253                                                                       \
 254   shdr->sh_name = sh_name;                                            \
 255   shdr->sh_type = sh_type;                                            \
 256   shdr->sh_addralign = POINTER_SIZE / BITS_PER_UNIT;                  \
 257   shdr->sh_flags = 0;                                                 \
 258   shdr->sh_entsize = 0;                                               \
 259 }
 260
 261 DEFINE_INIT_SHDR (32)
 262 DEFINE_INIT_SHDR (64)
 263
 264 static bool first_data_block;
 265
 266 /* Begin a new ELF section named NAME with type TYPE in the current output
 267    file.  TYPE is an SHT_* macro from the libelf headers.  */
 268
 269 static void
 270 lto_elf_begin_section_with_type (const char *name, size_t type)
 271 {
 272   lto_elf_file *file;
 273   Elf_Scn *scn;
 274   size_t sh_name;
 275
 276   /* Grab the current output file and do some basic assertion checking.  */
 277   file = (lto_elf_file *) lto_get_current_out_file (),
 278   gcc_assert (file);
 279   gcc_assert (file->elf);
 280   gcc_assert (!file->scn);
 281
 282   /* Create a new section.  */
 283   scn = elf_newscn (file->elf);
 284   if (!scn)
 285     fatal_error ("could not create a new ELF section: %s", elf_errmsg (-1));
 286   file->scn = scn;
 287
 288   /* Add a string table entry and record the offset.  */
 289   gcc_assert (file->shstrtab_stream);
 290   sh_name = file->shstrtab_stream->total_size;
 291   lto_output_data_stream (file->shstrtab_stream, name, strlen (name) + 1);
 292
 293   /* Initialize the section header.  */
 294   switch (cached_file_attrs.bits)
 295     {
 296     case 32:
 297       init_shdr32 (scn, sh_name, type);
 298       break;
 299
 300     case 64:
 301       init_shdr64 (scn, sh_name, type);
 302       break;
 303
 304     default:
 305       gcc_unreachable ();
 306     }
 307
 308   first_data_block = true;
 309 }
 310
 311
 312 /* Begin a new ELF section named NAME in the current output file.  */
 313
 314 void
 315 lto_obj_begin_section (const char *name)
 316 {
 317   lto_elf_begin_section_with_type (name, SHT_PROGBITS);
 318 }
 319
 320
 321 /* Append DATA of length LEN to the current output section.  BASE is a pointer
 322    to the output page containing DATA.  It is freed once the output file has
 323    been written.  */
 324
 325 void
 326 lto_obj_append_data (const void *data, size_t len, void *block)
 327 {
 328   lto_elf_file *file;
 329   Elf_Data *elf_data;
 330   struct lto_char_ptr_base *base = (struct lto_char_ptr_base *) block;
 331
 332   /* Grab the current output file and do some basic assertion checking.  */
 333   file = (lto_elf_file *) lto_get_current_out_file ();
 334   gcc_assert (file);
 335   gcc_assert (file->scn);
 336
 337   elf_data = elf_newdata (file->scn);
 338   if (!elf_data)
 339     fatal_error ("could not append data to ELF section: %s", elf_errmsg (-1));
 340
 341   if (first_data_block)
 342     {
 343       elf_data->d_align = POINTER_SIZE / BITS_PER_UNIT;
 344       first_data_block = false;
 345     }
 346   else
 347     elf_data->d_align = 1;
 348   elf_data->d_buf = CONST_CAST (void *, data);
 349   elf_data->d_off = 0LL;
 350   elf_data->d_size = len;
 351   elf_data->d_type = ELF_T_BYTE;
 352   elf_data->d_version = EV_CURRENT;
 353
 354   base->ptr = (char *)file->data;
 355   file->data = base;
 356 }
 357
 358
 359 /* End the current output section.  This just does some assertion checking
 360    and sets the current output file's scn member to NULL.  */
 361
 362 void
 363 lto_obj_end_section (void)
 364 {
 365   lto_elf_file *file;
 366
 367   /* Grab the current output file and validate some basic assertions.  */
 368   file = (lto_elf_file *) lto_get_current_out_file ();
 369   gcc_assert (file);
 370   gcc_assert (file->scn);
 371
 372   file->scn = NULL;
 373 }
 374
 375
 376 /* Return true if ELF_MACHINE is compatible with the cached value of the
 377    architecture and possibly update the latter.  Return false otherwise.
 378
 379    Note: if you want to add more EM_* cases, you'll need to provide the
 380    corresponding definitions at the beginning of the file.  */
 381
 382 static bool
 383 is_compatible_architecture (Elf64_Half elf_machine)
 384 {
 385   if (cached_file_attrs.elf_machine == elf_machine)
 386     return true;
 387
 388   switch (cached_file_attrs.elf_machine)
 389     {
 390     case EM_SPARC:
 391       if (elf_machine == EM_SPARC32PLUS)
 392         {
 393           cached_file_attrs.elf_machine = elf_machine;
 394           return true;
 395         }
 396       break;
 397
 398     case EM_SPARC32PLUS:
 399       if (elf_machine == EM_SPARC)
 400         return true;
 401       break;
 402
 403     default:
 404       break;
 405     }
 406
 407   return false;
 408 }
 409
 410
 411 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
 412    uninitialized, caches the architecture.  */
 413
 414 #define DEFINE_VALIDATE_EHDR(BITS)                              \
 415 static bool                                                     \
 416 validate_ehdr##BITS (lto_elf_file *elf_file)                    \
 417 {                                                               \
 418   Elf##BITS##_Ehdr *elf_header;                                 \
 419                                                                 \
 420   elf_header = elf##BITS##_getehdr (elf_file->elf);             \
 421   if (!elf_header)                                              \
 422     {                                                           \
 423       error ("could not read ELF header: %s", elf_errmsg (0));  \
 424       return false;                                             \
 425     }                                                           \
 426                                                                 \
 427   if (elf_header->e_type != ET_REL)                             \
 428     {                                                           \
 429       error ("not a relocatable ELF object file");              \
 430       return false;                                             \
 431     }                                                           \
 432                                                                 \
 433   if (!cached_file_attrs.initialized)                           \
 434     cached_file_attrs.elf_machine = elf_header->e_machine;      \
 435   else if (!is_compatible_architecture (elf_header->e_machine)) \
 436     {                                                           \
 437       error ("inconsistent file architecture detected");        \
 438       return false;                                             \
 439     }                                                           \
 440                                                                 \
 441   return true;                                                  \
 442 }
 443
 444 DEFINE_VALIDATE_EHDR (32)
 445 DEFINE_VALIDATE_EHDR (64)
 446
 447
 448 #ifndef HAVE_ELF_GETSHDRSTRNDX
 449 /* elf_getshdrstrndx replacement for systems that lack it, but provide
 450    either the gABI conformant or Solaris 2 variant of elf_getshstrndx
 451    instead.  */
 452
 453 static int
 454 elf_getshdrstrndx (Elf *elf, size_t *dst)
 455 {
 456 #ifdef HAVE_ELF_GETSHSTRNDX_GABI
 457   return elf_getshstrndx (elf, dst);
 458 #else
 459   return elf_getshstrndx (elf, dst) ? 0 : -1;
 460 #endif
 461 }
 462 #endif
 463
 464 /* Validate's ELF_FILE's executable header and, if cached_file_attrs is
 465    uninitialized, caches the results.  Also records the section header string
 466    table's section index.  Returns true on success or false on failure.  */
 467
 468 static bool
 469 validate_file (lto_elf_file *elf_file)
 470 {
 471   const char *elf_ident;
 472
 473   /* Some aspects of the libelf API are dependent on whether the
 474      object file is a 32-bit or 64-bit file.  Determine which kind of
 475      file this is now.  */
 476   elf_ident = elf_getident (elf_file->elf, NULL);
 477   if (!elf_ident)
 478     {
 479       error ("could not read ELF identification information: %s",
 480               elf_errmsg (0));
 481       return false;
 482     }
 483
 484   if (!cached_file_attrs.initialized)
 485     {
 486       switch (elf_ident[EI_CLASS])
 487         {
 488         case ELFCLASS32:
 489           cached_file_attrs.bits = 32;
 490           break;
 491
 492         case ELFCLASS64:
 493           cached_file_attrs.bits = 64;
 494           break;
 495
 496         default:
 497           error ("unsupported ELF file class");
 498           return false;
 499         }
 500
 501       memcpy (cached_file_attrs.elf_ident, elf_ident,
 502               sizeof cached_file_attrs.elf_ident);
 503     }
 504   else
 505     {
 506       char elf_ident_buf[EI_NIDENT];
 507
 508       memcpy (elf_ident_buf, elf_ident, sizeof elf_ident_buf);
 509
 510       if (elf_ident_buf[EI_OSABI] != cached_file_attrs.elf_ident[EI_OSABI])
 511         {
 512           /* Allow mixing ELFOSABI_NONE with ELFOSABI_LINUX, with the result
 513              ELFOSABI_LINUX.  */
 514           if (elf_ident_buf[EI_OSABI] == ELFOSABI_NONE
 515               && cached_file_attrs.elf_ident[EI_OSABI] == ELFOSABI_LINUX)
 516             elf_ident_buf[EI_OSABI] = cached_file_attrs.elf_ident[EI_OSABI];
 517           else if (elf_ident_buf[EI_OSABI] == ELFOSABI_LINUX
 518                    && cached_file_attrs.elf_ident[EI_OSABI] == ELFOSABI_NONE)
 519             cached_file_attrs.elf_ident[EI_OSABI] = elf_ident_buf[EI_OSABI];
 520         }
 521
 522       if (memcmp (elf_ident_buf, cached_file_attrs.elf_ident,
 523                   sizeof cached_file_attrs.elf_ident))
 524         {
 525           error ("incompatible ELF identification");
 526           return false;
 527         }
 528     }
 529
 530   /* Check that the input file is a relocatable object file with the correct
 531      architecture.  */
 532   switch (cached_file_attrs.bits)
 533     {
 534     case 32:
 535       if (!validate_ehdr32 (elf_file))
 536         return false;
 537       break;
 538
 539     case 64:
 540       if (!validate_ehdr64 (elf_file))
 541         return false;
 542       break;
 543
 544     default:
 545       gcc_unreachable ();
 546     }
 547
 548   /* Read the string table used for section header names.  */
 549   if (elf_getshdrstrndx (elf_file->elf, &elf_file->sec_strtab) == -1)
 550     {
 551       error ("could not locate ELF string table: %s", elf_errmsg (0));
 552       return false;
 553     }
 554
 555   cached_file_attrs.initialized = true;
 556   return true;
 557 }
 558
 559
 560 /* Helper functions used by init_ehdr.  Initialize ELF_FILE's executable
 561    header using cached data from previously read files.  */
 562
 563 #define DEFINE_INIT_EHDR(BITS)                                        \
 564 static void                                                           \
 565 init_ehdr##BITS (lto_elf_file *elf_file)                              \
 566 {                                                                     \
 567   Elf##BITS##_Ehdr *ehdr;                                             \
 568                                                                       \
 569   gcc_assert (cached_file_attrs.bits);                                \
 570                                                                       \
 571   ehdr = elf##BITS##_newehdr (elf_file->elf);                         \
 572   if (!ehdr)                                                          \
 573     {                                                                 \
 574       if (BITS == 32)                                                 \
 575         fatal_error ("elf32_newehdr() failed: %s", elf_errmsg (-1));  \
 576       else                                                            \
 577         fatal_error ("elf64_newehdr() failed: %s", elf_errmsg (-1));  \
 578     }                                                                 \
 579                                                                       \
 580   memcpy (ehdr->e_ident, cached_file_attrs.elf_ident,                 \
 581           sizeof cached_file_attrs.elf_ident);                        \
 582   ehdr->e_type = ET_REL;                                              \
 583   ehdr->e_version = EV_CURRENT;                                       \
 584   ehdr->e_machine = cached_file_attrs.elf_machine;                    \
 585 }
 586
 587 DEFINE_INIT_EHDR (32)
 588 DEFINE_INIT_EHDR (64)
 589
 590
 591 /* Initialize ELF_FILE's executable header using cached data from previously
 592    read files.  */
 593
 594 static void
 595 init_ehdr (lto_elf_file *elf_file)
 596 {
 597   switch (cached_file_attrs.bits)
 598     {
 599     case 32:
 600       init_ehdr32 (elf_file);
 601       break;
 602
 603     case 64:
 604       init_ehdr64 (elf_file);
 605       break;
 606
 607     default:
 608       gcc_unreachable ();
 609     }
 610 }
 611
 612 /* Open ELF file FILENAME.  If WRITABLE is true, the file is opened for write
 613    and, if necessary, created.  Otherwise, the file is opened for reading.
 614    Returns the opened file.  */
 615
 616 lto_file *
 617 lto_obj_file_open (const char *filename, bool writable)
 618 {
 619   lto_elf_file *elf_file;
 620   lto_file *result = NULL;
 621   off_t offset;
 622   long loffset;
 623   off_t header_offset;
 624   const char *offset_p;
 625   char *fname;
 626   int consumed;
 627
 628   offset_p = strrchr (filename, '@');
 629   if (offset_p
 630       && offset_p != filename
 631       && sscanf (offset_p, "@%li%n", &loffset, &consumed) >= 1
 632       && strlen (offset_p) == (unsigned int)consumed)
 633     {
 634       fname = (char *) xmalloc (offset_p - filename + 1);
 635       memcpy (fname, filename, offset_p - filename);
 636       fname[offset_p - filename] = '\0';
 637       offset = (off_t)loffset;
 638       /* elf_rand expects the offset to point to the ar header, not the
 639          object itself. Subtract the size of the ar header (60 bytes).
 640          We don't uses sizeof (struct ar_hd) to avoid including ar.h */
 641       header_offset = offset - 60;
 642     }
 643   else
 644     {
 645       fname = xstrdup (filename);
 646       offset = 0;
 647       header_offset = 0;
 648     }
 649
 650   /* Set up.  */
 651   elf_file = XCNEW (lto_elf_file);
 652   result = (lto_file *) elf_file;
 653   lto_file_init (result, fname, offset);
 654   elf_file->fd = -1;
 655
 656   /* Open the file.  */
 657   elf_file->fd = open (fname, writable ? O_WRONLY|O_CREAT|O_BINARY
 658                                        : O_RDONLY|O_BINARY, 0666);
 659   if (elf_file->fd == -1)
 660     {
 661       error ("could not open file %s", fname);
 662       goto fail;
 663     }
 664
 665   /* Initialize the ELF library.  */
 666   if (elf_version (EV_CURRENT) == EV_NONE)
 667     {
 668       error ("ELF library is older than that used when building GCC");
 669       goto fail;
 670     }
 671
 672   /* Open the ELF file descriptor.  */
 673   elf_file->elf = elf_begin (elf_file->fd, writable ? ELF_C_WRITE : ELF_C_READ,
 674                              NULL);
 675   if (!elf_file->elf)
 676     {
 677       error ("could not open %s as an ELF file: %s", fname, elf_errmsg (0));
 678       goto fail;
 679     }
 680
 681   if (offset != 0)
 682     {
 683       Elf *e;
 684       off_t t = elf_rand (elf_file->elf, header_offset);
 685       if (t != header_offset)
 686         {
 687           error ("could not seek in archive");
 688           goto fail;
 689         }
 690
 691       e = elf_begin (elf_file->fd, ELF_C_READ, elf_file->elf);
 692       if (e == NULL)
 693         {
 694           error("could not find archive member");
 695           goto fail;
 696         }
 697       elf_end (elf_file->elf);
 698       elf_file->elf = e;
 699     }
 700
 701   if (writable)
 702     {
 703       init_ehdr (elf_file);
 704       elf_file->shstrtab_stream = XCNEW (struct lto_output_stream);
 705       /* Output an empty string to the section header table.  This becomes the
 706          name of the initial NULL section.  */
 707       lto_output_1_stream (elf_file->shstrtab_stream, '\0');
 708     }
 709   else
 710     if (!validate_file (elf_file))
 711       goto fail;
 712
 713   return result;
 714
 715  fail:
 716   if (result)
 717     lto_obj_file_close (result);
 718   return NULL;
 719 }
 720
 721
 722 /* Close ELF file FILE and clean up any associated data structures.  If FILE
 723    was opened for writing, the file's ELF data is written at this time, and
 724    any cached data buffers are freed.  */
 725
 726 void
 727 lto_obj_file_close (lto_file *file)
 728 {
 729   lto_elf_file *elf_file = (lto_elf_file *) file;
 730   struct lto_char_ptr_base *cur, *tmp;
 731
 732   /* Write the ELF section header string table.  */
 733   if (elf_file->shstrtab_stream)
 734     {
 735       size_t strtab;
 736       GElf_Ehdr *ehdr_p, ehdr_buf;
 737       lto_file *old_file = lto_set_current_out_file (file);
 738
 739       lto_elf_begin_section_with_type (".shstrtab", SHT_STRTAB);
 740       ehdr_p = gelf_getehdr (elf_file->elf, &ehdr_buf);
 741       if (ehdr_p == NULL)
 742         fatal_error ("gelf_getehdr() failed: %s", elf_errmsg (-1));
 743       strtab = elf_ndxscn (elf_file->scn);
 744       if (strtab < SHN_LORESERVE)
 745         ehdr_p->e_shstrndx = strtab;
 746       else
 747         {
 748           GElf_Shdr *shdr_p, shdr_buf;
 749           Elf_Scn *scn_p = elf_getscn (elf_file->elf, 0);
 750           if (scn_p == NULL)
 751             fatal_error ("elf_getscn() failed: %s", elf_errmsg (-1));
 752           shdr_p = gelf_getshdr (scn_p, &shdr_buf);
 753           if (shdr_p == NULL)
 754             fatal_error ("gelf_getshdr() failed: %s", elf_errmsg (-1));
 755           shdr_p->sh_link = strtab;
 756           if (gelf_update_shdr (scn_p, shdr_p) == 0)
 757             fatal_error ("gelf_update_shdr() failed: %s", elf_errmsg (-1));
 758           ehdr_p->e_shstrndx = SHN_XINDEX;
 759         }
 760       if (gelf_update_ehdr (elf_file->elf, ehdr_p) == 0)
 761         fatal_error ("gelf_update_ehdr() failed: %s", elf_errmsg (-1));
 762       lto_write_stream (elf_file->shstrtab_stream);
 763       lto_obj_end_section ();
 764
 765       lto_set_current_out_file (old_file);
 766       free (elf_file->shstrtab_stream);
 767
 768       if (elf_update (elf_file->elf, ELF_C_WRITE) < 0)
 769         fatal_error ("elf_update() failed: %s", elf_errmsg (-1));
 770     }
 771
 772   if (elf_file->elf)
 773     elf_end (elf_file->elf);
 774   if (elf_file->fd != -1)
 775     close (elf_file->fd);
 776
 777   /* Free any ELF data buffers.  */
 778   cur = elf_file->data;
 779   while (cur)
 780     {
 781       tmp = cur;
 782       cur = (struct lto_char_ptr_base *) cur->ptr;
 783       free (tmp);
 784     }
 785
 786   free (file);
 787 }
 788
 789
 790 /* The current output file.  */
 791 static lto_file *current_out_file;
 792
 793
 794 /* Sets the current output file to FILE.  Returns the old output file or
 795    NULL.  */
 796
 797 lto_file *
 798 lto_set_current_out_file (lto_file *file)
 799 {
 800   lto_file *old_file = current_out_file;
 801   current_out_file = file;
 802   return old_file;
 803 }
 804
 805
 806 /* Returns the current output file.  */
 807
 808 lto_file *
 809 lto_get_current_out_file (void)
 810 {
 811   return current_out_file;
 812 }