comparison gcc/lto-section-out.c @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
comparison
equal deleted inserted replaced
15:561a7518be6b 16:04ced10e8804
1 /* Functions for writing LTO sections. 1 /* Functions for writing LTO sections.
2 2
3 Copyright (C) 2009, 2010 Free Software Foundation, Inc. 3 Copyright (C) 2009-2017 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com> 4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5 5
6 This file is part of GCC. 6 This file is part of GCC.
7 7
8 GCC is free software; you can redistribute it and/or modify it under 8 GCC is free software; you can redistribute it and/or modify it under
20 <http://www.gnu.org/licenses/>. */ 20 <http://www.gnu.org/licenses/>. */
21 21
22 #include "config.h" 22 #include "config.h"
23 #include "system.h" 23 #include "system.h"
24 #include "coretypes.h" 24 #include "coretypes.h"
25 #include "tm.h" 25 #include "backend.h"
26 #include "rtl.h"
26 #include "tree.h" 27 #include "tree.h"
27 #include "expr.h" 28 #include "gimple.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" 29 #include "cgraph.h"
35 #include "function.h" 30 #include "data-streamer.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" 31 #include "langhooks.h"
42 #include "lto-streamer.h"
43 #include "lto-compress.h" 32 #include "lto-compress.h"
44 33
45 static VEC(lto_out_decl_state_ptr, heap) *decl_state_stack; 34 static vec<lto_out_decl_state_ptr> decl_state_stack;
46 35
47 /* List of out decl states used by functions. We use this to 36 /* List of out decl states used by functions. We use this to
48 generate the decl directory later. */ 37 generate the decl directory later. */
49 38
50 VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states; 39 vec<lto_out_decl_state_ptr> lto_function_decl_states;
51 /* Returns a hash code for P. */ 40
52
53 hashval_t
54 lto_hash_decl_slot_node (const void *p)
55 {
56 const struct lto_decl_slot *ds = (const struct lto_decl_slot *) p;
57
58 /*
59 return (hashval_t) DECL_UID (ds->t);
60 */
61 return (hashval_t) TREE_HASH (ds->t);
62 }
63
64
65 /* Returns nonzero if P1 and P2 are equal. */
66
67 int
68 lto_eq_decl_slot_node (const void *p1, const void *p2)
69 {
70 const struct lto_decl_slot *ds1 =
71 (const struct lto_decl_slot *) p1;
72 const struct lto_decl_slot *ds2 =
73 (const struct lto_decl_slot *) p2;
74
75 /*
76 return DECL_UID (ds1->t) == DECL_UID (ds2->t);
77 */
78 return ds1->t == ds2->t;
79 }
80
81
82 /* Returns a hash code for P. */
83
84 hashval_t
85 lto_hash_type_slot_node (const void *p)
86 {
87 const struct lto_decl_slot *ds = (const struct lto_decl_slot *) p;
88 return (hashval_t) TYPE_UID (ds->t);
89 }
90
91
92 /* Returns nonzero if P1 and P2 are equal. */
93
94 int
95 lto_eq_type_slot_node (const void *p1, const void *p2)
96 {
97 const struct lto_decl_slot *ds1 =
98 (const struct lto_decl_slot *) p1;
99 const struct lto_decl_slot *ds2 =
100 (const struct lto_decl_slot *) p2;
101
102 return TYPE_UID (ds1->t) == TYPE_UID (ds2->t);
103 }
104 41
105 /***************************************************************************** 42 /*****************************************************************************
106 Output routines shared by all of the serialization passes. 43 Output routines shared by all of the serialization passes.
107 *****************************************************************************/ 44 *****************************************************************************/
108 45
127 void 64 void
128 lto_begin_section (const char *name, bool compress) 65 lto_begin_section (const char *name, bool compress)
129 { 66 {
130 lang_hooks.lto.begin_section (name); 67 lang_hooks.lto.begin_section (name);
131 68
132 /* FIXME lto: for now, suppress compression if the lang_hook that appends
133 data is anything other than assembler output. The effect here is that
134 we get compression of IL only in non-ltrans object files. */
135 gcc_assert (compression_stream == NULL); 69 gcc_assert (compression_stream == NULL);
136 if (compress) 70 if (compress)
137 compression_stream = lto_start_compression (lto_append_data, NULL); 71 compression_stream = lto_start_compression (lto_append_data, NULL);
138 } 72 }
139 73
149 compression_stream = NULL; 83 compression_stream = NULL;
150 } 84 }
151 lang_hooks.lto.end_section (); 85 lang_hooks.lto.end_section ();
152 } 86 }
153 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 }
154 106
155 /* Write all of the chars in OBS to the assembler. Recycle the blocks 107 /* Write all of the chars in OBS to the assembler. Recycle the blocks
156 in obs as this is being done. */ 108 in obs as this is being done. */
157 109
158 void 110 void
174 this block; subtract from num_chars to obtain occupancy. */ 126 this block; subtract from num_chars to obtain occupancy. */
175 next_block = (struct lto_char_ptr_base *) block->ptr; 127 next_block = (struct lto_char_ptr_base *) block->ptr;
176 if (!next_block) 128 if (!next_block)
177 num_chars -= obs->left_in_block; 129 num_chars -= obs->left_in_block;
178 130
179 /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append
180 output data. This hook is not happy with the way that compression
181 blocks up output differently to the way it's blocked here. So for
182 now, we don't compress WPA output. */
183 if (compression_stream) 131 if (compression_stream)
184 { 132 lto_compress_block (compression_stream, base, num_chars);
185 lto_compress_block (compression_stream, base, num_chars);
186 lang_hooks.lto.append_data (NULL, 0, block);
187 }
188 else 133 else
189 lang_hooks.lto.append_data (base, num_chars, block); 134 lang_hooks.lto.append_data (base, num_chars, block);
135 free (block);
190 block_size *= 2; 136 block_size *= 2;
191 } 137 }
192 }
193
194
195 /* Adds a new block to output stream OBS. */
196
197 static void
198 append_block (struct lto_output_stream *obs)
199 {
200 struct lto_char_ptr_base *new_block;
201
202 gcc_assert (obs->left_in_block == 0);
203
204 if (obs->first_block == NULL)
205 {
206 /* This is the first time the stream has been written
207 into. */
208 obs->block_size = 1024;
209 new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
210 obs->first_block = new_block;
211 }
212 else
213 {
214 struct lto_char_ptr_base *tptr;
215 /* Get a new block that is twice as big as the last block
216 and link it into the list. */
217 obs->block_size *= 2;
218 new_block = (struct lto_char_ptr_base*) xmalloc (obs->block_size);
219 /* The first bytes of the block are reserved as a pointer to
220 the next block. Set the chain of the full block to the
221 pointer to the new block. */
222 tptr = obs->current_block;
223 tptr->ptr = (char *) new_block;
224 }
225
226 /* Set the place for the next char at the first position after the
227 chain to the next block. */
228 obs->current_pointer
229 = ((char *) new_block) + sizeof (struct lto_char_ptr_base);
230 obs->current_block = new_block;
231 /* Null out the newly allocated block's pointer to the next block. */
232 new_block->ptr = NULL;
233 obs->left_in_block = obs->block_size - sizeof (struct lto_char_ptr_base);
234 }
235
236
237 /* Write a character to the output block. */
238
239 void
240 lto_output_1_stream (struct lto_output_stream *obs, char c)
241 {
242 /* No space left. */
243 if (obs->left_in_block == 0)
244 append_block (obs);
245
246 /* Write the actual character. */
247 *obs->current_pointer = c;
248 obs->current_pointer++;
249 obs->total_size++;
250 obs->left_in_block--;
251 }
252
253
254 /* Write raw DATA of length LEN to the output block OB. */
255
256 void
257 lto_output_data_stream (struct lto_output_stream *obs, const void *data,
258 size_t len)
259 {
260 while (len)
261 {
262 size_t copy;
263
264 /* No space left. */
265 if (obs->left_in_block == 0)
266 append_block (obs);
267
268 /* Determine how many bytes to copy in this loop. */
269 if (len <= obs->left_in_block)
270 copy = len;
271 else
272 copy = obs->left_in_block;
273
274 /* Copy the data and do bookkeeping. */
275 memcpy (obs->current_pointer, data, copy);
276 obs->current_pointer += copy;
277 obs->total_size += copy;
278 obs->left_in_block -= copy;
279 data = (const char *) data + copy;
280 len -= copy;
281 }
282 }
283
284
285 /* Output an unsigned LEB128 quantity to OBS. */
286
287 void
288 lto_output_uleb128_stream (struct lto_output_stream *obs,
289 unsigned HOST_WIDE_INT work)
290 {
291 do
292 {
293 unsigned int byte = (work & 0x7f);
294 work >>= 7;
295 if (work != 0)
296 /* More bytes to follow. */
297 byte |= 0x80;
298
299 lto_output_1_stream (obs, byte);
300 }
301 while (work != 0);
302 }
303
304 /* Identical to output_uleb128_stream above except using unsigned
305 HOST_WIDEST_INT type. For efficiency on host where unsigned HOST_WIDEST_INT
306 is not native, we only use this if we know that HOST_WIDE_INT is not wide
307 enough. */
308
309 void
310 lto_output_widest_uint_uleb128_stream (struct lto_output_stream *obs,
311 unsigned HOST_WIDEST_INT work)
312 {
313 do
314 {
315 unsigned int byte = (work & 0x7f);
316 work >>= 7;
317 if (work != 0)
318 /* More bytes to follow. */
319 byte |= 0x80;
320
321 lto_output_1_stream (obs, byte);
322 }
323 while (work != 0);
324 }
325
326
327 /* Output a signed LEB128 quantity. */
328
329 void
330 lto_output_sleb128_stream (struct lto_output_stream *obs, HOST_WIDE_INT work)
331 {
332 int more, byte;
333
334 do
335 {
336 byte = (work & 0x7f);
337 /* arithmetic shift */
338 work >>= 7;
339 more = !((work == 0 && (byte & 0x40) == 0)
340 || (work == -1 && (byte & 0x40) != 0));
341 if (more)
342 byte |= 0x80;
343
344 lto_output_1_stream (obs, byte);
345 }
346 while (more);
347 } 138 }
348 139
349 140
350 /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in 141 /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in
351 ENCODER for NAME with the next available index of ENCODER, then 142 ENCODER for NAME with the next available index of ENCODER, then
357 bool 148 bool
358 lto_output_decl_index (struct lto_output_stream *obs, 149 lto_output_decl_index (struct lto_output_stream *obs,
359 struct lto_tree_ref_encoder *encoder, 150 struct lto_tree_ref_encoder *encoder,
360 tree name, unsigned int *this_index) 151 tree name, unsigned int *this_index)
361 { 152 {
362 void **slot;
363 struct lto_decl_slot d_slot;
364 int index;
365 bool new_entry_p = FALSE; 153 bool new_entry_p = FALSE;
366 154 bool existed_p;
367 d_slot.t = name; 155
368 slot = htab_find_slot (encoder->tree_hash_table, &d_slot, INSERT); 156 unsigned int &index
369 if (*slot == NULL) 157 = encoder->tree_hash_table->get_or_insert (name, &existed_p);
158 if (!existed_p)
370 { 159 {
371 struct lto_decl_slot *new_slot 160 index = encoder->trees.length ();
372 = (struct lto_decl_slot *) xmalloc (sizeof (struct lto_decl_slot)); 161 encoder->trees.safe_push (name);
373 index = encoder->next_index++;
374
375 new_slot->t = name;
376 new_slot->slot_num = index;
377 *slot = new_slot;
378 VEC_safe_push (tree, heap, encoder->trees, name);
379 new_entry_p = TRUE; 162 new_entry_p = TRUE;
380 } 163 }
381 else
382 {
383 struct lto_decl_slot *old_slot = (struct lto_decl_slot *)*slot;
384 index = old_slot->slot_num;
385 }
386 164
387 if (obs) 165 if (obs)
388 lto_output_uleb128_stream (obs, index); 166 streamer_write_uhwi_stream (obs, index);
389 *this_index = index; 167 *this_index = index;
390 return new_entry_p; 168 return new_entry_p;
391 } 169 }
392 170
393 /* Output a field DECL to OBS. */ 171 /* Output a field DECL to OBS. */
481 void 259 void
482 lto_destroy_simple_output_block (struct lto_simple_output_block *ob) 260 lto_destroy_simple_output_block (struct lto_simple_output_block *ob)
483 { 261 {
484 char *section_name; 262 char *section_name;
485 struct lto_simple_header header; 263 struct lto_simple_header header;
486 struct lto_output_stream *header_stream;
487 264
488 section_name = lto_get_section_name (ob->section_type, NULL, NULL); 265 section_name = lto_get_section_name (ob->section_type, NULL, NULL);
489 lto_begin_section (section_name, !flag_wpa); 266 lto_begin_section (section_name, !flag_wpa);
490 free (section_name); 267 free (section_name);
491 268
492 /* Write the header which says how to decode the pieces of the 269 /* Write the header which says how to decode the pieces of the
493 t. */ 270 t. */
494 memset (&header, 0, sizeof (struct lto_simple_header)); 271 memset (&header, 0, sizeof (struct lto_simple_header));
495 header.lto_header.major_version = LTO_major_version; 272 header.major_version = LTO_major_version;
496 header.lto_header.minor_version = LTO_minor_version; 273 header.minor_version = LTO_minor_version;
497 header.lto_header.section_type = LTO_section_cgraph;
498
499 header.compressed_size = 0;
500
501 header.main_size = ob->main_stream->total_size; 274 header.main_size = ob->main_stream->total_size;
502 275 lto_write_data (&header, sizeof header);
503 header_stream = XCNEW (struct lto_output_stream);
504 lto_output_data_stream (header_stream, &header, sizeof header);
505 lto_write_stream (header_stream);
506 free (header_stream);
507 276
508 lto_write_stream (ob->main_stream); 277 lto_write_stream (ob->main_stream);
509 278
510 /* Put back the assembly section that was there before we started 279 /* Put back the assembly section that was there before we started
511 writing lto info. */ 280 writing lto info. */
521 struct lto_out_decl_state * 290 struct lto_out_decl_state *
522 lto_new_out_decl_state (void) 291 lto_new_out_decl_state (void)
523 { 292 {
524 struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state); 293 struct lto_out_decl_state *state = XCNEW (struct lto_out_decl_state);
525 int i; 294 int i;
526 htab_hash hash_fn;
527 htab_eq eq_fn;
528 295
529 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 296 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
530 { 297 lto_init_tree_ref_encoder (&state->streams[i]);
531 if (i == LTO_DECL_STREAM_TYPE) 298
532 { 299 /* At WPA time we do not compress sections by default. */
533 hash_fn = lto_hash_type_slot_node; 300 state->compressed = !flag_wpa;
534 eq_fn = lto_eq_type_slot_node;
535 }
536 else
537 {
538 hash_fn = lto_hash_decl_slot_node;
539 eq_fn = lto_eq_decl_slot_node;
540 }
541 lto_init_tree_ref_encoder (&state->streams[i], hash_fn, eq_fn);
542 }
543 301
544 return state; 302 return state;
545 } 303 }
546 304
547 305
562 /* Get the currently used lto_out_decl_state structure. */ 320 /* Get the currently used lto_out_decl_state structure. */
563 321
564 struct lto_out_decl_state * 322 struct lto_out_decl_state *
565 lto_get_out_decl_state (void) 323 lto_get_out_decl_state (void)
566 { 324 {
567 return VEC_last (lto_out_decl_state_ptr, decl_state_stack); 325 return decl_state_stack.last ();
568 } 326 }
569 327
570 /* Push STATE to top of out decl stack. */ 328 /* Push STATE to top of out decl stack. */
571 329
572 void 330 void
573 lto_push_out_decl_state (struct lto_out_decl_state *state) 331 lto_push_out_decl_state (struct lto_out_decl_state *state)
574 { 332 {
575 VEC_safe_push (lto_out_decl_state_ptr, heap, decl_state_stack, state); 333 decl_state_stack.safe_push (state);
576 } 334 }
577 335
578 /* Pop the currently used out-decl state from top of stack. */ 336 /* Pop the currently used out-decl state from top of stack. */
579 337
580 struct lto_out_decl_state * 338 struct lto_out_decl_state *
581 lto_pop_out_decl_state (void) 339 lto_pop_out_decl_state (void)
582 { 340 {
583 return VEC_pop (lto_out_decl_state_ptr, decl_state_stack); 341 return decl_state_stack.pop ();
584 } 342 }
585 343
586 /* Record STATE after it has been used in serializing the body of 344 /* Record STATE after it has been used in serializing the body of
587 FN_DECL. STATE should no longer be used by the caller. The ownership 345 FN_DECL. STATE should no longer be used by the caller. The ownership
588 of it is taken over from this point. */ 346 of it is taken over from this point. */
595 353
596 /* Strip all hash tables to save some memory. */ 354 /* Strip all hash tables to save some memory. */
597 for (i = 0; i < LTO_N_DECL_STREAMS; i++) 355 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
598 if (state->streams[i].tree_hash_table) 356 if (state->streams[i].tree_hash_table)
599 { 357 {
600 htab_delete (state->streams[i].tree_hash_table); 358 delete state->streams[i].tree_hash_table;
601 state->streams[i].tree_hash_table = NULL; 359 state->streams[i].tree_hash_table = NULL;
602 } 360 }
603 state->fn_decl = fn_decl; 361 state->fn_decl = fn_decl;
604 VEC_safe_push (lto_out_decl_state_ptr, heap, lto_function_decl_states, 362 lto_function_decl_states.safe_push (state);
605 state); 363 }
606 }