re PR tree-optimization/55253 (Revision 193298 miscompiles sqlite with -Os)
[gcc.git] / gcc / tree-streamer.c
1 /* Miscellaneous utilities for tree streaming. Things that are used
2 in both input and output are here.
3
4 Copyright 2011 Free Software Foundation, Inc.
5 Contributed by Diego Novillo <dnovillo@google.com>
6
7 This file is part of GCC.
8
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.
13
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.
18
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/>. */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "streamer-hooks.h"
27 #include "tree-streamer.h"
28
29 /* Check that all the TS_* structures handled by the streamer_write_* and
30 streamer_read_* routines are exactly ALL the structures defined in
31 treestruct.def. */
32
33 void
34 streamer_check_handled_ts_structures (void)
35 {
36 bool handled_p[LAST_TS_ENUM];
37 unsigned i;
38
39 memset (&handled_p, 0, sizeof (handled_p));
40
41 /* These are the TS_* structures that are either handled or
42 explicitly ignored by the streamer routines. */
43 handled_p[TS_BASE] = true;
44 handled_p[TS_TYPED] = true;
45 handled_p[TS_COMMON] = true;
46 handled_p[TS_INT_CST] = true;
47 handled_p[TS_REAL_CST] = true;
48 handled_p[TS_FIXED_CST] = true;
49 handled_p[TS_VECTOR] = true;
50 handled_p[TS_STRING] = true;
51 handled_p[TS_COMPLEX] = true;
52 handled_p[TS_IDENTIFIER] = true;
53 handled_p[TS_DECL_MINIMAL] = true;
54 handled_p[TS_DECL_COMMON] = true;
55 handled_p[TS_DECL_WRTL] = true;
56 handled_p[TS_DECL_NON_COMMON] = true;
57 handled_p[TS_DECL_WITH_VIS] = true;
58 handled_p[TS_FIELD_DECL] = true;
59 handled_p[TS_VAR_DECL] = true;
60 handled_p[TS_PARM_DECL] = true;
61 handled_p[TS_LABEL_DECL] = true;
62 handled_p[TS_RESULT_DECL] = true;
63 handled_p[TS_CONST_DECL] = true;
64 handled_p[TS_TYPE_DECL] = true;
65 handled_p[TS_FUNCTION_DECL] = true;
66 handled_p[TS_TYPE_COMMON] = true;
67 handled_p[TS_TYPE_WITH_LANG_SPECIFIC] = true;
68 handled_p[TS_TYPE_NON_COMMON] = true;
69 handled_p[TS_LIST] = true;
70 handled_p[TS_VEC] = true;
71 handled_p[TS_EXP] = true;
72 handled_p[TS_SSA_NAME] = true;
73 handled_p[TS_BLOCK] = true;
74 handled_p[TS_BINFO] = true;
75 handled_p[TS_STATEMENT_LIST] = true;
76 handled_p[TS_CONSTRUCTOR] = true;
77 handled_p[TS_OMP_CLAUSE] = true;
78 handled_p[TS_OPTIMIZATION] = true;
79 handled_p[TS_TARGET_OPTION] = true;
80 handled_p[TS_TRANSLATION_UNIT_DECL] = true;
81
82 /* Anything not marked above will trigger the following assertion.
83 If this assertion triggers, it means that there is a new TS_*
84 structure that should be handled by the streamer. */
85 for (i = 0; i < LAST_TS_ENUM; i++)
86 gcc_assert (handled_p[i]);
87 }
88
89
90 /* Helper for streamer_tree_cache_insert_1. Add T to CACHE->NODES at
91 slot IX. */
92
93 static void
94 streamer_tree_cache_add_to_node_array (struct streamer_tree_cache_d *cache,
95 unsigned ix, tree t)
96 {
97 /* Make sure we're either replacing an old element or
98 appending consecutively. */
99 gcc_assert (ix <= VEC_length (tree, cache->nodes));
100
101 if (ix == VEC_length (tree, cache->nodes))
102 VEC_safe_push (tree, heap, cache->nodes, t);
103 else
104 VEC_replace (tree, cache->nodes, ix, t);
105 }
106
107
108 /* Helper for streamer_tree_cache_insert and streamer_tree_cache_insert_at.
109 CACHE, T, and IX_P are as in streamer_tree_cache_insert.
110
111 If INSERT_AT_NEXT_SLOT_P is true, T is inserted at the next available
112 slot in the cache. Otherwise, T is inserted at the position indicated
113 in *IX_P.
114
115 If T already existed in CACHE, return true. Otherwise,
116 return false. */
117
118 static bool
119 streamer_tree_cache_insert_1 (struct streamer_tree_cache_d *cache,
120 tree t, unsigned *ix_p,
121 bool insert_at_next_slot_p)
122 {
123 void **slot;
124 unsigned ix;
125 bool existed_p;
126
127 gcc_assert (t);
128
129 slot = pointer_map_insert (cache->node_map, t);
130 if (!*slot)
131 {
132 /* Determine the next slot to use in the cache. */
133 if (insert_at_next_slot_p)
134 ix = VEC_length (tree, cache->nodes);
135 else
136 ix = *ix_p;
137 *slot = (void *)(size_t) (ix + 1);
138
139 streamer_tree_cache_add_to_node_array (cache, ix, t);
140
141 /* Indicate that the item was not present in the cache. */
142 existed_p = false;
143 }
144 else
145 {
146 ix = (size_t) *slot - 1;
147
148 if (!insert_at_next_slot_p && ix != *ix_p)
149 {
150 /* If the caller wants to insert T at a specific slot
151 location, and ENTRY->TO does not match *IX_P, add T to
152 the requested location slot. */
153 ix = *ix_p;
154 streamer_tree_cache_add_to_node_array (cache, ix, t);
155 }
156
157 /* Indicate that T was already in the cache. */
158 existed_p = true;
159 }
160
161 if (ix_p)
162 *ix_p = ix;
163
164 return existed_p;
165 }
166
167
168 /* Insert tree node T in CACHE. If T already existed in the cache
169 return true. Otherwise, return false.
170
171 If IX_P is non-null, update it with the index into the cache where
172 T has been stored. */
173
174 bool
175 streamer_tree_cache_insert (struct streamer_tree_cache_d *cache, tree t,
176 unsigned *ix_p)
177 {
178 return streamer_tree_cache_insert_1 (cache, t, ix_p, true);
179 }
180
181
182 /* Insert tree node T in CACHE at slot IX. If T already
183 existed in the cache return true. Otherwise, return false. */
184
185 bool
186 streamer_tree_cache_insert_at (struct streamer_tree_cache_d *cache,
187 tree t, unsigned ix)
188 {
189 return streamer_tree_cache_insert_1 (cache, t, &ix, false);
190 }
191
192
193 /* Appends tree node T to CACHE, even if T already existed in it. */
194
195 void
196 streamer_tree_cache_append (struct streamer_tree_cache_d *cache, tree t)
197 {
198 unsigned ix = VEC_length (tree, cache->nodes);
199 streamer_tree_cache_insert_1 (cache, t, &ix, false);
200 }
201
202 /* Return true if tree node T exists in CACHE, otherwise false. If IX_P is
203 not NULL, write to *IX_P the index into the cache where T is stored
204 ((unsigned)-1 if T is not found). */
205
206 bool
207 streamer_tree_cache_lookup (struct streamer_tree_cache_d *cache, tree t,
208 unsigned *ix_p)
209 {
210 void **slot;
211 bool retval;
212 unsigned ix;
213
214 gcc_assert (t);
215
216 slot = pointer_map_contains (cache->node_map, t);
217 if (slot == NULL)
218 {
219 retval = false;
220 ix = -1;
221 }
222 else
223 {
224 retval = true;
225 ix = (size_t) *slot - 1;
226 }
227
228 if (ix_p)
229 *ix_p = ix;
230
231 return retval;
232 }
233
234
235 /* Record NODE in CACHE. */
236
237 static void
238 record_common_node (struct streamer_tree_cache_d *cache, tree node)
239 {
240 /* We have to make sure to fill exactly the same number of
241 elements for all frontends. That can include NULL trees.
242 As our hash table can't deal with zero entries we'll simply stream
243 a random other tree. A NULL tree never will be looked up so it
244 doesn't matter which tree we replace it with, just to be sure
245 use error_mark_node. */
246 if (!node)
247 node = error_mark_node;
248
249 streamer_tree_cache_append (cache, node);
250
251 if (POINTER_TYPE_P (node)
252 || TREE_CODE (node) == COMPLEX_TYPE
253 || TREE_CODE (node) == ARRAY_TYPE)
254 record_common_node (cache, TREE_TYPE (node));
255 else if (TREE_CODE (node) == RECORD_TYPE)
256 {
257 /* The FIELD_DECLs of structures should be shared, so that every
258 COMPONENT_REF uses the same tree node when referencing a field.
259 Pointer equality between FIELD_DECLs is used by the alias
260 machinery to compute overlapping memory references (See
261 nonoverlapping_component_refs_p). */
262 tree f;
263 for (f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
264 record_common_node (cache, f);
265 }
266 }
267
268
269 /* Preload common nodes into CACHE and make sure they are merged
270 properly according to the gimple type table. */
271
272 static void
273 preload_common_nodes (struct streamer_tree_cache_d *cache)
274 {
275 unsigned i;
276
277 for (i = 0; i < itk_none; i++)
278 /* Skip itk_char. char_type_node is dependent on -f[un]signed-char. */
279 if (i != itk_char)
280 record_common_node (cache, integer_types[i]);
281
282 for (i = 0; i < stk_type_kind_last; i++)
283 record_common_node (cache, sizetype_tab[i]);
284
285 for (i = 0; i < TI_MAX; i++)
286 /* Skip boolean type and constants, they are frontend dependent. */
287 if (i != TI_BOOLEAN_TYPE
288 && i != TI_BOOLEAN_FALSE
289 && i != TI_BOOLEAN_TRUE)
290 record_common_node (cache, global_trees[i]);
291 }
292
293
294 /* Create a cache of pickled nodes. */
295
296 struct streamer_tree_cache_d *
297 streamer_tree_cache_create (void)
298 {
299 struct streamer_tree_cache_d *cache;
300
301 cache = XCNEW (struct streamer_tree_cache_d);
302
303 cache->node_map = pointer_map_create ();
304
305 /* Load all the well-known tree nodes that are always created by
306 the compiler on startup. This prevents writing them out
307 unnecessarily. */
308 preload_common_nodes (cache);
309
310 return cache;
311 }
312
313
314 /* Delete the streamer cache C. */
315
316 void
317 streamer_tree_cache_delete (struct streamer_tree_cache_d *c)
318 {
319 if (c == NULL)
320 return;
321
322 pointer_map_destroy (c->node_map);
323 VEC_free (tree, heap, c->nodes);
324 free (c);
325 }