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 /* Return the tree node at slot IX in CACHE. */ 236 237 tree 238 streamer_tree_cache_get (struct streamer_tree_cache_d *cache, unsigned ix) 239 { 240 gcc_assert (cache); 241 242 /* Make sure we're not requesting something we don't have. */ 243 gcc_assert (ix < VEC_length (tree, cache->nodes)); 244 245 return VEC_index (tree, cache->nodes, ix); 246 } 247 248 249 /* Record NODE in CACHE. */ 250 251 static void 252 record_common_node (struct streamer_tree_cache_d *cache, tree node) 253 { 254 /* If we recursively end up at nodes we do not want to preload simply don't. 255 ??? We'd want to verify that this doesn't happen, or alternatively 256 do not recurse at all. */ 257 if (node == char_type_node) 258 return; 259 260 gcc_checking_assert (node != boolean_type_node 261 && node != boolean_true_node 262 && node != boolean_false_node); 263 264 /* We have to make sure to fill exactly the same number of 265 elements for all frontends. That can include NULL trees. 266 As our hash table can't deal with zero entries we'll simply stream 267 a random other tree. A NULL tree never will be looked up so it 268 doesn't matter which tree we replace it with, just to be sure 269 use error_mark_node. */ 270 if (!node) 271 node = error_mark_node; 272 273 streamer_tree_cache_append (cache, node); 274 275 if (POINTER_TYPE_P (node) 276 || TREE_CODE (node) == COMPLEX_TYPE 277 || TREE_CODE (node) == ARRAY_TYPE) 278 record_common_node (cache, TREE_TYPE (node)); 279 else if (TREE_CODE (node) == RECORD_TYPE) 280 { 281 /* The FIELD_DECLs of structures should be shared, so that every 282 COMPONENT_REF uses the same tree node when referencing a field. 283 Pointer equality between FIELD_DECLs is used by the alias 284 machinery to compute overlapping memory references (See 285 nonoverlapping_component_refs_p). */ 286 tree f; 287 for (f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f)) 288 record_common_node (cache, f); 289 } 290 } 291 292 293 /* Preload common nodes into CACHE and make sure they are merged 294 properly according to the gimple type table. */ 295 296 static void 297 preload_common_nodes (struct streamer_tree_cache_d *cache) 298 { 299 unsigned i; 300 301 for (i = 0; i < itk_none; i++) 302 /* Skip itk_char. char_type_node is dependent on -f[un]signed-char. */ 303 if (i != itk_char) 304 record_common_node (cache, integer_types[i]); 305 306 for (i = 0; i < TYPE_KIND_LAST; i++) 307 record_common_node (cache, sizetype_tab[i]); 308 309 for (i = 0; i < TI_MAX; i++) 310 /* Skip boolean type and constants, they are frontend dependent. */ 311 if (i != TI_BOOLEAN_TYPE 312 && i != TI_BOOLEAN_FALSE 313 && i != TI_BOOLEAN_TRUE) 314 record_common_node (cache, global_trees[i]); 315 } 316 317 318 /* Create a cache of pickled nodes. */ 319 320 struct streamer_tree_cache_d * 321 streamer_tree_cache_create (void) 322 { 323 struct streamer_tree_cache_d *cache; 324 325 cache = XCNEW (struct streamer_tree_cache_d); 326 327 cache->node_map = pointer_map_create (); 328 329 /* Load all the well-known tree nodes that are always created by 330 the compiler on startup. This prevents writing them out 331 unnecessarily. */ 332 preload_common_nodes (cache); 333 334 return cache; 335 } 336 337 338 /* Delete the streamer cache C. */ 339 340 void 341 streamer_tree_cache_delete (struct streamer_tree_cache_d *c) 342 { 343 if (c == NULL) 344 return; 345 346 pointer_map_destroy (c->node_map); 347 VEC_free (tree, heap, c->nodes); 348 free (c); 349 } 350