1 /* Functions for writing LTO sections.
3 Copyright (C) 2009-2014 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"
27 #include "basic-block.h"
28 #include "tree-ssa-alias.h"
29 #include "internal-fn.h"
30 #include "gimple-expr.h"
39 #include "langhooks.h"
40 #include "data-streamer.h"
41 #include "lto-streamer.h"
42 #include "lto-compress.h"
44 static vec
<lto_out_decl_state_ptr
> decl_state_stack
;
46 /* List of out decl states used by functions. We use this to
47 generate the decl directory later. */
49 vec
<lto_out_decl_state_ptr
> lto_function_decl_states
;
52 /*****************************************************************************
53 Output routines shared by all of the serialization passes.
54 *****************************************************************************/
57 /* Flush compressed stream data function, sends NUM_CHARS from CHARS
58 to the append lang hook, OPAQUE is currently always NULL. */
61 lto_append_data (const char *chars
, unsigned int num_chars
, void *opaque
)
63 gcc_assert (opaque
== NULL
);
64 lang_hooks
.lto
.append_data (chars
, num_chars
, opaque
);
67 /* Pointer to the current compression stream. */
69 static struct lto_compression_stream
*compression_stream
= NULL
;
71 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress
75 lto_begin_section (const char *name
, bool compress
)
77 lang_hooks
.lto
.begin_section (name
);
79 /* FIXME lto: for now, suppress compression if the lang_hook that appends
80 data is anything other than assembler output. The effect here is that
81 we get compression of IL only in non-ltrans object files. */
82 gcc_assert (compression_stream
== NULL
);
84 compression_stream
= lto_start_compression (lto_append_data
, NULL
);
88 /* End the current output section. */
91 lto_end_section (void)
93 if (compression_stream
)
95 lto_end_compression (compression_stream
);
96 compression_stream
= NULL
;
98 lang_hooks
.lto
.end_section ();
101 /* Write SIZE bytes starting at DATA to the assembler. */
104 lto_write_data (const void *data
, unsigned int size
)
106 if (compression_stream
)
107 lto_compress_block (compression_stream
, (const char *)data
, size
);
109 lang_hooks
.lto
.append_data ((const char *)data
, size
, NULL
);
112 /* Write all of the chars in OBS to the assembler. Recycle the blocks
113 in obs as this is being done. */
116 lto_write_stream (struct lto_output_stream
*obs
)
118 unsigned int block_size
= 1024;
119 struct lto_char_ptr_base
*block
;
120 struct lto_char_ptr_base
*next_block
;
121 if (!obs
->first_block
)
124 for (block
= obs
->first_block
; block
; block
= next_block
)
126 const char *base
= ((char *)block
) + sizeof (struct lto_char_ptr_base
);
127 unsigned int num_chars
= block_size
- sizeof (struct lto_char_ptr_base
);
129 /* If this is not the last block, it is full. If it is the last
130 block, left_in_block indicates how many chars are unoccupied in
131 this block; subtract from num_chars to obtain occupancy. */
132 next_block
= (struct lto_char_ptr_base
*) block
->ptr
;
134 num_chars
-= obs
->left_in_block
;
136 /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append
137 output data. This hook is not happy with the way that compression
138 blocks up output differently to the way it's blocked here. So for
139 now, we don't compress WPA output. */
140 if (compression_stream
)
141 lto_compress_block (compression_stream
, base
, num_chars
);
143 lang_hooks
.lto
.append_data (base
, num_chars
, block
);
150 /* Adds a new block to output stream OBS. */
153 lto_append_block (struct lto_output_stream
*obs
)
155 struct lto_char_ptr_base
*new_block
;
157 gcc_assert (obs
->left_in_block
== 0);
159 if (obs
->first_block
== NULL
)
161 /* This is the first time the stream has been written
163 obs
->block_size
= 1024;
164 new_block
= (struct lto_char_ptr_base
*) xmalloc (obs
->block_size
);
165 obs
->first_block
= new_block
;
169 struct lto_char_ptr_base
*tptr
;
170 /* Get a new block that is twice as big as the last block
171 and link it into the list. */
172 obs
->block_size
*= 2;
173 new_block
= (struct lto_char_ptr_base
*) xmalloc (obs
->block_size
);
174 /* The first bytes of the block are reserved as a pointer to
175 the next block. Set the chain of the full block to the
176 pointer to the new block. */
177 tptr
= obs
->current_block
;
178 tptr
->ptr
= (char *) new_block
;
181 /* Set the place for the next char at the first position after the
182 chain to the next block. */
184 = ((char *) new_block
) + sizeof (struct lto_char_ptr_base
);
185 obs
->current_block
= new_block
;
186 /* Null out the newly allocated block's pointer to the next block. */
187 new_block
->ptr
= NULL
;
188 obs
->left_in_block
= obs
->block_size
- sizeof (struct lto_char_ptr_base
);
192 /* Write raw DATA of length LEN to the output block OB. */
195 lto_output_data_stream (struct lto_output_stream
*obs
, const void *data
,
203 if (obs
->left_in_block
== 0)
204 lto_append_block (obs
);
206 /* Determine how many bytes to copy in this loop. */
207 if (len
<= obs
->left_in_block
)
210 copy
= obs
->left_in_block
;
212 /* Copy the data and do bookkeeping. */
213 memcpy (obs
->current_pointer
, data
, copy
);
214 obs
->current_pointer
+= copy
;
215 obs
->total_size
+= copy
;
216 obs
->left_in_block
-= copy
;
217 data
= (const char *) data
+ copy
;
223 /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in
224 ENCODER for NAME with the next available index of ENCODER, then
225 print the index to OBS. True is returned if NAME was added to
226 ENCODER. The resulting index is stored in THIS_INDEX.
228 If OBS is NULL, the only action is to add NAME to the encoder. */
231 lto_output_decl_index (struct lto_output_stream
*obs
,
232 struct lto_tree_ref_encoder
*encoder
,
233 tree name
, unsigned int *this_index
)
235 bool new_entry_p
= FALSE
;
239 = encoder
->tree_hash_table
->get_or_insert (name
, &existed_p
);
242 index
= encoder
->trees
.length ();
243 encoder
->trees
.safe_push (name
);
248 streamer_write_uhwi_stream (obs
, index
);
253 /* Output a field DECL to OBS. */
256 lto_output_field_decl_index (struct lto_out_decl_state
*decl_state
,
257 struct lto_output_stream
* obs
, tree decl
)
260 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_FIELD_DECL
],
264 /* Output a function DECL to OBS. */
267 lto_output_fn_decl_index (struct lto_out_decl_state
*decl_state
,
268 struct lto_output_stream
* obs
, tree decl
)
271 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_FN_DECL
],
275 /* Output a namespace DECL to OBS. */
278 lto_output_namespace_decl_index (struct lto_out_decl_state
*decl_state
,
279 struct lto_output_stream
* obs
, tree decl
)
282 lto_output_decl_index (obs
,
283 &decl_state
->streams
[LTO_DECL_STREAM_NAMESPACE_DECL
],
287 /* Output a static or extern var DECL to OBS. */
290 lto_output_var_decl_index (struct lto_out_decl_state
*decl_state
,
291 struct lto_output_stream
* obs
, tree decl
)
294 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_VAR_DECL
],
298 /* Output a type DECL to OBS. */
301 lto_output_type_decl_index (struct lto_out_decl_state
*decl_state
,
302 struct lto_output_stream
* obs
, tree decl
)
305 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_TYPE_DECL
],
309 /* Output a type REF to OBS. */
312 lto_output_type_ref_index (struct lto_out_decl_state
*decl_state
,
313 struct lto_output_stream
*obs
, tree ref
)
316 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_TYPE
],
321 /* Create the output block and return it. */
323 struct lto_simple_output_block
*
324 lto_create_simple_output_block (enum lto_section_type section_type
)
326 struct lto_simple_output_block
*ob
327 = ((struct lto_simple_output_block
*)
328 xcalloc (1, sizeof (struct lto_simple_output_block
)));
330 ob
->section_type
= section_type
;
331 ob
->decl_state
= lto_get_out_decl_state ();
332 ob
->main_stream
= ((struct lto_output_stream
*)
333 xcalloc (1, sizeof (struct lto_output_stream
)));
339 /* Produce a simple section for one of the ipa passes. */
342 lto_destroy_simple_output_block (struct lto_simple_output_block
*ob
)
345 struct lto_simple_header header
;
347 section_name
= lto_get_section_name (ob
->section_type
, NULL
, NULL
);
348 lto_begin_section (section_name
, !flag_wpa
);
351 /* Write the header which says how to decode the pieces of the
353 memset (&header
, 0, sizeof (struct lto_simple_header
));
354 header
.lto_header
.major_version
= LTO_major_version
;
355 header
.lto_header
.minor_version
= LTO_minor_version
;
356 header
.compressed_size
= 0;
357 header
.main_size
= ob
->main_stream
->total_size
;
358 lto_write_data (&header
, sizeof header
);
360 lto_write_stream (ob
->main_stream
);
362 /* Put back the assembly section that was there before we started
366 free (ob
->main_stream
);
371 /* Return a new lto_out_decl_state. */
373 struct lto_out_decl_state
*
374 lto_new_out_decl_state (void)
376 struct lto_out_decl_state
*state
= XCNEW (struct lto_out_decl_state
);
379 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
380 lto_init_tree_ref_encoder (&state
->streams
[i
]);
386 /* Delete STATE and components. */
389 lto_delete_out_decl_state (struct lto_out_decl_state
*state
)
393 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
394 lto_destroy_tree_ref_encoder (&state
->streams
[i
]);
400 /* Get the currently used lto_out_decl_state structure. */
402 struct lto_out_decl_state
*
403 lto_get_out_decl_state (void)
405 return decl_state_stack
.last ();
408 /* Push STATE to top of out decl stack. */
411 lto_push_out_decl_state (struct lto_out_decl_state
*state
)
413 decl_state_stack
.safe_push (state
);
416 /* Pop the currently used out-decl state from top of stack. */
418 struct lto_out_decl_state
*
419 lto_pop_out_decl_state (void)
421 return decl_state_stack
.pop ();
424 /* Record STATE after it has been used in serializing the body of
425 FN_DECL. STATE should no longer be used by the caller. The ownership
426 of it is taken over from this point. */
429 lto_record_function_out_decl_state (tree fn_decl
,
430 struct lto_out_decl_state
*state
)
434 /* Strip all hash tables to save some memory. */
435 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
436 if (state
->streams
[i
].tree_hash_table
)
438 delete state
->streams
[i
].tree_hash_table
;
439 state
->streams
[i
].tree_hash_table
= NULL
;
441 state
->fn_decl
= fn_decl
;
442 lto_function_decl_states
.safe_push (state
);