1 /* Functions for writing 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 "except.h" 63 #include "langhooks.h" 64 #include "hash-map.h" 65 #include "plugin-api.h" 66 #include "ipa-ref.h" 67 #include "cgraph.h" 68 #include "data-streamer.h" 69 #include "lto-streamer.h" 70 #include "lto-compress.h" 71 72 static vec<lto_out_decl_state_ptr> decl_state_stack; 73 74 /* List of out decl states used by functions. We use this to 75 generate the decl directory later. */ 76 77 vec<lto_out_decl_state_ptr> lto_function_decl_states; 78 79 80 /***************************************************************************** 81 Output routines shared by all of the serialization passes. 82 *****************************************************************************/ 83 84 85 /* Flush compressed stream data function, sends NUM_CHARS from CHARS 86 to the append lang hook, OPAQUE is currently always NULL. */ 87 88 static void 89 lto_append_data (const char *chars, unsigned int num_chars, void *opaque) 90 { 91 gcc_assert (opaque == NULL); 92 lang_hooks.lto.append_data (chars, num_chars, opaque); 93 } 94 95 /* Pointer to the current compression stream. */ 96 97 static struct lto_compression_stream *compression_stream = NULL; 98 99 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress 100 the section. */ 101 102 void 103 lto_begin_section (const char *name, bool compress) 104 { 105 lang_hooks.lto.begin_section (name); 106 107 /* FIXME lto: for now, suppress compression if the lang_hook that appends 108 data is anything other than assembler output. The effect here is that 109 we get compression of IL only in non-ltrans object files. */ 110 gcc_assert (compression_stream == NULL); 111 if (compress) 112 compression_stream = lto_start_compression (lto_append_data, NULL); 113 } 114 115 116 /* End the current output section. */ 117 118 void 119 lto_end_section (void) 120 { 121 if (compression_stream) 122 { 123 lto_end_compression (compression_stream); 124 compression_stream = NULL; 125 } 126 lang_hooks.lto.end_section (); 127 } 128 129 /* Write SIZE bytes starting at DATA to the assembler. */ 130 131 void 132 lto_write_data (const void *data, unsigned int size) 133 { 134 if (compression_stream) 135 lto_compress_block (compression_stream, (const char *)data, size); 136 else 137 lang_hooks.lto.append_data ((const char *)data, size, NULL); 138 } 139 140 /* Write all of the chars in OBS to the assembler. Recycle the blocks 141 in obs as this is being done. */ 142 143 void 144 lto_write_stream (struct lto_output_stream *obs) 145 { 146 unsigned int block_size = 1024; 147 struct lto_char_ptr_base *block; 148 struct lto_char_ptr_base *next_block; 149 if (!obs->first_block) 150 return; 151 152 for (block = obs->first_block; block; block = next_block) 153 { 154 const char *base = ((char *)block) + sizeof (struct lto_char_ptr_base); 155 unsigned int num_chars = block_size - sizeof (struct lto_char_ptr_base); 156 157 /* If this is not the last block, it is full. If it is the last 158 block, left_in_block indicates how many chars are unoccupied in 159 this block; subtract from num_chars to obtain occupancy. */ 160 next_block = (struct lto_char_ptr_base *) block->ptr; 161 if (!next_block) 162 num_chars -= obs->left_in_block; 163 164 /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append 165 output data. This hook is not happy with the way that compression 166 blocks up output differently to the way it's blocked here. So for 167 now, we don't compress WPA output. */ 168 if (compression_stream) 169 lto_compress_block (compression_stream, base, num_chars); 170 else 171 lang_hooks.lto.append_data (base, num_chars, block); 172 free (block); 173 block_size *= 2; 174 } 175 } 176 177 178 /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in 179 ENCODER for NAME with the next available index of ENCODER, then 180 print the index to OBS. True is returned if NAME was added to 181 ENCODER. The resulting index is stored in THIS_INDEX. 182 183 If OBS is NULL, the only action is to add NAME to the encoder. */ 184 185 bool 186 lto_output_decl_index (struct lto_output_stream *obs, 187 struct lto_tree_ref_encoder *encoder, 188 tree name, unsigned int *this_index) 189 { 190 bool new_entry_p = FALSE; 191 bool existed_p; 192 193 unsigned int &index 194 = encoder->tree_hash_table->get_or_insert (name, &existed_p); 195 if (!existed_p) 196 { 197 index = encoder->trees.length (); 198 encoder->trees.safe_push (name); 199 new_entry_p = TRUE; 200 } 201 202 if (obs) 203 streamer_write_uhwi_stream (obs, index); 204 *this_index = index; 205 return new_entry_p; 206 } 207 208 /* Output a field DECL to OBS. */ 209 210 void 211 lto_output_field_decl_index (struct lto_out_decl_state *decl_state, 212 struct lto_output_stream * obs, tree decl) 213 { 214 unsigned int index; 215 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FIELD_DECL], 216 decl, &index); 217 } 218 219 /* Output a function DECL to OBS. */ 220 221 void 222 lto_output_fn_decl_index (struct lto_out_decl_state *decl_state, 223 struct lto_output_stream * obs, tree decl) 224 { 225 unsigned int index; 226 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_FN_DECL], 227 decl, &index); 228 } 229 230 /* Output a namespace DECL to OBS. */ 231 232 void 233 lto_output_namespace_decl_index (struct lto_out_decl_state *decl_state, 234 struct lto_output_stream * obs, tree decl) 235 { 236 unsigned int index; 237 lto_output_decl_index (obs, 238 &decl_state->streams[LTO_DECL_STREAM_NAMESPACE_DECL], 239 decl, &index); 240 } 241 242 /* Output a static or extern var DECL to OBS. */ 243 244 void 245 lto_output_var_decl_index (struct lto_out_decl_state *decl_state, 246 struct lto_output_stream * obs, tree decl) 247 { 248 unsigned int index; 249 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_VAR_DECL], 250 decl, &index); 251 } 252 253 /* Output a type DECL to OBS. */ 254 255 void 256 lto_output_type_decl_index (struct lto_out_decl_state *decl_state, 257 struct lto_output_stream * obs, tree decl) 258 { 259 unsigned int index; 260 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE_DECL], 261 decl, &index); 262 } 263 264 /* Output a type REF to OBS. */ 265 266 void 267 lto_output_type_ref_index (struct lto_out_decl_state *decl_state, 268 struct lto_output_stream *obs, tree ref) 269 { 270 unsigned int index; 271 lto_output_decl_index (obs, &decl_state->streams[LTO_DECL_STREAM_TYPE], 272 ref, &index); 273 } 274 275 276 /* Create the output block and return it. */ 277 278 struct lto_simple_output_block * 279 lto_create_simple_output_block (enum lto_section_type section_type) 280 { 281 struct lto_simple_output_block *ob 282 = ((struct lto_simple_output_block *) 283 xcalloc (1, sizeof (struct lto_simple_output_block))); 284 285 ob->section_type = section_type; 286 ob->decl_state = lto_get_out_decl_state (); 287 ob->main_stream = ((struct lto_output_stream *) 288 xcalloc (1, sizeof (struct lto_output_stream))); 289 290 return ob; 291 } 292 293 294 /* Produce a simple section for one of the ipa passes. */ 295 296 void 297 lto_destroy_simple_output_block (struct lto_simple_output_block *ob) 298 { 299 char *section_name; 300 struct lto_simple_header header; 301 302 section_name = lto_get_section_name (ob->section_type, NULL, NULL); 303 lto_begin_section (section_name, !flag_wpa); 304 free (section_name); 305 306 /* Write the header which says how to decode the pieces of the 307 t. */ 308 memset (&header, 0, sizeof (struct lto_simple_header)); 309 header.major_version = LTO_major_version; 310 header.minor_version = LTO_minor_version; 311 header.main_size = ob->main_stream->total_size; 312 lto_write_data (&header, sizeof header); 313 314 lto_write_stream (ob->main_stream); 315 316 /* Put back the assembly section that was there before we started 317 writing lto info. */ 318 lto_end_section (); 319 320 free (ob->main_stream); 321 free (ob); 322 } 323 324 325 /* Return a new lto_out_decl_state. */ 326 327 struct lto_out_decl_state * 328 lto_new_out_decl_state (void) 329 { 330 struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state); 331 int i; 332 333 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 334 lto_init_tree_ref_encoder (&state->streams[i]); 335 336 return state; 337 } 338 339 340 /* Delete STATE and components. */ 341 342 void 343 lto_delete_out_decl_state (struct lto_out_decl_state *state) 344 { 345 int i; 346 347 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 348 lto_destroy_tree_ref_encoder (&state->streams[i]); 349 350 free (state); 351 } 352 353 354 /* Get the currently used lto_out_decl_state structure. */ 355 356 struct lto_out_decl_state * 357 lto_get_out_decl_state (void) 358 { 359 return decl_state_stack.last (); 360 } 361 362 /* Push STATE to top of out decl stack. */ 363 364 void 365 lto_push_out_decl_state (struct lto_out_decl_state *state) 366 { 367 decl_state_stack.safe_push (state); 368 } 369 370 /* Pop the currently used out-decl state from top of stack. */ 371 372 struct lto_out_decl_state * 373 lto_pop_out_decl_state (void) 374 { 375 return decl_state_stack.pop (); 376 } 377 378 /* Record STATE after it has been used in serializing the body of 379 FN_DECL. STATE should no longer be used by the caller. The ownership 380 of it is taken over from this point. */ 381 382 void 383 lto_record_function_out_decl_state (tree fn_decl, 384 struct lto_out_decl_state *state) 385 { 386 int i; 387 388 /* Strip all hash tables to save some memory. */ 389 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 390 if (state->streams[i].tree_hash_table) 391 { 392 delete state->streams[i].tree_hash_table; 393 state->streams[i].tree_hash_table = NULL; 394 } 395 state->fn_decl = fn_decl; 396 lto_function_decl_states.safe_push (state); 397 } 398