1 /* Functions for writing LTO sections.
3 Copyright (C) 2009 Free Software Foundation, Inc.
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
32 #include "basic-block.h"
33 #include "tree-flow.h"
34 #include "tree-pass.h"
40 #include "pointer-set.h"
42 #include "langhooks.h"
43 #include "lto-streamer.h"
44 #include "lto-compress.h"
46 static VEC(lto_out_decl_state_ptr
, heap
) *decl_state_stack
;
48 /* List of out decl states used by functions. We use this to
49 generate the decl directory later. */
51 VEC(lto_out_decl_state_ptr
, heap
) *lto_function_decl_states
;
52 /* Returns a hash code for P. */
55 lto_hash_decl_slot_node (const void *p
)
57 const struct lto_decl_slot
*ds
= (const struct lto_decl_slot
*) p
;
60 return (hashval_t) DECL_UID (ds->t);
62 return (hashval_t
) TREE_HASH (ds
->t
);
66 /* Returns nonzero if P1 and P2 are equal. */
69 lto_eq_decl_slot_node (const void *p1
, const void *p2
)
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
;
77 return DECL_UID (ds1->t) == DECL_UID (ds2->t);
79 return ds1
->t
== ds2
->t
;
83 /* Returns a hash code for P. */
86 lto_hash_type_slot_node (const void *p
)
88 const struct lto_decl_slot
*ds
= (const struct lto_decl_slot
*) p
;
89 return (hashval_t
) TYPE_UID (ds
->t
);
93 /* Returns nonzero if P1 and P2 are equal. */
96 lto_eq_type_slot_node (const void *p1
, const void *p2
)
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
;
103 return TYPE_UID (ds1
->t
) == TYPE_UID (ds2
->t
);
106 /*****************************************************************************
107 Output routines shared by all of the serialization passes.
108 *****************************************************************************/
111 /* Flush compressed stream data function, sends NUM_CHARS from CHARS
112 to the append lang hook, OPAQUE is currently always NULL. */
115 lto_append_data (const char *chars
, unsigned int num_chars
, void *opaque
)
117 gcc_assert (opaque
== NULL
);
118 lang_hooks
.lto
.append_data (chars
, num_chars
, opaque
);
121 /* Pointer to the current compression stream. */
123 static struct lto_compression_stream
*compression_stream
= NULL
;
125 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress
129 lto_begin_section (const char *name
, bool compress
)
131 lang_hooks
.lto
.begin_section (name
);
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
);
138 compression_stream
= lto_start_compression (lto_append_data
, NULL
);
142 /* End the current output section. */
145 lto_end_section (void)
147 if (compression_stream
)
149 lto_end_compression (compression_stream
);
150 compression_stream
= NULL
;
152 lang_hooks
.lto
.end_section ();
156 /* Write all of the chars in OBS to the assembler. Recycle the blocks
157 in obs as this is being done. */
160 lto_write_stream (struct lto_output_stream
*obs
)
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
)
168 for (block
= obs
->first_block
; block
; block
= next_block
)
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
);
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
;
178 num_chars
-= obs
->left_in_block
;
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
)
186 lto_compress_block (compression_stream
, base
, num_chars
);
187 lang_hooks
.lto
.append_data (NULL
, 0, block
);
190 lang_hooks
.lto
.append_data (base
, num_chars
, block
);
196 /* Adds a new block to output stream OBS. */
199 append_block (struct lto_output_stream
*obs
)
201 struct lto_char_ptr_base
*new_block
;
203 gcc_assert (obs
->left_in_block
== 0);
205 if (obs
->first_block
== NULL
)
207 /* This is the first time the stream has been written
209 obs
->block_size
= 1024;
210 new_block
= (struct lto_char_ptr_base
*) xmalloc (obs
->block_size
);
211 obs
->first_block
= new_block
;
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
;
227 /* Set the place for the next char at the first position after the
228 chain to the next block. */
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
);
238 /* Write a character to the output block. */
241 lto_output_1_stream (struct lto_output_stream
*obs
, char c
)
244 if (obs
->left_in_block
== 0)
247 /* Write the actual character. */
248 *obs
->current_pointer
= c
;
249 obs
->current_pointer
++;
251 obs
->left_in_block
--;
255 /* Write raw DATA of length LEN to the output block OB. */
258 lto_output_data_stream (struct lto_output_stream
*obs
, const void *data
,
266 if (obs
->left_in_block
== 0)
269 /* Determine how many bytes to copy in this loop. */
270 if (len
<= obs
->left_in_block
)
273 copy
= obs
->left_in_block
;
275 /* Copy the data and do bookkeeping. */
276 memcpy (obs
->current_pointer
, data
, copy
);
277 obs
->current_pointer
+= copy
;
278 obs
->total_size
+= copy
;
279 obs
->left_in_block
-= copy
;
280 data
= (const char *) data
+ copy
;
286 /* Output an unsigned LEB128 quantity to OBS. */
289 lto_output_uleb128_stream (struct lto_output_stream
*obs
,
290 unsigned HOST_WIDE_INT work
)
294 unsigned int byte
= (work
& 0x7f);
297 /* More bytes to follow. */
300 lto_output_1_stream (obs
, byte
);
305 /* Identical to output_uleb128_stream above except using unsigned
306 HOST_WIDEST_INT type. For efficiency on host where unsigned HOST_WIDEST_INT
307 is not native, we only use this if we know that HOST_WIDE_INT is not wide
311 lto_output_widest_uint_uleb128_stream (struct lto_output_stream
*obs
,
312 unsigned HOST_WIDEST_INT work
)
316 unsigned int byte
= (work
& 0x7f);
319 /* More bytes to follow. */
322 lto_output_1_stream (obs
, byte
);
328 /* Output a signed LEB128 quantity. */
331 lto_output_sleb128_stream (struct lto_output_stream
*obs
, HOST_WIDE_INT work
)
337 byte
= (work
& 0x7f);
338 /* arithmetic shift */
340 more
= !((work
== 0 && (byte
& 0x40) == 0)
341 || (work
== -1 && (byte
& 0x40) != 0));
345 lto_output_1_stream (obs
, byte
);
351 /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in
352 ENCODER for NAME with the next available index of ENCODER, then
353 print the index to OBS. True is returned if NAME was added to
354 ENCODER. The resulting index is stored in THIS_INDEX.
356 If OBS is NULL, the only action is to add NAME to the encoder. */
359 lto_output_decl_index (struct lto_output_stream
*obs
,
360 struct lto_tree_ref_encoder
*encoder
,
361 tree name
, unsigned int *this_index
)
364 struct lto_decl_slot d_slot
;
366 bool new_entry_p
= FALSE
;
369 slot
= htab_find_slot (encoder
->tree_hash_table
, &d_slot
, INSERT
);
372 struct lto_decl_slot
*new_slot
373 = (struct lto_decl_slot
*) xmalloc (sizeof (struct lto_decl_slot
));
374 index
= encoder
->next_index
++;
377 new_slot
->slot_num
= index
;
379 VEC_safe_push (tree
, heap
, encoder
->trees
, name
);
384 struct lto_decl_slot
*old_slot
= (struct lto_decl_slot
*)*slot
;
385 index
= old_slot
->slot_num
;
389 lto_output_uleb128_stream (obs
, index
);
394 /* Output a field DECL to OBS. */
397 lto_output_field_decl_index (struct lto_out_decl_state
*decl_state
,
398 struct lto_output_stream
* obs
, tree decl
)
401 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_FIELD_DECL
],
405 /* Output a function DECL to OBS. */
408 lto_output_fn_decl_index (struct lto_out_decl_state
*decl_state
,
409 struct lto_output_stream
* obs
, tree decl
)
412 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_FN_DECL
],
416 /* Output a namespace DECL to OBS. */
419 lto_output_namespace_decl_index (struct lto_out_decl_state
*decl_state
,
420 struct lto_output_stream
* obs
, tree decl
)
423 lto_output_decl_index (obs
,
424 &decl_state
->streams
[LTO_DECL_STREAM_NAMESPACE_DECL
],
428 /* Output a static or extern var DECL to OBS. */
431 lto_output_var_decl_index (struct lto_out_decl_state
*decl_state
,
432 struct lto_output_stream
* obs
, tree decl
)
435 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_VAR_DECL
],
439 /* Output a type DECL to OBS. */
442 lto_output_type_decl_index (struct lto_out_decl_state
*decl_state
,
443 struct lto_output_stream
* obs
, tree decl
)
446 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_TYPE_DECL
],
450 /* Output a type REF to OBS. */
453 lto_output_type_ref_index (struct lto_out_decl_state
*decl_state
,
454 struct lto_output_stream
*obs
, tree ref
)
457 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_TYPE
],
462 /* Create the output block and return it. */
464 struct lto_simple_output_block
*
465 lto_create_simple_output_block (enum lto_section_type section_type
)
467 struct lto_simple_output_block
*ob
468 = ((struct lto_simple_output_block
*)
469 xcalloc (1, sizeof (struct lto_simple_output_block
)));
471 ob
->section_type
= section_type
;
472 ob
->decl_state
= lto_get_out_decl_state ();
473 ob
->main_stream
= ((struct lto_output_stream
*)
474 xcalloc (1, sizeof (struct lto_output_stream
)));
480 /* Produce a simple section for one of the ipa passes. */
483 lto_destroy_simple_output_block (struct lto_simple_output_block
*ob
)
486 struct lto_simple_header header
;
487 struct lto_output_stream
*header_stream
;
489 section_name
= lto_get_section_name (ob
->section_type
, NULL
);
490 lto_begin_section (section_name
, !flag_wpa
);
493 /* Write the header which says how to decode the pieces of the
495 memset (&header
, 0, sizeof (struct lto_simple_header
));
496 header
.lto_header
.major_version
= LTO_major_version
;
497 header
.lto_header
.minor_version
= LTO_minor_version
;
498 header
.lto_header
.section_type
= LTO_section_cgraph
;
500 header
.compressed_size
= 0;
502 header
.main_size
= ob
->main_stream
->total_size
;
504 header_stream
= XCNEW (struct lto_output_stream
);
505 lto_output_data_stream (header_stream
, &header
, sizeof header
);
506 lto_write_stream (header_stream
);
507 free (header_stream
);
509 lto_write_stream (ob
->main_stream
);
511 /* Put back the assembly section that was there before we started
515 free (ob
->main_stream
);
520 /* Return a new lto_out_decl_state. */
522 struct lto_out_decl_state
*
523 lto_new_out_decl_state (void)
525 struct lto_out_decl_state
*state
= XCNEW (struct lto_out_decl_state
);
530 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
532 if (i
== LTO_DECL_STREAM_TYPE
)
534 hash_fn
= lto_hash_type_slot_node
;
535 eq_fn
= lto_eq_type_slot_node
;
539 hash_fn
= lto_hash_decl_slot_node
;
540 eq_fn
= lto_eq_decl_slot_node
;
542 lto_init_tree_ref_encoder (&state
->streams
[i
], hash_fn
, eq_fn
);
545 state
->cgraph_node_encoder
= lto_cgraph_encoder_new ();
551 /* Delete STATE and components. */
554 lto_delete_out_decl_state (struct lto_out_decl_state
*state
)
558 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
559 lto_destroy_tree_ref_encoder (&state
->streams
[i
]);
565 /* Get the currently used lto_out_decl_state structure. */
567 struct lto_out_decl_state
*
568 lto_get_out_decl_state (void)
570 return VEC_last (lto_out_decl_state_ptr
, decl_state_stack
);
573 /* Push STATE to top of out decl stack. */
576 lto_push_out_decl_state (struct lto_out_decl_state
*state
)
578 VEC_safe_push (lto_out_decl_state_ptr
, heap
, decl_state_stack
, state
);
581 /* Pop the currently used out-decl state from top of stack. */
583 struct lto_out_decl_state
*
584 lto_pop_out_decl_state (void)
586 return VEC_pop (lto_out_decl_state_ptr
, decl_state_stack
);
589 /* Record STATE after it has been used in serializing the body of
590 FN_DECL. STATE should no longer be used by the caller. The ownership
591 of it is taken over from this point. */
594 lto_record_function_out_decl_state (tree fn_decl
,
595 struct lto_out_decl_state
*state
)
599 /* Strip all hash tables to save some memory. */
600 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
601 if (state
->streams
[i
].tree_hash_table
)
603 htab_delete (state
->streams
[i
].tree_hash_table
);
604 state
->streams
[i
].tree_hash_table
= NULL
;
606 state
->fn_decl
= fn_decl
;
607 VEC_safe_push (lto_out_decl_state_ptr
, heap
, lto_function_decl_states
,