gcc/tree-ssa-copy.c

   1 /* Copy propagation and SSA_NAME replacement support routines.
   2    Copyright (C) 2004-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 3, or (at your option)
   9 any later version.
  10
  11 GCC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "tree.h"
  25 #include "flags.h"
  26 #include "tm_p.h"
  27 #include "basic-block.h"
  28 #include "function.h"
  29 #include "gimple-pretty-print.h"
  30 #include "tree-ssa-alias.h"
  31 #include "internal-fn.h"
  32 #include "gimple-expr.h"
  33 #include "is-a.h"
  34 #include "gimple.h"
  35 #include "gimple-iterator.h"
  36 #include "gimple-ssa.h"
  37 #include "tree-cfg.h"
  38 #include "tree-phinodes.h"
  39 #include "ssa-iterators.h"
  40 #include "stringpool.h"
  41 #include "tree-ssanames.h"
  42 #include "tree-pass.h"
  43 #include "tree-ssa-propagate.h"
  44 #include "langhooks.h"
  45 #include "cfgloop.h"
  46 #include "tree-scalar-evolution.h"
  47 #include "tree-ssa-dom.h"
  48 #include "tree-ssa-loop-niter.h"
  49
  50
  51 /* This file implements the copy propagation pass and provides a
  52    handful of interfaces for performing const/copy propagation and
  53    simple expression replacement which keep variable annotations
  54    up-to-date.
  55
  56    We require that for any copy operation where the RHS and LHS have
  57    a non-null memory tag the memory tag be the same.   It is OK
  58    for one or both of the memory tags to be NULL.
  59
  60    We also require tracking if a variable is dereferenced in a load or
  61    store operation.
  62
  63    We enforce these requirements by having all copy propagation and
  64    replacements of one SSA_NAME with a different SSA_NAME to use the
  65    APIs defined in this file.  */
  66
  67 /*---------------------------------------------------------------------------
  68                                 Copy propagation
  69 ---------------------------------------------------------------------------*/
  70 /* Lattice for copy-propagation.  The lattice is initialized to
  71    UNDEFINED (value == NULL) for SSA names that can become a copy
  72    of something or VARYING (value == self) if not (see get_copy_of_val
  73    and stmt_may_generate_copy).  Other values make the name a COPY
  74    of that value.
  75
  76    When visiting a statement or PHI node the lattice value for an
  77    SSA name can transition from UNDEFINED to COPY to VARYING.  */
  78
  79 struct prop_value_d {
  80     /* Copy-of value.  */
  81     tree value;
  82 };
  83 typedef struct prop_value_d prop_value_t;
  84
  85 static prop_value_t *copy_of;
  86 static unsigned n_copy_of;
  87
  88
  89 /* Return true if this statement may generate a useful copy.  */
  90
  91 static bool
  92 stmt_may_generate_copy (gimple stmt)
  93 {
  94   if (gimple_code (stmt) == GIMPLE_PHI)
  95     return !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_phi_result (stmt));
  96
  97   if (gimple_code (stmt) != GIMPLE_ASSIGN)
  98     return false;
  99
 100   /* If the statement has volatile operands, it won't generate a
 101      useful copy.  */
 102   if (gimple_has_volatile_ops (stmt))
 103     return false;
 104
 105   /* Statements with loads and/or stores will never generate a useful copy.  */
 106   if (gimple_vuse (stmt))
 107     return false;
 108
 109   /* Otherwise, the only statements that generate useful copies are
 110      assignments whose RHS is just an SSA name that doesn't flow
 111      through abnormal edges.  */
 112   return ((gimple_assign_rhs_code (stmt) == SSA_NAME
 113            && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt)))
 114           || is_gimple_min_invariant (gimple_assign_rhs1 (stmt)));
 115 }
 116
 117
 118 /* Return the copy-of value for VAR.  */
 119
 120 static inline prop_value_t *
 121 get_copy_of_val (tree var)
 122 {
 123   prop_value_t *val = &copy_of[SSA_NAME_VERSION (var)];
 124
 125   if (val->value == NULL_TREE
 126       && !stmt_may_generate_copy (SSA_NAME_DEF_STMT (var)))
 127     {
 128       /* If the variable will never generate a useful copy relation,
 129          make it its own copy.  */
 130       val->value = var;
 131     }
 132
 133   return val;
 134 }
 135
 136 /* Return the variable VAR is a copy of or VAR if VAR isn't the result
 137    of a copy.  */
 138
 139 static inline tree
 140 valueize_val (tree var)
 141 {
 142   if (TREE_CODE (var) == SSA_NAME)
 143     {
 144       tree val = get_copy_of_val (var)->value;
 145       if (val)
 146         return val;
 147     }
 148   return var;
 149 }
 150
 151 /* Set VAL to be the copy of VAR.  If that changed return true.  */
 152
 153 static inline bool
 154 set_copy_of_val (tree var, tree val)
 155 {
 156   unsigned int ver = SSA_NAME_VERSION (var);
 157   tree old;
 158
 159   /* Set FIRST to be the first link in COPY_OF[DEST].  If that
 160      changed, return true.  */
 161   old = copy_of[ver].value;
 162   copy_of[ver].value = val;
 163
 164   if (old != val
 165       || (val && !operand_equal_p (old, val, 0)))
 166     return true;
 167
 168   return false;
 169 }
 170
 171
 172 /* Dump the copy-of value for variable VAR to FILE.  */
 173
 174 static void
 175 dump_copy_of (FILE *file, tree var)
 176 {
 177   tree val;
 178
 179   print_generic_expr (file, var, dump_flags);
 180   if (TREE_CODE (var) != SSA_NAME)
 181     return;
 182
 183   val = copy_of[SSA_NAME_VERSION (var)].value;
 184   fprintf (file, " copy-of chain: ");
 185   print_generic_expr (file, var, 0);
 186   fprintf (file, " ");
 187   if (!val)
 188     fprintf (file, "[UNDEFINED]");
 189   else if (val == var)
 190     fprintf (file, "[NOT A COPY]");
 191   else
 192     {
 193       fprintf (file, "-> ");
 194       print_generic_expr (file, val, 0);
 195       fprintf (file, " ");
 196       fprintf (file, "[COPY]");
 197     }
 198 }
 199
 200
 201 /* Evaluate the RHS of STMT.  If it produces a valid copy, set the LHS
 202    value and store the LHS into *RESULT_P.  */
 203
 204 static enum ssa_prop_result
 205 copy_prop_visit_assignment (gimple stmt, tree *result_p)
 206 {
 207   tree lhs, rhs;
 208
 209   lhs = gimple_assign_lhs (stmt);
 210   rhs = valueize_val (gimple_assign_rhs1 (stmt));
 211
 212   if (TREE_CODE (lhs) == SSA_NAME)
 213     {
 214       /* Straight copy between two SSA names.  First, make sure that
 215          we can propagate the RHS into uses of LHS.  */
 216       if (!may_propagate_copy (lhs, rhs))
 217         return SSA_PROP_VARYING;
 218
 219       *result_p = lhs;
 220       if (set_copy_of_val (*result_p, rhs))
 221         return SSA_PROP_INTERESTING;
 222       else
 223         return SSA_PROP_NOT_INTERESTING;
 224     }
 225
 226   return SSA_PROP_VARYING;
 227 }
 228
 229
 230 /* Visit the GIMPLE_COND STMT.  Return SSA_PROP_INTERESTING
 231    if it can determine which edge will be taken.  Otherwise, return
 232    SSA_PROP_VARYING.  */
 233
 234 static enum ssa_prop_result
 235 copy_prop_visit_cond_stmt (gimple stmt, edge *taken_edge_p)
 236 {
 237   enum ssa_prop_result retval = SSA_PROP_VARYING;
 238   location_t loc = gimple_location (stmt);
 239
 240   tree op0 = gimple_cond_lhs (stmt);
 241   tree op1 = gimple_cond_rhs (stmt);
 242
 243   /* The only conditionals that we may be able to compute statically
 244      are predicates involving two SSA_NAMEs.  */
 245   if (TREE_CODE (op0) == SSA_NAME && TREE_CODE (op1) == SSA_NAME)
 246     {
 247       op0 = valueize_val (op0);
 248       op1 = valueize_val (op1);
 249
 250       /* See if we can determine the predicate's value.  */
 251       if (dump_file && (dump_flags & TDF_DETAILS))
 252         {
 253           fprintf (dump_file, "Trying to determine truth value of ");
 254           fprintf (dump_file, "predicate ");
 255           print_gimple_stmt (dump_file, stmt, 0, 0);
 256         }
 257
 258       /* We can fold COND and get a useful result only when we have
 259          the same SSA_NAME on both sides of a comparison operator.  */
 260       if (op0 == op1)
 261         {
 262           tree folded_cond = fold_binary_loc (loc, gimple_cond_code (stmt),
 263                                           boolean_type_node, op0, op1);
 264           if (folded_cond)
 265             {
 266               basic_block bb = gimple_bb (stmt);
 267               *taken_edge_p = find_taken_edge (bb, folded_cond);
 268               if (*taken_edge_p)
 269                 retval = SSA_PROP_INTERESTING;
 270             }
 271         }
 272     }
 273
 274   if (dump_file && (dump_flags & TDF_DETAILS) && *taken_edge_p)
 275     fprintf (dump_file, "\nConditional will always take edge %d->%d\n",
 276              (*taken_edge_p)->src->index, (*taken_edge_p)->dest->index);
 277
 278   return retval;
 279 }
 280
 281
 282 /* Evaluate statement STMT.  If the statement produces a new output
 283    value, return SSA_PROP_INTERESTING and store the SSA_NAME holding
 284    the new value in *RESULT_P.
 285
 286    If STMT is a conditional branch and we can determine its truth
 287    value, set *TAKEN_EDGE_P accordingly.
 288
 289    If the new value produced by STMT is varying, return
 290    SSA_PROP_VARYING.  */
 291
 292 static enum ssa_prop_result
 293 copy_prop_visit_stmt (gimple stmt, edge *taken_edge_p, tree *result_p)
 294 {
 295   enum ssa_prop_result retval;
 296
 297   if (dump_file && (dump_flags & TDF_DETAILS))
 298     {
 299       fprintf (dump_file, "\nVisiting statement:\n");
 300       print_gimple_stmt (dump_file, stmt, 0, dump_flags);
 301       fprintf (dump_file, "\n");
 302     }
 303
 304   if (gimple_assign_single_p (stmt)
 305       && TREE_CODE (gimple_assign_lhs (stmt)) == SSA_NAME
 306       && (TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
 307           || is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
 308     {
 309       /* If the statement is a copy assignment, evaluate its RHS to
 310          see if the lattice value of its output has changed.  */
 311       retval = copy_prop_visit_assignment (stmt, result_p);
 312     }
 313   else if (gimple_code (stmt) == GIMPLE_COND)
 314     {
 315       /* See if we can determine which edge goes out of a conditional
 316          jump.  */
 317       retval = copy_prop_visit_cond_stmt (stmt, taken_edge_p);
 318     }
 319   else
 320     retval = SSA_PROP_VARYING;
 321
 322   if (retval == SSA_PROP_VARYING)
 323     {
 324       tree def;
 325       ssa_op_iter i;
 326
 327       /* Any other kind of statement is not interesting for constant
 328          propagation and, therefore, not worth simulating.  */
 329       if (dump_file && (dump_flags & TDF_DETAILS))
 330         fprintf (dump_file, "No interesting values produced.\n");
 331
 332       /* The assignment is not a copy operation.  Don't visit this
 333          statement again and mark all the definitions in the statement
 334          to be copies of nothing.  */
 335       FOR_EACH_SSA_TREE_OPERAND (def, stmt, i, SSA_OP_ALL_DEFS)
 336         set_copy_of_val (def, def);
 337     }
 338
 339   return retval;
 340 }
 341
 342
 343 /* Visit PHI node PHI.  If all the arguments produce the same value,
 344    set it to be the value of the LHS of PHI.  */
 345
 346 static enum ssa_prop_result
 347 copy_prop_visit_phi_node (gimple phi)
 348 {
 349   enum ssa_prop_result retval;
 350   unsigned i;
 351   prop_value_t phi_val = { NULL_TREE };
 352
 353   tree lhs = gimple_phi_result (phi);
 354
 355   if (dump_file && (dump_flags & TDF_DETAILS))
 356     {
 357       fprintf (dump_file, "\nVisiting PHI node: ");
 358       print_gimple_stmt (dump_file, phi, 0, dump_flags);
 359     }
 360
 361   for (i = 0; i < gimple_phi_num_args (phi); i++)
 362     {
 363       prop_value_t *arg_val;
 364       tree arg_value;
 365       tree arg = gimple_phi_arg_def (phi, i);
 366       edge e = gimple_phi_arg_edge (phi, i);
 367
 368       /* We don't care about values flowing through non-executable
 369          edges.  */
 370       if (!(e->flags & EDGE_EXECUTABLE))
 371         continue;
 372
 373       /* Names that flow through abnormal edges cannot be used to
 374          derive copies.  */
 375       if (TREE_CODE (arg) == SSA_NAME && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (arg))
 376         {
 377           phi_val.value = lhs;
 378           break;
 379         }
 380
 381       if (dump_file && (dump_flags & TDF_DETAILS))
 382         {
 383           fprintf (dump_file, "\tArgument #%d: ", i);
 384           dump_copy_of (dump_file, arg);
 385           fprintf (dump_file, "\n");
 386         }
 387
 388       if (TREE_CODE (arg) == SSA_NAME)
 389         {
 390           arg_val = get_copy_of_val (arg);
 391
 392           /* If we didn't visit the definition of arg yet treat it as
 393              UNDEFINED.  This also handles PHI arguments that are the
 394              same as lhs.  We'll come here again.  */
 395           if (!arg_val->value)
 396             continue;
 397
 398           arg_value = arg_val->value;
 399         }
 400       else
 401         arg_value = valueize_val (arg);
 402
 403       /* Avoid copy propagation from an inner into an outer loop.
 404          Otherwise, this may introduce uses of loop variant variables
 405          outside of their loops and prevent coalescing opportunities.
 406          In loop-closed SSA form do not copy-propagate through
 407          PHI nodes in blocks with a loop exit edge predecessor.  */
 408       if (TREE_CODE (arg_value) == SSA_NAME
 409           && (loop_depth_of_name (arg_value) > loop_depth_of_name (lhs)
 410               || (loops_state_satisfies_p (LOOP_CLOSED_SSA)
 411                   && loop_exit_edge_p (e->src->loop_father, e))))
 412         {
 413           phi_val.value = lhs;
 414           break;
 415         }
 416
 417       /* If the LHS didn't have a value yet, make it a copy of the
 418          first argument we find.   */
 419       if (phi_val.value == NULL_TREE)
 420         {
 421           phi_val.value = arg_value;
 422           continue;
 423         }
 424
 425       /* If PHI_VAL and ARG don't have a common copy-of chain, then
 426          this PHI node cannot be a copy operation.  */
 427       if (phi_val.value != arg_value
 428           && !operand_equal_p (phi_val.value, arg_value, 0))
 429         {
 430           phi_val.value = lhs;
 431           break;
 432         }
 433     }
 434
 435   if (phi_val.value
 436       && may_propagate_copy (lhs, phi_val.value)
 437       && set_copy_of_val (lhs, phi_val.value))
 438     retval = (phi_val.value != lhs) ? SSA_PROP_INTERESTING : SSA_PROP_VARYING;
 439   else
 440     retval = SSA_PROP_NOT_INTERESTING;
 441
 442   if (dump_file && (dump_flags & TDF_DETAILS))
 443     {
 444       fprintf (dump_file, "PHI node ");
 445       dump_copy_of (dump_file, lhs);
 446       fprintf (dump_file, "\nTelling the propagator to ");
 447       if (retval == SSA_PROP_INTERESTING)
 448         fprintf (dump_file, "add SSA edges out of this PHI and continue.");
 449       else if (retval == SSA_PROP_VARYING)
 450         fprintf (dump_file, "add SSA edges out of this PHI and never visit again.");
 451       else
 452         fprintf (dump_file, "do nothing with SSA edges and keep iterating.");
 453       fprintf (dump_file, "\n\n");
 454     }
 455
 456   return retval;
 457 }
 458
 459
 460 /* Initialize structures used for copy propagation.  */
 461
 462 static void
 463 init_copy_prop (void)
 464 {
 465   basic_block bb;
 466
 467   n_copy_of = num_ssa_names;
 468   copy_of = XCNEWVEC (prop_value_t, n_copy_of);
 469
 470   FOR_EACH_BB_FN (bb, cfun)
 471     {
 472       gimple_stmt_iterator si;
 473       int depth = bb_loop_depth (bb);
 474
 475       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
 476         {
 477           gimple stmt = gsi_stmt (si);
 478           ssa_op_iter iter;
 479           tree def;
 480
 481           /* The only statements that we care about are those that may
 482              generate useful copies.  We also need to mark conditional
 483              jumps so that their outgoing edges are added to the work
 484              lists of the propagator.
 485
 486              Avoid copy propagation from an inner into an outer loop.
 487              Otherwise, this may move loop variant variables outside of
 488              their loops and prevent coalescing opportunities.  If the
 489              value was loop invariant, it will be hoisted by LICM and
 490              exposed for copy propagation.
 491              ???  This doesn't make sense.  */
 492           if (stmt_ends_bb_p (stmt))
 493             prop_set_simulate_again (stmt, true);
 494           else if (stmt_may_generate_copy (stmt)
 495                    /* Since we are iterating over the statements in
 496                       BB, not the phi nodes, STMT will always be an
 497                       assignment.  */
 498                    && loop_depth_of_name (gimple_assign_rhs1 (stmt)) <= depth)
 499             prop_set_simulate_again (stmt, true);
 500           else
 501             prop_set_simulate_again (stmt, false);
 502
 503           /* Mark all the outputs of this statement as not being
 504              the copy of anything.  */
 505           FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS)
 506             if (!prop_simulate_again_p (stmt))
 507               set_copy_of_val (def, def);
 508         }
 509
 510       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
 511         {
 512           gimple phi = gsi_stmt (si);
 513           tree def;
 514
 515           def = gimple_phi_result (phi);
 516           if (virtual_operand_p (def))
 517             prop_set_simulate_again (phi, false);
 518           else
 519             prop_set_simulate_again (phi, true);
 520
 521           if (!prop_simulate_again_p (phi))
 522             set_copy_of_val (def, def);
 523         }
 524     }
 525 }
 526
 527 /* Callback for substitute_and_fold to get at the final copy-of values.  */
 528
 529 static tree
 530 get_value (tree name)
 531 {
 532   tree val;
 533   if (SSA_NAME_VERSION (name) >= n_copy_of)
 534     return NULL_TREE;
 535   val = copy_of[SSA_NAME_VERSION (name)].value;
 536   if (val && val != name)
 537     return val;
 538   return NULL_TREE;
 539 }
 540
 541 /* Deallocate memory used in copy propagation and do final
 542    substitution.  */
 543
 544 static bool
 545 fini_copy_prop (void)
 546 {
 547   unsigned i;
 548
 549   /* Set the final copy-of value for each variable by traversing the
 550      copy-of chains.  */
 551   for (i = 1; i < num_ssa_names; i++)
 552     {
 553       tree var = ssa_name (i);
 554       if (!var
 555           || !copy_of[i].value
 556           || copy_of[i].value == var)
 557         continue;
 558
 559       /* In theory the points-to solution of all members of the
 560          copy chain is their intersection.  For now we do not bother
 561          to compute this but only make sure we do not lose points-to
 562          information completely by setting the points-to solution
 563          of the representative to the first solution we find if
 564          it doesn't have one already.  */
 565       if (copy_of[i].value != var
 566           && TREE_CODE (copy_of[i].value) == SSA_NAME)
 567         {
 568           basic_block copy_of_bb
 569             = gimple_bb (SSA_NAME_DEF_STMT (copy_of[i].value));
 570           basic_block var_bb = gimple_bb (SSA_NAME_DEF_STMT (var));
 571           if (POINTER_TYPE_P (TREE_TYPE (var))
 572               && SSA_NAME_PTR_INFO (var)
 573               && !SSA_NAME_PTR_INFO (copy_of[i].value))
 574             {
 575               duplicate_ssa_name_ptr_info (copy_of[i].value,
 576                                            SSA_NAME_PTR_INFO (var));
 577               /* Points-to information is cfg insensitive,
 578                  but alignment info might be cfg sensitive, if it
 579                  e.g. is derived from VRP derived non-zero bits.
 580                  So, do not copy alignment info if the two SSA_NAMEs
 581                  aren't defined in the same basic block.  */
 582               if (var_bb != copy_of_bb)
 583                 mark_ptr_info_alignment_unknown
 584                                 (SSA_NAME_PTR_INFO (copy_of[i].value));
 585             }
 586           else if (!POINTER_TYPE_P (TREE_TYPE (var))
 587                    && SSA_NAME_RANGE_INFO (var)
 588                    && !SSA_NAME_RANGE_INFO (copy_of[i].value)
 589                    && var_bb == copy_of_bb)
 590             duplicate_ssa_name_range_info (copy_of[i].value,
 591                                            SSA_NAME_RANGE_TYPE (var),
 592                                            SSA_NAME_RANGE_INFO (var));
 593         }
 594     }
 595
 596   bool changed = substitute_and_fold (get_value, NULL, true);
 597   if (changed)
 598     {
 599       free_numbers_of_iterations_estimates ();
 600       if (scev_initialized_p ())
 601         scev_reset ();
 602     }
 603
 604   free (copy_of);
 605
 606   return changed;
 607 }
 608
 609
 610 /* Main entry point to the copy propagator.
 611
 612    PHIS_ONLY is true if we should only consider PHI nodes as generating
 613    copy propagation opportunities.
 614
 615    The algorithm propagates the value COPY-OF using ssa_propagate.  For
 616    every variable X_i, COPY-OF(X_i) indicates which variable is X_i created
 617    from.  The following example shows how the algorithm proceeds at a
 618    high level:
 619
 620             1   a_24 = x_1
 621             2   a_2 = PHI <a_24, x_1>
 622             3   a_5 = PHI <a_2>
 623             4   x_1 = PHI <x_298, a_5, a_2>
 624
 625    The end result should be that a_2, a_5, a_24 and x_1 are a copy of
 626    x_298.  Propagation proceeds as follows.
 627
 628    Visit #1: a_24 is copy-of x_1.  Value changed.
 629    Visit #2: a_2 is copy-of x_1.  Value changed.
 630    Visit #3: a_5 is copy-of x_1.  Value changed.
 631    Visit #4: x_1 is copy-of x_298.  Value changed.
 632    Visit #1: a_24 is copy-of x_298.  Value changed.
 633    Visit #2: a_2 is copy-of x_298.  Value changed.
 634    Visit #3: a_5 is copy-of x_298.  Value changed.
 635    Visit #4: x_1 is copy-of x_298.  Stable state reached.
 636
 637    When visiting PHI nodes, we only consider arguments that flow
 638    through edges marked executable by the propagation engine.  So,
 639    when visiting statement #2 for the first time, we will only look at
 640    the first argument (a_24) and optimistically assume that its value
 641    is the copy of a_24 (x_1).  */
 642
 643 static unsigned int
 644 execute_copy_prop (void)
 645 {
 646   init_copy_prop ();
 647   ssa_propagate (copy_prop_visit_stmt, copy_prop_visit_phi_node);
 648   if (fini_copy_prop ())
 649     return TODO_cleanup_cfg;
 650   return 0;
 651 }
 652
 653 namespace {
 654
 655 const pass_data pass_data_copy_prop =
 656 {
 657   GIMPLE_PASS, /* type */
 658   "copyprop", /* name */
 659   OPTGROUP_NONE, /* optinfo_flags */
 660   true, /* has_execute */
 661   TV_TREE_COPY_PROP, /* tv_id */
 662   ( PROP_ssa | PROP_cfg ), /* properties_required */
 663   0, /* properties_provided */
 664   0, /* properties_destroyed */
 665   0, /* todo_flags_start */
 666   0, /* todo_flags_finish */
 667 };
 668
 669 class pass_copy_prop : public gimple_opt_pass
 670 {
 671 public:
 672   pass_copy_prop (gcc::context *ctxt)
 673     : gimple_opt_pass (pass_data_copy_prop, ctxt)
 674   {}
 675
 676   /* opt_pass methods: */
 677   opt_pass * clone () { return new pass_copy_prop (m_ctxt); }
 678   virtual bool gate (function *) { return flag_tree_copy_prop != 0; }
 679   virtual unsigned int execute (function *) { return execute_copy_prop (); }
 680
 681 }; // class pass_copy_prop
 682
 683 } // anon namespace
 684
 685 gimple_opt_pass *
 686 make_pass_copy_prop (gcc::context *ctxt)
 687 {
 688   return new pass_copy_prop (ctxt);
 689 }