I noticed that checking time is dominated by walk_gimple_op and
walk_tree, not so much by the core worker. walk_gimple_op can
be micro-optimized a bit and the simple predicate is_gimple_reg_type
can be trivially inlined.
Bootstrap & testing in progress.
That was what is low-hanging.
Richard.
2012-02-24 Richard Guenther <rguent...@suse.de>
PR middle-end/52361
* gimple.c (walk_gimple_op): Use predicates with less redundant
tests.
(is_gimple_reg_type): Move inline ...
* gimple.h (is_gimple_reg_type): ... here.
Index: gcc/gimple.c
===================================================================
*** gcc/gimple.c (revision 184551)
--- gcc/gimple.c (working copy)
*************** walk_gimple_op (gimple stmt, walk_tree_f
*** 1481,1487 ****
tree lhs = gimple_assign_lhs (stmt);
wi->val_only
= (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
! || !gimple_assign_single_p (stmt);
}
for (i = 1; i < gimple_num_ops (stmt); i++)
--- 1481,1487 ----
tree lhs = gimple_assign_lhs (stmt);
wi->val_only
= (is_gimple_reg_type (TREE_TYPE (lhs)) && !is_gimple_reg (lhs))
! || gimple_assign_rhs_class (stmt) != GIMPLE_SINGLE_RHS;
}
for (i = 1; i < gimple_num_ops (stmt); i++)
*************** walk_gimple_op (gimple stmt, walk_tree_f
*** 1497,1507 ****
if (wi)
{
/* If the RHS has more than 1 operand, it is not appropriate
! for the memory. */
! wi->val_only = !(is_gimple_mem_rhs (gimple_assign_rhs1 (stmt))
! || TREE_CODE (gimple_assign_rhs1 (stmt))
! == CONSTRUCTOR)
! || !gimple_assign_single_p (stmt);
wi->is_lhs = true;
}
--- 1497,1510 ----
if (wi)
{
/* If the RHS has more than 1 operand, it is not appropriate
! for the memory.
! ??? A lhs always requires an lvalue, checking the val_only flag
! does not make any sense, so we should be able to avoid computing
! it here. */
! tree rhs1 = gimple_assign_rhs1 (stmt);
! wi->val_only = !(is_gimple_mem_rhs (rhs1)
! || TREE_CODE (rhs1) == CONSTRUCTOR)
! || gimple_assign_rhs_class (stmt) !=
GIMPLE_SINGLE_RHS;
wi->is_lhs = true;
}
*************** is_gimple_id (tree t)
*** 2908,2921 ****
|| TREE_CODE (t) == STRING_CST);
}
- /* Return true if TYPE is a suitable type for a scalar register variable. */
-
- bool
- is_gimple_reg_type (tree type)
- {
- return !AGGREGATE_TYPE_P (type);
- }
-
/* Return true if T is a non-aggregate register variable. */
bool
--- 2911,2916 ----
Index: gcc/gimple.h
===================================================================
*** gcc/gimple.h (revision 184551)
--- gcc/gimple.h (working copy)
*************** tree gimple_extract_devirt_binfo_from_cs
*** 963,970 ****
/* Returns true iff T is a valid GIMPLE statement. */
extern bool is_gimple_stmt (tree);
- /* Returns true iff TYPE is a valid type for a scalar register variable. */
- extern bool is_gimple_reg_type (tree);
/* Returns true iff T is a scalar register variable. */
extern bool is_gimple_reg (tree);
/* Returns true iff T is any sort of variable. */
--- 963,968 ----
*************** gimple_expr_type (const_gimple stmt)
*** 4838,4843 ****
--- 4836,4848 ----
return void_type_node;
}
+ /* Return true if TYPE is a suitable type for a scalar register variable. */
+
+ static inline bool
+ is_gimple_reg_type (tree type)
+ {
+ return !AGGREGATE_TYPE_P (type);
+ }
/* Return a new iterator pointing to GIMPLE_SEQ's first statement. */
