* tree.def (PAREN_EXPR): New tree code.
* fold-const.c (fold_unary): Remove PAREN_EXPR around constants
and PAREN_EXPR.
* tree-pretty-print.c (dump_generic_node): Handle PAREN_EXPR.
* expr.c (expand_expr_real_1): Likewise.
* tree-inline.c (estimate_num_insns_1): Likewise.
* tree-complex.c (expand_complex_move): Likewise.
* tree-vectorizer.c (vect_is_simple_use): Treat PAREN_EXPR (x)
as plain x.
* trans-expr.c (gfc_conv_expr_op): Expand INTRINSIC_PARENTHESES
as unary PAREN_EXPR for real and complex typed expressions.
(gfc_conv_unary_op): Fold the built tree.
* gfortran.dg/reassoc_1.f90: New testcase.
* gfortran.dg/reassoc_2.f90: Likewise.
* gfortran.dg/reassoc_3.f90: Likewise.
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@132515
138bc75d-0d04-0410-961f-
82ee72b054a4
+2008-02-21 Richard Guenther <rguenther@suse.de>
+
+ * tree.def (PAREN_EXPR): New tree code.
+ * fold-const.c (fold_unary): Remove PAREN_EXPR around constants
+ and PAREN_EXPR.
+ * tree-pretty-print.c (dump_generic_node): Handle PAREN_EXPR.
+ * expr.c (expand_expr_real_1): Likewise.
+ * tree-inline.c (estimate_num_insns_1): Likewise.
+ * tree-complex.c (expand_complex_move): Likewise.
+ * tree-vectorizer.c (vect_is_simple_use): Treat PAREN_EXPR (x)
+ as plain x.
+
2008-02-20 Kaz Kojima <kkojima@gcc.gnu.org>
PR target/35225
}
return expand_call (exp, target, ignore);
+ case PAREN_EXPR:
case NON_LVALUE_EXPR:
case NOP_EXPR:
case CONVERT_EXPR:
switch (code)
{
+ case PAREN_EXPR:
+ /* Re-association barriers around constants and other re-association
+ barriers can be removed. */
+ if (CONSTANT_CLASS_P (op0)
+ || TREE_CODE (op0) == PAREN_EXPR)
+ return fold_convert (type, op0);
+ return NULL_TREE;
+
case NOP_EXPR:
case FLOAT_EXPR:
case CONVERT_EXPR:
+2008-02-21 Richard Guenther <rguenther@suse.de>
+
+ * trans-expr.c (gfc_conv_expr_op): Expand INTRINSIC_PARENTHESES
+ as unary PAREN_EXPR for real and complex typed expressions.
+ (gfc_conv_unary_op): Fold the built tree.
+
2008-02-20 Tobias Burnus <burnus@net-b.de>
PR fortran/34997
We must convert it to a compare to 0 (e.g. EQ_EXPR (op1, 0)).
All other unary operators have an equivalent GIMPLE unary operator. */
if (code == TRUTH_NOT_EXPR)
- se->expr = build2 (EQ_EXPR, type, operand.expr,
- build_int_cst (type, 0));
+ se->expr = fold_build2 (EQ_EXPR, type, operand.expr,
+ build_int_cst (type, 0));
else
- se->expr = build1 (code, type, operand.expr);
+ se->expr = fold_build1 (code, type, operand.expr);
}
lop = 0;
switch (expr->value.op.operator)
{
- case INTRINSIC_UPLUS:
case INTRINSIC_PARENTHESES:
+ if (expr->ts.type == BT_REAL
+ || expr->ts.type == BT_COMPLEX)
+ {
+ gfc_conv_unary_op (PAREN_EXPR, se, expr);
+ gcc_assert (FLOAT_TYPE_P (TREE_TYPE (se->expr)));
+ return;
+ }
+
+ /* Fallthrough. */
+ case INTRINSIC_UPLUS:
gfc_conv_expr (se, expr->value.op.op1);
return;
+2008-02-21 Richard Guenther <rguenther@suse.de>
+
+ * gfortran.dg/reassoc_1.f90: New testcase.
+ * gfortran.dg/reassoc_2.f90: Likewise.
+ * gfortran.dg/reassoc_3.f90: Likewise.
+
2008-02-20 Jerry DeLisle <jvdelisle@gcc.gnu.org>
PR libfortran/34974
--- /dev/null
+! { dg-do compile }
+! { dg-options "-O3 -ffast-math -fdump-tree-optimized" }
+
+function test(b)
+ real a
+ a = (b + 5.) - 5.
+ test = a
+end
+
+! { dg-final { scan-tree-dump "\\\+ 5.*\\\)\\\) - 5" "optimized" } }
--- /dev/null
+! { dg-do compile }
+! { dg-options "-O3 -ffast-math -fdump-tree-optimized" }
+
+! Make sure that FRE does not replace c with b in d = c - 5
+
+function test(a)
+ real a, b, c, d
+ b = a + 5.
+ c = (a + 5.)
+ d = c - 5.
+ call foo(b)
+ test = d
+end
+
+! { dg-final { scan-tree-dump "- 5" "optimized" } }
--- /dev/null
+! { dg-do compile }
+! { dg-options "-O -ffast-math -fdump-tree-original -fdump-tree-optimized" }
+
+! Verify we associate properly during folding
+! Verify we propagate constants in the presence of PAREN_EXPR
+
+function test(a)
+ real b, c, d
+ c = a
+ d = 5
+ b = (c + 5 - c)
+ b = (c + d - c)
+ test = a + b - 5
+end
+
+! { dg-final { scan-tree-dump "b = 5" "original" } }
+! { dg-final { scan-tree-dump "return .a" "optimized" } }
i = build1 (IMAGPART_EXPR, inner_type, lhs);
update_complex_components_on_edge (e, lhs, r, i);
}
- else if (TREE_CODE (rhs) == CALL_EXPR || TREE_SIDE_EFFECTS (rhs))
+ else if (TREE_CODE (rhs) == CALL_EXPR || TREE_SIDE_EFFECTS (rhs)
+ || TREE_CODE (rhs) == PAREN_EXPR)
{
r = build1 (REALPART_EXPR, inner_type, lhs);
i = build1 (IMAGPART_EXPR, inner_type, lhs);
case COMPOUND_EXPR:
case BIND_EXPR:
case WITH_CLEANUP_EXPR:
+ case PAREN_EXPR:
case NOP_EXPR:
case CONVERT_EXPR:
case VIEW_CONVERT_EXPR:
pp_character (buffer, ')');
break;
+ case PAREN_EXPR:
+ pp_string (buffer, "((");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, "))");
+ break;
+
case NON_LVALUE_EXPR:
pp_string (buffer, "NON_LVALUE_EXPR <");
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
*dt = vect_invariant_def;
return true;
}
-
+
+ if (TREE_CODE (operand) == PAREN_EXPR)
+ {
+ if (vect_print_dump_info (REPORT_DETAILS))
+ fprintf (vect_dump, "non-associatable copy.");
+ operand = TREE_OPERAND (operand, 0);
+ }
if (TREE_CODE (operand) != SSA_NAME)
{
if (vect_print_dump_info (REPORT_DETAILS))
DEFTREECODE (RANGE_EXPR, "range_expr", tcc_binary, 2)
+/* Represents a re-association barrier for floating point expressions
+ like explicit parenthesis in fortran. */
+DEFTREECODE (PAREN_EXPR, "paren_expr", tcc_unary, 1)
+
/* Represents a conversion of type of a value.
All conversions, including implicit ones, must be
represented by CONVERT_EXPR or NOP_EXPR nodes. */