diff mbox

patch: remove is_gimple_non_addressable

Message ID 4F0729BF.60709@redhat.com
State New
Headers show

Commit Message

Aldy Hernandez Jan. 6, 2012, 5:05 p.m. UTC 
On 01/05/12 09:36, Richard Guenther wrote:
> On Thu, Jan 5, 2012 at 3:48 PM, Aldy Hernandez<aldyh@redhat.com>  wrote:
>> As you suggested here:
>>
>> http://gcc.gnu.org/ml/gcc-patches/2012-01/msg00232.html
>>
>> Bootregged on x86-64 Linux.
>>
>> OK?
>
> No, this pessimizes things too much at gimplification time, please simply
> inline the predicate instead.
>
> Richard.

It wasn't clear from your other message whether you want me to replace 
the call with:

	!is_gimple_reg () && !TREE_ADDRESSABLE ()

or outright inline the exact function call as we have now.

I have done the later.  Let me know if you want the former.

Tested on x86-64 Linux.

OK?
* gimple.c (is_gimple_non_addressable): Remove.
	* gimple.h: Remove is_gimple_non_addressable.
	* gimplify.c (gimplify_modify_expr_rhs): Use is_gimple_reg instead of
	is_gimple_non_addressable.
	* trans-mem.c (expand_assign_tm): Same.

Comments

Richard Biener Jan. 9, 2012, 9:42 a.m. UTC | #1 
On Fri, Jan 6, 2012 at 6:05 PM, Aldy Hernandez <aldyh@redhat.com> wrote:
> On 01/05/12 09:36, Richard Guenther wrote:
>>
>> On Thu, Jan 5, 2012 at 3:48 PM, Aldy Hernandez<aldyh@redhat.com>  wrote:
>>>
>>> As you suggested here:
>>>
>>> http://gcc.gnu.org/ml/gcc-patches/2012-01/msg00232.html
>>>
>>> Bootregged on x86-64 Linux.
>>>
>>> OK?
>>
>>
>> No, this pessimizes things too much at gimplification time, please simply
>> inline the predicate instead.
>>
>> Richard.
>
>
> It wasn't clear from your other message whether you want me to replace the
> call with:
>
>        !is_gimple_reg () && !TREE_ADDRESSABLE ()
>
> or outright inline the exact function call as we have now.
>
> I have done the later.  Let me know if you want the former.
>
> Tested on x86-64 Linux.
>
> OK?

Ok with simply excluding SSA_NAMEs like

@@ -4411,16 +4411,27 @@ gimplify_modify_expr_rhs (tree *expr_p,
 		/* It's OK to use the target directly if it's being
 		   initialized. */
 		use_target = true;
-	      else if (TREE_CODE (*to_p) != SSA_NAME
                         && ....)
-		/* Don't use the original target if it's already addressable;
-		   if its address escapes, and the called function uses the
-		   NRV optimization, a conforming program could see *to_p
-		   change before the called function returns; see c++/19317.
-		   When optimizing, the return_slot pass marks more functions
-		   as safe after we have escape info.  */
-		use_target = false;
- 	      else
-		use_target = true;

as SSA_NAMEs can never become addressable during gimplification.

Thanks,
Richard.
diff mbox

Patch

Index: trans-mem.c
===================================================================
--- trans-mem.c	(revision 182908)
+++ trans-mem.c	(working copy)
@@ -2184,7 +2184,7 @@  expand_assign_tm (struct tm_region *regi
       /* ??? Figure out if there's any possible overlap between the LHS
 	 and the RHS and if not, use MEMCPY.  */
 
-      if (load_p && is_gimple_non_addressable (lhs))
+      if (load_p && is_gimple_reg (lhs))
 	{
 	  tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
 	  lhs_addr = build_fold_addr_expr (tmp);
Index: gimplify.c
===================================================================
--- gimplify.c	(revision 182848)
+++ gimplify.c	(working copy)
@@ -4411,16 +4411,27 @@  gimplify_modify_expr_rhs (tree *expr_p,
 		/* It's OK to use the target directly if it's being
 		   initialized. */
 		use_target = true;
-	      else if (!is_gimple_non_addressable (*to_p))
-		/* Don't use the original target if it's already addressable;
-		   if its address escapes, and the called function uses the
-		   NRV optimization, a conforming program could see *to_p
-		   change before the called function returns; see c++/19317.
-		   When optimizing, the return_slot pass marks more functions
-		   as safe after we have escape info.  */
-		use_target = false;
 	      else
-		use_target = true;
+		{
+		  tree t;
+
+		  if (TREE_CODE (*to_p) == SSA_NAME)
+		    t = SSA_NAME_VAR (*to_p);
+		  else
+		    t = *to_p;
+		  if (!is_gimple_variable (t) || needs_to_live_in_memory (t))
+		    /* Don't use the original target if it's already
+		       addressable; if its address escapes, and the
+		       called function uses the NRV optimization, a
+		       conforming program could see *to_p change
+		       before the called function returns; see
+		       c++/19317.  When optimizing, the return_slot
+		       pass marks more functions as safe after we have
+		       escape info.  */
+		    use_target = false;
+		  else
+		    use_target = true;
+		}
 
 	      if (use_target)
 		{
Index: gimple.c
===================================================================
--- gimple.c	(revision 182848)
+++ gimple.c	(working copy)
@@ -2963,17 +2963,6 @@  is_gimple_reg (tree t)
 }
 
 
-/* Return true if T is a GIMPLE variable whose address is not needed.  */
-
-bool
-is_gimple_non_addressable (tree t)
-{
-  if (TREE_CODE (t) == SSA_NAME)
-    t = SSA_NAME_VAR (t);
-
-  return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
-}
-
 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  */
 
 bool
Index: gimple.h
===================================================================
--- gimple.h	(revision 182848)
+++ gimple.h	(working copy)
@@ -1006,9 +1006,6 @@  extern bool is_gimple_mem_rhs (tree);
 /* Returns true iff T is a valid if-statement condition.  */
 extern bool is_gimple_condexpr (tree);
 
-/* Returns true iff T is a variable that does not need to live in memory.  */
-extern bool is_gimple_non_addressable (tree t);
-
 /* Returns true iff T is a valid call address expression.  */
 extern bool is_gimple_call_addr (tree);