1 /* LTO routines to use object files. 2 Copyright (C) 2010-2013 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 { 137 free (attrs); 138 goto fail_errmsg; 139 } 140 } 141 } 142 else 143 { 144 gcc_assert (saved_attributes != NULL); 145 lo->sobj_w = simple_object_start_write (saved_attributes, 146 LTO_SEGMENT_NAME, 147 &errmsg, &err); 148 if (lo->sobj_w == NULL) 149 goto fail_errmsg; 150 } 151 152 return &lo->base; 153 154 fail_errmsg: 155 if (err == 0) 156 error ("%s: %s", fname, errmsg); 157 else 158 error ("%s: %s: %s", fname, errmsg, xstrerror (err)); 159 160 fail: 161 if (lo->fd != -1) 162 lto_obj_file_close ((lto_file *) lo); 163 free (lo); 164 return NULL; 165 } 166 167 168 /* Close FILE. If FILE was opened for writing, it is written out 169 now. */ 170 171 void 172 lto_obj_file_close (lto_file *file) 173 { 174 struct lto_simple_object *lo = (struct lto_simple_object *) file; 175 176 if (lo->sobj_r != NULL) 177 simple_object_release_read (lo->sobj_r); 178 else if (lo->sobj_w != NULL) 179 { 180 const char *errmsg; 181 int err; 182 183 gcc_assert (lo->base.offset == 0); 184 185 errmsg = simple_object_write_to_file (lo->sobj_w, lo->fd, &err); 186 if (errmsg != NULL) 187 { 188 if (err == 0) 189 fatal_error ("%s", errmsg); 190 else 191 fatal_error ("%s: %s", errmsg, xstrerror (err)); 192 } 193 194 simple_object_release_write (lo->sobj_w); 195 } 196 197 if (lo->fd != -1) 198 { 199 if (close (lo->fd) < 0) 200 fatal_error ("close: %s", xstrerror (errno)); 201 } 202 } 203 204 /* This is passed to lto_obj_add_section. */ 205 206 struct lto_obj_add_section_data 207 { 208 /* The hash table of sections. */ 209 htab_t section_hash_table; 210 /* The offset of this file. */ 211 off_t base_offset; 212 /* List in linker order */ 213 struct lto_section_list *list; 214 }; 215 216 /* This is called for each section in the file. */ 217 218 static int 219 lto_obj_add_section (void *data, const char *name, off_t offset, 220 off_t length) 221 { 222 struct lto_obj_add_section_data *loasd = 223 (struct lto_obj_add_section_data *) data; 224 htab_t section_hash_table = (htab_t) loasd->section_hash_table; 225 char *new_name; 226 struct lto_section_slot s_slot; 227 void **slot; 228 struct lto_section_list *list = loasd->list; 229 230 if (strncmp (name, LTO_SECTION_NAME_PREFIX, 231 strlen (LTO_SECTION_NAME_PREFIX)) != 0) 232 return 1; 233 234 new_name = xstrdup (name); 235 s_slot.name = new_name; 236 slot = htab_find_slot (section_hash_table, &s_slot, INSERT); 237 if (*slot == NULL) 238 { 239 struct lto_section_slot *new_slot = XCNEW (struct lto_section_slot); 240 241 new_slot->name = new_name; 242 new_slot->start = loasd->base_offset + offset; 243 new_slot->len = length; 244 *slot = new_slot; 245 246 if (list != NULL) 247 { 248 if (!list->first) 249 list->first = new_slot; 250 if (list->last) 251 list->last->next = new_slot; 252 list->last = new_slot; 253 } 254 } 255 else 256 { 257 error ("two or more sections for %s", new_name); 258 return 0; 259 } 260 261 return 1; 262 } 263 264 /* Build a hash table whose key is the section name and whose data is 265 the start and size of each section in the .o file. */ 266 267 htab_t 268 lto_obj_build_section_table (lto_file *lto_file, struct lto_section_list *list) 269 { 270 struct lto_simple_object *lo = (struct lto_simple_object *) lto_file; 271 htab_t section_hash_table; 272 struct lto_obj_add_section_data loasd; 273 const char *errmsg; 274 int err; 275 276 section_hash_table = lto_obj_create_section_hash_table (); 277 278 gcc_assert (lo->sobj_r != NULL && lo->sobj_w == NULL); 279 loasd.section_hash_table = section_hash_table; 280 loasd.base_offset = lo->base.offset; 281 loasd.list = list; 282 errmsg = simple_object_find_sections (lo->sobj_r, lto_obj_add_section, 283 &loasd, &err); 284 if (errmsg != NULL) 285 { 286 if (err == 0) 287 error ("%s", errmsg); 288 else 289 error ("%s: %s", errmsg, xstrerror (err)); 290 htab_delete (section_hash_table); 291 return NULL; 292 } 293 294 return section_hash_table; 295 } 296 297 /* The current output file. */ 298 299 static lto_file *current_out_file; 300 301 /* Set the current output file. Return the old one. */ 302 303 lto_file * 304 lto_set_current_out_file (lto_file *file) 305 { 306 lto_file *old_file; 307 308 old_file = current_out_file; 309 current_out_file = file; 310 return old_file; 311 } 312 313 /* Return the current output file. */ 314 315 lto_file * 316 lto_get_current_out_file (void) 317 { 318 return current_out_file; 319 } 320 321 /* Begin writing a new section named NAME in the current output 322 file. */ 323 324 void 325 lto_obj_begin_section (const char *name) 326 { 327 struct lto_simple_object *lo; 328 int align; 329 const char *errmsg; 330 int err; 331 332 lo = (struct lto_simple_object *) current_out_file; 333 gcc_assert (lo != NULL 334 && lo->sobj_r == NULL 335 && lo->sobj_w != NULL 336 && lo->section == NULL); 337 338 align = exact_log2 (POINTER_SIZE / BITS_PER_UNIT); 339 lo->section = simple_object_write_create_section (lo->sobj_w, name, align, 340 &errmsg, &err); 341 if (lo->section == NULL) 342 { 343 if (err == 0) 344 fatal_error ("%s", errmsg); 345 else 346 fatal_error ("%s: %s", errmsg, xstrerror (errno)); 347 } 348 } 349 350 /* Add data to a section. BLOCK is a pointer to memory containing 351 DATA. */ 352 353 void 354 lto_obj_append_data (const void *data, size_t len, void *block) 355 { 356 struct lto_simple_object *lo; 357 const char *errmsg; 358 int err; 359 360 lo = (struct lto_simple_object *) current_out_file; 361 gcc_assert (lo != NULL && lo->section != NULL); 362 363 errmsg = simple_object_write_add_data (lo->sobj_w, lo->section, data, len, 364 1, &err); 365 if (errmsg != NULL) 366 { 367 if (err == 0) 368 fatal_error ("%s", errmsg); 369 else 370 fatal_error ("%s: %s", errmsg, xstrerror (errno)); 371 } 372 373 free (block); 374 } 375 376 /* Stop writing to the current output section. */ 377 378 void 379 lto_obj_end_section (void) 380 { 381 struct lto_simple_object *lo; 382 383 lo = (struct lto_simple_object *) current_out_file; 384 gcc_assert (lo != NULL && lo->section != NULL); 385 lo->section = NULL; 386 } 387