1 /* Functions for writing LTO sections.
3 Copyright (C) 2009-2015 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"
29 #include "fold-const.h"
31 #include "hard-reg-set.h"
33 #include "basic-block.h"
34 #include "tree-ssa-alias.h"
35 #include "internal-fn.h"
36 #include "gimple-expr.h"
40 #include "insn-config.h"
51 #include "langhooks.h"
53 #include "data-streamer.h"
54 #include "lto-streamer.h"
55 #include "lto-compress.h"
57 static vec
<lto_out_decl_state_ptr
> decl_state_stack
;
59 /* List of out decl states used by functions. We use this to
60 generate the decl directory later. */
62 vec
<lto_out_decl_state_ptr
> lto_function_decl_states
;
65 /*****************************************************************************
66 Output routines shared by all of the serialization passes.
67 *****************************************************************************/
70 /* Flush compressed stream data function, sends NUM_CHARS from CHARS
71 to the append lang hook, OPAQUE is currently always NULL. */
74 lto_append_data (const char *chars
, unsigned int num_chars
, void *opaque
)
76 gcc_assert (opaque
== NULL
);
77 lang_hooks
.lto
.append_data (chars
, num_chars
, opaque
);
80 /* Pointer to the current compression stream. */
82 static struct lto_compression_stream
*compression_stream
= NULL
;
84 /* Begin a new output section named NAME. If COMPRESS is true, zlib compress
88 lto_begin_section (const char *name
, bool compress
)
90 lang_hooks
.lto
.begin_section (name
);
92 /* FIXME lto: for now, suppress compression if the lang_hook that appends
93 data is anything other than assembler output. The effect here is that
94 we get compression of IL only in non-ltrans object files. */
95 gcc_assert (compression_stream
== NULL
);
97 compression_stream
= lto_start_compression (lto_append_data
, NULL
);
101 /* End the current output section. */
104 lto_end_section (void)
106 if (compression_stream
)
108 lto_end_compression (compression_stream
);
109 compression_stream
= NULL
;
111 lang_hooks
.lto
.end_section ();
114 /* Write SIZE bytes starting at DATA to the assembler. */
117 lto_write_data (const void *data
, unsigned int size
)
119 if (compression_stream
)
120 lto_compress_block (compression_stream
, (const char *)data
, size
);
122 lang_hooks
.lto
.append_data ((const char *)data
, size
, NULL
);
125 /* Write all of the chars in OBS to the assembler. Recycle the blocks
126 in obs as this is being done. */
129 lto_write_stream (struct lto_output_stream
*obs
)
131 unsigned int block_size
= 1024;
132 struct lto_char_ptr_base
*block
;
133 struct lto_char_ptr_base
*next_block
;
134 if (!obs
->first_block
)
137 for (block
= obs
->first_block
; block
; block
= next_block
)
139 const char *base
= ((char *)block
) + sizeof (struct lto_char_ptr_base
);
140 unsigned int num_chars
= block_size
- sizeof (struct lto_char_ptr_base
);
142 /* If this is not the last block, it is full. If it is the last
143 block, left_in_block indicates how many chars are unoccupied in
144 this block; subtract from num_chars to obtain occupancy. */
145 next_block
= (struct lto_char_ptr_base
*) block
->ptr
;
147 num_chars
-= obs
->left_in_block
;
149 /* FIXME lto: WPA mode uses an ELF function as a lang_hook to append
150 output data. This hook is not happy with the way that compression
151 blocks up output differently to the way it's blocked here. So for
152 now, we don't compress WPA output. */
153 if (compression_stream
)
154 lto_compress_block (compression_stream
, base
, num_chars
);
156 lang_hooks
.lto
.append_data (base
, num_chars
, block
);
163 /* Lookup NAME in ENCODER. If NAME is not found, create a new entry in
164 ENCODER for NAME with the next available index of ENCODER, then
165 print the index to OBS. True is returned if NAME was added to
166 ENCODER. The resulting index is stored in THIS_INDEX.
168 If OBS is NULL, the only action is to add NAME to the encoder. */
171 lto_output_decl_index (struct lto_output_stream
*obs
,
172 struct lto_tree_ref_encoder
*encoder
,
173 tree name
, unsigned int *this_index
)
175 bool new_entry_p
= FALSE
;
179 = encoder
->tree_hash_table
->get_or_insert (name
, &existed_p
);
182 index
= encoder
->trees
.length ();
183 encoder
->trees
.safe_push (name
);
188 streamer_write_uhwi_stream (obs
, index
);
193 /* Output a field DECL to OBS. */
196 lto_output_field_decl_index (struct lto_out_decl_state
*decl_state
,
197 struct lto_output_stream
* obs
, tree decl
)
200 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_FIELD_DECL
],
204 /* Output a function DECL to OBS. */
207 lto_output_fn_decl_index (struct lto_out_decl_state
*decl_state
,
208 struct lto_output_stream
* obs
, tree decl
)
211 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_FN_DECL
],
215 /* Output a namespace DECL to OBS. */
218 lto_output_namespace_decl_index (struct lto_out_decl_state
*decl_state
,
219 struct lto_output_stream
* obs
, tree decl
)
222 lto_output_decl_index (obs
,
223 &decl_state
->streams
[LTO_DECL_STREAM_NAMESPACE_DECL
],
227 /* Output a static or extern var DECL to OBS. */
230 lto_output_var_decl_index (struct lto_out_decl_state
*decl_state
,
231 struct lto_output_stream
* obs
, tree decl
)
234 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_VAR_DECL
],
238 /* Output a type DECL to OBS. */
241 lto_output_type_decl_index (struct lto_out_decl_state
*decl_state
,
242 struct lto_output_stream
* obs
, tree decl
)
245 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_TYPE_DECL
],
249 /* Output a type REF to OBS. */
252 lto_output_type_ref_index (struct lto_out_decl_state
*decl_state
,
253 struct lto_output_stream
*obs
, tree ref
)
256 lto_output_decl_index (obs
, &decl_state
->streams
[LTO_DECL_STREAM_TYPE
],
261 /* Create the output block and return it. */
263 struct lto_simple_output_block
*
264 lto_create_simple_output_block (enum lto_section_type section_type
)
266 struct lto_simple_output_block
*ob
267 = ((struct lto_simple_output_block
*)
268 xcalloc (1, sizeof (struct lto_simple_output_block
)));
270 ob
->section_type
= section_type
;
271 ob
->decl_state
= lto_get_out_decl_state ();
272 ob
->main_stream
= ((struct lto_output_stream
*)
273 xcalloc (1, sizeof (struct lto_output_stream
)));
279 /* Produce a simple section for one of the ipa passes. */
282 lto_destroy_simple_output_block (struct lto_simple_output_block
*ob
)
285 struct lto_simple_header header
;
287 section_name
= lto_get_section_name (ob
->section_type
, NULL
, NULL
);
288 lto_begin_section (section_name
, !flag_wpa
);
291 /* Write the header which says how to decode the pieces of the
293 memset (&header
, 0, sizeof (struct lto_simple_header
));
294 header
.major_version
= LTO_major_version
;
295 header
.minor_version
= LTO_minor_version
;
296 header
.main_size
= ob
->main_stream
->total_size
;
297 lto_write_data (&header
, sizeof header
);
299 lto_write_stream (ob
->main_stream
);
301 /* Put back the assembly section that was there before we started
305 free (ob
->main_stream
);
310 /* Return a new lto_out_decl_state. */
312 struct lto_out_decl_state
*
313 lto_new_out_decl_state (void)
315 struct lto_out_decl_state
*state
= XCNEW (struct lto_out_decl_state
);
318 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
319 lto_init_tree_ref_encoder (&state
->streams
[i
]);
325 /* Delete STATE and components. */
328 lto_delete_out_decl_state (struct lto_out_decl_state
*state
)
332 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
333 lto_destroy_tree_ref_encoder (&state
->streams
[i
]);
339 /* Get the currently used lto_out_decl_state structure. */
341 struct lto_out_decl_state
*
342 lto_get_out_decl_state (void)
344 return decl_state_stack
.last ();
347 /* Push STATE to top of out decl stack. */
350 lto_push_out_decl_state (struct lto_out_decl_state
*state
)
352 decl_state_stack
.safe_push (state
);
355 /* Pop the currently used out-decl state from top of stack. */
357 struct lto_out_decl_state
*
358 lto_pop_out_decl_state (void)
360 return decl_state_stack
.pop ();
363 /* Record STATE after it has been used in serializing the body of
364 FN_DECL. STATE should no longer be used by the caller. The ownership
365 of it is taken over from this point. */
368 lto_record_function_out_decl_state (tree fn_decl
,
369 struct lto_out_decl_state
*state
)
373 /* Strip all hash tables to save some memory. */
374 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
375 if (state
->streams
[i
].tree_hash_table
)
377 delete state
->streams
[i
].tree_hash_table
;
378 state
->streams
[i
].tree_hash_table
= NULL
;
380 state
->fn_decl
= fn_decl
;
381 lto_function_decl_states
.safe_push (state
);