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   gimp1 = is_gimple_tmp_var (root1);
 191   gimp2 = is_gimple_tmp_var (root2);
 192
 193   /* Never attempt to coalesce 2 user variables unless one is an inline
 194      variable.  */
 195   if (!gimp1 && !gimp2)
 196     {
 197       if (DECL_FROM_INLINE (root2))
 198         gimp2 = true;
 199       else
 200         if (DECL_FROM_INLINE (root1))
 201           gimp1 = true;
 202         else
 203           {
 204             if (debug)
 205               fprintf (debug, " : 2 different USER vars. No coalesce.\n");
 206             return;
 207           }
 208     }
 209
 210
 211   /* Don't coalesce if there are two different memory tags.  */
 212   if (ann1->type_mem_tag && ann2->type_mem_tag
 213       && ann1->type_mem_tag != ann2->type_mem_tag)
 214     {
 215       if (debug)
 216         fprintf (debug, " : 2 memory tags. No coalesce.\n");
 217       return;
 218     }
 219
 220   /* If both values have default defs, we can't coalesce.  If only one has a
 221      tag, make sure that variable is the new root partition.  */
 222   if (default_def (root1))
 223     {
 224       if (default_def (root2))
 225         {
 226           if (debug)
 227             fprintf (debug, " : 2 default defs. No coalesce.\n");
 228           return;
 229         }
 230       else
 231         {
 232           gimp2 = true;
 233           gimp1 = false;
 234         }
 235     }
 236   else
 237     if (default_def (root2))
 238       {
 239         gimp1 = true;
 240         gimp2 = false;
 241       }
 242
 243   /* Merge the two partitions.  */
 244   p3 = partition_union (map->var_partition, p1, p2);
 245
 246   /* Set the root variable of the partition to the better choice, if there is
 247      one.  */
 248   if (!gimp2)
 249     SSA_NAME_VAR (partition_to_var (map, p3)) = root2;
 250   else
 251     if (!gimp1)
 252       SSA_NAME_VAR (partition_to_var (map, p3)) = root1;
 253
 254   /* Update the various flag widgitry of the current base representative.  */
 255   ann3 = var_ann (SSA_NAME_VAR (partition_to_var (map, p3)));
 256   if (ann1->type_mem_tag)
 257     ann3->type_mem_tag = ann1->type_mem_tag;
 258   else
 259     ann3->type_mem_tag = ann2->type_mem_tag;
 260
 261   if (debug)
 262     {
 263       fprintf (debug, " --> P%d ", p3);
 264       print_generic_expr (debug, SSA_NAME_VAR (partition_to_var (map, p3)),
 265                           TDF_SLIM);
 266       fprintf (debug, "\n");
 267     }
 268 }
 269
 270
 271 /* This function will make a pass through the IL, and attempt to coalesce any
 272    SSA versions which occur in PHI's or copies.  Coalescing is accomplished by
 273    changing the underlying root variable of all coalesced version.  This will
 274    then cause the SSA->normal pass to attempt to coalesce them all to the same
 275    variable.  */
 276
 277 void
 278 rename_ssa_copies (void)
 279 {
 280   var_map map;
 281   basic_block bb;
 282   block_stmt_iterator bsi;
 283   tree phi, stmt, var, part_var;
 284   unsigned x;
 285   FILE *debug;
 286
 287   if (dump_file && (dump_flags & TDF_DETAILS))
 288     debug = dump_file;
 289   else
 290     debug = NULL;
 291
 292   map = init_var_map (highest_ssa_version + 1);
 293
 294   FOR_EACH_BB (bb)
 295     {
 296       /* Scan for real copies.  */
 297       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 298         {
 299           stmt = bsi_stmt (bsi);
 300           if (TREE_CODE (stmt) == MODIFY_EXPR)
 301             {
 302               tree lhs = TREE_OPERAND (stmt, 0);
 303               tree rhs = TREE_OPERAND (stmt, 1);
 304
 305               if (TREE_CODE (lhs) == SSA_NAME
 306                   && !has_hidden_use (SSA_NAME_VAR (lhs))
 307                   && TREE_CODE (rhs) == SSA_NAME)
 308                 copy_rename_partition_coalesce (map, lhs, rhs, debug);
 309             }
 310         }
 311     }
 312
 313   FOR_EACH_BB (bb)
 314     {
 315       /* Treat PHI nodes as copies between the result and each argument.  */
 316       for (phi = phi_nodes (bb); phi; phi = TREE_CHAIN (phi))
 317         {
 318           int i;
 319           tree res = PHI_RESULT (phi);
 320
 321           /* Do not process virtual SSA_NAMES or variables which have
 322              hidden uses.  */
 323           if (!is_gimple_reg (SSA_NAME_VAR (res))
 324               || has_hidden_use (SSA_NAME_VAR (res)))
 325             continue;
 326
 327           for (i = 0; i < PHI_NUM_ARGS (phi); i++)
 328             {
 329               tree arg = PHI_ARG_DEF (phi, i);
 330               if (TREE_CODE (arg) == SSA_NAME)
 331                 copy_rename_partition_coalesce (map, res, arg, debug);
 332             }
 333         }
 334     }
 335
 336   if (debug)
 337     dump_var_map (debug, map);
 338
 339   /* Now one more pass to make all elements of a partition share the same
 340      root variable.  */
 341
 342   for (x = 1; x <= highest_ssa_version; x++)
 343     {
 344       part_var = partition_to_var (map, x);
 345       if (!part_var)
 346         continue;
 347       var = map->partition_to_var[x];
 348       if (debug)
 349         {
 350           if (SSA_NAME_VAR (var) != SSA_NAME_VAR (part_var))
 351             {
 352               fprintf (debug, "Coalesced ");
 353               print_generic_expr (debug, var, TDF_SLIM);
 354               fprintf (debug, " to ");
 355               print_generic_expr (debug, part_var, TDF_SLIM);
 356               fprintf (debug, "\n");
 357             }
 358         }
 359       SSA_NAME_VAR (var) = SSA_NAME_VAR (part_var);
 360     }
 361
 362   delete_var_map (map);
 363 }
 364
 365 /* Return true if copy rename is to be performed.  */
 366
 367 static bool
 368 gate_copyrename (void)
 369 {
 370   return flag_tree_copyrename != 0;
 371 }
 372
 373 struct tree_opt_pass pass_rename_ssa_copies =
 374 {
 375   "copyrename",                         /* name */
 376   gate_copyrename,                      /* gate */
 377   rename_ssa_copies,                    /* execute */
 378   NULL,                                 /* sub */
 379   NULL,                                 /* next */
 380   0,                                    /* static_pass_number */
 381   TV_TREE_COPY_RENAME,                  /* tv_id */
 382   PROP_cfg | PROP_ssa,                  /* properties_required */
 383   0,                                    /* properties_provided */
 384   0,                                    /* properties_destroyed */
 385   0,                                    /* todo_flags_start */
 386   TODO_dump_func | TODO_verify_ssa      /* todo_flags_finish */
 387 };
 388