From 726a989a8b74bf238a96029860bcf7ba14eff317 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Mon, 28 Jul 2008 14:33:56 +0000 Subject: backport: ChangeLog.tuples: ChangeLog from gimple-tuples-branch. 2008-07-28 Richard Guenther Merge from gimple-tuples-branch. * ChangeLog.tuples: ChangeLog from gimple-tuples-branch. * gimple.def: New file. * gsstruct.def: Likewise. * gimple-iterator.c: Likewise. * gimple-pretty-print.c: Likewise. * tree-gimple.c: Removed. Merged into ... * gimple.c: ... here. New file. * tree-gimple.h: Removed. Merged into ... * gimple.h: ... here. New file. * Makefile.in: Add dependencies on GIMPLE_H and tree-iterator.h. * configure.ac: Added support for ENABLE_GIMPLE_CHECKING and the --enable-checking=gimple flag. * config.in: Likewise. * configure: Regenerated. * tree-ssa-operands.h: Tuplified. * tree-vrp.c: Likewise. * tree-loop-linear.c: Likewise. * tree-into-ssa.c: Likewise. * tree-ssa-loop-im.c: Likewise. * tree-dump.c: Likewise. * tree-complex.c: Likewise. * cgraphbuild.c: Likewise. * tree-ssa-threadupdate.c: Likewise. * tree-ssa-loop-niter.c: Likewise. * tree-pretty-print.c: Likewise. * tracer.c: Likewise. * gengtype.c: Likewise. * tree-loop-distribution.c: Likewise. * tree-ssa-loop-unswitch.c: Likewise. * cgraph.c: Likewise. * cgraph.h: Likewise. * tree-ssa-loop-manip.c: Likewise. * value-prof.c: Likewise. * tree-ssa-loop-ch.c: Likewise. * tree-tailcall.c: Likewise. * value-prof.h: Likewise. * tree.c: Likewise. * tree.h: Likewise. * tree-pass.h: Likewise. * ipa-cp.c: Likewise. * tree-scalar-evolution.c: Likewise. * tree-scalar-evolution.h: Likewise. * target.h: Likewise. * lambda-mat.c: Likewise. * tree-phinodes.c: Likewise. * diagnostic.h: Likewise. * builtins.c: Likewise. * tree-ssa-alias-warnings.c: Likewise. * cfghooks.c: Likewise. * fold-const.c: Likewise. * cfghooks.h: Likewise. * omp-low.c: Likewise. * tree-ssa-dse.c: Likewise. * ipa-reference.c: Likewise. * tree-ssa-uncprop.c: Likewise. * toplev.c: Likewise. * tree-gimple.c: Likewise. * tree-gimple.h: Likewise. * tree-chrec.c: Likewise. * tree-chrec.h: Likewise. * tree-ssa-sccvn.c: Likewise. * tree-ssa-sccvn.h: Likewise. * cgraphunit.c: Likewise. * tree-ssa-copyrename.c: Likewise. * tree-ssa-ccp.c: Likewise. * tree-ssa-loop-ivopts.c: Likewise. * tree-nomudflap.c: Likewise. * tree-call-cdce.c: Likewise. * ipa-pure-const.c: Likewise. * c-format.c: Likewise. * tree-stdarg.c: Likewise. * tree-ssa-math-opts.c: Likewise. * tree-ssa-dom.c: Likewise. * tree-nrv.c: Likewise. * tree-ssa-propagate.c: Likewise. * ipa-utils.c: Likewise. * tree-ssa-propagate.h: Likewise. * tree-ssa-alias.c: Likewise. * gimple-low.c: Likewise. * tree-ssa-sink.c: Likewise. * ipa-inline.c: Likewise. * c-semantics.c: Likewise. * dwarf2out.c: Likewise. * expr.c: Likewise. * tree-ssa-loop-ivcanon.c: Likewise. * predict.c: Likewise. * tree-ssa-loop.c: Likewise. * tree-parloops.c: Likewise. * tree-ssa-address.c: Likewise. * tree-ssa-ifcombine.c: Likewise. * matrix-reorg.c: Likewise. * c-decl.c: Likewise. * tree-eh.c: Likewise. * c-pretty-print.c: Likewise. * lambda-trans.c: Likewise. * function.c: Likewise. * langhooks.c: Likewise. * ebitmap.h: Likewise. * tree-vectorizer.c: Likewise. * function.h: Likewise. * langhooks.h: Likewise. * tree-vectorizer.h: Likewise. * ipa-type-escape.c: Likewise. * ipa-type-escape.h: Likewise. * domwalk.c: Likewise. * tree-if-conv.c: Likewise. * profile.c: Likewise. * domwalk.h: Likewise. * tree-data-ref.c: Likewise. * tree-data-ref.h: Likewise. * tree-flow-inline.h: Likewise. * tree-affine.c: Likewise. * tree-vect-analyze.c: Likewise. * c-typeck.c: Likewise. * gimplify.c: Likewise. * coretypes.h: Likewise. * tree-ssa-phiopt.c: Likewise. * calls.c: Likewise. * tree-ssa-coalesce.c: Likewise. * tree.def: Likewise. * tree-dfa.c: Likewise. * except.c: Likewise. * except.h: Likewise. * cfgexpand.c: Likewise. * tree-cfgcleanup.c: Likewise. * tree-ssa-pre.c: Likewise. * tree-ssa-live.c: Likewise. * tree-sra.c: Likewise. * tree-ssa-live.h: Likewise. * tree-predcom.c: Likewise. * lambda.h: Likewise. * tree-mudflap.c: Likewise. * ipa-prop.c: Likewise. * print-tree.c: Likewise. * tree-ssa-copy.c: Likewise. * ipa-prop.h: Likewise. * tree-ssa-forwprop.c: Likewise. * ggc-page.c: Likewise. * c-omp.c: Likewise. * tree-ssa-dce.c: Likewise. * tree-vect-patterns.c: Likewise. * tree-ssa-ter.c: Likewise. * tree-nested.c: Likewise. * tree-ssa.c: Likewise. * lambda-code.c: Likewise. * tree-ssa-loop-prefetch.c: Likewise. * tree-inline.c: Likewise. * tree-inline.h: Likewise. * tree-iterator.c: Likewise. * tree-optimize.c: Likewise. * tree-ssa-phiprop.c: Likewise. * tree-vect-transform.c: Likewise. * tree-object-size.c: Likewise. * tree-outof-ssa.c: Likewise. * cfgloop.c: Likewise. * system.h: Likewise. * tree-profile.c: Likewise. * cfgloop.h: Likewise. * c-gimplify.c: Likewise. * c-common.c: Likewise. * tree-vect-generic.c: Likewise. * tree-flow.h: Likewise. * c-common.h: Likewise. * basic-block.h: Likewise. * tree-ssa-structalias.c: Likewise. * tree-switch-conversion.c: Likewise. * tree-ssa-structalias.h: Likewise. * tree-cfg.c: Likewise. * passes.c: Likewise. * ipa-struct-reorg.c: Likewise. * ipa-struct-reorg.h: Likewise. * tree-ssa-reassoc.c: Likewise. * cfgrtl.c: Likewise. * varpool.c: Likewise. * stmt.c: Likewise. * tree-ssanames.c: Likewise. * tree-ssa-threadedge.c: Likewise. * langhooks-def.h: Likewise. * tree-ssa-operands.c: Likewise. * config/alpha/alpha.c: Likewise. * config/frv/frv.c: Likewise. * config/s390/s390.c: Likewise. * config/m32c/m32c.c: Likewise. * config/m32c/m32c-protos.h: Likewise. * config/spu/spu.c: Likewise. * config/sparc/sparc.c: Likewise. * config/i386/i386.c: Likewise. * config/sh/sh.c: Likewise. * config/xtensa/xtensa.c: Likewise. * config/stormy16/stormy16.c: Likewise. * config/ia64/ia64.c: Likewise. * config/rs6000/rs6000.c: Likewise. * config/pa/pa.c: Likewise. * config/mips/mips.c: Likewise. From-SVN: r138207 --- gcc/tree-ssa-dse.c | 185 +++++++++++++++++++++++++++-------------------------- 1 file changed, 94 insertions(+), 91 deletions(-) (limited to 'gcc/tree-ssa-dse.c') diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c index 2f7e923..b4be514 100644 --- a/gcc/tree-ssa-dse.c +++ b/gcc/tree-ssa-dse.c @@ -63,7 +63,7 @@ along with GCC; see the file COPYING3. If not see relationship between dead store and redundant load elimination. In fact, they are the same transformation applied to different views of the CFG. */ - + struct dse_global_data { @@ -97,7 +97,7 @@ static void dse_initialize_block_local_data (struct dom_walk_data *, bool); static void dse_optimize_stmt (struct dom_walk_data *, basic_block, - block_stmt_iterator); + gimple_stmt_iterator); static void dse_record_phis (struct dom_walk_data *, basic_block); static void dse_finalize_block (struct dom_walk_data *, basic_block); static void record_voperand_set (bitmap, bitmap *, unsigned int); @@ -105,12 +105,13 @@ static void record_voperand_set (bitmap, bitmap *, unsigned int); /* Returns uid of statement STMT. */ static unsigned -get_stmt_uid (tree stmt) +get_stmt_uid (gimple stmt) { - if (TREE_CODE (stmt) == PHI_NODE) - return SSA_NAME_VERSION (PHI_RESULT (stmt)) + gimple_stmt_max_uid (cfun); + if (gimple_code (stmt) == GIMPLE_PHI) + return SSA_NAME_VERSION (gimple_phi_result (stmt)) + + gimple_stmt_max_uid (cfun); - return gimple_stmt_uid (stmt); + return gimple_uid (stmt); } /* Set bit UID in bitmaps GLOBAL and *LOCAL, creating *LOCAL as needed. */ @@ -162,7 +163,7 @@ memory_ssa_name_same (tree *expr_p, int *walk_subtrees ATTRIBUTE_UNUSED, { struct address_walk_data *walk_data = (struct address_walk_data *) data; tree expr = *expr_p; - tree def_stmt; + gimple def_stmt; basic_block def_bb; if (TREE_CODE (expr) != SSA_NAME) @@ -174,7 +175,7 @@ memory_ssa_name_same (tree *expr_p, int *walk_subtrees ATTRIBUTE_UNUSED, return NULL_TREE; def_stmt = SSA_NAME_DEF_STMT (expr); - def_bb = bb_for_stmt (def_stmt); + def_bb = gimple_bb (def_stmt); /* DEF_STMT must dominate both stores. So if it is in the same basic block as one, it does not post-dominate that store. */ @@ -185,7 +186,7 @@ memory_ssa_name_same (tree *expr_p, int *walk_subtrees ATTRIBUTE_UNUSED, || !dominated_by_p (CDI_POST_DOMINATORS, walk_data->store2_bb, def_bb)) /* Return non-NULL to stop the walk. */ - return def_stmt; + return *expr_p; } return NULL_TREE; @@ -195,14 +196,14 @@ memory_ssa_name_same (tree *expr_p, int *walk_subtrees ATTRIBUTE_UNUSED, might be modified after STORE1, before control reaches STORE2. */ static bool -memory_address_same (tree store1, tree store2) +memory_address_same (gimple store1, gimple store2) { struct address_walk_data walk_data; - walk_data.store1_bb = bb_for_stmt (store1); - walk_data.store2_bb = bb_for_stmt (store2); + walk_data.store1_bb = gimple_bb (store1); + walk_data.store2_bb = gimple_bb (store2); - return (walk_tree (&GIMPLE_STMT_OPERAND (store1, 0), memory_ssa_name_same, + return (walk_tree (gimple_assign_lhs_ptr (store1), memory_ssa_name_same, &walk_data, NULL) == NULL); } @@ -214,15 +215,15 @@ memory_address_same (tree store1, tree store2) STMT. *USE_P is set to the vop killed by *USE_STMT. */ static bool -get_kill_of_stmt_lhs (tree stmt, +get_kill_of_stmt_lhs (gimple stmt, use_operand_p * first_use_p, - use_operand_p * use_p, tree * use_stmt) + use_operand_p * use_p, gimple * use_stmt) { tree lhs; - gcc_assert (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT); + gcc_assert (is_gimple_assign (stmt)); - lhs = GIMPLE_STMT_OPERAND (stmt, 0); + lhs = gimple_assign_lhs (stmt); /* We now walk the chain of single uses of the single VDEFs. We succeeded finding a kill if the lhs of the use stmt is @@ -231,7 +232,7 @@ get_kill_of_stmt_lhs (tree stmt, the stmt. */ do { - tree use_lhs, use_rhs; + tree use_lhs; def_operand_p def_p; /* The stmt must have a single VDEF. */ @@ -245,17 +246,14 @@ get_kill_of_stmt_lhs (tree stmt, first_use_p = use_p; /* If there are possible hidden uses, give up. */ - if (TREE_CODE (stmt) != GIMPLE_MODIFY_STMT) - return false; - use_rhs = GIMPLE_STMT_OPERAND (stmt, 1); - if (TREE_CODE (use_rhs) == CALL_EXPR - || (!is_gimple_min_invariant (use_rhs) - && TREE_CODE (use_rhs) != SSA_NAME)) + if (!gimple_assign_single_p (stmt) + || (TREE_CODE (gimple_assign_rhs1 (stmt)) != SSA_NAME + && !is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))) return false; /* If the use stmts lhs matches the original lhs we have found the kill, otherwise continue walking. */ - use_lhs = GIMPLE_STMT_OPERAND (stmt, 0); + use_lhs = gimple_assign_lhs (stmt); if (operand_equal_p (use_lhs, lhs, 0)) { *use_stmt = stmt; @@ -266,16 +264,16 @@ get_kill_of_stmt_lhs (tree stmt, } /* A helper of dse_optimize_stmt. - Given a GIMPLE_MODIFY_STMT in STMT, check that each VDEF has one + Given a GIMPLE_ASSIGN in STMT, check that each VDEF has one use, and that one use is another VDEF clobbering the first one. Return TRUE if the above conditions are met, otherwise FALSE. */ static bool -dse_possible_dead_store_p (tree stmt, +dse_possible_dead_store_p (gimple stmt, use_operand_p *first_use_p, use_operand_p *use_p, - tree *use_stmt, + gimple *use_stmt, struct dse_global_data *dse_gd, struct dse_block_local_data *bd) { @@ -283,8 +281,9 @@ dse_possible_dead_store_p (tree stmt, bool fail = false; def_operand_p var1; vuse_vec_p vv; - tree defvar = NULL_TREE, temp; + tree defvar = NULL_TREE; tree prev_defvar = NULL_TREE; + gimple temp; /* We want to verify that each virtual definition in STMT has precisely one use and that all the virtual definitions are @@ -309,9 +308,9 @@ dse_possible_dead_store_p (tree stmt, gcc_assert (*use_p != NULL_USE_OPERAND_P); *first_use_p = *use_p; - /* ??? If we hit a PHI_NODE we could skip to the PHI_RESULT uses. + /* ??? If we hit a GIMPLE_PHI we could skip to the PHI_RESULT uses. Don't bother to do that for now. */ - if (TREE_CODE (temp) == PHI_NODE) + if (gimple_code (temp) == GIMPLE_PHI) { fail = true; break; @@ -326,10 +325,10 @@ dse_possible_dead_store_p (tree stmt, So we must make sure we're talking about the same LHS. */ - if (TREE_CODE (temp) == GIMPLE_MODIFY_STMT) + if (is_gimple_assign (temp)) { - tree base1 = get_base_address (GIMPLE_STMT_OPERAND (stmt, 0)); - tree base2 = get_base_address (GIMPLE_STMT_OPERAND (temp, 0)); + tree base1 = get_base_address (gimple_assign_lhs (stmt)); + tree base2 = get_base_address (gimple_assign_lhs (temp)); while (base1 && INDIRECT_REF_P (base1)) base1 = TREE_OPERAND (base1, 0); @@ -360,7 +359,7 @@ dse_possible_dead_store_p (tree stmt, if (fail) { - record_voperand_set (dse_gd->stores, &bd->stores, gimple_stmt_uid (stmt)); + record_voperand_set (dse_gd->stores, &bd->stores, gimple_uid (stmt)); return false; } @@ -382,36 +381,35 @@ dse_possible_dead_store_p (tree stmt, static void dse_optimize_stmt (struct dom_walk_data *walk_data, basic_block bb ATTRIBUTE_UNUSED, - block_stmt_iterator bsi) + gimple_stmt_iterator gsi) { struct dse_block_local_data *bd = (struct dse_block_local_data *) VEC_last (void_p, walk_data->block_data_stack); struct dse_global_data *dse_gd = (struct dse_global_data *) walk_data->global_data; - tree stmt = bsi_stmt (bsi); - stmt_ann_t ann = stmt_ann (stmt); + gimple stmt = gsi_stmt (gsi); /* If this statement has no virtual defs, then there is nothing to do. */ if (ZERO_SSA_OPERANDS (stmt, SSA_OP_VDEF)) return; - /* We know we have virtual definitions. If this is a GIMPLE_MODIFY_STMT + /* We know we have virtual definitions. If this is a GIMPLE_ASSIGN that's not also a function call, then record it into our table. */ - if (get_call_expr_in (stmt)) + if (is_gimple_call (stmt) && gimple_call_fndecl (stmt)) return; - if (ann->has_volatile_ops) + if (gimple_has_volatile_ops (stmt)) return; - if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT) + if (is_gimple_assign (stmt)) { use_operand_p first_use_p = NULL_USE_OPERAND_P; use_operand_p use_p = NULL; - tree use_stmt; + gimple use_stmt; - if (!dse_possible_dead_store_p (stmt, &first_use_p, &use_p, &use_stmt, + if (!dse_possible_dead_store_p (stmt, &first_use_p, &use_p, &use_stmt, dse_gd, bd)) return; @@ -421,8 +419,8 @@ dse_optimize_stmt (struct dom_walk_data *walk_data, SSA-form variables in the address will have the same values. */ if (use_p != NULL_USE_OPERAND_P && bitmap_bit_p (dse_gd->stores, get_stmt_uid (use_stmt)) - && !operand_equal_p (GIMPLE_STMT_OPERAND (stmt, 0), - GIMPLE_STMT_OPERAND (use_stmt, 0), 0) + && !operand_equal_p (gimple_assign_lhs (stmt), + gimple_assign_lhs (use_stmt), 0) && memory_address_same (stmt, use_stmt)) { /* If we have precisely one immediate use at this point, but @@ -431,7 +429,8 @@ dse_optimize_stmt (struct dom_walk_data *walk_data, memory location. */ if (!get_kill_of_stmt_lhs (stmt, &first_use_p, &use_p, &use_stmt)) { - record_voperand_set (dse_gd->stores, &bd->stores, gimple_stmt_uid (stmt)); + record_voperand_set (dse_gd->stores, &bd->stores, + gimple_uid (stmt)); return; } } @@ -442,8 +441,8 @@ dse_optimize_stmt (struct dom_walk_data *walk_data, memory location, then we may have found redundant store. */ if (use_p != NULL_USE_OPERAND_P && bitmap_bit_p (dse_gd->stores, get_stmt_uid (use_stmt)) - && operand_equal_p (GIMPLE_STMT_OPERAND (stmt, 0), - GIMPLE_STMT_OPERAND (use_stmt, 0), 0) + && operand_equal_p (gimple_assign_lhs (stmt), + gimple_assign_lhs (use_stmt), 0) && memory_address_same (stmt, use_stmt)) { ssa_op_iter op_iter; @@ -462,18 +461,19 @@ dse_optimize_stmt (struct dom_walk_data *walk_data, *p = *u; *p = *v; where p might be v, then USE_STMT acts as a use as well as definition, so store in STMT is not dead. */ - if (LOADED_SYMS (use_stmt) - && bitmap_intersect_p (LOADED_SYMS (use_stmt), - STORED_SYMS (use_stmt))) + if (gimple_loaded_syms (use_stmt) + && bitmap_intersect_p (gimple_loaded_syms (use_stmt), + gimple_stored_syms (use_stmt))) { - record_voperand_set (dse_gd->stores, &bd->stores, ann->uid); + record_voperand_set (dse_gd->stores, &bd->stores, + gimple_uid (stmt)); return; } if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, " Deleted dead store '"); - print_generic_expr (dump_file, bsi_stmt (bsi), dump_flags); + print_gimple_stmt (dump_file, gsi_stmt (gsi), dump_flags, 0); fprintf (dump_file, "'\n"); } @@ -481,7 +481,8 @@ dse_optimize_stmt (struct dom_walk_data *walk_data, stmt_lhs = USE_FROM_PTR (first_use_p); FOR_EACH_SSA_VDEF_OPERAND (var1, vv, stmt, op_iter) { - tree usevar, temp; + tree usevar; + gimple temp; single_imm_use (DEF_FROM_PTR (var1), &use_p, &temp); gcc_assert (VUSE_VECT_NUM_ELEM (*vv) == 1); @@ -494,14 +495,14 @@ dse_optimize_stmt (struct dom_walk_data *walk_data, } /* Remove the dead store. */ - bsi_remove (&bsi, true); + gsi_remove (&gsi, true); /* And release any SSA_NAMEs set in this statement back to the SSA_NAME manager. */ release_defs (stmt); } - record_voperand_set (dse_gd->stores, &bd->stores, gimple_stmt_uid (stmt)); + record_voperand_set (dse_gd->stores, &bd->stores, gimple_uid (stmt)); } } @@ -515,13 +516,15 @@ dse_record_phis (struct dom_walk_data *walk_data, basic_block bb) VEC_last (void_p, walk_data->block_data_stack); struct dse_global_data *dse_gd = (struct dse_global_data *) walk_data->global_data; - tree phi; + gimple phi; + gimple_stmt_iterator gsi; - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) - if (!is_gimple_reg (PHI_RESULT (phi))) - record_voperand_set (dse_gd->stores, - &bd->stores, - get_stmt_uid (phi)); + for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + { + phi = gsi_stmt (gsi); + if (!is_gimple_reg (gimple_phi_result (phi))) + record_voperand_set (dse_gd->stores, &bd->stores, get_stmt_uid (phi)); + } } static void @@ -633,7 +636,7 @@ struct gimple_opt_pass pass_dse = static unsigned int execute_simple_dse (void) { - block_stmt_iterator bsi; + gimple_stmt_iterator gsi; basic_block bb; bitmap variables_loaded = BITMAP_ALLOC (NULL); unsigned int todo = 0; @@ -641,24 +644,29 @@ execute_simple_dse (void) /* Collect into VARIABLES LOADED all variables that are read in function body. */ FOR_EACH_BB (bb) - for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi)) - if (LOADED_SYMS (bsi_stmt (bsi))) + for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + + if (gimple_loaded_syms (gsi_stmt (gsi))) bitmap_ior_into (variables_loaded, - LOADED_SYMS (bsi_stmt (bsi))); + gimple_loaded_syms (gsi_stmt (gsi))); /* Look for statements writing into the write only variables. And try to remove them. */ FOR_EACH_BB (bb) - for (bsi = bsi_start (bb); !bsi_end_p (bsi);) + for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);) { - tree stmt = bsi_stmt (bsi), op; + gimple stmt = gsi_stmt (gsi); + tree op; bool removed = false; ssa_op_iter iter; - if (STORED_SYMS (stmt) && TREE_CODE (stmt) == GIMPLE_MODIFY_STMT - && TREE_CODE (stmt) != RETURN_EXPR - && !bitmap_intersect_p (STORED_SYMS (stmt), variables_loaded)) + if (gimple_stored_syms (stmt) + && !bitmap_empty_p (gimple_stored_syms (stmt)) + && (is_gimple_assign (stmt) + || (is_gimple_call (stmt) + && gimple_call_lhs (stmt))) + && !bitmap_intersect_p (gimple_stored_syms (stmt), variables_loaded)) { unsigned int i; bitmap_iterator bi; @@ -673,7 +681,7 @@ execute_simple_dse (void) from removing them as dead. The flag thus has no use for us and we need to look into all operands. */ - EXECUTE_IF_SET_IN_BITMAP (STORED_SYMS (stmt), 0, i, bi) + EXECUTE_IF_SET_IN_BITMAP (gimple_stored_syms (stmt), 0, i, bi) { tree var = referenced_var_lookup (i); if (TREE_ADDRESSABLE (var) @@ -682,8 +690,8 @@ execute_simple_dse (void) dead = false; } - if (dead && LOADED_SYMS (stmt)) - EXECUTE_IF_SET_IN_BITMAP (LOADED_SYMS (stmt), 0, i, bi) + if (dead && gimple_loaded_syms (stmt)) + EXECUTE_IF_SET_IN_BITMAP (gimple_loaded_syms (stmt), 0, i, bi) if (TREE_THIS_VOLATILE (referenced_var_lookup (i))) dead = false; @@ -695,49 +703,44 @@ execute_simple_dse (void) /* Look for possible occurrence var = indirect_ref (...) where indirect_ref itself is volatile. */ - if (dead && TREE_THIS_VOLATILE (GIMPLE_STMT_OPERAND (stmt, 1))) + if (dead && is_gimple_assign (stmt) + && TREE_THIS_VOLATILE (gimple_assign_rhs1 (stmt))) dead = false; if (dead) { - tree call = get_call_expr_in (stmt); - /* When LHS of var = call (); is dead, simplify it into call (); saving one operand. */ - if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT - && call - && TREE_SIDE_EFFECTS (call)) + if (is_gimple_call (stmt) + && gimple_has_side_effects (stmt)) { if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "Deleted LHS of call: "); - print_generic_stmt (dump_file, stmt, TDF_SLIM); + print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM); fprintf (dump_file, "\n"); } - push_stmt_changes (bsi_stmt_ptr (bsi)); - TREE_BLOCK (call) = TREE_BLOCK (stmt); - bsi_replace (&bsi, call, false); - maybe_clean_or_replace_eh_stmt (stmt, call); - mark_symbols_for_renaming (call); - pop_stmt_changes (bsi_stmt_ptr (bsi)); + push_stmt_changes (gsi_stmt_ptr (&gsi)); + gimple_call_set_lhs (stmt, NULL); + pop_stmt_changes (gsi_stmt_ptr (&gsi)); } else { if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, " Deleted dead store '"); - print_generic_expr (dump_file, stmt, dump_flags); + print_gimple_stmt (dump_file, stmt, 0, dump_flags); fprintf (dump_file, "'\n"); } removed = true; - bsi_remove (&bsi, true); + gsi_remove (&gsi, true); todo |= TODO_cleanup_cfg; } todo |= TODO_remove_unused_locals | TODO_ggc_collect; } } if (!removed) - bsi_next (&bsi); + gsi_next (&gsi); } BITMAP_FREE (variables_loaded); return todo; -- cgit v1.1