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