diff mbox

trans-mem: virtual ops for gimple_transaction

Message ID 4F345153.8090602@redhat.com
State New
Headers show

Commit Message

Richard Henderson Feb. 9, 2012, 11:05 p.m. UTC 
> From: rguenth at gcc dot gnu.org <gcc-bugzilla@gcc.gnu.org>
> the __transaction_atomic  // SUBCODE=[ GTMA_HAVE_STORE ] statement
> looks like an overly optimistic way to start a transaction in my quick view.

Indeed.  At some point this worked, but this may have gotten lost
during one of the merges.  Now,

  # .MEM_8 = VDEF <.MEM_7(D)>
  __transaction_relaxed  // SUBCODE=[ ... ]

Bootstrapped and tested on x86_64.  Ok?


r~
* tree-ssa-dce.c (propagate_necessity): Handle GIMPLE_TRANSACTION.
	* tree-ssa-operands.c (parse_ssa_operands): Add virtual operands
	for GIMPLE_TRANSACTION.  Tidy if's into a switch.

Comments

Torvald Riegel Feb. 10, 2012, 12:25 a.m. UTC | #1 
On Thu, 2012-02-09 at 15:05 -0800, Richard Henderson wrote:
> +             /* The beginning of a transaction is a memory barrier.
> */
> +             /* ??? If we were really cool, we'd only be a barrier
> +                for the memories touched within the transaction.  */

Why?  I'm not quite sure what kind of memory barrier you mean here, but
a transaction can synchronize with other transactions and thus should be
a barrier for all memory accesses, or not?  We could move safe code into
it, but not out of it or across it.  We could perhaps move
transaction_pure code across it, or out of it, IIRC.


Torvald
diff mbox

Patch

diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c
index ccdf14a..ace9ef9 100644
--- a/gcc/tree-ssa-dce.c
+++ b/gcc/tree-ssa-dce.c
@@ -965,6 +965,13 @@  propagate_necessity (struct edge_list *el)
 		    mark_aliased_reaching_defs_necessary (stmt, op);
 		}
 	    }
+	  else if (gimple_code (stmt) == GIMPLE_TRANSACTION)
+	    {
+	      /* The beginning of a transaction is a memory barrier.  */
+	      /* ??? If we were really cool, we'd only be a barrier
+		 for the memories touched within the transaction.  */
+	      mark_all_reaching_defs_necessary (stmt);
+	    }
 	  else
 	    gcc_unreachable ();
 
diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c
index 0045dd8..ed0d34d 100644
--- a/gcc/tree-ssa-operands.c
+++ b/gcc/tree-ssa-operands.c
@@ -1043,35 +1043,46 @@  static void
 parse_ssa_operands (gimple stmt)
 {
   enum gimple_code code = gimple_code (stmt);
+  size_t i, n, start = 0;
 
-  if (code == GIMPLE_ASM)
-    get_asm_expr_operands (stmt);
-  else if (is_gimple_debug (stmt))
+  switch (code)
     {
+    case GIMPLE_ASM:
+      get_asm_expr_operands (stmt);
+      break;
+
+    case GIMPLE_TRANSACTION:
+      /* The start of a transaction is a memory barrier.  */
+      add_virtual_operand (stmt, opf_def | opf_use);
+      break;
+
+    case GIMPLE_DEBUG:
       if (gimple_debug_bind_p (stmt)
 	  && gimple_debug_bind_has_value_p (stmt))
 	get_expr_operands (stmt, gimple_debug_bind_get_value_ptr (stmt),
 			   opf_use | opf_no_vops);
-    }
-  else
-    {
-      size_t i, start = 0;
+      break;
 
-      if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
-	{
-	  get_expr_operands (stmt, gimple_op_ptr (stmt, 0), opf_def);
-	  start = 1;
-	}
-
-      for (i = start; i < gimple_num_ops (stmt); i++)
-	get_expr_operands (stmt, gimple_op_ptr (stmt, i), opf_use);
+    case GIMPLE_RETURN:
+      append_vuse (gimple_vop (cfun));
+      goto do_default;
 
+    case GIMPLE_CALL:
       /* Add call-clobbered operands, if needed.  */
-      if (code == GIMPLE_CALL)
-	maybe_add_call_vops (stmt);
+      maybe_add_call_vops (stmt);
+      /* FALLTHRU */
 
-      if (code == GIMPLE_RETURN)
-	append_vuse (gimple_vop (cfun));
+    case GIMPLE_ASSIGN:
+      get_expr_operands (stmt, gimple_op_ptr (stmt, 0), opf_def);
+      start = 1;
+      /* FALLTHRU */
+
+    default:
+    do_default:
+      n = gimple_num_ops (stmt);
+      for (i = start; i < n; i++)
+	get_expr_operands (stmt, gimple_op_ptr (stmt, i), opf_use);
+      break;
     }
 }