This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] Some more speedups for PR52361


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  <rguenther@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.  */
  


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]