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