gcc/ipa-pure-const.c

   1 /* Callgraph based analysis of static variables.
   2    Copyright (C) 2004, 2005 Free Software Foundation, Inc.
   3    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 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 the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  21
  22 /* This file mark functions as being either const (TREE_READONLY) or
  23    pure (DECL_IS_PURE).
  24
  25    This must be run after inlining decisions have been made since
  26    otherwise, the local sets will not contain information that is
  27    consistent with post inlined state.  The global sets are not prone
  28    to this problem since they are by definition transitive.  */
  29
  30 /* The code in this module is called by the ipa pass manager. It
  31    should be one of the later passes since it's information is used by
  32    the rest of the compilation. */
  33
  34 #include "config.h"
  35 #include "system.h"
  36 #include "coretypes.h"
  37 #include "tm.h"
  38 #include "tree.h"
  39 #include "tree-flow.h"
  40 #include "tree-inline.h"
  41 #include "tree-pass.h"
  42 #include "langhooks.h"
  43 #include "pointer-set.h"
  44 #include "ggc.h"
  45 #include "ipa-utils.h"
  46 #include "c-common.h"
  47 #include "tree-gimple.h"
  48 #include "cgraph.h"
  49 #include "output.h"
  50 #include "flags.h"
  51 #include "timevar.h"
  52 #include "diagnostic.h"
  53 #include "langhooks.h"
  54 #include "target.h"
  55
  56 static struct pointer_set_t *visited_nodes;
  57
  58 /* Lattice values for const and pure functions.  Everything starts out
  59    being const, then may drop to pure and then neither depending on
  60    what is found.  */
  61 enum pure_const_state_e
  62 {
  63   IPA_CONST,
  64   IPA_PURE,
  65   IPA_NEITHER
  66 };
  67
  68 /* Holder inserted into the ipa_dfs_info aux field to hold the
  69    const_state.  */
  70 struct funct_state_d
  71 {
  72   enum pure_const_state_e pure_const_state;
  73   bool state_set_in_source;
  74 };
  75
  76 typedef struct funct_state_d * funct_state;
  77
  78 /* Return the function state from NODE.  */
  79
  80 static inline funct_state
  81 get_function_state (struct cgraph_node *node)
  82 {
  83   struct ipa_dfs_info * info = node->aux;
  84   return info->aux;
  85 }
  86
  87 /* Check to see if the use (or definition when CHECHING_WRITE is true)
  88    variable T is legal in a function that is either pure or const.  */
  89
  90 static inline void
  91 check_decl (funct_state local,
  92             tree t, bool checking_write)
  93 {
  94   /* If the variable has the "used" attribute, treat it as if it had a
  95      been touched by the devil.  */
  96   if (lookup_attribute ("used", DECL_ATTRIBUTES (t)))
  97     {
  98       local->pure_const_state = IPA_NEITHER;
  99       return;
 100     }
 101
 102   /* Do not want to do anything with volatile except mark any
 103      function that uses one to be not const or pure.  */
 104   if (TREE_THIS_VOLATILE (t))
 105     {
 106       local->pure_const_state = IPA_NEITHER;
 107       return;
 108     }
 109
 110   /* Do not care about a local automatic that is not static.  */
 111   if (!TREE_STATIC (t) && !DECL_EXTERNAL (t))
 112     return;
 113
 114   /* Since we have dealt with the locals and params cases above, if we
 115      are CHECKING_WRITE, this cannot be a pure or constant
 116      function.  */
 117   if (checking_write)
 118     local->pure_const_state = IPA_NEITHER;
 119
 120   if (DECL_EXTERNAL (t) || TREE_PUBLIC (t))
 121     {
 122       /* If the front end set the variable to be READONLY and
 123          constant, we can allow this variable in pure or const
 124          functions but the scope is too large for our analysis to set
 125          these bits ourselves.  */
 126
 127       if (TREE_READONLY (t)
 128           && DECL_INITIAL (t)
 129           && is_gimple_min_invariant (DECL_INITIAL (t)))
 130         ; /* Read of a constant, do not change the function state.  */
 131       else
 132         {
 133           /* Just a regular read.  */
 134           if (local->pure_const_state == IPA_CONST)
 135             local->pure_const_state = IPA_PURE;
 136         }
 137     }
 138
 139   /* Compilation level statics can be read if they are readonly
 140      variables.  */
 141   if (TREE_READONLY (t))
 142     return;
 143
 144   /* Just a regular read.  */
 145   if (local->pure_const_state == IPA_CONST)
 146     local->pure_const_state = IPA_PURE;
 147 }
 148
 149 /* If T is a VAR_DECL check to see if it is an allowed reference.  */
 150
 151 static void
 152 check_operand (funct_state local,
 153                tree t, bool checking_write)
 154 {
 155   if (!t) return;
 156
 157   if (TREE_CODE (t) == VAR_DECL)
 158     check_decl (local, t, checking_write);
 159 }
 160
 161 /* Examine tree T for references.  */
 162
 163 static void
 164 check_tree (funct_state local, tree t, bool checking_write)
 165 {
 166   if ((TREE_CODE (t) == EXC_PTR_EXPR) || (TREE_CODE (t) == FILTER_EXPR)
 167       || TREE_CODE (t) == SSA_NAME)
 168     return;
 169
 170   /* Any tree which is volatile disqualifies thie function from being
 171      const or pure. */
 172   if (TREE_THIS_VOLATILE (t))
 173     {
 174       local->pure_const_state = IPA_NEITHER;
 175       return;
 176     }
 177
 178   while (TREE_CODE (t) == REALPART_EXPR
 179          || TREE_CODE (t) == IMAGPART_EXPR
 180          || handled_component_p (t))
 181     {
 182       if (TREE_CODE (t) == ARRAY_REF)
 183         check_operand (local, TREE_OPERAND (t, 1), false);
 184       t = TREE_OPERAND (t, 0);
 185     }
 186
 187   /* The bottom of an indirect reference can only be read, not
 188      written.  */
 189   if (INDIRECT_REF_P (t))
 190     {
 191       check_tree (local, TREE_OPERAND (t, 0), false);
 192
 193       /* Any indirect reference that occurs on the lhs
 194          disqualifies the function from being pure or const. Any
 195          indirect reference that occurs on the rhs disqualifies the
 196          function from being const.  */
 197       if (checking_write)
 198         {
 199           local->pure_const_state = IPA_NEITHER;
 200           return;
 201         }
 202       else if (local->pure_const_state == IPA_CONST)
 203         local->pure_const_state = IPA_PURE;
 204     }
 205
 206   if (SSA_VAR_P (t))
 207     check_operand (local, t, checking_write);
 208 }
 209
 210 /* Scan tree T to see if there are any addresses taken in within T.  */
 211
 212 static void
 213 look_for_address_of (funct_state local, tree t)
 214 {
 215   if (TREE_CODE (t) == ADDR_EXPR)
 216     {
 217       tree x = get_base_var (t);
 218       if (TREE_CODE (x) == VAR_DECL)
 219         {
 220           check_decl (local, x, false);
 221
 222           /* Taking the address of something appears to be reasonable
 223              in PURE code.  Not allowed in const.  */
 224           if (local->pure_const_state == IPA_CONST)
 225             local->pure_const_state = IPA_PURE;
 226         }
 227     }
 228 }
 229
 230 /* Check to see if T is a read or address of operation on a var we are
 231    interested in analyzing.  LOCAL is passed in to get access to its
 232    bit vectors.  */
 233
 234 static void
 235 check_rhs_var (funct_state local, tree t)
 236 {
 237   look_for_address_of (local, t);
 238
 239   /* Memcmp and strlen can both trap and they are declared pure.  */
 240   if (tree_could_trap_p (t)
 241       && local->pure_const_state == IPA_CONST)
 242     local->pure_const_state = IPA_PURE;
 243
 244   check_tree(local, t, false);
 245 }
 246
 247 /* Check to see if T is an assignment to a var we are interested in
 248    analyzing.  LOCAL is passed in to get access to its bit vectors. */
 249
 250 static void
 251 check_lhs_var (funct_state local, tree t)
 252 {
 253   /* Memcmp and strlen can both trap and they are declared pure.
 254      Which seems to imply that we can apply the same rule here.  */
 255   if (tree_could_trap_p (t)
 256       && local->pure_const_state == IPA_CONST)
 257     local->pure_const_state = IPA_PURE;
 258
 259   check_tree(local, t, true);
 260 }
 261
 262 /* This is a scaled down version of get_asm_expr_operands from
 263    tree_ssa_operands.c.  The version there runs much later and assumes
 264    that aliasing information is already available. Here we are just
 265    trying to find if the set of inputs and outputs contain references
 266    or address of operations to local static variables.  STMT is the
 267    actual asm statement.  */
 268
 269 static void
 270 get_asm_expr_operands (funct_state local, tree stmt)
 271 {
 272   int noutputs = list_length (ASM_OUTPUTS (stmt));
 273   const char **oconstraints
 274     = (const char **) alloca ((noutputs) * sizeof (const char *));
 275   int i;
 276   tree link;
 277   const char *constraint;
 278   bool allows_mem, allows_reg, is_inout;
 279
 280   for (i=0, link = ASM_OUTPUTS (stmt); link; ++i, link = TREE_CHAIN (link))
 281     {
 282       oconstraints[i] = constraint
 283         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 284       parse_output_constraint (&constraint, i, 0, 0,
 285                                &allows_mem, &allows_reg, &is_inout);
 286
 287       check_lhs_var (local, TREE_VALUE (link));
 288     }
 289
 290   for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
 291     {
 292       constraint
 293         = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
 294       parse_input_constraint (&constraint, 0, 0, noutputs, 0,
 295                               oconstraints, &allows_mem, &allows_reg);
 296
 297       check_rhs_var (local, TREE_VALUE (link));
 298     }
 299
 300   for (link = ASM_CLOBBERS (stmt); link; link = TREE_CHAIN (link))
 301     if (simple_cst_equal(TREE_VALUE (link), memory_identifier_string) == 1)
 302       /* Abandon all hope, ye who enter here. */
 303       local->pure_const_state = IPA_NEITHER;
 304
 305   if (ASM_VOLATILE_P (stmt))
 306     local->pure_const_state = IPA_NEITHER;
 307 }
 308
 309 /* Check the parameters of a function call to CALL_EXPR to see if
 310    there are any references in the parameters that are not allowed for
 311    pure or const functions.  Also check to see if this is either an
 312    indirect call, a call outside the compilation unit, or has special
 313    attributes that may also effect the purity.  The CALL_EXPR node for
 314    the entire call expression.  */
 315
 316 static void
 317 check_call (funct_state local, tree call_expr)
 318 {
 319   int flags = call_expr_flags (call_expr);
 320   tree operand;
 321   call_expr_arg_iterator iter;
 322   tree callee_t = get_callee_fndecl (call_expr);
 323   struct cgraph_node* callee;
 324   enum availability avail = AVAIL_NOT_AVAILABLE;
 325
 326   FOR_EACH_CALL_EXPR_ARG (operand, iter, call_expr)
 327     check_rhs_var (local, operand);
 328
 329   /* The const and pure flags are set by a variety of places in the
 330      compiler (including here).  If someone has already set the flags
 331      for the callee, (such as for some of the builtins) we will use
 332      them, otherwise we will compute our own information.
 333
 334      Const and pure functions have less clobber effects than other
 335      functions so we process these first.  Otherwise if it is a call
 336      outside the compilation unit or an indirect call we punt.  This
 337      leaves local calls which will be processed by following the call
 338      graph.  */
 339   if (callee_t)
 340     {
 341       callee = cgraph_node(callee_t);
 342       avail = cgraph_function_body_availability (callee);
 343
 344       /* When bad things happen to bad functions, they cannot be const
 345          or pure.  */
 346       if (setjmp_call_p (callee_t))
 347         local->pure_const_state = IPA_NEITHER;
 348
 349       if (DECL_BUILT_IN_CLASS (callee_t) == BUILT_IN_NORMAL)
 350         switch (DECL_FUNCTION_CODE (callee_t))
 351           {
 352           case BUILT_IN_LONGJMP:
 353           case BUILT_IN_NONLOCAL_GOTO:
 354             local->pure_const_state = IPA_NEITHER;
 355             break;
 356           default:
 357             break;
 358           }
 359     }
 360
 361   /* The callee is either unknown (indirect call) or there is just no
 362      scannable code for it (external call) .  We look to see if there
 363      are any bits available for the callee (such as by declaration or
 364      because it is builtin) and process solely on the basis of those
 365      bits. */
 366   if (avail == AVAIL_NOT_AVAILABLE || avail == AVAIL_OVERWRITABLE)
 367     {
 368       if (flags & ECF_PURE)
 369         {
 370           if (local->pure_const_state == IPA_CONST)
 371             local->pure_const_state = IPA_PURE;
 372         }
 373       else
 374         local->pure_const_state = IPA_NEITHER;
 375     }
 376   else
 377     {
 378       /* We have the code and we will scan it for the effects. */
 379       if (flags & ECF_PURE)
 380         {
 381           if (local->pure_const_state == IPA_CONST)
 382             local->pure_const_state = IPA_PURE;
 383         }
 384     }
 385 }
 386
 387 /* TP is the part of the tree currently under the microscope.
 388    WALK_SUBTREES is part of the walk_tree api but is unused here.
 389    DATA is cgraph_node of the function being walked.  */
 390
 391 /* FIXME: When this is converted to run over SSA form, this code
 392    should be converted to use the operand scanner.  */
 393
 394 static tree
 395 scan_function (tree *tp,
 396                       int *walk_subtrees,
 397                       void *data)
 398 {
 399   struct cgraph_node *fn = data;
 400   tree t = *tp;
 401   funct_state local = get_function_state (fn);
 402
 403   switch (TREE_CODE (t))
 404     {
 405     case VAR_DECL:
 406       if (DECL_INITIAL (t))
 407         walk_tree (&DECL_INITIAL (t), scan_function, fn, visited_nodes);
 408       *walk_subtrees = 0;
 409       break;
 410
 411     case GIMPLE_MODIFY_STMT:
 412       {
 413         /* First look on the lhs and see what variable is stored to */
 414         tree lhs = GIMPLE_STMT_OPERAND (t, 0);
 415         tree rhs = GIMPLE_STMT_OPERAND (t, 1);
 416         check_lhs_var (local, lhs);
 417
 418         /* For the purposes of figuring out what the cast affects */
 419
 420         /* Next check the operands on the rhs to see if they are ok. */
 421         switch (TREE_CODE_CLASS (TREE_CODE (rhs)))
 422           {
 423           case tcc_binary:
 424             {
 425               tree op0 = TREE_OPERAND (rhs, 0);
 426               tree op1 = TREE_OPERAND (rhs, 1);
 427               check_rhs_var (local, op0);
 428               check_rhs_var (local, op1);
 429             }
 430             break;
 431           case tcc_unary:
 432             {
 433               tree op0 = TREE_OPERAND (rhs, 0);
 434               check_rhs_var (local, op0);
 435             }
 436
 437             break;
 438           case tcc_reference:
 439             check_rhs_var (local, rhs);
 440             break;
 441           case tcc_declaration:
 442             check_rhs_var (local, rhs);
 443             break;
 444           case tcc_expression:
 445             switch (TREE_CODE (rhs))
 446               {
 447               case ADDR_EXPR:
 448                 check_rhs_var (local, rhs);
 449                 break;
 450               default:
 451                 break;
 452               }
 453             break;
 454           case tcc_vl_exp:
 455             switch (TREE_CODE (rhs))
 456               {
 457               case CALL_EXPR:
 458                 check_call (local, rhs);
 459                 break;
 460               default:
 461                 break;
 462               }
 463             break;
 464           default:
 465             break;
 466           }
 467         *walk_subtrees = 0;
 468       }
 469       break;
 470
 471     case ADDR_EXPR:
 472       /* This case is here to find addresses on rhs of constructors in
 473          decl_initial of static variables. */
 474       check_rhs_var (local, t);
 475       *walk_subtrees = 0;
 476       break;
 477
 478     case LABEL_EXPR:
 479       if (DECL_NONLOCAL (TREE_OPERAND (t, 0)))
 480         /* Target of long jump. */
 481         local->pure_const_state = IPA_NEITHER;
 482       break;
 483
 484     case CALL_EXPR:
 485       check_call (local, t);
 486       *walk_subtrees = 0;
 487       break;
 488
 489     case ASM_EXPR:
 490       get_asm_expr_operands (local, t);
 491       *walk_subtrees = 0;
 492       break;
 493
 494     default:
 495       break;
 496     }
 497   return NULL;
 498 }
 499
 500 /* This is the main routine for finding the reference patterns for
 501    global variables within a function FN.  */
 502
 503 static void
 504 analyze_function (struct cgraph_node *fn)
 505 {
 506   funct_state l = XCNEW (struct funct_state_d);
 507   tree decl = fn->decl;
 508   struct ipa_dfs_info * w_info = fn->aux;
 509
 510   w_info->aux = l;
 511
 512   l->pure_const_state = IPA_CONST;
 513   l->state_set_in_source = false;
 514
 515   /* If this function does not return normally or does not bind local,
 516      do not touch this unless it has been marked as const or pure by the
 517      front end.  */
 518   if (TREE_THIS_VOLATILE (decl)
 519       || !targetm.binds_local_p (decl))
 520     {
 521       l->pure_const_state = IPA_NEITHER;
 522       return;
 523     }
 524
 525   if (TREE_READONLY (decl))
 526     {
 527       l->pure_const_state = IPA_CONST;
 528       l->state_set_in_source = true;
 529     }
 530   if (DECL_IS_PURE (decl))
 531     {
 532       l->pure_const_state = IPA_PURE;
 533       l->state_set_in_source = true;
 534     }
 535
 536   if (dump_file)
 537     {
 538       fprintf (dump_file, "\n local analysis of %s with initial value = %d\n ",
 539                cgraph_node_name (fn),
 540                l->pure_const_state);
 541     }
 542
 543   if (!l->state_set_in_source)
 544     {
 545       struct function *this_cfun = DECL_STRUCT_FUNCTION (decl);
 546       basic_block this_block;
 547
 548       FOR_EACH_BB_FN (this_block, this_cfun)
 549         {
 550           block_stmt_iterator bsi;
 551           for (bsi = bsi_start (this_block); !bsi_end_p (bsi); bsi_next (&bsi))
 552             {
 553               walk_tree (bsi_stmt_ptr (bsi), scan_function,
 554                          fn, visited_nodes);
 555               if (l->pure_const_state == IPA_NEITHER)
 556                 goto end;
 557             }
 558         }
 559
 560       if (l->pure_const_state != IPA_NEITHER)
 561         {
 562           tree old_decl = current_function_decl;
 563           /* Const functions cannot have back edges (an
 564              indication of possible infinite loop side
 565              effect.  */
 566
 567           current_function_decl = fn->decl;
 568
 569           /* The C++ front end, has a tendency to some times jerk away
 570              a function after it has created it.  This should have
 571              been fixed.  */
 572           gcc_assert (DECL_STRUCT_FUNCTION (fn->decl));
 573
 574           push_cfun (DECL_STRUCT_FUNCTION (fn->decl));
 575
 576           if (mark_dfs_back_edges ())
 577             l->pure_const_state = IPA_NEITHER;
 578
 579           current_function_decl = old_decl;
 580           pop_cfun ();
 581         }
 582     }
 583
 584 end:
 585   if (dump_file)
 586     {
 587       fprintf (dump_file, "after local analysis of %s with initial value = %d\n ",
 588                cgraph_node_name (fn),
 589                l->pure_const_state);
 590     }
 591 }
 592
 593 \f
 594 /* Produce the global information by preforming a transitive closure
 595    on the local information that was produced by ipa_analyze_function
 596    and ipa_analyze_variable.  */
 597
 598 static unsigned int
 599 static_execute (void)
 600 {
 601   struct cgraph_node *node;
 602   struct cgraph_node *w;
 603   struct cgraph_node **order =
 604     XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
 605   int order_pos = order_pos = ipa_utils_reduced_inorder (order, true, false);
 606   int i;
 607   struct ipa_dfs_info * w_info;
 608
 609   if (!memory_identifier_string)
 610     memory_identifier_string = build_string(7, "memory");
 611
 612   /* There are some shared nodes, in particular the initializers on
 613      static declarations.  We do not need to scan them more than once
 614      since all we would be interested in are the addressof
 615      operations.  */
 616   visited_nodes = pointer_set_create ();
 617
 618   /* Process all of the functions.
 619
 620      We do not want to process any of the clones so we check that this
 621      is a master clone.  However, we do NOT process any
 622      AVAIL_OVERWRITABLE functions (these are never clones) we cannot
 623      guarantee that what we learn about the one we see will be true
 624      for the one that overriders it.
 625   */
 626   for (node = cgraph_nodes; node; node = node->next)
 627     if (node->analyzed && cgraph_is_master_clone (node))
 628       analyze_function (node);
 629
 630   pointer_set_destroy (visited_nodes);
 631   visited_nodes = NULL;
 632   if (dump_file)
 633     {
 634       dump_cgraph (dump_file);
 635       ipa_utils_print_order(dump_file, "reduced", order, order_pos);
 636     }
 637
 638   /* Propagate the local information thru the call graph to produce
 639      the global information.  All the nodes within a cycle will have
 640      the same info so we collapse cycles first.  Then we can do the
 641      propagation in one pass from the leaves to the roots.  */
 642   for (i = 0; i < order_pos; i++ )
 643     {
 644       enum pure_const_state_e pure_const_state = IPA_CONST;
 645       node = order[i];
 646
 647       /* Find the worst state for any node in the cycle.  */
 648       w = node;
 649       while (w)
 650         {
 651           funct_state w_l = get_function_state (w);
 652           if (pure_const_state < w_l->pure_const_state)
 653             pure_const_state = w_l->pure_const_state;
 654
 655           if (pure_const_state == IPA_NEITHER)
 656             break;
 657
 658           if (!w_l->state_set_in_source)
 659             {
 660               struct cgraph_edge *e;
 661               for (e = w->callees; e; e = e->next_callee)
 662                 {
 663                   struct cgraph_node *y = e->callee;
 664                   /* Only look at the master nodes and skip external nodes.  */
 665                   y = cgraph_master_clone (y);
 666                   if (y)
 667                     {
 668                       funct_state y_l = get_function_state (y);
 669                       if (pure_const_state < y_l->pure_const_state)
 670                         pure_const_state = y_l->pure_const_state;
 671                       if (pure_const_state == IPA_NEITHER)
 672                         break;
 673                     }
 674                 }
 675             }
 676           w_info = w->aux;
 677           w = w_info->next_cycle;
 678         }
 679
 680       /* Copy back the region's pure_const_state which is shared by
 681          all nodes in the region.  */
 682       w = node;
 683       while (w)
 684         {
 685           funct_state w_l = get_function_state (w);
 686
 687           /* All nodes within a cycle share the same info.  */
 688           if (!w_l->state_set_in_source)
 689             {
 690               w_l->pure_const_state = pure_const_state;
 691               switch (pure_const_state)
 692                 {
 693                 case IPA_CONST:
 694                   TREE_READONLY (w->decl) = 1;
 695                   if (dump_file)
 696                     fprintf (dump_file, "Function found to be const: %s\n",
 697                              lang_hooks.decl_printable_name(w->decl, 2));
 698                   break;
 699
 700                 case IPA_PURE:
 701                   DECL_IS_PURE (w->decl) = 1;
 702                   if (dump_file)
 703                     fprintf (dump_file, "Function found to be pure: %s\n",
 704                              lang_hooks.decl_printable_name(w->decl, 2));
 705                   break;
 706
 707                 default:
 708                   break;
 709                 }
 710             }
 711           w_info = w->aux;
 712           w = w_info->next_cycle;
 713         }
 714     }
 715
 716   /* Cleanup. */
 717   for (node = cgraph_nodes; node; node = node->next)
 718     /* Get rid of the aux information.  */
 719     if (node->aux)
 720       {
 721         w_info = node->aux;
 722         if (w_info->aux)
 723           free (w_info->aux);
 724         free (node->aux);
 725         node->aux = NULL;
 726       }
 727
 728   free (order);
 729   return 0;
 730 }
 731
 732 static bool
 733 gate_pure_const (void)
 734 {
 735   return (flag_unit_at_a_time != 0 && flag_ipa_pure_const
 736           /* Don't bother doing anything if the program has errors.  */
 737           && !(errorcount || sorrycount));
 738 }
 739
 740 struct tree_opt_pass pass_ipa_pure_const =
 741 {
 742   "pure-const",                         /* name */
 743   gate_pure_const,                      /* gate */
 744   static_execute,                       /* execute */
 745   NULL,                                 /* sub */
 746   NULL,                                 /* next */
 747   0,                                    /* static_pass_number */
 748   TV_IPA_PURE_CONST,                    /* tv_id */
 749   0,                                    /* properties_required */
 750   0,                                    /* properties_provided */
 751   0,                                    /* properties_destroyed */
 752   0,                                    /* todo_flags_start */
 753   0,                                    /* todo_flags_finish */
 754   0                                     /* letter */
 755 };
 756
 757