gcc/tree-ssa-copyrename.c

   1 /* Rename SSA copies.
   2    Copyright (C) 2004 Free Software Foundation, Inc.
   3    Contributed by Andrew MacLeod <amacleod@redhat.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "flags.h"
  28 #include "basic-block.h"
  29 #include "function.h"
  30 #include "diagnostic.h"
  31 #include "bitmap.h"
  32 #include "tree-flow.h"
  33 #include "tree-gimple.h"
  34 #include "tree-inline.h"
  35 #include "timevar.h"
  36 #include "tree-alias-common.h"
  37 #include "hashtab.h"
  38 #include "tree-dump.h"
  39 #include "tree-ssa-live.h"
  40 #include "tree-pass.h"
  41
  42 extern void rename_ssa_copies (void);
  43
  44 /* The following routines implement the SSA copy renaming phase.
  45
  46    This optimization looks for copies between 2 SSA_NAMES, either through a
  47    direct copy, or an implicit one via a PHI node result and its arguments.
  48
  49    Each copy is examined to determine if it is possible to rename the base
  50    variable of one of the operands to the same variable as the other operand.
  51    ie.
  52    T.3_5 = <blah>
  53    a_1 = T.3_5
  54
  55    If this copy couldn't be copy propagated, it could possibly remain in the
  56    program throughout the optimization phases.   After SSA->normal, it would
  57    become:
  58
  59    T.3 = <blah>
  60    a = T.3
  61
  62    Since T.3_5 is distinct from all other SSA versions of T.3, there is no
  63    fundamental reason why the base variable needs to be T.3, subject to
  64    certain restrictions.  This optimization attempts to determine if we can
  65    change the base variable on copies like this, and result in code such as:
  66
  67    a_5 = <blah>
  68    a_1 = a_5
  69
  70    This gives the SSA->normal pass a shot at coalescing a_1 and a_5. If it is
  71    possible, the copy goes away completely. If it isn't possible, a new temp
  72    will be created for a_5, and you will end up with the exact same code:
  73
  74    a.8 = <blah>
  75    a = a.8
  76
  77    The other benefit of performing this optimization relates to what variables
  78    are chosen in copies.  Gimplification of the program uses temporaries for
  79    a lot of things. expressions like
  80
  81    a_1 = <blah>
  82    <blah2> = a_1
  83
  84    get turned into
  85
  86    T.3_5 = <blah>
  87    a_1 = T.3_5
  88    <blah2> = a_1
  89
  90    Copy propagation is done in a forward direction, and if we can propagate
  91    through the copy, we end up with:
  92
  93    T.3_5 = <blah>
  94    <blah2> = T.3_5
  95
  96    The copy is gone, but so is all reference to the user variable 'a'. By
  97    performing this optimization, we would see the sequence:
  98
  99    a_5 = <blah>
 100    a_1 = a_5
 101    <blah2> = a_1
 102
 103    which copy propagation would then turn into:
 104
 105    a_5 = <blah>
 106    <blah2> = a_5
 107
 108    and so we still retain the user variable whenever possible.  */
 109
 110
 111 /* Coalesce the partitions in MAP representing VAR1 and VAR2 if it is valid.
 112    Choose a representative for the partition, and send debug info to DEBUG.  */
 113
 114 static void
 115 copy_rename_partition_coalesce (var_map map, tree var1, tree var2, FILE *debug)
 116 {
 117   int p1, p2, p3;
 118   tree root1, root2;
 119   var_ann_t ann1, ann2, ann3;
 120   bool gimp1, gimp2;
 121
 122 #ifdef ENABLE_CHECKING
 123   if (TREE_CODE (var1) != SSA_NAME || TREE_CODE (var2) != SSA_NAME)
 124     abort ();
 125 #endif
 126
 127   register_ssa_partition (map, var1, false);
 128   register_ssa_partition (map, var2, true);
 129
 130   p1 = partition_find (map->var_partition, SSA_NAME_VERSION (var1));
 131   p2 = partition_find (map->var_partition, SSA_NAME_VERSION (var2));
 132
 133   if (debug)
 134     {
 135       fprintf (debug, "Try : ");
 136       print_generic_expr (debug, var1, TDF_SLIM);
 137       fprintf (debug, "(P%d) & ", p1);
 138       print_generic_expr (debug, var2, TDF_SLIM);
 139       fprintf (debug, "(P%d)", p2);
 140     }
 141
 142 #ifdef ENABLE_CHECKING
 143   if (p1 == NO_PARTITION || p2 == NO_PARTITION)
 144     abort ();
 145 #endif
 146
 147   root1 = SSA_NAME_VAR (partition_to_var (map, p1));
 148   root2 = SSA_NAME_VAR (partition_to_var (map, p2));
 149
 150   if (DECL_HARD_REGISTER (root1) || DECL_HARD_REGISTER (root2))
 151     {
 152       if (debug)
 153         {
 154           if (DECL_HARD_REGISTER (root1))
 155             print_generic_expr (debug, var1, TDF_SLIM);
 156           else
 157             print_generic_expr (debug, var2, TDF_SLIM);
 158           fprintf (debug, " is a hardware register.  No Coalescing.\n");
 159         }
 160       return;
 161     }
 162
 163   ann1 = var_ann (root1);
 164   ann2 = var_ann (root2);
 165
 166   if (p1 == p2)
 167     {
 168       if (debug)
 169         fprintf (debug, " : Already coalesced.\n");
 170       return;
 171     }
 172
 173   /* Partitions already have the same root, simply merge them.  */
 174   if (root1 == root2)
 175     {
 176       p1 = partition_union (map->var_partition, p1, p2);
 177       if (debug)
 178         fprintf (debug, " : Same root, coalesced --> P%d.\n", p1);
 179       return;
 180     }
 181
 182   /* Never attempt to coalesce 2 difference parameters.  */
 183   if (TREE_CODE (root1) == PARM_DECL && TREE_CODE (root2) == PARM_DECL)
 184     {
 185       if (debug)
 186         fprintf (debug, " : 2 different PARM_DECLS. No coalesce.\n");
 187       return;
 188     }
 189
 190   if ((TREE_CODE (root1) == RESULT_DECL) != (TREE_CODE (root2) == RESULT_DECL))
 191     {
 192       if (debug)
 193         fprintf (debug, " : One root a RESULT_DECL. No coalesce.\n");
 194       return;
 195     }
 196
 197   gimp1 = is_gimple_tmp_var (root1);
 198   gimp2 = is_gimple_tmp_var (root2);
 199
 200   /* Never attempt to coalesce 2 user variables unless one is an inline
 201      variable.  */
 202   if (!gimp1 && !gimp2)
 203     {
 204       if (DECL_FROM_INLINE (root2))
 205         gimp2 = true;
 206       else
 207         if (DECL_FROM_INLINE (root1))
 208           gimp1 = true;
 209         else
 210           {
 211             if (debug)
 212               fprintf (debug, " : 2 different USER vars. No coalesce.\n");
 213             return;
 214           }
 215     }
 216
 217
 218   /* Don't coalesce if there are two different memory tags.  */
 219   if (ann1->type_mem_tag && ann2->type_mem_tag
 220       && ann1->type_mem_tag != ann2->type_mem_tag)
 221     {
 222       if (debug)
 223         fprintf (debug, " : 2 memory tags. No coalesce.\n");
 224       return;
 225     }
 226
 227   /* If both values have default defs, we can't coalesce.  If only one has a
 228      tag, make sure that variable is the new root partition.  */
 229   if (default_def (root1))
 230     {
 231       if (default_def (root2))
 232         {
 233           if (debug)
 234             fprintf (debug, " : 2 default defs. No coalesce.\n");
 235           return;
 236         }
 237       else
 238         {
 239           gimp2 = true;
 240           gimp1 = false;
 241         }
 242     }
 243   else
 244     if (default_def (root2))
 245       {
 246         gimp1 = true;
 247         gimp2 = false;
 248       }
 249
 250   /* Merge the two partitions.  */
 251   p3 = partition_union (map->var_partition, p1, p2);
 252
 253   /* Set the root variable of the partition to the better choice, if there is
 254      one.  */
 255   if (!gimp2)
 256     SSA_NAME_VAR (partition_to_var (map, p3)) = root2;
 257   else
 258     if (!gimp1)
 259       SSA_NAME_VAR (partition_to_var (map, p3)) = root1;
 260
 261   /* Update the various flag widgitry of the current base representative.  */
 262   ann3 = var_ann (SSA_NAME_VAR (partition_to_var (map, p3)));
 263   if (ann1->type_mem_tag)
 264     ann3->type_mem_tag = ann1->type_mem_tag;
 265   else
 266     ann3->type_mem_tag = ann2->type_mem_tag;
 267
 268   if (debug)
 269     {
 270       fprintf (debug, " --> P%d ", p3);
 271       print_generic_expr (debug, SSA_NAME_VAR (partition_to_var (map, p3)),
 272                           TDF_SLIM);
 273       fprintf (debug, "\n");
 274     }
 275 }
 276
 277
 278 /* This function will make a pass through the IL, and attempt to coalesce any
 279    SSA versions which occur in PHI's or copies.  Coalescing is accomplished by
 280    changing the underlying root variable of all coalesced version.  This will
 281    then cause the SSA->normal pass to attempt to coalesce them all to the same
 282    variable.  */
 283
 284 void
 285 rename_ssa_copies (void)
 286 {
 287   var_map map;
 288   basic_block bb;
 289   block_stmt_iterator bsi;
 290   tree phi, stmt, var, part_var;
 291   unsigned x;
 292   FILE *debug;
 293
 294   if (dump_file && (dump_flags & TDF_DETAILS))
 295     debug = dump_file;
 296   else
 297     debug = NULL;
 298
 299   map = init_var_map (num_ssa_names + 1);
 300
 301   FOR_EACH_BB (bb)
 302     {
 303       /* Scan for real copies.  */
 304       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 305         {
 306           stmt = bsi_stmt (bsi);
 307           if (TREE_CODE (stmt) == MODIFY_EXPR)
 308             {
 309               tree lhs = TREE_OPERAND (stmt, 0);
 310               tree rhs = TREE_OPERAND (stmt, 1);
 311
 312               if (TREE_CODE (lhs) == SSA_NAME
 313                   && !has_hidden_use (SSA_NAME_VAR (lhs))
 314                   && TREE_CODE (rhs) == SSA_NAME)
 315                 copy_rename_partition_coalesce (map, lhs, rhs, debug);
 316             }
 317         }
 318     }
 319
 320   FOR_EACH_BB (bb)
 321     {
 322       /* Treat PHI nodes as copies between the result and each argument.  */
 323       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
 324         {
 325           int i;
 326           tree res = PHI_RESULT (phi);
 327
 328           /* Do not process virtual SSA_NAMES or variables which have
 329              hidden uses.  */
 330           if (!is_gimple_reg (SSA_NAME_VAR (res))
 331               || has_hidden_use (SSA_NAME_VAR (res)))
 332             continue;
 333
 334           for (i = 0; i < PHI_NUM_ARGS (phi); i++)
 335             {
 336               tree arg = PHI_ARG_DEF (phi, i);
 337               if (TREE_CODE (arg) == SSA_NAME)
 338                 copy_rename_partition_coalesce (map, res, arg, debug);
 339             }
 340         }
 341     }
 342
 343   if (debug)
 344     dump_var_map (debug, map);
 345
 346   /* Now one more pass to make all elements of a partition share the same
 347      root variable.  */
 348
 349   for (x = 1; x <= num_ssa_names; x++)
 350     {
 351       part_var = partition_to_var (map, x);
 352       if (!part_var)
 353         continue;
 354       var = map->partition_to_var[x];
 355       if (debug)
 356         {
 357           if (SSA_NAME_VAR (var) != SSA_NAME_VAR (part_var))
 358             {
 359               fprintf (debug, "Coalesced ");
 360               print_generic_expr (debug, var, TDF_SLIM);
 361               fprintf (debug, " to ");
 362               print_generic_expr (debug, part_var, TDF_SLIM);
 363               fprintf (debug, "\n");
 364             }
 365         }
 366       SSA_NAME_VAR (var) = SSA_NAME_VAR (part_var);
 367     }
 368
 369   delete_var_map (map);
 370 }
 371
 372 /* Return true if copy rename is to be performed.  */
 373
 374 static bool
 375 gate_copyrename (void)
 376 {
 377   return flag_tree_copyrename != 0;
 378 }
 379
 380 struct tree_opt_pass pass_rename_ssa_copies =
 381 {
 382   "copyrename",                         /* name */
 383   gate_copyrename,                      /* gate */
 384   rename_ssa_copies,                    /* execute */
 385   NULL,                                 /* sub */
 386   NULL,                                 /* next */
 387   0,                                    /* static_pass_number */
 388   TV_TREE_COPY_RENAME,                  /* tv_id */
 389   PROP_cfg | PROP_ssa,                  /* properties_required */
 390   0,                                    /* properties_provided */
 391   0,                                    /* properties_destroyed */
 392   0,                                    /* todo_flags_start */
 393   TODO_dump_func | TODO_verify_ssa      /* todo_flags_finish */
 394 };
 395