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