gcc/lto/lto-object.c

   1 /* LTO routines to use object files.
   2    Copyright 2010 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Google.
   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 "lto.h"
  26 #include "tm.h"
  27 #include "lto-streamer.h"
  28 #include "simple-object.h"
  29
  30 /* Segment name for LTO sections.  This is only used for Mach-O.
  31    FIXME: This needs to be kept in sync with darwin.c.  */
  32
  33 #define LTO_SEGMENT_NAME "__GNU_LTO"
  34
  35 /* An LTO file wrapped around an simple_object.  */
  36
  37 struct lto_simple_object
  38 {
  39   /* The base information.  */
  40   lto_file base;
  41
  42   /* The system file descriptor.  */
  43   int fd;
  44
  45   /* The simple_object if we are reading the file.  */
  46   simple_object_read *sobj_r;
  47
  48   /* The simple_object if we are writing the file.  */
  49   simple_object_write *sobj_w;
  50
  51   /* The currently active section.  */
  52   simple_object_write_section *section;
  53 };
  54
  55 /* Saved simple_object attributes.  FIXME: Once set, this is never
  56    cleared.  */
  57
  58 static simple_object_attributes *saved_attributes;
  59
  60 /* Initialize FILE, an LTO file object for FILENAME.  */
  61
  62 static void
  63 lto_file_init (lto_file *file, const char *filename, off_t offset)
  64 {
  65   file->filename = filename;
  66   file->offset = offset;
  67 }
  68
  69 /* Open the file FILENAME.  It WRITABLE is true, the file is opened
  70    for write and, if necessary, created.  Otherwise, the file is
  71    opened for reading.  Returns the opened file.  */
  72
  73 lto_file *
  74 lto_obj_file_open (const char *filename, bool writable)
  75 {
  76   const char *offset_p;
  77   long loffset;
  78   int consumed;
  79   char *fname;
  80   off_t offset;
  81   struct lto_simple_object *lo;
  82   const char *errmsg;
  83   int err;
  84
  85   offset_p = strrchr (filename, '@');
  86   if (offset_p != NULL
  87       && offset_p != filename
  88       && sscanf (offset_p, "@%li%n", &loffset, &consumed) >= 1
  89       && strlen (offset_p) == (unsigned int) consumed)
  90     {
  91       fname = XNEWVEC (char, offset_p - filename + 1);
  92       memcpy (fname, filename, offset_p - filename);
  93       fname[offset_p - filename] = '\0';
  94       offset = (off_t) loffset;
  95     }
  96   else
  97     {
  98       fname = xstrdup (filename);
  99       offset = 0;
 100     }
 101
 102   lo = XCNEW (struct lto_simple_object);
 103   lto_file_init ((lto_file *) lo, fname, offset);
 104
 105   lo->fd = open (fname,
 106                  (writable
 107                   ? O_WRONLY | O_CREAT | O_BINARY
 108                   : O_RDONLY | O_BINARY),
 109                  0666);
 110   if (lo->fd == -1)
 111     {
 112       error ("open %s failed: %s", fname, xstrerror (errno));
 113       goto fail;
 114     }
 115
 116   if (!writable)
 117     {
 118       simple_object_attributes *attrs;
 119
 120       lo->sobj_r = simple_object_start_read (lo->fd, offset, LTO_SEGMENT_NAME,
 121                                              &errmsg, &err);
 122       if (lo->sobj_r == NULL)
 123         goto fail_errmsg;
 124
 125       attrs = simple_object_fetch_attributes (lo->sobj_r, &errmsg, &err);
 126       if (attrs == NULL)
 127         goto fail_errmsg;
 128
 129       if (saved_attributes == NULL)
 130         saved_attributes = attrs;
 131       else
 132         {
 133           errmsg = simple_object_attributes_merge (saved_attributes, attrs,
 134                                                    &err);
 135           if (errmsg != NULL)
 136             goto fail_errmsg;
 137         }
 138     }
 139   else
 140     {
 141       gcc_assert (saved_attributes != NULL);
 142       lo->sobj_w = simple_object_start_write (saved_attributes,
 143                                               LTO_SEGMENT_NAME,
 144                                               &errmsg, &err);
 145       if (lo->sobj_w == NULL)
 146         goto fail_errmsg;
 147     }
 148
 149   return &lo->base;
 150
 151  fail_errmsg:
 152   if (err == 0)
 153     error ("%s: %s", fname, errmsg);
 154   else
 155     error ("%s: %s: %s", fname, errmsg, xstrerror (err));
 156
 157  fail:
 158   if (lo != NULL)
 159     lto_obj_file_close ((lto_file *) lo);
 160   return NULL;
 161 }
 162
 163 /* Close FILE.  If FILE was opened for writing, it is written out
 164    now.  */
 165
 166 void
 167 lto_obj_file_close (lto_file *file)
 168 {
 169   struct lto_simple_object *lo = (struct lto_simple_object *) file;
 170
 171   if (lo->sobj_r != NULL)
 172     simple_object_release_read (lo->sobj_r);
 173   else if (lo->sobj_w != NULL)
 174     {
 175       const char *errmsg;
 176       int err;
 177
 178       gcc_assert (lo->base.offset == 0);
 179
 180       errmsg = simple_object_write_to_file (lo->sobj_w, lo->fd, &err);
 181       if (errmsg != NULL)
 182         {
 183           if (err == 0)
 184             fatal_error ("%s", errmsg);
 185           else
 186             fatal_error ("%s: %s", errmsg, xstrerror (err));
 187         }
 188
 189       simple_object_release_write (lo->sobj_w);
 190     }
 191
 192   if (lo->fd != -1)
 193     {
 194       if (close (lo->fd) < 0)
 195         fatal_error ("close: %s", xstrerror (errno));
 196     }
 197 }
 198
 199 /* This is passed to lto_obj_add_section.  */
 200
 201 struct lto_obj_add_section_data
 202 {
 203   /* The hash table of sections.  */
 204   htab_t section_hash_table;
 205   /* The offset of this file.  */
 206   off_t base_offset;
 207 };
 208
 209 /* This is called for each section in the file.  */
 210
 211 static int
 212 lto_obj_add_section (void *data, const char *name, off_t offset,
 213                      off_t length)
 214 {
 215   struct lto_obj_add_section_data *loasd =
 216     (struct lto_obj_add_section_data *) data;
 217   htab_t section_hash_table = (htab_t) loasd->section_hash_table;
 218   char *new_name;
 219   struct lto_section_slot s_slot;
 220   void **slot;
 221
 222   if (strncmp (name, LTO_SECTION_NAME_PREFIX,
 223                strlen (LTO_SECTION_NAME_PREFIX)) != 0)
 224     return 1;
 225
 226   new_name = xstrdup (name);
 227   s_slot.name = new_name;
 228   slot = htab_find_slot (section_hash_table, &s_slot, INSERT);
 229   if (*slot == NULL)
 230     {
 231       struct lto_section_slot *new_slot = XNEW (struct lto_section_slot);
 232
 233       new_slot->name = new_name;
 234       new_slot->start = loasd->base_offset + offset;
 235       new_slot->len = length;
 236       *slot = new_slot;
 237     }
 238   else
 239     {
 240       error ("two or more sections for %s", new_name);
 241       return 0;
 242     }
 243
 244   return 1;
 245 }
 246
 247 /* Build a hash table whose key is the section name and whose data is
 248    the start and size of each section in the .o file.  */
 249
 250 htab_t
 251 lto_obj_build_section_table (lto_file *lto_file)
 252 {
 253   struct lto_simple_object *lo = (struct lto_simple_object *) lto_file;
 254   htab_t section_hash_table;
 255   struct lto_obj_add_section_data loasd;
 256   const char *errmsg;
 257   int err;
 258
 259   section_hash_table = lto_obj_create_section_hash_table ();
 260
 261   gcc_assert (lo->sobj_r != NULL && lo->sobj_w == NULL);
 262   loasd.section_hash_table = section_hash_table;
 263   loasd.base_offset = lo->base.offset;
 264   errmsg = simple_object_find_sections (lo->sobj_r, lto_obj_add_section,
 265                                         &loasd, &err);
 266   if (errmsg != NULL)
 267     {
 268       if (err == 0)
 269         error ("%s", errmsg);
 270       else
 271         error ("%s: %s", errmsg, xstrerror (err));
 272       htab_delete (section_hash_table);
 273       return NULL;
 274     }
 275
 276   return section_hash_table;
 277 }
 278
 279 /* The current output file.  */
 280
 281 static lto_file *current_out_file;
 282
 283 /* Set the current output file.  Return the old one.  */
 284
 285 lto_file *
 286 lto_set_current_out_file (lto_file *file)
 287 {
 288   lto_file *old_file;
 289
 290   old_file = current_out_file;
 291   current_out_file = file;
 292   return old_file;
 293 }
 294
 295 /* Return the current output file.  */
 296
 297 lto_file *
 298 lto_get_current_out_file (void)
 299 {
 300   return current_out_file;
 301 }
 302
 303 /* Begin writing a new section named NAME in the current output
 304    file.  */
 305
 306 void
 307 lto_obj_begin_section (const char *name)
 308 {
 309   struct lto_simple_object *lo;
 310   int align;
 311   const char *errmsg;
 312   int err;
 313
 314   lo = (struct lto_simple_object *) current_out_file;
 315   gcc_assert (lo != NULL
 316               && lo->sobj_r == NULL
 317               && lo->sobj_w != NULL
 318               && lo->section == NULL);
 319
 320   align = exact_log2 (POINTER_SIZE / BITS_PER_UNIT);
 321   lo->section = simple_object_write_create_section (lo->sobj_w, name, align,
 322                                                     &errmsg, &err);
 323   if (lo->section == NULL)
 324     {
 325       if (err == 0)
 326         fatal_error ("%s", errmsg);
 327       else
 328         fatal_error ("%s: %s", errmsg, xstrerror (errno));
 329     }
 330 }
 331
 332 /* Add data to a section.  BLOCK is a pointer to memory containing
 333    DATA.  */
 334
 335 void
 336 lto_obj_append_data (const void *data, size_t len, void *block)
 337 {
 338   struct lto_simple_object *lo;
 339   const char *errmsg;
 340   int err;
 341
 342   lo = (struct lto_simple_object *) current_out_file;
 343   gcc_assert (lo != NULL && lo->section != NULL);
 344
 345   errmsg = simple_object_write_add_data (lo->sobj_w, lo->section, data, len,
 346                                          1, &err);
 347   if (errmsg != NULL)
 348     {
 349       if (err == 0)
 350         fatal_error ("%s", errmsg);
 351       else
 352         fatal_error ("%s: %s", errmsg, xstrerror (errno));
 353     }
 354
 355   free (block);
 356 }
 357
 358 /* Stop writing to the current output section.  */
 359
 360 void
 361 lto_obj_end_section (void)
 362 {
 363   struct lto_simple_object *lo;
 364
 365   lo = (struct lto_simple_object *) current_out_file;
 366   gcc_assert (lo != NULL && lo->section != NULL);
 367   lo->section = NULL;
 368 }