1 /* Input functions for reading LTO sections. 2 3 Copyright (C) 2009-2018 Free Software Foundation, Inc. 4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "backend.h" 26 #include "rtl.h" 27 #include "tree.h" 28 #include "gimple.h" 29 #include "cgraph.h" 30 #include "lto-streamer.h" 31 #include "lto-compress.h" 32 33 /* Section names. These must correspond to the values of 34 enum lto_section_type. */ 35 const char *lto_section_name[LTO_N_SECTION_TYPES] = 36 { 37 "decls", 38 "function_body", 39 "statics", 40 "symtab", 41 "refs", 42 "asm", 43 "jmpfuncs", 44 "pureconst", 45 "reference", 46 "profile", 47 "symbol_nodes", 48 "opts", 49 "cgraphopt", 50 "inline", 51 "ipcp_trans", 52 "icf", 53 "offload_table", 54 "mode_table", 55 "hsa" 56 }; 57 58 59 /* Hooks so that the ipa passes can call into the lto front end to get 60 sections. */ 61 62 static struct lto_file_decl_data ** file_decl_data; 63 static lto_get_section_data_f* get_section_f; 64 static lto_free_section_data_f* free_section_f; 65 66 67 /* This is called from the lto front end to set up the hooks that are 68 used by the ipa passes to get the data that they will 69 deserialize. */ 70 71 void 72 lto_set_in_hooks (struct lto_file_decl_data ** data, 73 lto_get_section_data_f* get_f, 74 lto_free_section_data_f* free_f) 75 { 76 file_decl_data = data; 77 get_section_f = get_f; 78 free_section_f = free_f; 79 } 80 81 82 /* Return an array of file decl datas for all of the files passed to 83 this compilation. */ 84 85 struct lto_file_decl_data ** 86 lto_get_file_decl_data (void) 87 { 88 gcc_assert (file_decl_data); 89 return file_decl_data; 90 } 91 92 /* Buffer structure for accumulating data from compression callbacks. */ 93 94 struct lto_buffer 95 { 96 char *data; 97 size_t length; 98 }; 99 100 /* Compression callback, append LENGTH bytes from DATA to the buffer pointed 101 to by OPAQUE. */ 102 103 static void 104 lto_append_data (const char *data, unsigned length, void *opaque) 105 { 106 struct lto_buffer *buffer = (struct lto_buffer *) opaque; 107 108 buffer->data = (char *) xrealloc (buffer->data, buffer->length + length); 109 memcpy (buffer->data + buffer->length, data, length); 110 buffer->length += length; 111 } 112 113 /* Header placed in returned uncompressed data streams. Allows the 114 uncompressed allocated data to be mapped back to the underlying 115 compressed data for use with free_section_f. */ 116 117 struct lto_data_header 118 { 119 const char *data; 120 size_t len; 121 }; 122 123 /* Return a char pointer to the start of a data stream for an LTO pass 124 or function. FILE_DATA indicates where to obtain the data. 125 SECTION_TYPE is the type of information to be obtained. NAME is 126 the name of the function and is only used when finding a function 127 body; otherwise it is NULL. LEN is the size of the data 128 returned. */ 129 130 const char * 131 lto_get_section_data (struct lto_file_decl_data *file_data, 132 enum lto_section_type section_type, 133 const char *name, 134 size_t *len, bool decompress) 135 { 136 const char *data = (get_section_f) (file_data, section_type, name, len); 137 const size_t header_length = sizeof (struct lto_data_header); 138 struct lto_data_header *header; 139 struct lto_buffer buffer; 140 struct lto_compression_stream *stream; 141 lto_stats.section_size[section_type] += *len; 142 143 if (data == NULL) 144 return NULL; 145 146 /* WPA->ltrans streams are not compressed with exception of function bodies 147 and variable initializers that has been verbatim copied from earlier 148 compilations. */ 149 if (!flag_ltrans || decompress) 150 { 151 /* Create a mapping header containing the underlying data and length, 152 and prepend this to the uncompression buffer. The uncompressed data 153 then follows, and a pointer to the start of the uncompressed data is 154 returned. */ 155 header = (struct lto_data_header *) xmalloc (header_length); 156 header->data = data; 157 header->len = *len; 158 159 buffer.data = (char *) header; 160 buffer.length = header_length; 161 162 stream = lto_start_uncompression (lto_append_data, &buffer); 163 lto_uncompress_block (stream, data, *len); 164 lto_end_uncompression (stream); 165 166 *len = buffer.length - header_length; 167 data = buffer.data + header_length; 168 } 169 170 lto_check_version (((const lto_header *)data)->major_version, 171 ((const lto_header *)data)->minor_version, 172 file_data->file_name); 173 return data; 174 } 175 176 /* Get the section data without any header parsing or uncompression. */ 177 178 const char * 179 lto_get_raw_section_data (struct lto_file_decl_data *file_data, 180 enum lto_section_type section_type, 181 const char *name, 182 size_t *len) 183 { 184 return (get_section_f) (file_data, section_type, name, len); 185 } 186 187 /* Free the data found from the above call. The first three 188 parameters are the same as above. DATA is the data to be freed and 189 LEN is the length of that data. */ 190 191 void 192 lto_free_section_data (struct lto_file_decl_data *file_data, 193 enum lto_section_type section_type, 194 const char *name, 195 const char *data, 196 size_t len, bool decompress) 197 { 198 const size_t header_length = sizeof (struct lto_data_header); 199 const char *real_data = data - header_length; 200 const struct lto_data_header *header 201 = (const struct lto_data_header *) real_data; 202 203 gcc_assert (free_section_f); 204 205 if (flag_ltrans && !decompress) 206 { 207 (free_section_f) (file_data, section_type, name, data, len); 208 return; 209 } 210 211 /* The underlying data address has been extracted from the mapping header. 212 Free that, then free the allocated uncompression buffer. */ 213 (free_section_f) (file_data, section_type, name, header->data, header->len); 214 free (CONST_CAST (char *, real_data)); 215 } 216 217 /* Free data allocated by lto_get_raw_section_data. */ 218 219 void 220 lto_free_raw_section_data (struct lto_file_decl_data *file_data, 221 enum lto_section_type section_type, 222 const char *name, 223 const char *data, 224 size_t len) 225 { 226 (free_section_f) (file_data, section_type, name, data, len); 227 } 228 229 /* Load a section of type SECTION_TYPE from FILE_DATA, parse the 230 header and then return an input block pointing to the section. The 231 raw pointer to the section is returned in DATAR and LEN. These are 232 used to free the section. Return NULL if the section is not present. */ 233 234 struct lto_input_block * 235 lto_create_simple_input_block (struct lto_file_decl_data *file_data, 236 enum lto_section_type section_type, 237 const char **datar, size_t *len) 238 { 239 const char *data = lto_get_section_data (file_data, section_type, NULL, len); 240 const struct lto_simple_header * header 241 = (const struct lto_simple_header *) data; 242 243 int main_offset = sizeof (struct lto_simple_header); 244 245 if (!data) 246 return NULL; 247 248 *datar = data; 249 return new lto_input_block (data + main_offset, header->main_size, 250 file_data->mode_table); 251 } 252 253 254 /* Close the section returned from a call to 255 LTO_CREATE_SIMPLE_INPUT_BLOCK. IB is the input block returned from 256 that call. The FILE_DATA and SECTION_TYPE are the same as what was 257 passed to that call and the DATA and LEN are what was returned from 258 that call. */ 259 260 void 261 lto_destroy_simple_input_block (struct lto_file_decl_data *file_data, 262 enum lto_section_type section_type, 263 struct lto_input_block *ib, 264 const char *data, size_t len) 265 { 266 delete ib; 267 lto_free_section_data (file_data, section_type, NULL, data, len); 268 } 269 270 /*****************************************************************************/ 271 /* Record renamings of static declarations */ 272 /*****************************************************************************/ 273 274 struct lto_renaming_slot 275 { 276 const char *old_name; 277 const char *new_name; 278 }; 279 280 /* Returns a hash code for P. */ 281 282 static hashval_t 283 hash_name (const void *p) 284 { 285 const struct lto_renaming_slot *ds = (const struct lto_renaming_slot *) p; 286 return (hashval_t) htab_hash_string (ds->new_name); 287 } 288 289 /* Returns nonzero if P1 and P2 are equal. */ 290 291 static int 292 eq_name (const void *p1, const void *p2) 293 { 294 const struct lto_renaming_slot *s1 = 295 (const struct lto_renaming_slot *) p1; 296 const struct lto_renaming_slot *s2 = 297 (const struct lto_renaming_slot *) p2; 298 299 return strcmp (s1->new_name, s2->new_name) == 0; 300 } 301 302 /* Free a renaming table entry. */ 303 304 static void 305 renaming_slot_free (void *slot) 306 { 307 struct lto_renaming_slot *s = (struct lto_renaming_slot *) slot; 308 309 free (CONST_CAST (void *, (const void *) s->old_name)); 310 free (CONST_CAST (void *, (const void *) s->new_name)); 311 free ((void *) s); 312 } 313 314 /* Create an empty hash table for recording declaration renamings. */ 315 316 htab_t 317 lto_create_renaming_table (void) 318 { 319 return htab_create (37, hash_name, eq_name, renaming_slot_free); 320 } 321 322 /* Record a declaration name mapping OLD_NAME -> NEW_NAME. DECL_DATA 323 holds the renaming hash table to use. */ 324 325 void 326 lto_record_renamed_decl (struct lto_file_decl_data *decl_data, 327 const char *old_name, const char *new_name) 328 { 329 void **slot; 330 struct lto_renaming_slot r_slot; 331 332 r_slot.new_name = new_name; 333 slot = htab_find_slot (decl_data->renaming_hash_table, &r_slot, INSERT); 334 if (*slot == NULL) 335 { 336 struct lto_renaming_slot *new_slot = XNEW (struct lto_renaming_slot); 337 new_slot->old_name = xstrdup (old_name); 338 new_slot->new_name = xstrdup (new_name); 339 *slot = new_slot; 340 } 341 else 342 gcc_unreachable (); 343 } 344 345 346 /* Given a string NAME, return the string that it has been mapped to 347 by lto_record_renamed_decl. If NAME was not renamed, it is 348 returned unchanged. DECL_DATA holds the renaming hash table to use. */ 349 350 const char * 351 lto_get_decl_name_mapping (struct lto_file_decl_data *decl_data, 352 const char *name) 353 { 354 htab_t renaming_hash_table = decl_data->renaming_hash_table; 355 struct lto_renaming_slot *slot; 356 struct lto_renaming_slot r_slot; 357 358 r_slot.new_name = name; 359 slot = (struct lto_renaming_slot *) htab_find (renaming_hash_table, &r_slot); 360 if (slot) 361 return slot->old_name; 362 else 363 return name; 364 } 365 366 /*****************************************************************************/ 367 /* Input decl state object. */ 368 /*****************************************************************************/ 369 370 /* Return a newly created in-decl state object. */ 371 372 struct lto_in_decl_state * 373 lto_new_in_decl_state (void) 374 { 375 return ggc_cleared_alloc<lto_in_decl_state> (); 376 } 377 378 /* Delete STATE and its components. */ 379 380 void 381 lto_delete_in_decl_state (struct lto_in_decl_state *state) 382 { 383 int i; 384 385 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 386 vec_free (state->streams[i]); 387 ggc_free (state); 388 } 389 390 /* Search the in-decl state of a function FUNC contained in the file 391 associated with FILE_DATA. Return NULL if not found. */ 392 393 struct lto_in_decl_state* 394 lto_get_function_in_decl_state (struct lto_file_decl_data *file_data, 395 tree func) 396 { 397 struct lto_in_decl_state temp; 398 lto_in_decl_state **slot; 399 400 temp.fn_decl = func; 401 slot = file_data->function_decl_states->find_slot (&temp, NO_INSERT); 402 return slot? *slot : NULL; 403 } 404 405 /* Free decl_states. */ 406 407 void 408 lto_free_function_in_decl_state (struct lto_in_decl_state *state) 409 { 410 int i; 411 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 412 vec_free (state->streams[i]); 413 ggc_free (state); 414 } 415 416 /* Free decl_states associated with NODE. This makes it possible to furhter 417 release trees needed by the NODE's body. */ 418 419 void 420 lto_free_function_in_decl_state_for_node (symtab_node *node) 421 { 422 struct lto_in_decl_state temp; 423 lto_in_decl_state **slot; 424 425 if (!node->lto_file_data) 426 return; 427 428 temp.fn_decl = node->decl; 429 slot 430 = node->lto_file_data->function_decl_states->find_slot (&temp, NO_INSERT); 431 if (slot && *slot) 432 { 433 lto_free_function_in_decl_state (*slot); 434 node->lto_file_data->function_decl_states->clear_slot (slot); 435 } 436 node->lto_file_data = NULL; 437 } 438 439 440 /* Report read pass end of the section. */ 441 442 void 443 lto_section_overrun (struct lto_input_block *ib) 444 { 445 fatal_error (input_location, "bytecode stream: trying to read %d bytes " 446 "after the end of the input buffer", ib->p - ib->len); 447 } 448 449 /* Report out of range value. */ 450 451 void 452 lto_value_range_error (const char *purpose, HOST_WIDE_INT val, 453 HOST_WIDE_INT min, HOST_WIDE_INT max) 454 { 455 fatal_error (input_location, 456 "%s out of range: Range is %i to %i, value is %i", 457 purpose, (int)min, (int)max, (int)val); 458 } 459