Daily bump.
[official-gcc.git] / gcc / tree-streamer.c
blob5fc4efdb1a0e16b26037c37ad61394a9abac8569
1 /* Miscellaneous utilities for tree streaming. Things that are used
2 in both input and output are here.
4 Copyright (C) 2011-2017 Free Software Foundation, Inc.
5 Contributed by Diego Novillo <dnovillo@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
12 version.
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "backend.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "tree-streamer.h"
30 #include "cgraph.h"
32 /* Table indexed by machine_mode, used for 2 different purposes.
33 During streaming out we record there non-zero value for all modes
34 that were streamed out.
35 During streaming in, we translate the on the disk mode using this
36 table. For normal LTO it is set to identity, for ACCEL_COMPILER
37 depending on the mode_table content. */
38 unsigned char streamer_mode_table[1 << 8];
40 /* Check that all the TS_* structures handled by the streamer_write_* and
41 streamer_read_* routines are exactly ALL the structures defined in
42 treestruct.def. */
44 void
45 streamer_check_handled_ts_structures (void)
47 bool handled_p[LAST_TS_ENUM];
48 unsigned i;
50 memset (&handled_p, 0, sizeof (handled_p));
52 /* These are the TS_* structures that are either handled or
53 explicitly ignored by the streamer routines. */
54 handled_p[TS_BASE] = true;
55 handled_p[TS_TYPED] = true;
56 handled_p[TS_COMMON] = true;
57 handled_p[TS_INT_CST] = true;
58 handled_p[TS_REAL_CST] = true;
59 handled_p[TS_FIXED_CST] = true;
60 handled_p[TS_VECTOR] = true;
61 handled_p[TS_STRING] = true;
62 handled_p[TS_COMPLEX] = true;
63 handled_p[TS_IDENTIFIER] = true;
64 handled_p[TS_DECL_MINIMAL] = true;
65 handled_p[TS_DECL_COMMON] = true;
66 handled_p[TS_DECL_WRTL] = true;
67 handled_p[TS_DECL_NON_COMMON] = true;
68 handled_p[TS_DECL_WITH_VIS] = true;
69 handled_p[TS_FIELD_DECL] = true;
70 handled_p[TS_VAR_DECL] = true;
71 handled_p[TS_PARM_DECL] = true;
72 handled_p[TS_LABEL_DECL] = true;
73 handled_p[TS_RESULT_DECL] = true;
74 handled_p[TS_CONST_DECL] = true;
75 handled_p[TS_TYPE_DECL] = true;
76 handled_p[TS_FUNCTION_DECL] = true;
77 handled_p[TS_TYPE_COMMON] = true;
78 handled_p[TS_TYPE_WITH_LANG_SPECIFIC] = true;
79 handled_p[TS_TYPE_NON_COMMON] = true;
80 handled_p[TS_LIST] = true;
81 handled_p[TS_VEC] = true;
82 handled_p[TS_EXP] = true;
83 handled_p[TS_SSA_NAME] = true;
84 handled_p[TS_BLOCK] = true;
85 handled_p[TS_BINFO] = true;
86 handled_p[TS_STATEMENT_LIST] = true;
87 handled_p[TS_CONSTRUCTOR] = true;
88 handled_p[TS_OMP_CLAUSE] = true;
89 handled_p[TS_OPTIMIZATION] = true;
90 handled_p[TS_TARGET_OPTION] = true;
91 handled_p[TS_TRANSLATION_UNIT_DECL] = true;
93 /* Anything not marked above will trigger the following assertion.
94 If this assertion triggers, it means that there is a new TS_*
95 structure that should be handled by the streamer. */
96 for (i = 0; i < LAST_TS_ENUM; i++)
97 gcc_assert (handled_p[i]);
101 /* Helper for streamer_tree_cache_insert_1. Add T to CACHE->NODES at
102 slot IX. */
104 static void
105 streamer_tree_cache_add_to_node_array (struct streamer_tree_cache_d *cache,
106 unsigned ix, tree t, hashval_t hash)
108 /* We're either replacing an old element or appending consecutively. */
109 if (cache->nodes.exists ())
111 if (cache->nodes.length () == ix)
112 cache->nodes.safe_push (t);
113 else
114 cache->nodes[ix] = t;
116 if (cache->hashes.exists ())
118 if (cache->hashes.length () == ix)
119 cache->hashes.safe_push (hash);
120 else
121 cache->hashes[ix] = hash;
126 /* Helper for streamer_tree_cache_insert and streamer_tree_cache_insert_at.
127 CACHE, T, and IX_P are as in streamer_tree_cache_insert.
129 If INSERT_AT_NEXT_SLOT_P is true, T is inserted at the next available
130 slot in the cache. Otherwise, T is inserted at the position indicated
131 in *IX_P.
133 If T already existed in CACHE, return true. Otherwise,
134 return false. */
136 static bool
137 streamer_tree_cache_insert_1 (struct streamer_tree_cache_d *cache,
138 tree t, hashval_t hash, unsigned *ix_p,
139 bool insert_at_next_slot_p)
141 bool existed_p;
143 gcc_assert (t);
145 unsigned int &ix = cache->node_map->get_or_insert (t, &existed_p);
146 if (!existed_p)
148 /* Determine the next slot to use in the cache. */
149 if (insert_at_next_slot_p)
150 ix = cache->next_idx++;
151 else
152 ix = *ix_p;
154 streamer_tree_cache_add_to_node_array (cache, ix, t, hash);
156 else
158 if (!insert_at_next_slot_p && ix != *ix_p)
160 /* If the caller wants to insert T at a specific slot
161 location, and ENTRY->TO does not match *IX_P, add T to
162 the requested location slot. */
163 ix = *ix_p;
164 streamer_tree_cache_add_to_node_array (cache, ix, t, hash);
168 if (ix_p)
169 *ix_p = ix;
171 return existed_p;
175 /* Insert tree node T in CACHE. If T already existed in the cache
176 return true. Otherwise, return false.
178 If IX_P is non-null, update it with the index into the cache where
179 T has been stored. */
181 bool
182 streamer_tree_cache_insert (struct streamer_tree_cache_d *cache, tree t,
183 hashval_t hash, unsigned *ix_p)
185 return streamer_tree_cache_insert_1 (cache, t, hash, ix_p, true);
189 /* Replace the tree node with T in CACHE at slot IX. */
191 void
192 streamer_tree_cache_replace_tree (struct streamer_tree_cache_d *cache,
193 tree t, unsigned ix)
195 hashval_t hash = 0;
196 if (cache->hashes.exists ())
197 hash = streamer_tree_cache_get_hash (cache, ix);
198 if (!cache->node_map)
199 streamer_tree_cache_add_to_node_array (cache, ix, t, hash);
200 else
201 streamer_tree_cache_insert_1 (cache, t, hash, &ix, false);
205 /* Appends tree node T to CACHE, even if T already existed in it. */
207 void
208 streamer_tree_cache_append (struct streamer_tree_cache_d *cache,
209 tree t, hashval_t hash)
211 unsigned ix = cache->next_idx++;
212 if (!cache->node_map)
213 streamer_tree_cache_add_to_node_array (cache, ix, t, hash);
214 else
215 streamer_tree_cache_insert_1 (cache, t, hash, &ix, false);
218 /* Return true if tree node T exists in CACHE, otherwise false. If IX_P is
219 not NULL, write to *IX_P the index into the cache where T is stored
220 ((unsigned)-1 if T is not found). */
222 bool
223 streamer_tree_cache_lookup (struct streamer_tree_cache_d *cache, tree t,
224 unsigned *ix_p)
226 unsigned *slot;
227 bool retval;
228 unsigned ix;
230 gcc_assert (t);
232 slot = cache->node_map->get (t);
233 if (slot == NULL)
235 retval = false;
236 ix = -1;
238 else
240 retval = true;
241 ix = *slot;
244 if (ix_p)
245 *ix_p = ix;
247 return retval;
251 /* Verify that NODE is in CACHE. */
253 static void
254 verify_common_node_recorded (struct streamer_tree_cache_d *cache, tree node)
256 /* Restrict this to flag_checking only because in general violating it is
257 harmless plus we never know what happens on all targets/frontend/flag(!)
258 combinations. */
259 if (!flag_checking)
260 return;
262 if (cache->node_map)
263 gcc_assert (streamer_tree_cache_lookup (cache, node, NULL));
264 else
266 bool found = false;
267 gcc_assert (cache->nodes.exists ());
268 /* Linear search... */
269 for (unsigned i = 0; !found && i < cache->nodes.length (); ++i)
270 if (cache->nodes[i] == node)
271 found = true;
272 gcc_assert (found);
277 /* Record NODE in CACHE. */
279 static void
280 record_common_node (struct streamer_tree_cache_d *cache, tree node)
282 /* If we recursively end up at nodes we do not want to preload simply don't.
283 ??? We'd want to verify that this doesn't happen, or alternatively
284 do not recurse at all. */
285 if (node == char_type_node)
286 return;
288 gcc_checking_assert (node != boolean_type_node
289 && node != boolean_true_node
290 && node != boolean_false_node);
292 /* We have to make sure to fill exactly the same number of
293 elements for all frontends. That can include NULL trees.
294 As our hash table can't deal with zero entries we'll simply stream
295 a random other tree. A NULL tree never will be looked up so it
296 doesn't matter which tree we replace it with, just to be sure
297 use error_mark_node. */
298 if (!node)
299 node = error_mark_node;
301 /* ??? FIXME, devise a better hash value. But the hash needs to be equal
302 for all frontend and lto1 invocations. So just use the position
303 in the cache as hash value. */
304 streamer_tree_cache_append (cache, node, cache->nodes.length ());
306 switch (TREE_CODE (node))
308 case ERROR_MARK:
309 case FIELD_DECL:
310 case FIXED_POINT_TYPE:
311 case IDENTIFIER_NODE:
312 case INTEGER_CST:
313 case INTEGER_TYPE:
314 case POINTER_BOUNDS_TYPE:
315 case REAL_TYPE:
316 case TREE_LIST:
317 case VOID_CST:
318 case VOID_TYPE:
319 /* No recursive trees. */
320 break;
321 case ARRAY_TYPE:
322 case POINTER_TYPE:
323 case REFERENCE_TYPE:
324 record_common_node (cache, TREE_TYPE (node));
325 break;
326 case COMPLEX_TYPE:
327 /* Verify that a complex type's component type (node_type) has been
328 handled already (and we thus don't need to recurse here). */
329 verify_common_node_recorded (cache, TREE_TYPE (node));
330 break;
331 case RECORD_TYPE:
332 /* The FIELD_DECLs of structures should be shared, so that every
333 COMPONENT_REF uses the same tree node when referencing a field.
334 Pointer equality between FIELD_DECLs is used by the alias
335 machinery to compute overlapping component references (see
336 nonoverlapping_component_refs_p and
337 nonoverlapping_component_refs_of_decl_p). */
338 for (tree f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
339 record_common_node (cache, f);
340 break;
341 default:
342 /* Unexpected tree code. */
343 gcc_unreachable ();
348 /* Preload common nodes into CACHE and make sure they are merged
349 properly according to the gimple type table. */
351 static void
352 preload_common_nodes (struct streamer_tree_cache_d *cache)
354 unsigned i;
356 for (i = 0; i < itk_none; i++)
357 /* Skip itk_char. char_type_node is dependent on -f[un]signed-char. */
358 if (i != itk_char)
359 record_common_node (cache, integer_types[i]);
361 for (i = 0; i < stk_type_kind_last; i++)
362 record_common_node (cache, sizetype_tab[i]);
364 for (i = 0; i < TI_MAX; i++)
365 /* Skip boolean type and constants, they are frontend dependent. */
366 if (i != TI_BOOLEAN_TYPE
367 && i != TI_BOOLEAN_FALSE
368 && i != TI_BOOLEAN_TRUE
369 /* MAIN_IDENTIFIER is not always initialized by Fortran FE. */
370 && i != TI_MAIN_IDENTIFIER
371 /* PID_TYPE is initialized only by C family front-ends. */
372 && i != TI_PID_TYPE
373 /* Skip optimization and target option nodes; they depend on flags. */
374 && i != TI_OPTIMIZATION_DEFAULT
375 && i != TI_OPTIMIZATION_CURRENT
376 && i != TI_TARGET_OPTION_DEFAULT
377 && i != TI_TARGET_OPTION_CURRENT
378 && i != TI_CURRENT_TARGET_PRAGMA
379 && i != TI_CURRENT_OPTIMIZE_PRAGMA
380 /* Skip va_list* related nodes if offloading. For native LTO
381 we want them to be merged for the stdarg pass, for offloading
382 they might not be identical between host and offloading target. */
383 && (!lto_stream_offload_p
384 || (i != TI_VA_LIST_TYPE
385 && i != TI_VA_LIST_GPR_COUNTER_FIELD
386 && i != TI_VA_LIST_FPR_COUNTER_FIELD)))
387 record_common_node (cache, global_trees[i]);
391 /* Create a cache of pickled nodes. */
393 struct streamer_tree_cache_d *
394 streamer_tree_cache_create (bool with_hashes, bool with_map, bool with_vec)
396 struct streamer_tree_cache_d *cache;
398 cache = XCNEW (struct streamer_tree_cache_d);
400 if (with_map)
401 cache->node_map = new hash_map<tree, unsigned> (251);
402 cache->next_idx = 0;
403 if (with_vec)
404 cache->nodes.create (165);
405 if (with_hashes)
406 cache->hashes.create (165);
408 /* Load all the well-known tree nodes that are always created by
409 the compiler on startup. This prevents writing them out
410 unnecessarily. */
411 preload_common_nodes (cache);
413 return cache;
417 /* Delete the streamer cache C. */
419 void
420 streamer_tree_cache_delete (struct streamer_tree_cache_d *c)
422 if (c == NULL)
423 return;
425 delete c->node_map;
426 c->node_map = NULL;
427 c->nodes.release ();
428 c->hashes.release ();
429 free (c);