1 /* Functions for writing LTO sections. 2 3 Copyright (C) 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 "params.h" 29 #include "input.h" 30 #include "hashtab.h" 31 #include "basic-block.h" 32 #include "tree-flow.h" 33 #include "tree-pass.h" 34 #include "cgraph.h" 35 #include "function.h" 36 #include "ggc.h" 37 #include "except.h" 38 #include "vec.h" 39 #include "pointer-set.h" 40 #include "bitmap.h" 41 #include "langhooks.h" 42 #include "data-streamer.h" 43 #include "lto-streamer.h" 44 #include "lto-compress.h" 45 46 static VEC(lto_out_decl_state_ptr, heap) *decl_state_stack; 47 48 /* List of out decl states used by functions. We use this to 49 generate the decl directory later. */ 50 51 VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states; 52 /* Returns a hash code for P. */ 53 54 hashval_t 55 lto_hash_decl_slot_node (const void *p) 56 { 57 const struct lto_decl_slot *ds = (const struct lto_decl_slot *) p; 58 59 /* 60 return (hashval_t) DECL_UID (ds->t); 61 */ 62 return (hashval_t) TREE_HASH (ds->t); 63 } 64 65 66 /* Returns nonzero if P1 and P2 are equal. */ 67 68 int 69 lto_eq_decl_slot_node (const void *p1, const void *p2) 70 { 71 const struct lto_decl_slot *ds1 = 72 (const struct lto_decl_slot *) p1; 73 const struct lto_decl_slot *ds2 = 74 (const struct lto_decl_slot *) p2; 75 76 /* 77 return DECL_UID (ds1->t) == DECL_UID (ds2->t); 78 */ 79 return ds1->t == ds2->t; 80 } 81 82 83 /* Returns a hash code for P. */ 84 85 hashval_t 86 lto_hash_type_slot_node (const void *p) 87 { 88 const struct lto_decl_slot *ds = (const struct lto_decl_slot *) p; 89 return (hashval_t) TYPE_UID (ds->t); 90 } 91 92 93 /* Returns nonzero if P1 and P2 are equal. */ 94 95 int 96 lto_eq_type_slot_node (const void *p1, const void *p2) 97 { 98 const struct lto_decl_slot *ds1 = 99 (const struct lto_decl_slot *) p1; 100 const struct lto_decl_slot *ds2 = 101 (const struct lto_decl_slot *) p2; 102 103 return TYPE_UID (ds1->t) == TYPE_UID (ds2->t); 104 } 105 106 /***************************************************************************** 107 Output routines shared by all of the serialization passes. 108 *****************************************************************************/ 109 110 111 /* Flush compressed stream data function, sends NUM_CHARS from CHARS 112 to the append lang hook, OPAQUE is currently always NULL. */ 113 114 static void 115 lto_append_data (const char *chars, unsigned int num_chars, void *opaque) 116 { 117 gcc_assert (opaque == NULL); 118 lang_hooks.lto.append_data (chars, num_chars, opaque); 119 } 120 121 /* Pointer to the current compression stream. */ 122 123 static struct lto_compression_stream *compression_stream = NULL; 124 125 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress 126 the section. */ 127 128 void 129 lto_begin_section (const char *name, bool compress) 130 { 131 lang_hooks.lto.begin_section (name); 132 133 /* FIXME lto: for now, suppress compression if the lang_hook that appends 134 data is anything other than assembler output. The effect here is that 135 we get compression of IL only in non-ltrans object files. */ 136 gcc_assert (compression_stream == NULL); 137 if (compress) 138 compression_stream = lto_start_compression (lto_append_data, NULL); 139 } 140 141 142 /* End the current output section. */ 143 144 void 145 lto_end_section (void) 146 { 147 if (compression_stream) 148 { 149 lto_end_compression (compression_stream); 150 compression_stream = NULL; 151 } 152 lang_hooks.lto.end_section (); 153 } 154 155 156 /* Write all of the chars in OBS to the assembler. Recycle the blocks 157 in obs as this is being done. */ 158 159 void 160 lto_write_stream (struct lto_output_stream *obs) 161 { 162 unsigned int block_size = 1024; 163 struct lto_char_ptr_base *block; 164 struct lto_char_ptr_base *next_block; 165 if (!obs->first_block) 166 return; 167 168 for (block = obs->first_block; block; block = next_block) 169 { 170 const char *base = ((char *)block) + sizeof (struct lto_char_ptr_base); 171 unsigned int num_chars = block_size - sizeof (struct lto_char_ptr_base); 172 173 /* If this is not the last block, it is full. If it is the last 174 block, left_in_block indicates how many chars are unoccupied in 175 this block; subtract from num_chars to obtain occupancy. */ 176 next_block = (struct lto_char_ptr_base *) block->ptr; 177 if (!next_block) 178 num_chars -= obs->left_in_block; 179 180 /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append 181 output data. This hook is not happy with the way that compression 182 blocks up output differently to the way it's blocked here. So for 183 now, we don't compress WPA output. */ 184 if (compression_stream) 185 { 186 lto_compress_block (compression_stream, base, num_chars); 187 lang_hooks.lto.append_data (NULL, 0, block); 188 } 189 else 190 lang_hooks.lto.append_data (base, num_chars, block); 191 block_size *= 2; 192 } 193 } 194 195 196 /* Adds a new block to output stream OBS. */ 197 198 void 199 lto_append_block (struct lto_output_stream *obs) 200 { 201 struct lto_char_ptr_base *new_block; 202 203 gcc_assert (obs->left_in_block == 0); 204 205 if (obs->first_block == NULL) 206 { 207 /* This is the first time the stream has been written 208 into. */ 209 obs->block_size = 1024; 210 new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size); 211 obs->first_block = new_block; 212 } 213 else 214 { 215 struct lto_char_ptr_base *tptr; 216 /* Get a new block that is twice as big as the last block 217 and link it into the list. */ 218 obs->block_size *= 2; 219 new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size); 220 /* The first bytes of the block are reserved as a pointer to 221 the next block. Set the chain of the full block to the 222 pointer to the new block. */ 223 tptr = obs->current_block; 224 tptr->ptr = (char *) new_block; 225 } 226 227 /* Set the place for the next char at the first position after the 228 chain to the next block. */ 229 obs->current_pointer 230 = ((char *) new_block) + sizeof (struct lto_char_ptr_base); 231 obs->current_block = new_block; 232 /* Null out the newly allocated block's pointer to the next block. */ 233 new_block->ptr = NULL; 234 obs->left_in_block = obs->block_size - sizeof (struct lto_char_ptr_base); 235 } 236 237 238 /* Write raw DATA of length LEN to the output block OB. */ 239 240 void 241 lto_output_data_stream (struct lto_output_stream *obs, const void *data, 242 size_t len) 243 { 244 while (len) 245 { 246 size_t copy; 247 248 /* No space left. */ 249 if (obs->left_in_block == 0) 250 lto_append_block (obs); 251 252 /* Determine how many bytes to copy in this loop. */ 253 if (len <= obs->left_in_block) 254 copy = len; 255 else 256 copy = obs->left_in_block; 257 258 /* Copy the data and do bookkeeping. */ 259 memcpy (obs->current_pointer, data, copy); 260 obs->current_pointer += copy; 261 obs->total_size += copy; 262 obs->left_in_block -= copy; 263 data = (const char *) data + copy; 264 len -= copy; 265 } 266 } 267 268 269 /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in 270 ENCODER for NAME with the next available index of ENCODER, then 271 print the index to OBS. True is returned if NAME was added to 272 ENCODER. The resulting index is stored in THIS_INDEX. 273 274 If OBS is NULL, the only action is to add NAME to the encoder. */ 275 276 bool 277 lto_output_decl_index (struct lto_output_stream *obs, 278 struct lto_tree_ref_encoder *encoder, 279 tree name, unsigned int *this_index) 280 { 281 void **slot; 282 struct lto_decl_slot d_slot; 283 int index; 284 bool new_entry_p = FALSE; 285 286 d_slot.t = name; 287 slot = htab_find_slot (encoder->tree_hash_table, &d_slot, INSERT); 288 if (*slot == NULL) 289 { 290 struct lto_decl_slot *new_slot 291 = (struct lto_decl_slot *) xmalloc (sizeof (struct lto_decl_slot)); 292 index = encoder->next_index++; 293 294 new_slot->t = name; 295 new_slot->slot_num = index; 296 *slot = new_slot; 297 VEC_safe_push (tree, heap, encoder->trees, name); 298 new_entry_p = TRUE; 299 } 300 else 301 { 302 struct lto_decl_slot *old_slot = (struct lto_decl_slot *)*slot; 303 index = old_slot->slot_num; 304 } 305 306 if (obs) 307 streamer_write_uhwi_stream (obs, index); 308 *this_index = index; 309 return new_entry_p; 310 } 311 312 /* Output a field DECL to OBS. */ 313 314 void 315 lto_output_field_decl_index (struct lto_out_decl_state *decl_state, 316 struct lto_output_stream * obs, tree decl) 317 { 318 unsigned int index; 319 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL], 320 decl, &index); 321 } 322 323 /* Output a function DECL to OBS. */ 324 325 void 326 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state, 327 struct lto_output_stream * obs, tree decl) 328 { 329 unsigned int index; 330 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL], 331 decl, &index); 332 } 333 334 /* Output a namespace DECL to OBS. */ 335 336 void 337 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state, 338 struct lto_output_stream * obs, tree decl) 339 { 340 unsigned int index; 341 lto_output_decl_index (obs, 342 &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL], 343 decl, &index); 344 } 345 346 /* Output a static or extern var DECL to OBS. */ 347 348 void 349 lto_output_var_decl_index (struct lto_out_decl_state *decl_state, 350 struct lto_output_stream * obs, tree decl) 351 { 352 unsigned int index; 353 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL], 354 decl, &index); 355 } 356 357 /* Output a type DECL to OBS. */ 358 359 void 360 lto_output_type_decl_index (struct lto_out_decl_state *decl_state, 361 struct lto_output_stream * obs, tree decl) 362 { 363 unsigned int index; 364 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL], 365 decl, &index); 366 } 367 368 /* Output a type REF to OBS. */ 369 370 void 371 lto_output_type_ref_index (struct lto_out_decl_state *decl_state, 372 struct lto_output_stream *obs, tree ref) 373 { 374 unsigned int index; 375 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE], 376 ref, &index); 377 } 378 379 380 /* Create the output block and return it. */ 381 382 struct lto_simple_output_block * 383 lto_create_simple_output_block (enum lto_section_type section_type) 384 { 385 struct lto_simple_output_block *ob 386 = ((struct lto_simple_output_block *) 387 xcalloc (1, sizeof (struct lto_simple_output_block))); 388 389 ob->section_type = section_type; 390 ob->decl_state = lto_get_out_decl_state (); 391 ob->main_stream = ((struct lto_output_stream *) 392 xcalloc (1, sizeof (struct lto_output_stream))); 393 394 return ob; 395 } 396 397 398 /* Produce a simple section for one of the ipa passes. */ 399 400 void 401 lto_destroy_simple_output_block (struct lto_simple_output_block *ob) 402 { 403 char *section_name; 404 struct lto_simple_header header; 405 struct lto_output_stream *header_stream; 406 407 section_name = lto_get_section_name (ob->section_type, NULL, NULL); 408 lto_begin_section (section_name, !flag_wpa); 409 free (section_name); 410 411 /* Write the header which says how to decode the pieces of the 412 t. */ 413 memset (&header, 0, sizeof (struct lto_simple_header)); 414 header.lto_header.major_version = LTO_major_version; 415 header.lto_header.minor_version = LTO_minor_version; 416 header.lto_header.section_type = LTO_section_cgraph; 417 418 header.compressed_size = 0; 419 420 header.main_size = ob->main_stream->total_size; 421 422 header_stream = XCNEW (struct lto_output_stream); 423 lto_output_data_stream (header_stream, &header, sizeof header); 424 lto_write_stream (header_stream); 425 free (header_stream); 426 427 lto_write_stream (ob->main_stream); 428 429 /* Put back the assembly section that was there before we started 430 writing lto info. */ 431 lto_end_section (); 432 433 free (ob->main_stream); 434 free (ob); 435 } 436 437 438 /* Return a new lto_out_decl_state. */ 439 440 struct lto_out_decl_state * 441 lto_new_out_decl_state (void) 442 { 443 struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state); 444 int i; 445 htab_hash hash_fn; 446 htab_eq eq_fn; 447 448 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 449 { 450 if (i == LTO_DECL_STREAM_TYPE) 451 { 452 hash_fn = lto_hash_type_slot_node; 453 eq_fn = lto_eq_type_slot_node; 454 } 455 else 456 { 457 hash_fn = lto_hash_decl_slot_node; 458 eq_fn = lto_eq_decl_slot_node; 459 } 460 lto_init_tree_ref_encoder (&state->streams[i], hash_fn, eq_fn); 461 } 462 463 return state; 464 } 465 466 467 /* Delete STATE and components. */ 468 469 void 470 lto_delete_out_decl_state (struct lto_out_decl_state *state) 471 { 472 int i; 473 474 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 475 lto_destroy_tree_ref_encoder (&state->streams[i]); 476 477 free (state); 478 } 479 480 481 /* Get the currently used lto_out_decl_state structure. */ 482 483 struct lto_out_decl_state * 484 lto_get_out_decl_state (void) 485 { 486 return VEC_last (lto_out_decl_state_ptr, decl_state_stack); 487 } 488 489 /* Push STATE to top of out decl stack. */ 490 491 void 492 lto_push_out_decl_state (struct lto_out_decl_state *state) 493 { 494 VEC_safe_push (lto_out_decl_state_ptr, heap, decl_state_stack, state); 495 } 496 497 /* Pop the currently used out-decl state from top of stack. */ 498 499 struct lto_out_decl_state * 500 lto_pop_out_decl_state (void) 501 { 502 return VEC_pop (lto_out_decl_state_ptr, decl_state_stack); 503 } 504 505 /* Record STATE after it has been used in serializing the body of 506 FN_DECL. STATE should no longer be used by the caller. The ownership 507 of it is taken over from this point. */ 508 509 void 510 lto_record_function_out_decl_state (tree fn_decl, 511 struct lto_out_decl_state *state) 512 { 513 int i; 514 515 /* Strip all hash tables to save some memory. */ 516 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 517 if (state->streams[i].tree_hash_table) 518 { 519 htab_delete (state->streams[i].tree_hash_table); 520 state->streams[i].tree_hash_table = NULL; 521 } 522 state->fn_decl = fn_decl; 523 VEC_safe_push (lto_out_decl_state_ptr, heap, lto_function_decl_states, 524 state); 525 } 526