Branch data Line data Source code
1 : : /* Routines for emitting trees to a file stream.
2 : :
3 : : Copyright (C) 2011-2024 Free Software Foundation, Inc.
4 : : Contributed by Diego Novillo <dnovillo@google.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 "target.h"
27 : : #include "tree.h"
28 : : #include "gimple.h"
29 : : #include "tree-streamer.h"
30 : : #include "cgraph.h"
31 : : #include "alias.h"
32 : : #include "stor-layout.h"
33 : : #include "gomp-constants.h"
34 : : #include "print-tree.h"
35 : :
36 : :
37 : : /* Output the STRING constant to the string
38 : : table in OB. Then put the index onto the INDEX_STREAM. */
39 : :
40 : : void
41 : 174762 : streamer_write_string_cst (struct output_block *ob,
42 : : struct lto_output_stream *index_stream,
43 : : tree string)
44 : : {
45 : 349458 : streamer_write_string_with_length (ob, index_stream,
46 : 174696 : string ? TREE_STRING_POINTER (string)
47 : : : NULL,
48 : 174696 : string ? TREE_STRING_LENGTH (string) : 0,
49 : : true);
50 : 174762 : }
51 : :
52 : :
53 : : /* Output the identifier ID to the string
54 : : table in OB. Then put the index onto the INDEX_STREAM. */
55 : :
56 : : static void
57 : 1448014 : write_identifier (struct output_block *ob,
58 : : struct lto_output_stream *index_stream,
59 : : tree id)
60 : : {
61 : 1448014 : streamer_write_string_with_length (ob, index_stream,
62 : 1448014 : IDENTIFIER_POINTER (id),
63 : 1448014 : IDENTIFIER_LENGTH (id),
64 : : true);
65 : 1448014 : }
66 : :
67 : :
68 : : /* Pack all the non-pointer fields of the TS_BASE structure of
69 : : expression EXPR into bitpack BP. */
70 : :
71 : : static inline void
72 : 6892687 : pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
73 : : {
74 : 6892687 : if (!TYPE_P (expr))
75 : : {
76 : 6273795 : bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
77 : 6273795 : bp_pack_value (bp, TREE_CONSTANT (expr), 1);
78 : 6273795 : bp_pack_value (bp, TREE_READONLY (expr), 1);
79 : :
80 : : /* TREE_PUBLIC is used on types to indicate that the type
81 : : has a TYPE_CACHED_VALUES vector. This is not streamed out,
82 : : so we skip it here. */
83 : 6273795 : bp_pack_value (bp, TREE_PUBLIC (expr), 1);
84 : : }
85 : : else
86 : 618892 : bp_pack_value (bp, 0, 4);
87 : 6892687 : bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
88 : 6892687 : bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
89 : 6892687 : if (DECL_P (expr))
90 : : {
91 : 1502709 : bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
92 : 1502709 : bp_pack_value (bp, DECL_NAMELESS (expr), 1);
93 : : }
94 : 5389978 : else if (TYPE_P (expr))
95 : 618892 : bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
96 : : else
97 : 4771086 : bp_pack_value (bp, 0, 1);
98 : : /* We write debug info two times, do not confuse the second one.
99 : : The only relevant TREE_ASM_WRITTEN use is on SSA names. */
100 : 6892687 : bp_pack_value (bp, (TREE_CODE (expr) != SSA_NAME
101 : 0 : ? 0 : TREE_ASM_WRITTEN (expr)), 1);
102 : 6892687 : if (TYPE_P (expr))
103 : 618892 : bp_pack_value (bp, TYPE_ARTIFICIAL (expr), 1);
104 : : else
105 : 6273795 : bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
106 : 6892687 : bp_pack_value (bp, TREE_NOTHROW (expr), 1);
107 : 6892687 : bp_pack_value (bp, TREE_STATIC (expr), 1);
108 : 6892687 : if (TREE_CODE (expr) != TREE_BINFO)
109 : 6885464 : bp_pack_value (bp, TREE_PRIVATE (expr), 1);
110 : : else
111 : 7223 : bp_pack_value (bp, 0, 1);
112 : 6892687 : bp_pack_value (bp, TREE_PROTECTED (expr), 1);
113 : 6892687 : bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
114 : 6892687 : if (TYPE_P (expr))
115 : : {
116 : 618892 : if (AGGREGATE_TYPE_P (expr))
117 : 132591 : bp_pack_value (bp, TYPE_REVERSE_STORAGE_ORDER (expr), 1);
118 : : else
119 : 486301 : bp_pack_value (bp, TYPE_SATURATING (expr), 1);
120 : 618892 : if (lto_stream_offload_p)
121 : : /* Host and offload targets have no common meaning of address
122 : : spaces. */
123 : : ;
124 : : else
125 : 618892 : bp_pack_value (bp, TYPE_ADDR_SPACE (expr), 8);
126 : : }
127 : 6273795 : else if (TREE_CODE (expr) == BIT_FIELD_REF || TREE_CODE (expr) == MEM_REF)
128 : : {
129 : 373004 : bp_pack_value (bp, REF_REVERSE_STORAGE_ORDER (expr), 1);
130 : 373004 : bp_pack_value (bp, 0, 8);
131 : : }
132 : 5900791 : else if (TREE_CODE (expr) == SSA_NAME)
133 : : {
134 : 0 : bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
135 : 0 : bp_pack_value (bp, 0, 8);
136 : : }
137 : 5900791 : else if (TREE_CODE (expr) == CALL_EXPR)
138 : : {
139 : 24 : bp_pack_value (bp, CALL_EXPR_BY_DESCRIPTOR (expr), 1);
140 : 24 : bp_pack_value (bp, 0, 8);
141 : : }
142 : : else
143 : 5900767 : bp_pack_value (bp, 0, 9);
144 : 6892687 : }
145 : :
146 : :
147 : : /* Pack all the non-pointer fields of the TS_INTEGER_CST structure of
148 : : expression EXPR into bitpack BP. */
149 : :
150 : : static void
151 : 39504 : pack_ts_int_cst_value_fields (struct bitpack_d *bp, tree expr)
152 : : {
153 : 39504 : int i;
154 : : /* Note that the number of elements has already been written out in
155 : : streamer_write_tree_header. */
156 : 80087 : for (i = 0; i < TREE_INT_CST_EXT_NUNITS (expr); i++)
157 : 40583 : bp_pack_var_len_int (bp, TREE_INT_CST_ELT (expr, i));
158 : 39504 : }
159 : :
160 : :
161 : : /* Pack all the non-pointer fields of the TS_REAL_CST structure of
162 : : expression EXPR into bitpack BP. */
163 : :
164 : : static void
165 : 112985 : pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
166 : : {
167 : 112985 : REAL_VALUE_TYPE r = TREE_REAL_CST (expr);
168 : 112985 : bp_pack_real_value (bp, &r);
169 : 112985 : }
170 : :
171 : :
172 : : /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
173 : : expression EXPR into bitpack BP. */
174 : :
175 : : static void
176 : 0 : pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
177 : : {
178 : 0 : struct fixed_value fv = TREE_FIXED_CST (expr);
179 : 0 : bp_pack_machine_mode (bp, fv.mode);
180 : 0 : bp_pack_var_len_int (bp, fv.data.low);
181 : 0 : bp_pack_var_len_int (bp, fv.data.high);
182 : 0 : }
183 : :
184 : : /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
185 : : of expression EXPR into bitpack BP. */
186 : :
187 : : static void
188 : 1502709 : pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
189 : : {
190 : : /* Similar to TYPE_MODE, avoid streaming out host-specific DECL_MODE
191 : : for aggregate type with offloading enabled, and while streaming-in
192 : : recompute appropriate DECL_MODE for accelerator. */
193 : 1502709 : if (lto_stream_offload_p
194 : 0 : && (VAR_P (expr)
195 : 0 : || TREE_CODE (expr) == PARM_DECL
196 : 0 : || TREE_CODE (expr) == FIELD_DECL)
197 : 1502709 : && (AGGREGATE_TYPE_P (TREE_TYPE (expr))
198 : 0 : || VECTOR_TYPE_P (TREE_TYPE (expr))))
199 : 0 : bp_pack_machine_mode (bp, VOIDmode);
200 : : else
201 : 1502709 : bp_pack_machine_mode (bp, DECL_MODE (expr));
202 : 1502709 : bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
203 : 1502709 : bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
204 : 1502709 : bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
205 : 1502709 : bp_pack_value (bp, DECL_ABSTRACT_P (expr), 1);
206 : 1502709 : bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
207 : 1502709 : bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
208 : 1502709 : bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
209 : 1502709 : bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
210 : 1502709 : bp_pack_value (bp, DECL_NOT_GIMPLE_REG_P (expr), 1);
211 : 1502709 : bp_pack_var_len_unsigned (bp, DECL_ALIGN (expr));
212 : :
213 : 1502709 : if (TREE_CODE (expr) == LABEL_DECL)
214 : : {
215 : : /* Note that we do not write LABEL_DECL_UID. The reader will
216 : : always assume an initial value of -1 so that the
217 : : label_to_block_map is recreated by gimple_set_bb. */
218 : 24806 : bp_pack_var_len_unsigned (bp, EH_LANDING_PAD_NR (expr));
219 : : }
220 : :
221 : 1477903 : else if (TREE_CODE (expr) == FIELD_DECL)
222 : : {
223 : 104513 : bp_pack_value (bp, DECL_PACKED (expr), 1);
224 : 104513 : bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
225 : 104513 : bp_pack_value (bp, DECL_PADDING_P (expr), 1);
226 : 104513 : if (DECL_BIT_FIELD (expr))
227 : 6116 : bp_pack_value (bp, DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD (expr), 1);
228 : : else
229 : 201113 : bp_pack_value (bp, DECL_FIELD_ABI_IGNORED (expr), 1);
230 : 104513 : bp_pack_value (bp, expr->decl_common.off_align, 8);
231 : 104513 : bp_pack_value (bp, DECL_NOT_FLEXARRAY (expr), 1);
232 : : }
233 : :
234 : 1373390 : else if (VAR_P (expr))
235 : : {
236 : 451097 : bp_pack_value (bp, DECL_HAS_DEBUG_EXPR_P (expr), 1);
237 : 451097 : bp_pack_value (bp, DECL_NONLOCAL_FRAME (expr), 1);
238 : : }
239 : :
240 : 922293 : else if (TREE_CODE (expr) == PARM_DECL)
241 : 327221 : bp_pack_value (bp, DECL_HIDDEN_STRING_LENGTH (expr), 1);
242 : :
243 : 1502709 : if (TREE_CODE (expr) == RESULT_DECL
244 : : || TREE_CODE (expr) == PARM_DECL
245 : : || VAR_P (expr))
246 : : {
247 : 886688 : bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
248 : 886688 : if (VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
249 : 778318 : bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
250 : : }
251 : 1502709 : }
252 : :
253 : :
254 : : /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
255 : : of expression EXPR into bitpack BP. */
256 : :
257 : : static void
258 : 1364473 : pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
259 : : {
260 : 1364473 : bp_pack_value (bp, DECL_REGISTER (expr), 1);
261 : 1364473 : }
262 : :
263 : :
264 : : /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
265 : : of expression EXPR into bitpack BP. */
266 : :
267 : : static void
268 : 903646 : pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
269 : : {
270 : 903646 : bp_pack_value (bp, DECL_COMMON (expr), 1);
271 : 903646 : bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
272 : 903646 : bp_pack_value (bp, DECL_WEAK (expr), 1);
273 : 903646 : bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr), 1);
274 : 903646 : bp_pack_value (bp, DECL_COMDAT (expr), 1);
275 : 903646 : bp_pack_value (bp, DECL_VISIBILITY (expr), 2);
276 : 903646 : bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr), 1);
277 : :
278 : 903646 : if (VAR_P (expr))
279 : : {
280 : 451097 : bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
281 : : /* DECL_IN_TEXT_SECTION is set during final asm output only. */
282 : 451097 : bp_pack_value (bp, DECL_IN_CONSTANT_POOL (expr), 1);
283 : : }
284 : :
285 : 903646 : if (TREE_CODE (expr) == FUNCTION_DECL)
286 : : {
287 : 424871 : bp_pack_value (bp, DECL_FINAL_P (expr), 1);
288 : 424871 : bp_pack_value (bp, DECL_CXX_CONSTRUCTOR_P (expr), 1);
289 : 424871 : bp_pack_value (bp, DECL_CXX_DESTRUCTOR_P (expr), 1);
290 : : }
291 : 903646 : }
292 : :
293 : :
294 : : /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
295 : : of expression EXPR into bitpack BP. */
296 : :
297 : : static void
298 : 424871 : pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
299 : : {
300 : 424871 : bp_pack_enum (bp, built_in_class, BUILT_IN_LAST,
301 : : DECL_BUILT_IN_CLASS (expr));
302 : 424871 : bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
303 : 424871 : bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
304 : 424871 : bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
305 : 424871 : bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
306 : 424871 : bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
307 : 424871 : bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
308 : 424871 : bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
309 : 424871 : bp_pack_value (bp, FUNCTION_DECL_DECL_TYPE (expr), 2);
310 : 424871 : bp_pack_value (bp, DECL_IS_OPERATOR_DELETE_P (expr), 1);
311 : 424871 : bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
312 : 424871 : bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
313 : 424871 : bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
314 : 424871 : bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
315 : 424871 : bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
316 : 424871 : bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
317 : 424871 : bp_pack_value (bp, DECL_PURE_P (expr), 1);
318 : 424871 : bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
319 : 424871 : bp_pack_value (bp, DECL_IS_REPLACEABLE_OPERATOR (expr), 1);
320 : 424871 : if (DECL_BUILT_IN_CLASS (expr) != NOT_BUILT_IN)
321 : 32274 : bp_pack_value (bp, DECL_UNCHECKED_FUNCTION_CODE (expr), 32);
322 : 424871 : }
323 : :
324 : :
325 : : /* Pack all the non-pointer fields of the TS_TYPE_COMMON structure
326 : : of expression EXPR into bitpack BP. */
327 : :
328 : : static void
329 : 618892 : pack_ts_type_common_value_fields (struct bitpack_d *bp, tree expr)
330 : : {
331 : : /* For offloading, avoid streaming out TYPE_MODE for aggregate type since
332 : : it may be host-specific. For eg, aarch64 uses OImode for ARRAY_TYPE
333 : : whose size is 256-bits, which is not representable on accelerator.
334 : : Instead stream out VOIDmode, and while streaming-in, recompute
335 : : appropriate TYPE_MODE for accelerator. */
336 : 618892 : if (lto_stream_offload_p
337 : 0 : && (AGGREGATE_TYPE_P (expr) || VECTOR_TYPE_P (expr)))
338 : 0 : bp_pack_machine_mode (bp, VOIDmode);
339 : : /* for VECTOR_TYPE, TYPE_MODE reevaluates the mode using target_flags
340 : : not necessary valid in a global context.
341 : : Use the raw value previously set by layout_type. */
342 : : else
343 : 618892 : bp_pack_machine_mode (bp, TYPE_MODE_RAW (expr));
344 : : /* TYPE_NO_FORCE_BLK is private to stor-layout and need
345 : : no streaming. */
346 : 618892 : bp_pack_value (bp, TYPE_PACKED (expr), 1);
347 : 618892 : bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
348 : 618892 : bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
349 : 618892 : bp_pack_value (bp, TYPE_READONLY (expr), 1);
350 : 618892 : unsigned vla_p;
351 : 618892 : if (in_lto_p)
352 : 181447 : vla_p = TYPE_LANG_FLAG_0 (TYPE_MAIN_VARIANT (expr));
353 : : else
354 : 437445 : vla_p = variably_modified_type_p (expr, NULL_TREE);
355 : 618892 : bp_pack_value (bp, vla_p, 1);
356 : : /* We used to stream TYPE_ALIAS_SET == 0 information to let frontends mark
357 : : types that are opaque for TBAA. This however did not work as intended,
358 : : because TYPE_ALIAS_SET == 0 was regularly lost in type merging. */
359 : 618892 : if (RECORD_OR_UNION_TYPE_P (expr))
360 : : {
361 : 89472 : bp_pack_value (bp, TYPE_TRANSPARENT_AGGR (expr), 1);
362 : 89472 : bp_pack_value (bp, TYPE_FINAL_P (expr), 1);
363 : : /* alias_ptr_types_compatible_p relies on fact that during LTO
364 : : types do not get refined from WPA time to ltrans. */
365 : 178944 : bp_pack_value (bp, flag_wpa && TYPE_CANONICAL (expr)
366 : 16698 : ? TYPE_CXX_ODR_P (TYPE_CANONICAL (expr))
367 : 72774 : : TYPE_CXX_ODR_P (expr), 1);
368 : : }
369 : 529420 : else if (TREE_CODE (expr) == ARRAY_TYPE)
370 : 43119 : bp_pack_value (bp, TYPE_NONALIASED_COMPONENT (expr), 1);
371 : 618892 : if (TREE_CODE (expr) == ARRAY_TYPE || TREE_CODE (expr) == INTEGER_TYPE)
372 : 104455 : bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
373 : 618892 : if (AGGREGATE_TYPE_P (expr))
374 : 132591 : bp_pack_value (bp, TYPE_TYPELESS_STORAGE (expr), 1);
375 : 618892 : bp_pack_value (bp, TYPE_EMPTY_P (expr), 1);
376 : 618892 : if (FUNC_OR_METHOD_TYPE_P (expr))
377 : 164537 : bp_pack_value (bp, TYPE_NO_NAMED_ARGS_STDARG_P (expr), 1);
378 : 618892 : if (RECORD_OR_UNION_TYPE_P (expr))
379 : 89472 : bp_pack_value (bp, TYPE_INCLUDES_FLEXARRAY (expr), 1);
380 : 618892 : bp_pack_var_len_unsigned (bp, TYPE_PRECISION_RAW (expr));
381 : 618892 : bp_pack_var_len_unsigned (bp, TYPE_ALIGN (expr));
382 : 618892 : }
383 : :
384 : :
385 : : /* Pack all the non-pointer fields of the TS_BLOCK structure
386 : : of expression EXPR into bitpack BP. */
387 : :
388 : : static void
389 : 334089 : pack_ts_block_value_fields (struct output_block *ob,
390 : : struct bitpack_d *bp, tree expr)
391 : : {
392 : : /* BLOCK_NUMBER is recomputed. */
393 : : /* Stream BLOCK_SOURCE_LOCATION for the limited cases we can handle - those
394 : : that represent inlined function scopes.
395 : : For the rest them on the floor instead of ICEing in dwarf2out.cc. */
396 : 334089 : if (inlined_function_outer_scope_p (expr))
397 : 74242 : stream_output_location (ob, bp, BLOCK_SOURCE_LOCATION (expr));
398 : : else
399 : 259847 : stream_output_location (ob, bp, UNKNOWN_LOCATION);
400 : 334089 : }
401 : :
402 : : /* Pack all the non-pointer fields of the TS_TRANSLATION_UNIT_DECL structure
403 : : of expression EXPR into bitpack BP. */
404 : :
405 : : static void
406 : 33593 : pack_ts_translation_unit_decl_value_fields (struct output_block *ob,
407 : : struct bitpack_d *bp, tree expr)
408 : : {
409 : 33593 : bp_pack_string (ob, bp, TRANSLATION_UNIT_LANGUAGE (expr), true);
410 : 33593 : }
411 : :
412 : :
413 : : /* Pack all the non-pointer fields of the TS_OMP_CLAUSE structure
414 : : of expression EXPR into bitpack BP. */
415 : :
416 : : static void
417 : 206 : pack_ts_omp_clause_value_fields (struct output_block *ob,
418 : : struct bitpack_d *bp, tree expr)
419 : : {
420 : 206 : stream_output_location (ob, bp, OMP_CLAUSE_LOCATION (expr));
421 : 206 : switch (OMP_CLAUSE_CODE (expr))
422 : : {
423 : 0 : case OMP_CLAUSE_DEFAULT:
424 : 0 : bp_pack_enum (bp, omp_clause_default_kind, OMP_CLAUSE_DEFAULT_LAST,
425 : : OMP_CLAUSE_DEFAULT_KIND (expr));
426 : 0 : break;
427 : 0 : case OMP_CLAUSE_SCHEDULE:
428 : 0 : bp_pack_enum (bp, omp_clause_schedule_kind, OMP_CLAUSE_SCHEDULE_LAST,
429 : : OMP_CLAUSE_SCHEDULE_KIND (expr));
430 : 0 : break;
431 : 0 : case OMP_CLAUSE_DEPEND:
432 : 0 : bp_pack_enum (bp, omp_clause_depend_kind, OMP_CLAUSE_DEPEND_LAST,
433 : : OMP_CLAUSE_DEPEND_KIND (expr));
434 : 0 : break;
435 : 0 : case OMP_CLAUSE_DOACROSS:
436 : 0 : bp_pack_enum (bp, omp_clause_doacross_kind, OMP_CLAUSE_DOACROSS_LAST,
437 : : OMP_CLAUSE_DOACROSS_KIND (expr));
438 : 0 : break;
439 : 0 : case OMP_CLAUSE_MAP:
440 : 0 : bp_pack_enum (bp, gomp_map_kind, GOMP_MAP_LAST,
441 : : OMP_CLAUSE_MAP_KIND (expr));
442 : 0 : break;
443 : 0 : case OMP_CLAUSE_PROC_BIND:
444 : 0 : bp_pack_enum (bp, omp_clause_proc_bind_kind, OMP_CLAUSE_PROC_BIND_LAST,
445 : : OMP_CLAUSE_PROC_BIND_KIND (expr));
446 : 0 : break;
447 : 0 : case OMP_CLAUSE_REDUCTION:
448 : 0 : case OMP_CLAUSE_TASK_REDUCTION:
449 : 0 : case OMP_CLAUSE_IN_REDUCTION:
450 : 0 : bp_pack_enum (bp, tree_code, MAX_TREE_CODES,
451 : : OMP_CLAUSE_REDUCTION_CODE (expr));
452 : 0 : break;
453 : : default:
454 : : break;
455 : : }
456 : 206 : }
457 : :
458 : :
459 : : /* Pack all the bitfields in EXPR into a bit pack. */
460 : :
461 : : void
462 : 6892687 : streamer_write_tree_bitfields (struct output_block *ob, tree expr)
463 : : {
464 : 6892687 : bitpack_d bp = bitpack_create (ob->main_stream);
465 : 6892687 : enum tree_code code;
466 : :
467 : 6892687 : code = TREE_CODE (expr);
468 : :
469 : : /* Note that all these functions are highly sensitive to changes in
470 : : the types and sizes of each of the fields being packed. */
471 : 6892687 : pack_ts_base_value_fields (&bp, expr);
472 : :
473 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
474 : 39504 : pack_ts_int_cst_value_fields (&bp, expr);
475 : :
476 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
477 : 112985 : pack_ts_real_cst_value_fields (&bp, expr);
478 : :
479 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
480 : 0 : pack_ts_fixed_cst_value_fields (&bp, expr);
481 : :
482 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
483 : 1502709 : stream_output_location (ob, &bp, DECL_SOURCE_LOCATION (expr));
484 : :
485 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
486 : 1502709 : pack_ts_decl_common_value_fields (&bp, expr);
487 : :
488 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
489 : 1364473 : pack_ts_decl_wrtl_value_fields (&bp, expr);
490 : :
491 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
492 : 903646 : pack_ts_decl_with_vis_value_fields (&bp, expr);
493 : :
494 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
495 : 424871 : pack_ts_function_decl_value_fields (&bp, expr);
496 : :
497 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
498 : 618892 : pack_ts_type_common_value_fields (&bp, expr);
499 : :
500 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
501 : : {
502 : 1694038 : stream_output_location (ob, &bp, EXPR_LOCATION (expr));
503 : 1694038 : if (code == MEM_REF
504 : 1694038 : || code == TARGET_MEM_REF)
505 : : {
506 : 369238 : bp_pack_value (&bp, MR_DEPENDENCE_CLIQUE (expr), sizeof (short) * 8);
507 : 369238 : if (MR_DEPENDENCE_CLIQUE (expr) != 0)
508 : 17919 : bp_pack_value (&bp, MR_DEPENDENCE_BASE (expr), sizeof (short) * 8);
509 : : }
510 : 1324800 : else if (code == CALL_EXPR)
511 : 24 : bp_pack_enum (&bp, internal_fn, IFN_LAST, CALL_EXPR_IFN (expr));
512 : : }
513 : :
514 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
515 : 334089 : pack_ts_block_value_fields (ob, &bp, expr);
516 : :
517 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
518 : 33593 : pack_ts_translation_unit_decl_value_fields (ob, &bp, expr);
519 : :
520 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
521 : 33086 : cl_optimization_stream_out (ob, &bp, TREE_OPTIMIZATION (expr));
522 : :
523 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
524 : : {
525 : 236390 : bp_pack_enum (&bp, clobber_kind, CLOBBER_LAST, CLOBBER_KIND (expr));
526 : 453367 : bp_pack_var_len_unsigned (&bp, CONSTRUCTOR_NELTS (expr));
527 : : }
528 : :
529 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION)
530 : : /* Don't stream these when passing things to a different target. */
531 : 32636 : && !lto_stream_offload_p)
532 : 32636 : cl_target_option_stream_out (ob, &bp, TREE_TARGET_OPTION (expr));
533 : :
534 : 6892687 : if (code == OMP_CLAUSE)
535 : 206 : pack_ts_omp_clause_value_fields (ob, &bp, expr);
536 : :
537 : 6892687 : streamer_write_bitpack (&bp);
538 : 6892687 : }
539 : :
540 : :
541 : : /* Emit the chain of tree nodes starting at T. OB is the output block
542 : : to write to. REF_P is true if chain elements should be emitted
543 : : as references. */
544 : :
545 : : static void
546 : 423561 : streamer_write_chain (struct output_block *ob, tree t)
547 : : {
548 : 698650 : while (t)
549 : : {
550 : : /* We avoid outputting external vars or functions by reference
551 : : to the global decls section as we do not want to have them
552 : : enter decl merging. We should not need to do this anymore because
553 : : free_lang_data removes them from block scopes. */
554 : 275089 : gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
555 : 275089 : stream_write_tree_ref (ob, t);
556 : :
557 : 275089 : t = TREE_CHAIN (t);
558 : : }
559 : :
560 : : /* Write a sentinel to terminate the chain. */
561 : 423561 : stream_write_tree_ref (ob, NULL_TREE);
562 : 423561 : }
563 : :
564 : :
565 : : /* Write all pointer fields in the TS_COMMON structure of EXPR to output
566 : : block OB. If REF_P is true, write a reference to EXPR's pointer
567 : : fields. */
568 : :
569 : : static void
570 : 6492876 : write_ts_common_tree_pointers (struct output_block *ob, tree expr)
571 : : {
572 : 6492876 : if (TREE_CODE (expr) != IDENTIFIER_NODE)
573 : 5044862 : stream_write_tree_ref (ob, TREE_TYPE (expr));
574 : 6492876 : }
575 : :
576 : :
577 : : /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
578 : : block OB. If REF_P is true, write a reference to EXPR's pointer
579 : : fields. */
580 : :
581 : : static void
582 : 5690 : write_ts_vector_tree_pointers (struct output_block *ob, tree expr)
583 : : {
584 : : /* Note that the number of elements for EXPR has already been emitted
585 : : in EXPR's header (see streamer_write_tree_header). */
586 : 5690 : unsigned int count = vector_cst_encoded_nelts (expr);
587 : 23626 : for (unsigned int i = 0; i < count; ++i)
588 : 17936 : stream_write_tree_ref (ob, VECTOR_CST_ENCODED_ELT (expr, i));
589 : 5690 : }
590 : :
591 : :
592 : : /* Write all pointer fields in the TS_POLY_INT_CST structure of EXPR to
593 : : output block OB. If REF_P is true, write a reference to EXPR's pointer
594 : : fields. */
595 : :
596 : : static void
597 : 0 : write_ts_poly_tree_pointers (struct output_block *ob, tree expr)
598 : : {
599 : 0 : for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
600 : 0 : stream_write_tree_ref (ob, POLY_INT_CST_COEFF (expr, i));
601 : 0 : }
602 : :
603 : :
604 : : /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
605 : : block OB. If REF_P is true, write a reference to EXPR's pointer
606 : : fields. */
607 : :
608 : : static void
609 : 8025 : write_ts_complex_tree_pointers (struct output_block *ob, tree expr)
610 : : {
611 : 8025 : stream_write_tree_ref (ob, TREE_REALPART (expr));
612 : 8025 : stream_write_tree_ref (ob, TREE_IMAGPART (expr));
613 : 8025 : }
614 : :
615 : :
616 : : /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
617 : : to output block OB. If REF_P is true, write a reference to EXPR's
618 : : pointer fields. */
619 : :
620 : : static void
621 : 1502709 : write_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr)
622 : : {
623 : : /* Drop names that were created for anonymous entities. */
624 : 1502709 : if (DECL_NAME (expr)
625 : 1324250 : && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE
626 : 2826959 : && IDENTIFIER_ANON_P (DECL_NAME (expr)))
627 : 490 : stream_write_tree_ref (ob, NULL_TREE);
628 : : else
629 : 1502219 : stream_write_tree_ref (ob, DECL_NAME (expr));
630 : 1502709 : if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL
631 : 1502709 : && ! DECL_CONTEXT (expr))
632 : 13982 : stream_write_tree_ref (ob, (*all_translation_units)[0]);
633 : : else
634 : 1488727 : stream_write_tree_ref (ob, DECL_CONTEXT (expr));
635 : 1502709 : }
636 : :
637 : :
638 : : /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
639 : : output block OB. If REF_P is true, write a reference to EXPR's
640 : : pointer fields. */
641 : :
642 : : static void
643 : 1502709 : write_ts_decl_common_tree_pointers (struct output_block *ob, tree expr)
644 : : {
645 : 1502709 : stream_write_tree_ref (ob, DECL_SIZE (expr));
646 : 1502709 : stream_write_tree_ref (ob, DECL_SIZE_UNIT (expr));
647 : :
648 : : /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs
649 : : special handling in LTO, it must be handled by streamer hooks. */
650 : :
651 : 1502709 : stream_write_tree_ref (ob, DECL_ATTRIBUTES (expr));
652 : :
653 : : /* On non-early-LTO enabled targets we claim we compiled with -g0
654 : : but dwarf2out still did its set_decl_origin_self game fooling
655 : : itself late. Und that here since we won't have access to the
656 : : early generated abstract DIEs. */
657 : 1502709 : tree ao = DECL_ABSTRACT_ORIGIN (expr);
658 : 1502709 : if (debug_info_level == DINFO_LEVEL_NONE
659 : 1380565 : && ao == expr)
660 : 1502709 : ao = NULL_TREE;
661 : 1502709 : stream_write_tree_ref (ob, ao);
662 : :
663 : 1051612 : if ((VAR_P (expr) || TREE_CODE (expr) == PARM_DECL)
664 : 1829930 : && DECL_HAS_VALUE_EXPR_P (expr))
665 : 6035 : stream_write_tree_ref (ob, DECL_VALUE_EXPR (expr));
666 : :
667 : 1502709 : if (VAR_P (expr)
668 : 1502709 : && DECL_HAS_DEBUG_EXPR_P (expr))
669 : 1412 : stream_write_tree_ref (ob, DECL_DEBUG_EXPR (expr));
670 : 1502709 : }
671 : :
672 : :
673 : : /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
674 : : EXPR to output block OB. If REF_P is true, write a reference to EXPR's
675 : : pointer fields. */
676 : :
677 : : static void
678 : 0 : write_ts_decl_non_common_tree_pointers (struct output_block *, tree)
679 : : {
680 : 0 : }
681 : :
682 : :
683 : : /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
684 : : to output block OB. If REF_P is true, write a reference to EXPR's
685 : : pointer fields. */
686 : :
687 : : static void
688 : 903646 : write_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr)
689 : : {
690 : : /* Make sure we don't inadvertently set the assembler name. */
691 : 903646 : if (DECL_ASSEMBLER_NAME_SET_P (expr))
692 : 733982 : stream_write_tree_ref (ob, DECL_ASSEMBLER_NAME (expr));
693 : : else
694 : 169664 : stream_write_tree_ref (ob, NULL_TREE);
695 : 903646 : }
696 : :
697 : :
698 : : /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
699 : : output block OB. If REF_P is true, write a reference to EXPR's
700 : : pointer fields. */
701 : :
702 : : static void
703 : 104513 : write_ts_field_decl_tree_pointers (struct output_block *ob, tree expr)
704 : : {
705 : 104513 : stream_write_tree_ref (ob, DECL_FIELD_OFFSET (expr));
706 : 104513 : stream_write_tree_ref (ob, DECL_BIT_FIELD_TYPE (expr));
707 : 104513 : stream_write_tree_ref (ob, DECL_BIT_FIELD_REPRESENTATIVE (expr));
708 : 104513 : stream_write_tree_ref (ob, DECL_FIELD_BIT_OFFSET (expr));
709 : 104513 : }
710 : :
711 : :
712 : : /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
713 : : to output block OB. If REF_P is true, write a reference to EXPR's
714 : : pointer fields. */
715 : :
716 : : static void
717 : 424871 : write_ts_function_decl_tree_pointers (struct output_block *ob, tree expr)
718 : : {
719 : : /* DECL_STRUCT_FUNCTION is handled by lto_output_function. */
720 : 424871 : stream_write_tree_ref (ob, DECL_FUNCTION_PERSONALITY (expr));
721 : : /* Don't stream these when passing things to a different target. */
722 : 424871 : if (!lto_stream_offload_p)
723 : 424871 : stream_write_tree_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr));
724 : 424871 : stream_write_tree_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr));
725 : 424871 : }
726 : :
727 : :
728 : : /* Write all pointer fields in the TS_TYPE_COMMON structure of EXPR to
729 : : output block OB. If REF_P is true, write a reference to EXPR's
730 : : pointer fields. */
731 : :
732 : : static void
733 : 618892 : write_ts_type_common_tree_pointers (struct output_block *ob, tree expr)
734 : : {
735 : 618892 : stream_write_tree_ref (ob, TYPE_SIZE (expr));
736 : 618892 : stream_write_tree_ref (ob, TYPE_SIZE_UNIT (expr));
737 : 618892 : stream_write_tree_ref (ob, TYPE_ATTRIBUTES (expr));
738 : 618892 : stream_write_tree_ref (ob, TYPE_NAME (expr));
739 : : /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
740 : : reconstructed during fixup. */
741 : : /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
742 : : during fixup. */
743 : 618892 : stream_write_tree_ref (ob, TYPE_MAIN_VARIANT (expr));
744 : 618892 : stream_write_tree_ref (ob, TYPE_CONTEXT (expr));
745 : : /* TYPE_CANONICAL is re-computed during type merging, so no need
746 : : to stream it here. */
747 : : /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
748 : : it cannot be freed by free_lang_data without triggering ICEs in
749 : : langhooks. */
750 : 618892 : }
751 : :
752 : : /* Write all pointer fields in the TS_TYPE_NON_COMMON structure of EXPR
753 : : to output block OB. If REF_P is true, write a reference to EXPR's
754 : : pointer fields. */
755 : :
756 : : static void
757 : 618892 : write_ts_type_non_common_tree_pointers (struct output_block *ob, tree expr)
758 : : {
759 : 618892 : if (TREE_CODE (expr) == ARRAY_TYPE)
760 : 43119 : stream_write_tree_ref (ob, TYPE_DOMAIN (expr));
761 : 575773 : else if (RECORD_OR_UNION_TYPE_P (expr))
762 : 89472 : streamer_write_chain (ob, TYPE_FIELDS (expr));
763 : 486301 : else if (FUNC_OR_METHOD_TYPE_P (expr))
764 : 164537 : stream_write_tree_ref (ob, TYPE_ARG_TYPES (expr));
765 : :
766 : 618892 : if (!POINTER_TYPE_P (expr))
767 : 371328 : stream_write_tree_ref (ob, TYPE_MIN_VALUE_RAW (expr));
768 : 618892 : stream_write_tree_ref (ob, TYPE_MAX_VALUE_RAW (expr));
769 : 618892 : }
770 : :
771 : :
772 : : /* Write all pointer fields in the TS_LIST structure of EXPR to output
773 : : block OB. If REF_P is true, write a reference to EXPR's pointer
774 : : fields. */
775 : :
776 : : static void
777 : 644549 : write_ts_list_tree_pointers (struct output_block *ob, tree expr)
778 : : {
779 : 644549 : stream_write_tree_ref (ob, TREE_PURPOSE (expr));
780 : 644549 : stream_write_tree_ref (ob, TREE_VALUE (expr));
781 : 644549 : stream_write_tree_ref (ob, TREE_CHAIN (expr));
782 : 644549 : }
783 : :
784 : :
785 : : /* Write all pointer fields in the TS_VEC structure of EXPR to output
786 : : block OB. If REF_P is true, write a reference to EXPR's pointer
787 : : fields. */
788 : :
789 : : static void
790 : 0 : write_ts_vec_tree_pointers (struct output_block *ob, tree expr)
791 : : {
792 : 0 : int i;
793 : :
794 : : /* Note that the number of slots for EXPR has already been emitted
795 : : in EXPR's header (see streamer_write_tree_header). */
796 : 0 : for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
797 : 0 : stream_write_tree_ref (ob, TREE_VEC_ELT (expr, i));
798 : 0 : }
799 : :
800 : :
801 : : /* Write all pointer fields in the TS_EXP structure of EXPR to output
802 : : block OB. If REF_P is true, write a reference to EXPR's pointer
803 : : fields. */
804 : :
805 : : static void
806 : 1694038 : write_ts_exp_tree_pointers (struct output_block *ob, tree expr)
807 : : {
808 : 1694038 : int i;
809 : :
810 : 4093344 : for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
811 : 2399306 : stream_write_tree_ref (ob, TREE_OPERAND (expr, i));
812 : 1694038 : stream_write_tree_ref (ob, TREE_BLOCK (expr));
813 : 1694038 : }
814 : :
815 : :
816 : : /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
817 : : block OB. If REF_P is true, write a reference to EXPR's pointer
818 : : fields. */
819 : :
820 : : static void
821 : 334089 : write_ts_block_tree_pointers (struct output_block *ob, tree expr)
822 : : {
823 : 334089 : streamer_write_chain (ob, BLOCK_VARS (expr));
824 : :
825 : 334089 : stream_write_tree_ref (ob, BLOCK_SUPERCONTEXT (expr));
826 : 334089 : stream_write_tree_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr));
827 : :
828 : : /* Do not stream BLOCK_NONLOCALIZED_VARS. We cannot handle debug information
829 : : for early inlined BLOCKs so drop it on the floor instead of ICEing in
830 : : dwarf2out.cc. */
831 : :
832 : : /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
833 : : streaming time. */
834 : :
835 : : /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this
836 : : list is re-constructed from BLOCK_SUPERCONTEXT. */
837 : 334089 : }
838 : :
839 : :
840 : : /* Write all pointer fields in the TS_BINFO structure of EXPR to output
841 : : block OB. If REF_P is true, write a reference to EXPR's pointer
842 : : fields. */
843 : :
844 : : static void
845 : 7223 : write_ts_binfo_tree_pointers (struct output_block *ob, tree expr)
846 : : {
847 : 7223 : unsigned i;
848 : 7223 : tree t;
849 : :
850 : : /* Note that the number of BINFO slots has already been emitted in
851 : : EXPR's header (see streamer_write_tree_header) because this length
852 : : is needed to build the empty BINFO node on the reader side. */
853 : 14157 : FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
854 : 6934 : stream_write_tree_ref (ob, t);
855 : 7223 : stream_write_tree_ref (ob, NULL_TREE);
856 : :
857 : 7223 : stream_write_tree_ref (ob, BINFO_OFFSET (expr));
858 : 7223 : stream_write_tree_ref (ob, BINFO_VTABLE (expr));
859 : :
860 : : /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
861 : : BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used by C++ FE only. */
862 : 7223 : }
863 : :
864 : :
865 : : /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
866 : : output block OB. If REF_P is true, write a reference to EXPR's
867 : : pointer fields. */
868 : :
869 : : static void
870 : 236390 : write_ts_constructor_tree_pointers (struct output_block *ob, tree expr)
871 : : {
872 : 236390 : unsigned i;
873 : 236390 : tree index, value;
874 : :
875 : 762394 : FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
876 : : {
877 : 526004 : stream_write_tree_ref (ob, index);
878 : 526004 : stream_write_tree_ref (ob, value);
879 : : }
880 : 236390 : }
881 : :
882 : :
883 : : /* Write all pointer fields in the RAW_DATA_CST/TS_RAW_DATA_CST structure of
884 : : EXPR to output block OB. */
885 : :
886 : : static void
887 : 21 : write_ts_raw_data_cst_tree_pointers (struct output_block *ob, tree expr)
888 : : {
889 : : /* Only write this for non-NULL RAW_DATA_OWNER. RAW_DATA_CST with
890 : : NULL RAW_DATA_OWNER is streamed to be read back as STRING_CST. */
891 : 21 : if (RAW_DATA_OWNER (expr) != NULL_TREE)
892 : 19 : stream_write_tree_ref (ob, RAW_DATA_OWNER (expr));
893 : 21 : }
894 : :
895 : :
896 : : /* Write all pointer fields in the TS_OMP_CLAUSE structure of EXPR
897 : : to output block OB. If REF_P is true, write a reference to EXPR's
898 : : pointer fields. */
899 : :
900 : : static void
901 : 206 : write_ts_omp_clause_tree_pointers (struct output_block *ob, tree expr)
902 : : {
903 : 206 : int i;
904 : 482 : for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++)
905 : 276 : stream_write_tree_ref (ob, OMP_CLAUSE_OPERAND (expr, i));
906 : 206 : switch (OMP_CLAUSE_CODE (expr))
907 : : {
908 : 0 : case OMP_CLAUSE_REDUCTION:
909 : 0 : case OMP_CLAUSE_TASK_REDUCTION:
910 : 0 : case OMP_CLAUSE_IN_REDUCTION:
911 : : /* We don't stream these right now, handle it if streaming
912 : : of them is needed. */
913 : 0 : gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (expr) == NULL);
914 : 0 : gcc_assert (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (expr) == NULL);
915 : : break;
916 : : default:
917 : : break;
918 : : }
919 : 206 : stream_write_tree_ref (ob, OMP_CLAUSE_CHAIN (expr));
920 : 206 : }
921 : :
922 : :
923 : : /* Write all pointer fields in EXPR to output block OB. If REF_P is true,
924 : : the leaves of EXPR are emitted as references. */
925 : :
926 : : void
927 : 6892687 : streamer_write_tree_body (struct output_block *ob, tree expr)
928 : : {
929 : 6892687 : enum tree_code code;
930 : :
931 : 6892687 : lto_stats.num_tree_bodies_output++;
932 : :
933 : 6892687 : code = TREE_CODE (expr);
934 : :
935 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
936 : 6492876 : write_ts_common_tree_pointers (ob, expr);
937 : :
938 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
939 : 5690 : write_ts_vector_tree_pointers (ob, expr);
940 : :
941 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
942 : 0 : write_ts_poly_tree_pointers (ob, expr);
943 : :
944 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
945 : 8025 : write_ts_complex_tree_pointers (ob, expr);
946 : :
947 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
948 : 1502709 : write_ts_decl_minimal_tree_pointers (ob, expr);
949 : :
950 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
951 : 1502709 : write_ts_decl_common_tree_pointers (ob, expr);
952 : :
953 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
954 : 6892687 : write_ts_decl_non_common_tree_pointers (ob, expr);
955 : :
956 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
957 : 903646 : write_ts_decl_with_vis_tree_pointers (ob, expr);
958 : :
959 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
960 : 104513 : write_ts_field_decl_tree_pointers (ob, expr);
961 : :
962 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
963 : 424871 : write_ts_function_decl_tree_pointers (ob, expr);
964 : :
965 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
966 : 618892 : write_ts_type_common_tree_pointers (ob, expr);
967 : :
968 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
969 : 618892 : write_ts_type_non_common_tree_pointers (ob, expr);
970 : :
971 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_LIST))
972 : 644549 : write_ts_list_tree_pointers (ob, expr);
973 : :
974 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_VEC))
975 : 0 : write_ts_vec_tree_pointers (ob, expr);
976 : :
977 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_EXP))
978 : 1694038 : write_ts_exp_tree_pointers (ob, expr);
979 : :
980 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
981 : 334089 : write_ts_block_tree_pointers (ob, expr);
982 : :
983 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
984 : 7223 : write_ts_binfo_tree_pointers (ob, expr);
985 : :
986 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
987 : 236390 : write_ts_constructor_tree_pointers (ob, expr);
988 : :
989 : 6892687 : if (code == RAW_DATA_CST)
990 : 21 : write_ts_raw_data_cst_tree_pointers (ob, expr);
991 : :
992 : 6892687 : if (code == OMP_CLAUSE)
993 : 206 : write_ts_omp_clause_tree_pointers (ob, expr);
994 : 6892687 : }
995 : :
996 : :
997 : : /* Emit header information for tree EXPR to output block OB. The header
998 : : contains everything needed to instantiate an empty skeleton for
999 : : EXPR on the reading side. IX is the index into the streamer cache
1000 : : where EXPR is stored. */
1001 : :
1002 : : void
1003 : 6892687 : streamer_write_tree_header (struct output_block *ob, tree expr)
1004 : : {
1005 : 6892687 : enum LTO_tags tag;
1006 : 6892687 : enum tree_code code;
1007 : :
1008 : 6892687 : if (streamer_dump_file)
1009 : : {
1010 : 416 : print_node_brief (streamer_dump_file, " Streaming header of ",
1011 : : expr, 4);
1012 : 416 : fprintf (streamer_dump_file, " to %s\n",
1013 : 416 : lto_section_name[ob->section_type]);
1014 : : }
1015 : :
1016 : : /* We should not see any tree nodes not handled by the streamer. */
1017 : 6892687 : code = TREE_CODE (expr);
1018 : :
1019 : : /* The header of a tree node consists of its tag, the size of
1020 : : the node, and any other information needed to instantiate
1021 : : EXPR on the reading side (such as the number of slots in
1022 : : variable sized nodes). */
1023 : 6892687 : tag = lto_tree_code_to_tag (code);
1024 : 6892687 : streamer_write_record_start (ob, tag);
1025 : :
1026 : : /* The text in strings and identifiers are completely emitted in
1027 : : the header. */
1028 : 6892687 : if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1029 : 174630 : streamer_write_string_cst (ob, ob->main_stream, expr);
1030 : 6718057 : else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1031 : 1448014 : write_identifier (ob, ob->main_stream, expr);
1032 : 5270043 : else if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1033 : : {
1034 : 5690 : bitpack_d bp = bitpack_create (ob->main_stream);
1035 : 5690 : bp_pack_value (&bp, VECTOR_CST_LOG2_NPATTERNS (expr), 8);
1036 : 5690 : bp_pack_value (&bp, VECTOR_CST_NELTS_PER_PATTERN (expr), 8);
1037 : 5690 : streamer_write_bitpack (&bp);
1038 : : }
1039 : 5264353 : else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1040 : 0 : streamer_write_hwi (ob, TREE_VEC_LENGTH (expr));
1041 : 5264353 : else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1042 : 7223 : streamer_write_uhwi (ob, BINFO_N_BASE_BINFOS (expr));
1043 : 5257130 : else if (TREE_CODE (expr) == CALL_EXPR)
1044 : 24 : streamer_write_uhwi (ob, call_expr_nargs (expr));
1045 : 5257106 : else if (TREE_CODE (expr) == OMP_CLAUSE)
1046 : 206 : streamer_write_uhwi (ob, OMP_CLAUSE_CODE (expr));
1047 : 5256900 : else if (TREE_CODE (expr) == RAW_DATA_CST)
1048 : : {
1049 : 21 : if (RAW_DATA_OWNER (expr) == NULL_TREE)
1050 : : {
1051 : : /* RAW_DATA_CST with NULL RAW_DATA_OWNER is an owner of other
1052 : : RAW_DATA_CST's data. This should be streamed out so that
1053 : : it can be streamed back in as a STRING_CST instead, but without
1054 : : the need to duplicate the possibly large data. */
1055 : 2 : streamer_write_uhwi (ob, 0);
1056 : 2 : streamer_write_string_with_length (ob, ob->main_stream,
1057 : 2 : RAW_DATA_POINTER (expr),
1058 : 2 : RAW_DATA_LENGTH (expr), true);
1059 : : }
1060 : : else
1061 : : {
1062 : 19 : streamer_write_uhwi (ob, RAW_DATA_LENGTH (expr));
1063 : 19 : tree owner = RAW_DATA_OWNER (expr);
1064 : 19 : unsigned HOST_WIDE_INT off;
1065 : 19 : if (TREE_CODE (owner) == STRING_CST)
1066 : 16 : off = RAW_DATA_POINTER (expr) - TREE_STRING_POINTER (owner);
1067 : : else
1068 : : {
1069 : 3 : gcc_checking_assert (TREE_CODE (owner) == RAW_DATA_CST
1070 : : && RAW_DATA_OWNER (owner) == NULL_TREE);
1071 : 3 : off = RAW_DATA_POINTER (expr) - RAW_DATA_POINTER (owner);
1072 : : }
1073 : 19 : streamer_write_uhwi (ob, off);
1074 : : }
1075 : : }
1076 : 5256879 : else if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1077 : : {
1078 : 39504 : gcc_checking_assert (TREE_INT_CST_NUNITS (expr));
1079 : 39504 : streamer_write_uhwi (ob, TREE_INT_CST_NUNITS (expr));
1080 : 39504 : streamer_write_uhwi (ob, TREE_INT_CST_EXT_NUNITS (expr));
1081 : : }
1082 : 6892687 : }
1083 : :
1084 : :
1085 : : /* Emit the integer constant CST to output block OB. If REF_P is true,
1086 : : CST's type will be emitted as a reference. */
1087 : :
1088 : : void
1089 : 1017689 : streamer_write_integer_cst (struct output_block *ob, tree cst)
1090 : : {
1091 : 1017689 : int i;
1092 : 1017689 : int len = TREE_INT_CST_NUNITS (cst);
1093 : 1017689 : gcc_assert (!TREE_OVERFLOW (cst));
1094 : 1017689 : if (streamer_dump_file)
1095 : : {
1096 : 140 : print_node_brief (streamer_dump_file, " Streaming integer ",
1097 : : cst, 4);
1098 : 140 : fprintf (streamer_dump_file, "\n");
1099 : : }
1100 : 1017689 : streamer_write_record_start (ob, LTO_integer_cst);
1101 : 1017689 : stream_write_tree_ref (ob, TREE_TYPE (cst));
1102 : : /* We're effectively streaming a non-sign-extended wide_int here,
1103 : : so there's no need to stream TREE_INT_CST_EXT_NUNITS or any
1104 : : array members beyond LEN. We'll recreate the tree from the
1105 : : wide_int and the type. */
1106 : 1017689 : streamer_write_uhwi (ob, len);
1107 : 3058333 : for (i = 0; i < len; i++)
1108 : 1022955 : streamer_write_hwi (ob, TREE_INT_CST_ELT (cst, i));
1109 : 1017689 : }
|
