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