gcc/tree-ssa.c

   1 /* Miscellaneous SSA utility functions.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 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 "rtl.h"
  27 #include "tm_p.h"
  28 #include "ggc.h"
  29 #include "langhooks.h"
  30 #include "hard-reg-set.h"
  31 #include "basic-block.h"
  32 #include "output.h"
  33 #include "expr.h"
  34 #include "function.h"
  35 #include "diagnostic.h"
  36 #include "bitmap.h"
  37 #include "pointer-set.h"
  38 #include "tree-flow.h"
  39 #include "tree-gimple.h"
  40 #include "tree-inline.h"
  41 #include "varray.h"
  42 #include "timevar.h"
  43 #include "hashtab.h"
  44 #include "tree-dump.h"
  45 #include "tree-pass.h"
  46 #include "toplev.h"
  47
  48 /* Remove the corresponding arguments from the PHI nodes in E's
  49    destination block and redirect it to DEST.  Return redirected edge.
  50    The list of removed arguments is stored in PENDING_STMT (e).  */
  51
  52 edge
  53 ssa_redirect_edge (edge e, basic_block dest)
  54 {
  55   tree phi;
  56   tree list = NULL, *last = &list;
  57   tree src, dst, node;
  58
  59   /* Remove the appropriate PHI arguments in E's destination block.  */
  60   for (phi = phi_nodes (e->dest); phi; phi = PHI_CHAIN (phi))
  61     {
  62       if (PHI_ARG_DEF (phi, e->dest_idx) == NULL_TREE)
  63         continue;
  64
  65       src = PHI_ARG_DEF (phi, e->dest_idx);
  66       dst = PHI_RESULT (phi);
  67       node = build_tree_list (dst, src);
  68       *last = node;
  69       last = &TREE_CHAIN (node);
  70     }
  71
  72   e = redirect_edge_succ_nodup (e, dest);
  73   PENDING_STMT (e) = list;
  74
  75   return e;
  76 }
  77
  78 /* Add PHI arguments queued in PENDING_STMT list on edge E to edge
  79    E->dest.  */
  80
  81 void
  82 flush_pending_stmts (edge e)
  83 {
  84   tree phi, arg;
  85
  86   if (!PENDING_STMT (e))
  87     return;
  88
  89   for (phi = phi_nodes (e->dest), arg = PENDING_STMT (e);
  90        phi;
  91        phi = PHI_CHAIN (phi), arg = TREE_CHAIN (arg))
  92     {
  93       tree def = TREE_VALUE (arg);
  94       add_phi_arg (phi, def, e);
  95     }
  96
  97   PENDING_STMT (e) = NULL;
  98 }
  99
 100 /* Return true if SSA_NAME is malformed and mark it visited.
 101
 102    IS_VIRTUAL is true if this SSA_NAME was found inside a virtual
 103       operand.  */
 104
 105 static bool
 106 verify_ssa_name (tree ssa_name, bool is_virtual)
 107 {
 108   if (TREE_CODE (ssa_name) != SSA_NAME)
 109     {
 110       error ("expected an SSA_NAME object");
 111       return true;
 112     }
 113
 114   if (TREE_TYPE (ssa_name) != TREE_TYPE (SSA_NAME_VAR (ssa_name)))
 115     {
 116       error ("type mismatch between an SSA_NAME and its symbol");
 117       return true;
 118     }
 119
 120   if (SSA_NAME_IN_FREE_LIST (ssa_name))
 121     {
 122       error ("found an SSA_NAME that had been released into the free pool");
 123       return true;
 124     }
 125
 126   if (is_virtual && is_gimple_reg (ssa_name))
 127     {
 128       error ("found a virtual definition for a GIMPLE register");
 129       return true;
 130     }
 131
 132   if (!is_virtual && !is_gimple_reg (ssa_name))
 133     {
 134       error ("found a real definition for a non-register");
 135       return true;
 136     }
 137
 138   if (is_virtual && var_ann (SSA_NAME_VAR (ssa_name))
 139       && get_subvars_for_var (SSA_NAME_VAR (ssa_name)) != NULL)
 140     {
 141       error ("found real variable when subvariables should have appeared");
 142       return true;
 143     }
 144
 145   if (SSA_NAME_IS_DEFAULT_DEF (ssa_name)
 146       && !IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name)))
 147     {
 148       error ("found a default name with a non-empty defining statement");
 149       return true;
 150     }
 151
 152   return false;
 153 }
 154
 155
 156 /* Return true if the definition of SSA_NAME at block BB is malformed.
 157
 158    STMT is the statement where SSA_NAME is created.
 159
 160    DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
 161       version numbers.  If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
 162       it means that the block in that array slot contains the
 163       definition of SSA_NAME.
 164
 165    IS_VIRTUAL is true if SSA_NAME is created by a VDEF.  */
 166
 167 static bool
 168 verify_def (basic_block bb, basic_block *definition_block, tree ssa_name,
 169             tree stmt, bool is_virtual)
 170 {
 171   if (verify_ssa_name (ssa_name, is_virtual))
 172     goto err;
 173
 174   if (definition_block[SSA_NAME_VERSION (ssa_name)])
 175     {
 176       error ("SSA_NAME created in two different blocks %i and %i",
 177              definition_block[SSA_NAME_VERSION (ssa_name)]->index, bb->index);
 178       goto err;
 179     }
 180
 181   definition_block[SSA_NAME_VERSION (ssa_name)] = bb;
 182
 183   if (SSA_NAME_DEF_STMT (ssa_name) != stmt)
 184     {
 185       error ("SSA_NAME_DEF_STMT is wrong");
 186       fprintf (stderr, "Expected definition statement:\n");
 187       print_generic_stmt (stderr, SSA_NAME_DEF_STMT (ssa_name), TDF_VOPS);
 188       fprintf (stderr, "\nActual definition statement:\n");
 189       print_generic_stmt (stderr, stmt, TDF_VOPS);
 190       goto err;
 191     }
 192
 193   return false;
 194
 195 err:
 196   fprintf (stderr, "while verifying SSA_NAME ");
 197   print_generic_expr (stderr, ssa_name, 0);
 198   fprintf (stderr, " in statement\n");
 199   print_generic_stmt (stderr, stmt, TDF_VOPS);
 200
 201   return true;
 202 }
 203
 204
 205 /* Return true if the use of SSA_NAME at statement STMT in block BB is
 206    malformed.
 207
 208    DEF_BB is the block where SSA_NAME was found to be created.
 209
 210    IDOM contains immediate dominator information for the flowgraph.
 211
 212    CHECK_ABNORMAL is true if the caller wants to check whether this use
 213       is flowing through an abnormal edge (only used when checking PHI
 214       arguments).
 215
 216    If NAMES_DEFINED_IN_BB is not NULL, it contains a bitmap of ssa names
 217      that are defined before STMT in basic block BB.  */
 218
 219 static bool
 220 verify_use (basic_block bb, basic_block def_bb, use_operand_p use_p,
 221             tree stmt, bool check_abnormal, bitmap names_defined_in_bb)
 222 {
 223   bool err = false;
 224   tree ssa_name = USE_FROM_PTR (use_p);
 225
 226   if (!TREE_VISITED (ssa_name))
 227     if (verify_imm_links (stderr, ssa_name))
 228       err = true;
 229
 230   TREE_VISITED (ssa_name) = 1;
 231
 232   if (IS_EMPTY_STMT (SSA_NAME_DEF_STMT (ssa_name))
 233       && SSA_NAME_IS_DEFAULT_DEF (ssa_name))
 234     ; /* Default definitions have empty statements.  Nothing to do.  */
 235   else if (!def_bb)
 236     {
 237       error ("missing definition");
 238       err = true;
 239     }
 240   else if (bb != def_bb
 241            && !dominated_by_p (CDI_DOMINATORS, bb, def_bb))
 242     {
 243       error ("definition in block %i does not dominate use in block %i",
 244              def_bb->index, bb->index);
 245       err = true;
 246     }
 247   else if (bb == def_bb
 248            && names_defined_in_bb != NULL
 249            && !bitmap_bit_p (names_defined_in_bb, SSA_NAME_VERSION (ssa_name)))
 250     {
 251       error ("definition in block %i follows the use", def_bb->index);
 252       err = true;
 253     }
 254
 255   if (check_abnormal
 256       && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ssa_name))
 257     {
 258       error ("SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set");
 259       err = true;
 260     }
 261
 262   /* Make sure the use is in an appropriate list by checking the previous
 263      element to make sure it's the same.  */
 264   if (use_p->prev == NULL)
 265     {
 266       error ("no immediate_use list");
 267       err = true;
 268     }
 269   else
 270     {
 271       tree listvar ;
 272       if (use_p->prev->use == NULL)
 273         listvar = use_p->prev->stmt;
 274       else
 275         listvar = USE_FROM_PTR (use_p->prev);
 276       if (listvar != ssa_name)
 277         {
 278           error ("wrong immediate use list");
 279           err = true;
 280         }
 281     }
 282
 283   if (err)
 284     {
 285       fprintf (stderr, "for SSA_NAME: ");
 286       print_generic_expr (stderr, ssa_name, TDF_VOPS);
 287       fprintf (stderr, " in statement:\n");
 288       print_generic_stmt (stderr, stmt, TDF_VOPS);
 289     }
 290
 291   return err;
 292 }
 293
 294
 295 /* Return true if any of the arguments for PHI node PHI at block BB is
 296    malformed.
 297
 298    DEFINITION_BLOCK is an array of basic blocks indexed by SSA_NAME
 299       version numbers.  If DEFINITION_BLOCK[SSA_NAME_VERSION] is set,
 300       it means that the block in that array slot contains the
 301       definition of SSA_NAME.  */
 302
 303 static bool
 304 verify_phi_args (tree phi, basic_block bb, basic_block *definition_block)
 305 {
 306   edge e;
 307   bool err = false;
 308   unsigned i, phi_num_args = PHI_NUM_ARGS (phi);
 309
 310   if (EDGE_COUNT (bb->preds) != phi_num_args)
 311     {
 312       error ("incoming edge count does not match number of PHI arguments");
 313       err = true;
 314       goto error;
 315     }
 316
 317   for (i = 0; i < phi_num_args; i++)
 318     {
 319       use_operand_p op_p = PHI_ARG_DEF_PTR (phi, i);
 320       tree op = USE_FROM_PTR (op_p);
 321
 322       e = EDGE_PRED (bb, i);
 323
 324       if (op == NULL_TREE)
 325         {
 326           error ("PHI argument is missing for edge %d->%d",
 327                  e->src->index,
 328                  e->dest->index);
 329           err = true;
 330           goto error;
 331         }
 332
 333       if (TREE_CODE (op) != SSA_NAME && !is_gimple_min_invariant (op))
 334         {
 335           error ("PHI argument is not SSA_NAME, or invariant");
 336           err = true;
 337         }
 338
 339       if (TREE_CODE (op) == SSA_NAME)
 340         {
 341           err = verify_ssa_name (op, !is_gimple_reg (PHI_RESULT (phi)));
 342           err |= verify_use (e->src, definition_block[SSA_NAME_VERSION (op)],
 343                              op_p, phi, e->flags & EDGE_ABNORMAL, NULL);
 344         }
 345
 346       if (e->dest != bb)
 347         {
 348           error ("wrong edge %d->%d for PHI argument",
 349                  e->src->index, e->dest->index);
 350           err = true;
 351         }
 352
 353       if (err)
 354         {
 355           fprintf (stderr, "PHI argument\n");
 356           print_generic_stmt (stderr, op, TDF_VOPS);
 357           goto error;
 358         }
 359     }
 360
 361 error:
 362   if (err)
 363     {
 364       fprintf (stderr, "for PHI node\n");
 365       print_generic_stmt (stderr, phi, TDF_VOPS|TDF_MEMSYMS);
 366     }
 367
 368
 369   return err;
 370 }
 371
 372
 373 static void
 374 verify_flow_insensitive_alias_info (void)
 375 {
 376   tree var;
 377   referenced_var_iterator rvi;
 378
 379   FOR_EACH_REFERENCED_VAR (var, rvi)
 380     {
 381       unsigned int j;
 382       bitmap aliases;
 383       tree alias;
 384       bitmap_iterator bi;
 385
 386       if (!MTAG_P (var) || !MTAG_ALIASES (var))
 387         continue;
 388
 389       aliases = MTAG_ALIASES (var);
 390
 391       EXECUTE_IF_SET_IN_BITMAP (aliases, 0, j, bi)
 392         {
 393           alias = referenced_var (j);
 394
 395           if (TREE_CODE (alias) != MEMORY_PARTITION_TAG
 396               && !may_be_aliased (alias))
 397             {
 398               error ("non-addressable variable inside an alias set");
 399               debug_variable (alias);
 400               goto err;
 401             }
 402         }
 403     }
 404
 405   return;
 406
 407 err:
 408   debug_variable (var);
 409   internal_error ("verify_flow_insensitive_alias_info failed");
 410 }
 411
 412
 413 static void
 414 verify_flow_sensitive_alias_info (void)
 415 {
 416   size_t i;
 417   tree ptr;
 418
 419   for (i = 1; i < num_ssa_names; i++)
 420     {
 421       tree var;
 422       var_ann_t ann;
 423       struct ptr_info_def *pi;
 424
 425
 426       ptr = ssa_name (i);
 427       if (!ptr)
 428         continue;
 429
 430       /* We only care for pointers that are actually referenced in the
 431          program.  */
 432       if (!POINTER_TYPE_P (TREE_TYPE (ptr)) || !TREE_VISITED (ptr))
 433         continue;
 434
 435       /* RESULT_DECL is special.  If it's a GIMPLE register, then it
 436          is only written-to only once in the return statement.
 437          Otherwise, aggregate RESULT_DECLs may be written-to more than
 438          once in virtual operands.  */
 439       var = SSA_NAME_VAR (ptr);
 440       if (TREE_CODE (var) == RESULT_DECL
 441           && is_gimple_reg (ptr))
 442         continue;
 443
 444       pi = SSA_NAME_PTR_INFO (ptr);
 445       if (pi == NULL)
 446         continue;
 447
 448       ann = var_ann (var);
 449       if (pi->is_dereferenced && !pi->name_mem_tag && !ann->symbol_mem_tag)
 450         {
 451           error ("dereferenced pointers should have a name or a symbol tag");
 452           goto err;
 453         }
 454
 455       if (pi->name_mem_tag
 456           && (pi->pt_vars == NULL || bitmap_empty_p (pi->pt_vars)))
 457         {
 458           error ("pointers with a memory tag, should have points-to sets");
 459           goto err;
 460         }
 461
 462       if (pi->value_escapes_p && pi->name_mem_tag)
 463         {
 464           tree t = memory_partition (pi->name_mem_tag);
 465           if (t == NULL_TREE)
 466             t = pi->name_mem_tag;
 467
 468           if (!is_call_clobbered (t))
 469             {
 470               error ("pointer escapes but its name tag is not call-clobbered");
 471               goto err;
 472             }
 473         }
 474     }
 475
 476   return;
 477
 478 err:
 479   debug_variable (ptr);
 480   internal_error ("verify_flow_sensitive_alias_info failed");
 481 }
 482
 483
 484 /* Verify the consistency of call clobbering information.  */
 485
 486 static void
 487 verify_call_clobbering (void)
 488 {
 489   unsigned int i;
 490   bitmap_iterator bi;
 491   tree var;
 492   referenced_var_iterator rvi;
 493
 494   /* At all times, the result of the call_clobbered flag should
 495      match the result of the call_clobbered_vars bitmap.  Verify both
 496      that everything in call_clobbered_vars is marked
 497      call_clobbered, and that everything marked
 498      call_clobbered is in call_clobbered_vars.  */
 499   EXECUTE_IF_SET_IN_BITMAP (gimple_call_clobbered_vars (cfun), 0, i, bi)
 500     {
 501       var = referenced_var (i);
 502
 503       if (memory_partition (var))
 504         var = memory_partition (var);
 505
 506       if (!MTAG_P (var) && !var_ann (var)->call_clobbered)
 507         {
 508           error ("variable in call_clobbered_vars but not marked "
 509                  "call_clobbered");
 510           debug_variable (var);
 511           goto err;
 512         }
 513     }
 514
 515   FOR_EACH_REFERENCED_VAR (var, rvi)
 516     {
 517       if (is_gimple_reg (var))
 518         continue;
 519
 520       if (memory_partition (var))
 521         var = memory_partition (var);
 522
 523       if (!MTAG_P (var)
 524           && var_ann (var)->call_clobbered
 525           && !bitmap_bit_p (gimple_call_clobbered_vars (cfun), DECL_UID (var)))
 526         {
 527           error ("variable marked call_clobbered but not in "
 528                  "call_clobbered_vars bitmap.");
 529           debug_variable (var);
 530           goto err;
 531         }
 532     }
 533
 534   return;
 535
 536  err:
 537     internal_error ("verify_call_clobbering failed");
 538 }
 539
 540
 541 /* Verify invariants in memory partitions.  */
 542
 543 static void
 544 verify_memory_partitions (void)
 545 {
 546   unsigned i;
 547   tree mpt;
 548   VEC(tree,heap) *mpt_table = gimple_ssa_operands (cfun)->mpt_table;
 549   struct pointer_set_t *partitioned_syms = pointer_set_create ();
 550
 551   for (i = 0; VEC_iterate (tree, mpt_table, i, mpt); i++)
 552     {
 553       unsigned j;
 554       bitmap_iterator bj;
 555
 556       if (MPT_SYMBOLS (mpt) == NULL)
 557         {
 558           error ("Memory partitions should have at least one symbol");
 559           debug_variable (mpt);
 560           goto err;
 561         }
 562
 563       EXECUTE_IF_SET_IN_BITMAP (MPT_SYMBOLS (mpt), 0, j, bj)
 564         {
 565           tree var = referenced_var (j);
 566           if (pointer_set_insert (partitioned_syms, var))
 567             {
 568               error ("Partitioned symbols should belong to exactly one "
 569                      "partition");
 570               debug_variable (var);
 571               goto err;
 572             }
 573         }
 574     }
 575
 576   pointer_set_destroy (partitioned_syms);
 577
 578   return;
 579
 580 err:
 581   internal_error ("verify_memory_partitions failed");
 582 }
 583
 584
 585 /* Verify the consistency of aliasing information.  */
 586
 587 static void
 588 verify_alias_info (void)
 589 {
 590   verify_flow_sensitive_alias_info ();
 591   verify_call_clobbering ();
 592   verify_flow_insensitive_alias_info ();
 593   verify_memory_partitions ();
 594 }
 595
 596
 597 /* Verify common invariants in the SSA web.
 598    TODO: verify the variable annotations.  */
 599
 600 void
 601 verify_ssa (bool check_modified_stmt)
 602 {
 603   size_t i;
 604   basic_block bb;
 605   basic_block *definition_block = XCNEWVEC (basic_block, num_ssa_names);
 606   ssa_op_iter iter;
 607   tree op;
 608   enum dom_state orig_dom_state = dom_info_state (CDI_DOMINATORS);
 609   bitmap names_defined_in_bb = BITMAP_ALLOC (NULL);
 610
 611   gcc_assert (!need_ssa_update_p ());
 612
 613   verify_stmts ();
 614
 615   timevar_push (TV_TREE_SSA_VERIFY);
 616
 617   /* Keep track of SSA names present in the IL.  */
 618   for (i = 1; i < num_ssa_names; i++)
 619     {
 620       tree name = ssa_name (i);
 621       if (name)
 622         {
 623           tree stmt;
 624           TREE_VISITED (name) = 0;
 625
 626           stmt = SSA_NAME_DEF_STMT (name);
 627           if (!IS_EMPTY_STMT (stmt))
 628             {
 629               basic_block bb = bb_for_stmt (stmt);
 630               verify_def (bb, definition_block,
 631                           name, stmt, !is_gimple_reg (name));
 632
 633             }
 634         }
 635     }
 636
 637   calculate_dominance_info (CDI_DOMINATORS);
 638
 639   /* Now verify all the uses and make sure they agree with the definitions
 640      found in the previous pass.  */
 641   FOR_EACH_BB (bb)
 642     {
 643       edge e;
 644       tree phi;
 645       edge_iterator ei;
 646       block_stmt_iterator bsi;
 647
 648       /* Make sure that all edges have a clear 'aux' field.  */
 649       FOR_EACH_EDGE (e, ei, bb->preds)
 650         {
 651           if (e->aux)
 652             {
 653               error ("AUX pointer initialized for edge %d->%d", e->src->index,
 654                       e->dest->index);
 655               goto err;
 656             }
 657         }
 658
 659       /* Verify the arguments for every PHI node in the block.  */
 660       for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
 661         {
 662           if (verify_phi_args (phi, bb, definition_block))
 663             goto err;
 664
 665           bitmap_set_bit (names_defined_in_bb,
 666                           SSA_NAME_VERSION (PHI_RESULT (phi)));
 667         }
 668
 669       /* Now verify all the uses and vuses in every statement of the block.  */
 670       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 671         {
 672           tree stmt = bsi_stmt (bsi);
 673           use_operand_p use_p;
 674
 675           if (check_modified_stmt && stmt_modified_p (stmt))
 676             {
 677               error ("stmt (%p) marked modified after optimization pass: ",
 678                      (void *)stmt);
 679               print_generic_stmt (stderr, stmt, TDF_VOPS);
 680               goto err;
 681             }
 682
 683           if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT
 684               && TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 0)) != SSA_NAME)
 685             {
 686               tree lhs, base_address;
 687
 688               lhs = GIMPLE_STMT_OPERAND (stmt, 0);
 689               base_address = get_base_address (lhs);
 690
 691               if (base_address
 692                   && gimple_aliases_computed_p (cfun)
 693                   && SSA_VAR_P (base_address)
 694                   && !stmt_ann (stmt)->has_volatile_ops
 695                   && ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF))
 696                 {
 697                   error ("statement makes a memory store, but has no VDEFS");
 698                   print_generic_stmt (stderr, stmt, TDF_VOPS);
 699                   goto err;
 700                 }
 701             }
 702
 703           FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_VIRTUALS)
 704             {
 705               if (verify_ssa_name (op, true))
 706                 {
 707                   error ("in statement");
 708                   print_generic_stmt (stderr, stmt, TDF_VOPS|TDF_MEMSYMS);
 709                   goto err;
 710                 }
 711             }
 712
 713           FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_USE|SSA_OP_DEF)
 714             {
 715               if (verify_ssa_name (op, false))
 716                 {
 717                   error ("in statement");
 718                   print_generic_stmt (stderr, stmt, TDF_VOPS|TDF_MEMSYMS);
 719                   goto err;
 720                 }
 721             }
 722
 723           FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE|SSA_OP_VUSE)
 724             {
 725               op = USE_FROM_PTR (use_p);
 726               if (verify_use (bb, definition_block[SSA_NAME_VERSION (op)],
 727                               use_p, stmt, false, names_defined_in_bb))
 728                 goto err;
 729             }
 730
 731           FOR_EACH_SSA_TREE_OPERAND (op, stmt, iter, SSA_OP_ALL_DEFS)
 732             bitmap_set_bit (names_defined_in_bb, SSA_NAME_VERSION (op));
 733         }
 734
 735       bitmap_clear (names_defined_in_bb);
 736     }
 737
 738   /* Finally, verify alias information.  */
 739   if (gimple_aliases_computed_p (cfun))
 740     verify_alias_info ();
 741
 742   free (definition_block);
 743
 744   /* Restore the dominance information to its prior known state, so
 745      that we do not perturb the compiler's subsequent behavior.  */
 746   if (orig_dom_state == DOM_NONE)
 747     free_dominance_info (CDI_DOMINATORS);
 748   else
 749     set_dom_info_availability (CDI_DOMINATORS, orig_dom_state);
 750
 751   BITMAP_FREE (names_defined_in_bb);
 752   timevar_pop (TV_TREE_SSA_VERIFY);
 753   return;
 754
 755 err:
 756   internal_error ("verify_ssa failed");
 757 }
 758
 759 /* Return true if the uid in both int tree maps are equal.  */
 760
 761 int
 762 int_tree_map_eq (const void *va, const void *vb)
 763 {
 764   const struct int_tree_map *a = (const struct int_tree_map *) va;
 765   const struct int_tree_map *b = (const struct int_tree_map *) vb;
 766   return (a->uid == b->uid);
 767 }
 768
 769 /* Hash a UID in a int_tree_map.  */
 770
 771 unsigned int
 772 int_tree_map_hash (const void *item)
 773 {
 774   return ((const struct int_tree_map *)item)->uid;
 775 }
 776
 777 /* Return true if the uid in both int tree maps are equal.  */
 778
 779 static int
 780 var_ann_eq (const void *va, const void *vb)
 781 {
 782   const struct static_var_ann_d *a = (const struct static_var_ann_d *) va;
 783   const_tree const b = (const_tree) vb;
 784   return (a->uid == DECL_UID (b));
 785 }
 786
 787 /* Hash a UID in a int_tree_map.  */
 788
 789 static unsigned int
 790 var_ann_hash (const void *item)
 791 {
 792   return ((const struct static_var_ann_d *)item)->uid;
 793 }
 794
 795
 796 /* Initialize global DFA and SSA structures.  */
 797
 798 void
 799 init_tree_ssa (void)
 800 {
 801   cfun->gimple_df = GGC_CNEW (struct gimple_df);
 802   cfun->gimple_df->referenced_vars = htab_create_ggc (20, int_tree_map_hash,
 803                                                       int_tree_map_eq, NULL);
 804   cfun->gimple_df->default_defs = htab_create_ggc (20, int_tree_map_hash,
 805                                                    int_tree_map_eq, NULL);
 806   cfun->gimple_df->var_anns = htab_create_ggc (20, var_ann_hash,
 807                                                var_ann_eq, NULL);
 808   cfun->gimple_df->call_clobbered_vars = BITMAP_GGC_ALLOC ();
 809   cfun->gimple_df->addressable_vars = BITMAP_GGC_ALLOC ();
 810   init_ssanames ();
 811   init_phinodes ();
 812 }
 813
 814
 815 /* Deallocate memory associated with SSA data structures for FNDECL.  */
 816
 817 void
 818 delete_tree_ssa (void)
 819 {
 820   size_t i;
 821   basic_block bb;
 822   block_stmt_iterator bsi;
 823   referenced_var_iterator rvi;
 824   tree var;
 825
 826   /* Release any ssa_names still in use.  */
 827   for (i = 0; i < num_ssa_names; i++)
 828     {
 829       tree var = ssa_name (i);
 830       if (var && TREE_CODE (var) == SSA_NAME)
 831         {
 832           SSA_NAME_IMM_USE_NODE (var).prev = &(SSA_NAME_IMM_USE_NODE (var));
 833           SSA_NAME_IMM_USE_NODE (var).next = &(SSA_NAME_IMM_USE_NODE (var));
 834         }
 835       release_ssa_name (var);
 836     }
 837
 838   /* Remove annotations from every tree in the function.  */
 839   FOR_EACH_BB (bb)
 840     {
 841       for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
 842         {
 843           tree stmt = bsi_stmt (bsi);
 844           stmt_ann_t ann = get_stmt_ann (stmt);
 845
 846           free_ssa_operands (&ann->operands);
 847           ann->addresses_taken = 0;
 848           mark_stmt_modified (stmt);
 849         }
 850       set_phi_nodes (bb, NULL);
 851     }
 852
 853   /* Remove annotations from every referenced variable.  */
 854   FOR_EACH_REFERENCED_VAR (var, rvi)
 855     {
 856       if (var->base.ann)
 857         ggc_free (var->base.ann);
 858       var->base.ann = NULL;
 859     }
 860   htab_delete (gimple_referenced_vars (cfun));
 861   cfun->gimple_df->referenced_vars = NULL;
 862
 863   fini_ssanames ();
 864   fini_phinodes ();
 865   /* we no longer maintain the SSA operand cache at this point.  */
 866   fini_ssa_operands ();
 867
 868   cfun->gimple_df->global_var = NULL_TREE;
 869
 870   htab_delete (cfun->gimple_df->default_defs);
 871   cfun->gimple_df->default_defs = NULL;
 872   htab_delete (cfun->gimple_df->var_anns);
 873   cfun->gimple_df->var_anns = NULL;
 874   cfun->gimple_df->call_clobbered_vars = NULL;
 875   cfun->gimple_df->addressable_vars = NULL;
 876   cfun->gimple_df->modified_noreturn_calls = NULL;
 877   if (gimple_aliases_computed_p (cfun))
 878     {
 879       delete_alias_heapvars ();
 880       gcc_assert (!need_ssa_update_p ());
 881     }
 882   cfun->gimple_df->aliases_computed_p = false;
 883   delete_mem_ref_stats (cfun);
 884
 885   cfun->gimple_df = NULL;
 886 }
 887
 888
 889 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
 890    useless type conversion, otherwise return false.
 891
 892    This function implicitly defines the middle-end type system.  With
 893    the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
 894    holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
 895    the following invariants shall be fulfilled:
 896
 897      1) useless_type_conversion_p is transitive.
 898         If a < b and b < c then a < c.
 899
 900      2) useless_type_conversion_p is not symmetric.
 901         From a < b does not follow a > b.
 902
 903      3) Types define the available set of operations applicable to values.
 904         A type conversion is useless if the operations for the target type
 905         is a subset of the operations for the source type.  For example
 906         casts to void* are useless, casts from void* are not (void* can't
 907         be dereferenced or offsetted, but copied, hence its set of operations
 908         is a strict subset of that of all other data pointer types).  Casts
 909         to const T* are useless (can't be written to), casts from const T*
 910         to T* are not.  */
 911
 912 bool
 913 useless_type_conversion_p (tree outer_type, tree inner_type)
 914 {
 915   /* Qualifiers on value types do not matter.  */
 916   inner_type = TYPE_MAIN_VARIANT (inner_type);
 917   outer_type = TYPE_MAIN_VARIANT (outer_type);
 918
 919   if (inner_type == outer_type)
 920     return true;
 921
 922   /* If we know the canonical types, compare them.  */
 923   if (TYPE_CANONICAL (inner_type)
 924       && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type))
 925     return true;
 926
 927   /* Changes in machine mode are never useless conversions.  */
 928   if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type))
 929     return false;
 930
 931   /* If both the inner and outer types are integral types, then the
 932      conversion is not necessary if they have the same mode and
 933      signedness and precision, and both or neither are boolean.  */
 934   if (INTEGRAL_TYPE_P (inner_type)
 935       && INTEGRAL_TYPE_P (outer_type))
 936     {
 937       /* Preserve changes in signedness or precision.  */
 938       if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
 939           || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
 940         return false;
 941
 942       /* Conversions from a non-base to a base type are not useless.
 943          This way we preserve the invariant to do arithmetic in
 944          base types only.  */
 945       if (TREE_TYPE (inner_type)
 946           && TREE_TYPE (inner_type) != inner_type
 947           && (TREE_TYPE (outer_type) == outer_type
 948               || TREE_TYPE (outer_type) == NULL_TREE))
 949         return false;
 950
 951       /* We don't need to preserve changes in the types minimum or
 952          maximum value in general as these do not generate code
 953          unless the types precisions are different.  */
 954
 955       return true;
 956     }
 957
 958   /* Scalar floating point types with the same mode are compatible.  */
 959   else if (SCALAR_FLOAT_TYPE_P (inner_type)
 960            && SCALAR_FLOAT_TYPE_P (outer_type))
 961     return true;
 962
 963   /* We need to take special care recursing to pointed-to types.  */
 964   else if (POINTER_TYPE_P (inner_type)
 965            && POINTER_TYPE_P (outer_type))
 966     {
 967       /* If the outer type is (void *), then the conversion is not
 968          necessary.  */
 969       if (TREE_CODE (TREE_TYPE (outer_type)) == VOID_TYPE)
 970         return true;
 971
 972       /* Don't lose casts between pointers to volatile and non-volatile
 973          qualified types.  Doing so would result in changing the semantics
 974          of later accesses.  */
 975       if ((TYPE_VOLATILE (TREE_TYPE (outer_type))
 976            != TYPE_VOLATILE (TREE_TYPE (inner_type)))
 977           && TYPE_VOLATILE (TREE_TYPE (outer_type)))
 978         return false;
 979
 980       /* Do not lose casts between pointers with different
 981          TYPE_REF_CAN_ALIAS_ALL setting or alias sets.  */
 982       if ((TYPE_REF_CAN_ALIAS_ALL (inner_type)
 983            != TYPE_REF_CAN_ALIAS_ALL (outer_type))
 984           || (get_alias_set (TREE_TYPE (inner_type))
 985               != get_alias_set (TREE_TYPE (outer_type))))
 986         return false;
 987
 988       /* Do not lose casts from const qualified to non-const
 989          qualified.  */
 990       if ((TYPE_READONLY (TREE_TYPE (outer_type))
 991            != TYPE_READONLY (TREE_TYPE (inner_type)))
 992           && TYPE_READONLY (TREE_TYPE (inner_type)))
 993         return false;
 994
 995       /* Do not lose casts to restrict qualified pointers.  */
 996       if ((TYPE_RESTRICT (outer_type)
 997            != TYPE_RESTRICT (inner_type))
 998           && TYPE_RESTRICT (outer_type))
 999         return false;
1000
1001       /* Otherwise pointers/references are equivalent if their pointed
1002          to types are effectively the same.  We can strip qualifiers
1003          on pointed-to types for further comparison, which is done in
1004          the callee.  */
1005       return useless_type_conversion_p (TREE_TYPE (outer_type),
1006                                         TREE_TYPE (inner_type));
1007     }
1008
1009   /* Recurse for complex types.  */
1010   else if (TREE_CODE (inner_type) == COMPLEX_TYPE
1011            && TREE_CODE (outer_type) == COMPLEX_TYPE)
1012     return useless_type_conversion_p (TREE_TYPE (outer_type),
1013                                       TREE_TYPE (inner_type));
1014
1015   /* Recurse for vector types with the same number of subparts.  */
1016   else if (TREE_CODE (inner_type) == VECTOR_TYPE
1017            && TREE_CODE (outer_type) == VECTOR_TYPE
1018            && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
1019     return useless_type_conversion_p (TREE_TYPE (outer_type),
1020                                       TREE_TYPE (inner_type));
1021
1022   /* For aggregates we may need to fall back to structural equality
1023      checks.  */
1024   else if (AGGREGATE_TYPE_P (inner_type)
1025            && AGGREGATE_TYPE_P (outer_type))
1026     {
1027       /* Different types of aggregates are incompatible.  */
1028       if (TREE_CODE (inner_type) != TREE_CODE (outer_type))
1029         return false;
1030
1031       /* ???  Add structural equivalence check.  */
1032
1033       /* ???  This should eventually just return false.  */
1034       return lang_hooks.types_compatible_p (inner_type, outer_type);
1035     }
1036
1037   return false;
1038 }
1039
1040 /* Return true if a conversion from either type of TYPE1 and TYPE2
1041    to the other is not required.  Otherwise return false.  */
1042
1043 bool
1044 types_compatible_p (tree type1, tree type2)
1045 {
1046   return (type1 == type2
1047           || (useless_type_conversion_p (type1, type2)
1048               && useless_type_conversion_p (type2, type1)));
1049 }
1050
1051 /* Return true if EXPR is a useless type conversion, otherwise return
1052    false.  */
1053
1054 bool
1055 tree_ssa_useless_type_conversion (tree expr)
1056 {
1057   /* If we have an assignment that merely uses a NOP_EXPR to change
1058      the top of the RHS to the type of the LHS and the type conversion
1059      is "safe", then strip away the type conversion so that we can
1060      enter LHS = RHS into the const_and_copies table.  */
1061   if (TREE_CODE (expr) == NOP_EXPR || TREE_CODE (expr) == CONVERT_EXPR
1062       || TREE_CODE (expr) == VIEW_CONVERT_EXPR
1063       || TREE_CODE (expr) == NON_LVALUE_EXPR)
1064     /* FIXME: Use of GENERIC_TREE_TYPE here is a temporary measure to work
1065        around known bugs with GIMPLE_MODIFY_STMTs appearing in places
1066        they shouldn't.  See PR 30391.  */
1067     return useless_type_conversion_p
1068       (TREE_TYPE (expr),
1069        GENERIC_TREE_TYPE (TREE_OPERAND (expr, 0)));
1070
1071   return false;
1072 }
1073
1074
1075 /* Internal helper for walk_use_def_chains.  VAR, FN and DATA are as
1076    described in walk_use_def_chains.
1077
1078    VISITED is a pointer set used to mark visited SSA_NAMEs to avoid
1079       infinite loops.  We used to have a bitmap for this to just mark
1080       SSA versions we had visited.  But non-sparse bitmaps are way too
1081       expensive, while sparse bitmaps may cause quadratic behavior.
1082
1083    IS_DFS is true if the caller wants to perform a depth-first search
1084       when visiting PHI nodes.  A DFS will visit each PHI argument and
1085       call FN after each one.  Otherwise, all the arguments are
1086       visited first and then FN is called with each of the visited
1087       arguments in a separate pass.  */
1088
1089 static bool
1090 walk_use_def_chains_1 (tree var, walk_use_def_chains_fn fn, void *data,
1091                        struct pointer_set_t *visited, bool is_dfs)
1092 {
1093   tree def_stmt;
1094
1095   if (pointer_set_insert (visited, var))
1096     return false;
1097
1098   def_stmt = SSA_NAME_DEF_STMT (var);
1099
1100   if (TREE_CODE (def_stmt) != PHI_NODE)
1101     {
1102       /* If we reached the end of the use-def chain, call FN.  */
1103       return fn (var, def_stmt, data);
1104     }
1105   else
1106     {
1107       int i;
1108
1109       /* When doing a breadth-first search, call FN before following the
1110          use-def links for each argument.  */
1111       if (!is_dfs)
1112         for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
1113           if (fn (PHI_ARG_DEF (def_stmt, i), def_stmt, data))
1114             return true;
1115
1116       /* Follow use-def links out of each PHI argument.  */
1117       for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
1118         {
1119           tree arg = PHI_ARG_DEF (def_stmt, i);
1120
1121           /* ARG may be NULL for newly introduced PHI nodes.  */
1122           if (arg
1123               && TREE_CODE (arg) == SSA_NAME
1124               && walk_use_def_chains_1 (arg, fn, data, visited, is_dfs))
1125             return true;
1126         }
1127
1128       /* When doing a depth-first search, call FN after following the
1129          use-def links for each argument.  */
1130       if (is_dfs)
1131         for (i = 0; i < PHI_NUM_ARGS (def_stmt); i++)
1132           if (fn (PHI_ARG_DEF (def_stmt, i), def_stmt, data))
1133             return true;
1134     }
1135
1136   return false;
1137 }
1138
1139
1140
1141 /* Walk use-def chains starting at the SSA variable VAR.  Call
1142    function FN at each reaching definition found.  FN takes three
1143    arguments: VAR, its defining statement (DEF_STMT) and a generic
1144    pointer to whatever state information that FN may want to maintain
1145    (DATA).  FN is able to stop the walk by returning true, otherwise
1146    in order to continue the walk, FN should return false.
1147
1148    Note, that if DEF_STMT is a PHI node, the semantics are slightly
1149    different.  The first argument to FN is no longer the original
1150    variable VAR, but the PHI argument currently being examined.  If FN
1151    wants to get at VAR, it should call PHI_RESULT (PHI).
1152
1153    If IS_DFS is true, this function will:
1154
1155         1- walk the use-def chains for all the PHI arguments, and,
1156         2- call (*FN) (ARG, PHI, DATA) on all the PHI arguments.
1157
1158    If IS_DFS is false, the two steps above are done in reverse order
1159    (i.e., a breadth-first search).  */
1160
1161 void
1162 walk_use_def_chains (tree var, walk_use_def_chains_fn fn, void *data,
1163                      bool is_dfs)
1164 {
1165   tree def_stmt;
1166
1167   gcc_assert (TREE_CODE (var) == SSA_NAME);
1168
1169   def_stmt = SSA_NAME_DEF_STMT (var);
1170
1171   /* We only need to recurse if the reaching definition comes from a PHI
1172      node.  */
1173   if (TREE_CODE (def_stmt) != PHI_NODE)
1174     (*fn) (var, def_stmt, data);
1175   else
1176     {
1177       struct pointer_set_t *visited = pointer_set_create ();
1178       walk_use_def_chains_1 (var, fn, data, visited, is_dfs);
1179       pointer_set_destroy (visited);
1180     }
1181 }
1182
1183 \f
1184 /* Emit warnings for uninitialized variables.  This is done in two passes.
1185
1186    The first pass notices real uses of SSA names with default definitions.
1187    Such uses are unconditionally uninitialized, and we can be certain that
1188    such a use is a mistake.  This pass is run before most optimizations,
1189    so that we catch as many as we can.
1190
1191    The second pass follows PHI nodes to find uses that are potentially
1192    uninitialized.  In this case we can't necessarily prove that the use
1193    is really uninitialized.  This pass is run after most optimizations,
1194    so that we thread as many jumps and possible, and delete as much dead
1195    code as possible, in order to reduce false positives.  We also look
1196    again for plain uninitialized variables, since optimization may have
1197    changed conditionally uninitialized to unconditionally uninitialized.  */
1198
1199 /* Emit a warning for T, an SSA_NAME, being uninitialized.  The exact
1200    warning text is in MSGID and LOCUS may contain a location or be null.  */
1201
1202 static void
1203 warn_uninit (tree t, const char *gmsgid, void *data)
1204 {
1205   tree var = SSA_NAME_VAR (t);
1206   tree def = SSA_NAME_DEF_STMT (t);
1207   tree context = (tree) data;
1208   location_t *locus;
1209   expanded_location xloc, floc;
1210
1211   /* Default uses (indicated by an empty definition statement),
1212      are uninitialized.  */
1213   if (!IS_EMPTY_STMT (def))
1214     return;
1215
1216   /* Except for PARMs of course, which are always initialized.  */
1217   if (TREE_CODE (var) == PARM_DECL)
1218     return;
1219
1220   /* Hard register variables get their initial value from the ether.  */
1221   if (TREE_CODE (var) == VAR_DECL && DECL_HARD_REGISTER (var))
1222     return;
1223
1224   /* TREE_NO_WARNING either means we already warned, or the front end
1225      wishes to suppress the warning.  */
1226   if (TREE_NO_WARNING (var))
1227     return;
1228
1229   locus = (context != NULL && EXPR_HAS_LOCATION (context)
1230            ? EXPR_LOCUS (context)
1231            : &DECL_SOURCE_LOCATION (var));
1232   warning (OPT_Wuninitialized, gmsgid, locus, var);
1233   xloc = expand_location (*locus);
1234   floc = expand_location (DECL_SOURCE_LOCATION (cfun->decl));
1235   if (xloc.file != floc.file
1236       || xloc.line < floc.line
1237       || xloc.line > LOCATION_LINE (cfun->function_end_locus))
1238     inform ("%J%qD was declared here", var, var);
1239
1240   TREE_NO_WARNING (var) = 1;
1241 }
1242
1243 /* Called via walk_tree, look for SSA_NAMEs that have empty definitions
1244    and warn about them.  */
1245
1246 static tree
1247 warn_uninitialized_var (tree *tp, int *walk_subtrees, void *data)
1248 {
1249   tree t = *tp;
1250
1251   switch (TREE_CODE (t))
1252     {
1253     case SSA_NAME:
1254       /* We only do data flow with SSA_NAMEs, so that's all we
1255          can warn about.  */
1256       warn_uninit (t, "%H%qD is used uninitialized in this function", data);
1257       *walk_subtrees = 0;
1258       break;
1259
1260     case REALPART_EXPR:
1261     case IMAGPART_EXPR:
1262       /* The total store transformation performed during gimplification
1263          creates uninitialized variable uses.  If all is well, these will
1264          be optimized away, so don't warn now.  */
1265       if (TREE_CODE (TREE_OPERAND (t, 0)) == SSA_NAME)
1266         *walk_subtrees = 0;
1267       break;
1268
1269     default:
1270       if (IS_TYPE_OR_DECL_P (t))
1271         *walk_subtrees = 0;
1272       break;
1273     }
1274
1275   return NULL_TREE;
1276 }
1277
1278 /* Look for inputs to PHI that are SSA_NAMEs that have empty definitions
1279    and warn about them.  */
1280
1281 static void
1282 warn_uninitialized_phi (tree phi)
1283 {
1284   int i, n = PHI_NUM_ARGS (phi);
1285
1286   /* Don't look at memory tags.  */
1287   if (!is_gimple_reg (PHI_RESULT (phi)))
1288     return;
1289
1290   for (i = 0; i < n; ++i)
1291     {
1292       tree op = PHI_ARG_DEF (phi, i);
1293       if (TREE_CODE (op) == SSA_NAME)
1294         warn_uninit (op, "%H%qD may be used uninitialized in this function",
1295                      NULL);
1296     }
1297 }
1298
1299 static unsigned int
1300 execute_early_warn_uninitialized (void)
1301 {
1302   block_stmt_iterator bsi;
1303   basic_block bb;
1304
1305   FOR_EACH_BB (bb)
1306     for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
1307       {
1308         tree context = bsi_stmt (bsi);
1309         walk_tree (bsi_stmt_ptr (bsi), warn_uninitialized_var,
1310                    context, NULL);
1311       }
1312   return 0;
1313 }
1314
1315 static unsigned int
1316 execute_late_warn_uninitialized (void)
1317 {
1318   basic_block bb;
1319   tree phi;
1320
1321   /* Re-do the plain uninitialized variable check, as optimization may have
1322      straightened control flow.  Do this first so that we don't accidentally
1323      get a "may be" warning when we'd have seen an "is" warning later.  */
1324   execute_early_warn_uninitialized ();
1325
1326   FOR_EACH_BB (bb)
1327     for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
1328       warn_uninitialized_phi (phi);
1329   return 0;
1330 }
1331
1332 static bool
1333 gate_warn_uninitialized (void)
1334 {
1335   return warn_uninitialized != 0;
1336 }
1337
1338 struct tree_opt_pass pass_early_warn_uninitialized =
1339 {
1340   NULL,                                 /* name */
1341   gate_warn_uninitialized,              /* gate */
1342   execute_early_warn_uninitialized,     /* execute */
1343   NULL,                                 /* sub */
1344   NULL,                                 /* next */
1345   0,                                    /* static_pass_number */
1346   0,                                    /* tv_id */
1347   PROP_ssa,                             /* properties_required */
1348   0,                                    /* properties_provided */
1349   0,                                    /* properties_destroyed */
1350   0,                                    /* todo_flags_start */
1351   0,                                    /* todo_flags_finish */
1352   0                                     /* letter */
1353 };
1354
1355 struct tree_opt_pass pass_late_warn_uninitialized =
1356 {
1357   NULL,                                 /* name */
1358   gate_warn_uninitialized,              /* gate */
1359   execute_late_warn_uninitialized,      /* execute */
1360   NULL,                                 /* sub */
1361   NULL,                                 /* next */
1362   0,                                    /* static_pass_number */
1363   0,                                    /* tv_id */
1364   PROP_ssa,                             /* properties_required */
1365   0,                                    /* properties_provided */
1366   0,                                    /* properties_destroyed */
1367   0,                                    /* todo_flags_start */
1368   0,                                    /* todo_flags_finish */
1369   0                                     /* letter */
1370 };