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 (C) 2011-2013 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 <= cache->nodes.length ());
 100
 101   if (ix == cache->nodes.length ())
 102     cache->nodes.safe_push (t);
 103   else
 104     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 = cache->nodes.length ();
 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           *slot = (void *)(size_t) (ix + 1);
 156         }
 157
 158       /* Indicate that T was already in the cache.  */
 159       existed_p = true;
 160     }
 161
 162   if (ix_p)
 163     *ix_p = ix;
 164
 165   return existed_p;
 166 }
 167
 168
 169 /* Insert tree node T in CACHE.  If T already existed in the cache
 170    return true.  Otherwise, return false.
 171
 172    If IX_P is non-null, update it with the index into the cache where
 173    T has been stored.  */
 174
 175 bool
 176 streamer_tree_cache_insert (struct streamer_tree_cache_d *cache, tree t,
 177                             unsigned *ix_p)
 178 {
 179   return streamer_tree_cache_insert_1 (cache, t, ix_p, true);
 180 }
 181
 182
 183 /* Insert tree node T in CACHE at slot IX.  If T already
 184    existed in the cache return true.  Otherwise, return false.  */
 185
 186 bool
 187 streamer_tree_cache_insert_at (struct streamer_tree_cache_d *cache,
 188                                tree t, unsigned ix)
 189 {
 190   return streamer_tree_cache_insert_1 (cache, t, &ix, false);
 191 }
 192
 193
 194 /* Appends tree node T to CACHE, even if T already existed in it.  */
 195
 196 void
 197 streamer_tree_cache_append (struct streamer_tree_cache_d *cache, tree t)
 198 {
 199   unsigned ix = cache->nodes.length ();
 200   streamer_tree_cache_insert_1 (cache, t, &ix, false);
 201 }
 202
 203 /* Return true if tree node T exists in CACHE, otherwise false.  If IX_P is
 204    not NULL, write to *IX_P the index into the cache where T is stored
 205    ((unsigned)-1 if T is not found).  */
 206
 207 bool
 208 streamer_tree_cache_lookup (struct streamer_tree_cache_d *cache, tree t,
 209                             unsigned *ix_p)
 210 {
 211   void **slot;
 212   bool retval;
 213   unsigned ix;
 214
 215   gcc_assert (t);
 216
 217   slot = pointer_map_contains  (cache->node_map, t);
 218   if (slot == NULL)
 219     {
 220       retval = false;
 221       ix = -1;
 222     }
 223   else
 224     {
 225       retval = true;
 226       ix = (size_t) *slot - 1;
 227     }
 228
 229   if (ix_p)
 230     *ix_p = ix;
 231
 232   return retval;
 233 }
 234
 235
 236 /* Record NODE in CACHE.  */
 237
 238 static void
 239 record_common_node (struct streamer_tree_cache_d *cache, tree node)
 240 {
 241   /* If we recursively end up at nodes we do not want to preload simply don't.
 242      ???  We'd want to verify that this doesn't happen, or alternatively
 243      do not recurse at all.  */
 244   if (node == char_type_node)
 245     return;
 246
 247   gcc_checking_assert (node != boolean_type_node
 248                        && node != boolean_true_node
 249                        && node != boolean_false_node);
 250
 251   /* We have to make sure to fill exactly the same number of
 252      elements for all frontends.  That can include NULL trees.
 253      As our hash table can't deal with zero entries we'll simply stream
 254      a random other tree.  A NULL tree never will be looked up so it
 255      doesn't matter which tree we replace it with, just to be sure
 256      use error_mark_node.  */
 257   if (!node)
 258     node = error_mark_node;
 259
 260   streamer_tree_cache_append (cache, node);
 261
 262   if (POINTER_TYPE_P (node)
 263       || TREE_CODE (node) == COMPLEX_TYPE
 264       || TREE_CODE (node) == ARRAY_TYPE)
 265     record_common_node (cache, TREE_TYPE (node));
 266   else if (TREE_CODE (node) == RECORD_TYPE)
 267     {
 268       /* The FIELD_DECLs of structures should be shared, so that every
 269          COMPONENT_REF uses the same tree node when referencing a field.
 270          Pointer equality between FIELD_DECLs is used by the alias
 271          machinery to compute overlapping component references (see
 272          nonoverlapping_component_refs_p and
 273          nonoverlapping_component_refs_of_decl_p).  */
 274       for (tree f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
 275         record_common_node (cache, f);
 276     }
 277 }
 278
 279
 280 /* Preload common nodes into CACHE and make sure they are merged
 281    properly according to the gimple type table.  */
 282
 283 static void
 284 preload_common_nodes (struct streamer_tree_cache_d *cache)
 285 {
 286   unsigned i;
 287
 288   for (i = 0; i < itk_none; i++)
 289     /* Skip itk_char.  char_type_node is dependent on -f[un]signed-char.  */
 290     if (i != itk_char)
 291       record_common_node (cache, integer_types[i]);
 292
 293   for (i = 0; i < stk_type_kind_last; i++)
 294     record_common_node (cache, sizetype_tab[i]);
 295
 296   for (i = 0; i < TI_MAX; i++)
 297     /* Skip boolean type and constants, they are frontend dependent.  */
 298     if (i != TI_BOOLEAN_TYPE
 299         && i != TI_BOOLEAN_FALSE
 300         && i != TI_BOOLEAN_TRUE)
 301       record_common_node (cache, global_trees[i]);
 302 }
 303
 304
 305 /* Create a cache of pickled nodes.  */
 306
 307 struct streamer_tree_cache_d *
 308 streamer_tree_cache_create (void)
 309 {
 310   struct streamer_tree_cache_d *cache;
 311
 312   cache = XCNEW (struct streamer_tree_cache_d);
 313
 314   cache->node_map = pointer_map_create ();
 315
 316   /* Load all the well-known tree nodes that are always created by
 317      the compiler on startup.  This prevents writing them out
 318      unnecessarily.  */
 319   preload_common_nodes (cache);
 320
 321   return cache;
 322 }
 323
 324
 325 /* Delete the streamer cache C.  */
 326
 327 void
 328 streamer_tree_cache_delete (struct streamer_tree_cache_d *c)
 329 {
 330   if (c == NULL)
 331     return;
 332
 333   pointer_map_destroy (c->node_map);
 334   c->nodes.release ();
 335   free (c);
 336 }