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