X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-loop-distribution.c;h=13ac7ea584a46424910261e51df25e3baf610b22;hb=94144e6852b001bd69e74e1216438ec42aa1ce9b;hp=080eceacb55b679281609d76b1455bd6f3c913f5;hpb=8d093dba97a54597645292b551c6e9bc09aa8f9e;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c index 080eceacb55..13ac7ea584a 100644 --- a/gcc/tree-loop-distribution.c +++ b/gcc/tree-loop-distribution.c @@ -1,20 +1,20 @@ /* Loop distribution. - Copyright (C) 2006, 2007, 2008 Free Software Foundation, Inc. + Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Contributed by Georges-Andre Silber and Sebastian Pop . This file is part of GCC. - + GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. - + GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see . */ @@ -26,7 +26,7 @@ along with GCC; see the file COPYING3. If not see | D(I) = A(I-1)*E |ENDDO - is transformed to + is transformed to |DOALL I = 2, N | A(I) = B(I) + C @@ -77,9 +77,6 @@ static bitmap remaining_stmts; predecessor a node that writes to memory. */ static bitmap upstream_mem_writes; -/* TODOs we need to run after the pass. */ -static unsigned int todo; - /* Update the PHI nodes of NEW_LOOP. NEW_LOOP is a duplicate of ORIG_LOOP. */ @@ -100,17 +97,20 @@ update_phis_for_loop_copy (struct loop *orig_loop, struct loop *new_loop) gsi_next (&si_new), gsi_next (&si_orig)) { tree def; + source_location locus; gimple phi_new = gsi_stmt (si_new); gimple phi_orig = gsi_stmt (si_orig); /* Add the first phi argument for the phi in NEW_LOOP (the one associated with the entry of NEW_LOOP) */ def = PHI_ARG_DEF_FROM_EDGE (phi_orig, orig_entry_e); - add_phi_arg (phi_new, def, new_loop_entry_e); + locus = gimple_phi_arg_location_from_edge (phi_orig, orig_entry_e); + add_phi_arg (phi_new, def, new_loop_entry_e, locus); /* Add the second phi argument for the phi in NEW_LOOP (the one associated with the latch of NEW_LOOP) */ def = PHI_ARG_DEF_FROM_EDGE (phi_orig, orig_loop_latch); + locus = gimple_phi_arg_location_from_edge (phi_orig, orig_loop_latch); if (TREE_CODE (def) == SSA_NAME) { @@ -125,7 +125,7 @@ update_phis_for_loop_copy (struct loop *orig_loop, struct loop *new_loop) /* Could be an integer. */ new_ssa_name = def; - add_phi_arg (phi_new, new_ssa_name, loop_latch_edge (new_loop)); + add_phi_arg (phi_new, new_ssa_name, loop_latch_edge (new_loop), locus); } } @@ -219,20 +219,23 @@ generate_loops_for_partition (struct loop *loop, bitmap partition, bool copy_p) return true; } -/* Build size argument. */ +/* Build the size argument for a memset call. */ static inline tree -build_size_arg (tree nb_iter, tree op, gimple_seq* stmt_list) +build_size_arg_loc (location_t loc, tree nb_iter, tree op, + gimple_seq *stmt_list) { - tree nb_bytes; - gimple_seq stmts = NULL; + gimple_seq stmts; + tree x; - nb_bytes = fold_build2 (MULT_EXPR, TREE_TYPE (nb_iter), - nb_iter, TYPE_SIZE_UNIT (TREE_TYPE (op))); - nb_bytes = force_gimple_operand (nb_bytes, &stmts, true, NULL); - gimple_seq_add_seq (stmt_list, stmts); + x = fold_build2_loc (loc, MULT_EXPR, size_type_node, + fold_convert_loc (loc, size_type_node, nb_iter), + fold_convert_loc (loc, size_type_node, + TYPE_SIZE_UNIT (TREE_TYPE (op)))); + x = force_gimple_operand (x, &stmts, true, NULL); + gimple_seq_add_seq (stmt_list, stmts); - return nb_bytes; + return x; } /* Generate a call to memset. Return true when the operation succeeded. */ @@ -241,15 +244,14 @@ static bool generate_memset_zero (gimple stmt, tree op0, tree nb_iter, gimple_stmt_iterator bsi) { - tree t, addr_base; - tree nb_bytes = NULL; + tree addr_base, nb_bytes; bool res = false; - gimple_seq stmts = NULL, stmt_list = NULL; + gimple_seq stmt_list = NULL, stmts; gimple fn_call; - tree mem, fndecl, fntype, fn; + tree mem, fn; gimple_stmt_iterator i; - ssa_op_iter iter; struct data_reference *dr = XCNEW (struct data_reference); + location_t loc = gimple_location (stmt); DR_STMT (dr) = stmt; DR_REF (dr) = op0; @@ -257,32 +259,35 @@ generate_memset_zero (gimple stmt, tree op0, tree nb_iter, goto end; /* Test for a positive stride, iterating over every element. */ - if (integer_zerop (fold_build2 (MINUS_EXPR, integer_type_node, DR_STEP (dr), - TYPE_SIZE_UNIT (TREE_TYPE (op0))))) + if (integer_zerop (size_binop (MINUS_EXPR, + fold_convert (sizetype, DR_STEP (dr)), + TYPE_SIZE_UNIT (TREE_TYPE (op0))))) { - tree offset = fold_convert (sizetype, - size_binop (PLUS_EXPR, - DR_OFFSET (dr), - DR_INIT (dr))); - addr_base = fold_build2 (POINTER_PLUS_EXPR, - TREE_TYPE (DR_BASE_ADDRESS (dr)), - DR_BASE_ADDRESS (dr), offset); + addr_base = fold_convert_loc (loc, sizetype, + size_binop_loc (loc, PLUS_EXPR, + DR_OFFSET (dr), + DR_INIT (dr))); + addr_base = fold_build2_loc (loc, POINTER_PLUS_EXPR, + TREE_TYPE (DR_BASE_ADDRESS (dr)), + DR_BASE_ADDRESS (dr), addr_base); + + nb_bytes = build_size_arg_loc (loc, nb_iter, op0, &stmt_list); } /* Test for a negative stride, iterating over every element. */ - else if (integer_zerop (fold_build2 (PLUS_EXPR, integer_type_node, - TYPE_SIZE_UNIT (TREE_TYPE (op0)), - DR_STEP (dr)))) + else if (integer_zerop (size_binop (PLUS_EXPR, + TYPE_SIZE_UNIT (TREE_TYPE (op0)), + fold_convert (sizetype, DR_STEP (dr))))) { - nb_bytes = build_size_arg (nb_iter, op0, &stmt_list); - addr_base = size_binop (PLUS_EXPR, DR_OFFSET (dr), DR_INIT (dr)); - addr_base = fold_build2 (MINUS_EXPR, sizetype, addr_base, nb_bytes); - addr_base = force_gimple_operand (addr_base, &stmts, true, NULL); - gimple_seq_add_seq (&stmt_list, stmts); - - addr_base = fold_build2 (POINTER_PLUS_EXPR, - TREE_TYPE (DR_BASE_ADDRESS (dr)), - DR_BASE_ADDRESS (dr), addr_base); + nb_bytes = build_size_arg_loc (loc, nb_iter, op0, &stmt_list); + + addr_base = size_binop_loc (loc, PLUS_EXPR, DR_OFFSET (dr), DR_INIT (dr)); + addr_base = fold_convert_loc (loc, sizetype, addr_base); + addr_base = size_binop_loc (loc, MINUS_EXPR, addr_base, + fold_convert_loc (loc, sizetype, nb_bytes)); + addr_base = fold_build2_loc (loc, POINTER_PLUS_EXPR, + TREE_TYPE (DR_BASE_ADDRESS (dr)), + DR_BASE_ADDRESS (dr), addr_base); } else goto end; @@ -290,12 +295,7 @@ generate_memset_zero (gimple stmt, tree op0, tree nb_iter, mem = force_gimple_operand (addr_base, &stmts, true, NULL); gimple_seq_add_seq (&stmt_list, stmts); - fndecl = implicit_built_in_decls [BUILT_IN_MEMSET]; - fntype = TREE_TYPE (fndecl); - fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl); - - if (!nb_bytes) - nb_bytes = build_size_arg (nb_iter, op0, &stmt_list); + fn = build_fold_addr_expr (implicit_built_in_decls [BUILT_IN_MEMSET]); fn_call = gimple_build_call (fn, 3, mem, integer_zero_node, nb_bytes); gimple_seq_add_stmt (&stmt_list, fn_call); @@ -303,29 +303,6 @@ generate_memset_zero (gimple stmt, tree op0, tree nb_iter, { gimple s = gsi_stmt (i); update_stmt_if_modified (s); - - FOR_EACH_SSA_TREE_OPERAND (t, s, iter, SSA_OP_VIRTUAL_DEFS) - { - if (TREE_CODE (t) == SSA_NAME) - t = SSA_NAME_VAR (t); - mark_sym_for_renaming (t); - } - } - - /* Mark also the uses of the VDEFS of STMT to be renamed. */ - FOR_EACH_SSA_TREE_OPERAND (t, stmt, iter, SSA_OP_VIRTUAL_DEFS) - { - if (TREE_CODE (t) == SSA_NAME) - { - gimple s; - imm_use_iterator imm_iter; - - FOR_EACH_IMM_USE_STMT (s, imm_iter, t) - update_stmt (s); - - t = SSA_NAME_VAR (t); - } - mark_sym_for_renaming (t); } gsi_insert_seq_after (&bsi, stmt_list, GSI_CONTINUE_LINKING); @@ -334,8 +311,6 @@ generate_memset_zero (gimple stmt, tree op0, tree nb_iter, if (dump_file && (dump_flags & TDF_DETAILS)) fprintf (dump_file, "generated memset zero\n"); - todo |= TODO_rebuild_alias; - end: free_data_ref (dr); return res; @@ -542,7 +517,6 @@ mark_nodes_having_upstream_mem_writes (struct graph *rdg) { unsigned i; VEC (int, heap) *nodes = VEC_alloc (int, heap, 3); - bool has_upstream_mem_write_p = false; graphds_dfs (rdg, &v, 1, &nodes, false, NULL); @@ -560,7 +534,6 @@ mark_nodes_having_upstream_mem_writes (struct graph *rdg) should be placed in the same partition. */ || has_anti_dependence (&(rdg->vertices[x]))) { - has_upstream_mem_write_p = true; bitmap_set_bit (upstream_mem_writes, x); } } @@ -606,7 +579,6 @@ static void rdg_flag_uses (struct graph *rdg, int u, bitmap partition, bitmap loops, bitmap processed, bool *part_has_writes) { - ssa_op_iter iter; use_operand_p use_p; struct vertex *x = &(rdg->vertices[u]); gimple stmt = RDGV_STMT (x); @@ -626,7 +598,7 @@ rdg_flag_uses (struct graph *rdg, int u, bitmap partition, bitmap loops, if (gimple_code (stmt) != GIMPLE_PHI) { - FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_VIRTUAL_USES) + if ((use_p = gimple_vuse_op (stmt)) != NULL_USE_OPERAND_P) { tree use = USE_FROM_PTR (use_p); @@ -877,7 +849,7 @@ free_rdg_components (VEC (rdgc, heap) *components) of RDG in which the STARTING_VERTICES occur. */ static void -rdg_build_components (struct graph *rdg, VEC (int, heap) *starting_vertices, +rdg_build_components (struct graph *rdg, VEC (int, heap) *starting_vertices, VEC (rdgc, heap) **components) { int i, v; @@ -932,10 +904,10 @@ rdg_build_partitions (struct graph *rdg, VEC (rdgc, heap) *components, bitmap np; bool part_has_writes = false; int v = VEC_index (int, x->vertices, 0); - + if (bitmap_bit_p (processed, v)) continue; - + np = build_rdg_partition_for_component (rdg, x, &part_has_writes, other_stores); bitmap_ior_into (partition, np); @@ -1148,7 +1120,7 @@ ldist_gen (struct loop *loop, struct graph *rdg, static int distribute_loop (struct loop *loop, VEC (gimple, heap) *stmts) { - bool res = false; + int res = 0; struct graph *rdg; gimple s; unsigned i; @@ -1211,8 +1183,6 @@ tree_loop_distribution (void) loop_iterator li; int nb_generated_loops = 0; - todo = 0; - FOR_EACH_LOOP (li, loop, 0) { VEC (gimple, heap) *work_list = VEC_alloc (gimple, heap, 3); @@ -1244,7 +1214,7 @@ tree_loop_distribution (void) VEC_free (gimple, heap, work_list); } - return todo; + return 0; } static bool