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