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 lto_output_* and
  30    lto_input_* routines are exactly ALL the structures defined in
  31    treestruct.def.  */
  32
  33 void
  34 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 lto_streamer_cache_insert_1.  Add T to CACHE->NODES at
  91    slot IX.  */
  92
  93 static void
  94 lto_streamer_cache_add_to_node_array (struct lto_streamer_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 lto_streamer_cache_insert and lto_streamer_cache_insert_at.
 109    CACHE, T, and IX_P are as in lto_streamer_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 lto_streamer_cache_insert_1 (struct lto_streamer_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       lto_streamer_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           lto_streamer_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 lto_streamer_cache_insert (struct lto_streamer_cache_d *cache, tree t,
 176                            unsigned *ix_p)
 177 {
 178   return lto_streamer_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 lto_streamer_cache_insert_at (struct lto_streamer_cache_d *cache,
 187                               tree t, unsigned ix)
 188 {
 189   return lto_streamer_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 lto_streamer_cache_append (struct lto_streamer_cache_d *cache, tree t)
 197 {
 198   unsigned ix = VEC_length (tree, cache->nodes);
 199   lto_streamer_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 lto_streamer_cache_lookup (struct lto_streamer_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 lto_streamer_cache_get (struct lto_streamer_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 lto_record_common_node (struct lto_streamer_cache_d *cache, tree node)
 253 {
 254   /* We have to make sure to fill exactly the same number of
 255      elements for all frontends.  That can include NULL trees.
 256      As our hash table can't deal with zero entries we'll simply stream
 257      a random other tree.  A NULL tree never will be looked up so it
 258      doesn't matter which tree we replace it with, just to be sure
 259      use error_mark_node.  */
 260   if (!node)
 261     node = error_mark_node;
 262
 263   lto_streamer_cache_append (cache, node);
 264
 265   if (POINTER_TYPE_P (node)
 266       || TREE_CODE (node) == COMPLEX_TYPE
 267       || TREE_CODE (node) == ARRAY_TYPE)
 268     lto_record_common_node (cache, TREE_TYPE (node));
 269   else if (TREE_CODE (node) == RECORD_TYPE)
 270     {
 271       /* The FIELD_DECLs of structures should be shared, so that every
 272          COMPONENT_REF uses the same tree node when referencing a field.
 273          Pointer equality between FIELD_DECLs is used by the alias
 274          machinery to compute overlapping memory references (See
 275          nonoverlapping_component_refs_p).  */
 276       tree f;
 277       for (f = TYPE_FIELDS (node); f; f = TREE_CHAIN (f))
 278         lto_record_common_node (cache, f);
 279     }
 280 }
 281
 282
 283 /* Preload common nodes into CACHE and make sure they are merged
 284    properly according to the gimple type table.  */
 285
 286 static void
 287 preload_common_nodes (struct lto_streamer_cache_d *cache)
 288 {
 289   unsigned i;
 290
 291   for (i = 0; i < itk_none; i++)
 292     /* Skip itk_char.  char_type_node is dependent on -f[un]signed-char.  */
 293     if (i != itk_char)
 294       lto_record_common_node (cache, integer_types[i]);
 295
 296   for (i = 0; i < TYPE_KIND_LAST; i++)
 297     lto_record_common_node (cache, sizetype_tab[i]);
 298
 299   for (i = 0; i < TI_MAX; i++)
 300     /* Skip boolean type and constants, they are frontend dependent.  */
 301     if (i != TI_BOOLEAN_TYPE
 302         && i != TI_BOOLEAN_FALSE
 303         && i != TI_BOOLEAN_TRUE)
 304       lto_record_common_node (cache, global_trees[i]);
 305 }
 306
 307
 308 /* Create a cache of pickled nodes.  */
 309
 310 struct lto_streamer_cache_d *
 311 lto_streamer_cache_create (void)
 312 {
 313   struct lto_streamer_cache_d *cache;
 314
 315   cache = XCNEW (struct lto_streamer_cache_d);
 316
 317   cache->node_map = pointer_map_create ();
 318
 319   /* Load all the well-known tree nodes that are always created by
 320      the compiler on startup.  This prevents writing them out
 321      unnecessarily.  */
 322   preload_common_nodes (cache);
 323
 324   return cache;
 325 }
 326
 327
 328 /* Delete the streamer cache C.  */
 329
 330 void
 331 lto_streamer_cache_delete (struct lto_streamer_cache_d *c)
 332 {
 333   if (c == NULL)
 334     return;
 335
 336   pointer_map_destroy (c->node_map);
 337   VEC_free (tree, heap, c->nodes);
 338   free (c);
 339 }