From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 30840 invoked by alias); 1 Aug 2007 02:36:49 -0000 Received: (qmail 30828 invoked by uid 22791); 1 Aug 2007 02:36:48 -0000 X-Spam-Check-By: sourceware.org Received: from doa.scea.com (HELO Paris.playstation.sony.com) (64.157.7.133) by sourceware.org (qpsmtpd/0.31) with ESMTP; Wed, 01 Aug 2007 02:36:45 +0000 Received: from constantine.playstation.sony.com ([162.49.67.15]) by Paris.playstation.sony.com (Lotus Domino Release 6.5.5FP2) with ESMTP id 2007073119364054-7834 ; Tue, 31 Jul 2007 19:36:40 -0700 To: gcc-patches@gcc.gnu.org Subject: [PATCH] Fix IV-opts so it no longer produces MEM[index:] MIME-Version: 1.0 X-Mailer: Lotus Notes Release 6.5.4 March 27, 2005 Message-ID: From: Andrew_Pinski@PlayStation.Sony.Com Date: Wed, 01 Aug 2007 02:36:00 -0000 Content-Type: multipart/mixed; boundary="=_mixed 000E57788825732A_=" Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2007-08/txt/msg00006.txt.bz2 --=_mixed 000E57788825732A_= Content-Type: text/plain; charset="US-ASCII" Content-length: 2129 Hi, The problem here is that add_candidate_1 is using generic_type_for which causes the pointer type be converted over to sizetype and so when we go to use that candidate, we create MEM[index:]. This changes that and fixes up all the fallout in the testsuite I could find (including two new issues which showed up after the summit, I had originally tested it before the summit but I decided to test it again before submitting it). The fall out is having tree-affine use sizetype of the steps, fixing up add_to_parts to use POINTER_PLUS_EXPR instead of PLUS_EXPR for pointers, create_iv use sizetype variable for the step for pointer types, and also fixing up parts of iv-opts to use sizetype for steps. The main reason why I am doing this is to reduce the memory usage after IV-opts and also so maybe we can rerun may_alias after iv-opts and not get confused as much and it is nice to see no cast from pointer types to sizetype in the code any more and I think it also helps out with the REG_POINTER issue when I get rid of the DECL_AFTICIAL clause as we have a real pointer type here now. OK? Bootstrapped and tested on i686-linux-gnu and powerpc64-linux-gnu with no regressions. Thank, Andrew Pinski ChangeLog: * tree-ssa-loop-manip.c (create_iv): Use a new temp variable for the step with the correct type. * tree-ssa-loop-ivopts.c (find_bivs): Convert the step to sizetype if type is a pointer type. (add_candidate_1): Don't convert the base and step to the generic type if the orginal type is a pointer type. (add_iv_value_candidates): Use sizetype for the step if type is a pointer type. (cand_value_at): Likewise. * tree-ssa-address.c (add_to_parts): Use POINTER_PLUS_EXPR for pointer types. * tree-affine.c (tree_to_aff_combination ): Don't convert the tem affine to the type. (add_elt_to_tree): Use sizetype for the step if a pointer. Use POINTER_PLUS_EXPR for pointers. (aff_combination_to_tree): Use sizetype for the step if a pointer. --=_mixed 000E57788825732A_= Content-Transfer-Encoding: 8bit Content-Type: text/plain; name="fixupivopts-real.diff.txt" Content-Disposition: attachment; filename="fixupivopts-real.diff.txt" Content-length: 6763 Index: tree-ssa-loop-manip.c =================================================================== --- tree-ssa-loop-manip.c (revision 127066) +++ tree-ssa-loop-manip.c (working copy) @@ -56,12 +56,15 @@ create_iv (tree base, tree step, tree va tree vb, va; enum tree_code incr_op = PLUS_EXPR; edge pe = loop_preheader_edge (loop); + tree var1; if (!var) { var = create_tmp_var (TREE_TYPE (base), "ivtmp"); add_referenced_var (var); } + var1 = create_tmp_var (TREE_TYPE (step), "ivtmp"); + add_referenced_var (var1); vb = make_ssa_name (var, NULL_TREE); if (var_before) @@ -104,7 +107,7 @@ create_iv (tree base, tree step, tree va } /* Gimplify the step if necessary. We put the computations in front of the loop (i.e. the step should be loop invariant). */ - step = force_gimple_operand (step, &stmts, true, var); + step = force_gimple_operand (step, &stmts, true, var1); if (stmts) bsi_insert_on_edge_immediate (pe, stmts); Index: tree-ssa-loop-ivopts.c =================================================================== --- tree-ssa-loop-ivopts.c (revision 127066) +++ tree-ssa-loop-ivopts.c (working copy) @@ -901,7 +901,12 @@ find_bivs (struct ivopts_data *data) type = TREE_TYPE (PHI_RESULT (phi)); base = fold_convert (type, base); if (step) - step = fold_convert (type, step); + { + if (POINTER_TYPE_P (type)) + step = fold_convert (sizetype, step); + else + step = fold_convert (type, step); + } set_iv (data, PHI_RESULT (phi), base, step); found = true; @@ -1934,7 +1939,7 @@ add_candidate_1 (struct ivopts_data *dat { orig_type = TREE_TYPE (base); type = generic_type_for (orig_type); - if (type != orig_type) + if (type != orig_type && !POINTER_TYPE_P (orig_type)) { base = fold_convert (type, base); step = fold_convert (type, step); @@ -2131,13 +2136,17 @@ add_iv_value_candidates (struct ivopts_d { unsigned HOST_WIDE_INT offset; tree base; + tree basetype; add_candidate (data, iv->base, iv->step, false, use); /* The same, but with initial value zero. Make such variable important, since it is generic enough so that possibly many uses may be based on it. */ - add_candidate (data, build_int_cst (TREE_TYPE (iv->base), 0), + basetype = TREE_TYPE (iv->base); + if (POINTER_TYPE_P (basetype)) + basetype = sizetype; + add_candidate (data, build_int_cst (basetype, 0), iv->step, true, use); /* Third, try removing the constant offset. */ @@ -3562,10 +3571,13 @@ cand_value_at (struct loop *loop, struct aff_tree step, delta, nit; struct iv *iv = cand->iv; tree type = TREE_TYPE (iv->base); + tree steptype = type; + if (POINTER_TYPE_P (type)) + steptype = sizetype; - tree_to_aff_combination (iv->step, type, &step); + tree_to_aff_combination (iv->step, steptype, &step); tree_to_aff_combination (niter, TREE_TYPE (niter), &nit); - aff_combination_convert (&nit, type); + aff_combination_convert (&nit, steptype); aff_combination_mult (&nit, &step, &delta); if (stmt_after_increment (loop, cand, at)) aff_combination_add (&delta, &step); Index: tree-ssa-address.c =================================================================== --- tree-ssa-address.c (revision 127066) +++ tree-ssa-address.c (working copy) @@ -422,9 +422,13 @@ add_to_parts (struct mem_address *parts, /* Add ELT to base. */ type = TREE_TYPE (parts->base); - parts->base = fold_build2 (PLUS_EXPR, type, - parts->base, - fold_convert (type, elt)); + if (POINTER_TYPE_P (type)) + parts->base = fold_build2 (POINTER_PLUS_EXPR, type, + parts->base, fold_convert (sizetype, elt)); + else + parts->base = fold_build2 (PLUS_EXPR, type, + parts->base, + fold_convert (type, elt)); } /* Finds the most expensive multiplication in ADDR that can be Index: tree-affine.c =================================================================== --- tree-affine.c (revision 127066) +++ tree-affine.c (working copy) @@ -279,7 +279,6 @@ tree_to_aff_combination (tree expr, tree case POINTER_PLUS_EXPR: tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb); tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp); - aff_combination_convert (&tmp, type); aff_combination_add (comb, &tmp); return; @@ -350,29 +349,40 @@ add_elt_to_tree (tree expr, tree type, t aff_tree *comb) { enum tree_code code; + tree type1 = type; + if (POINTER_TYPE_P (type)) + type1 = sizetype; scale = double_int_ext_for_comb (scale, comb); - elt = fold_convert (type, elt); + elt = fold_convert (type1, elt); if (double_int_one_p (scale)) { if (!expr) - return elt; + return fold_convert (type, elt); + if (POINTER_TYPE_P (type)) + return fold_build2 (POINTER_PLUS_EXPR, type, expr, elt); return fold_build2 (PLUS_EXPR, type, expr, elt); } if (double_int_minus_one_p (scale)) { if (!expr) - return fold_build1 (NEGATE_EXPR, type, elt); + return fold_convert (type, fold_build1 (NEGATE_EXPR, type1, elt)); + if (POINTER_TYPE_P (type)) + { + elt = fold_build1 (NEGATE_EXPR, type1, elt); + return fold_build2 (POINTER_PLUS_EXPR, type, expr, elt); + } return fold_build2 (MINUS_EXPR, type, expr, elt); } if (!expr) - return fold_build2 (MULT_EXPR, type, elt, - double_int_to_tree (type, scale)); + return fold_convert (type, + fold_build2 (MULT_EXPR, type1, elt, + double_int_to_tree (type1, scale))); if (double_int_negative_p (scale)) { @@ -382,8 +392,14 @@ add_elt_to_tree (tree expr, tree type, t else code = PLUS_EXPR; - elt = fold_build2 (MULT_EXPR, type, elt, - double_int_to_tree (type, scale)); + elt = fold_build2 (MULT_EXPR, type1, elt, + double_int_to_tree (type1, scale)); + if (POINTER_TYPE_P (type)) + { + if (code == MINUS_EXPR) + elt = fold_build1 (NEGATE_EXPR, type1, elt); + return fold_build2 (POINTER_PLUS_EXPR, type, expr, elt); + } return fold_build2 (code, type, expr, elt); } @@ -396,6 +412,9 @@ aff_combination_to_tree (aff_tree *comb) tree expr = comb->rest; unsigned i; double_int off, sgn; + tree type1 = type; + if (POINTER_TYPE_P (type)) + type1 = sizetype; gcc_assert (comb->n == MAX_AFF_ELTS || comb->rest == NULL_TREE); @@ -415,7 +434,7 @@ aff_combination_to_tree (aff_tree *comb) off = comb->offset; sgn = double_int_one; } - return add_elt_to_tree (expr, type, double_int_to_tree (type, off), sgn, + return add_elt_to_tree (expr, type, double_int_to_tree (type1, off), sgn, comb); } --=_mixed 000E57788825732A_=--