CbC/CbC_gcc: gcc/trans-mem.c comparison

comparison gcc/trans-mem.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Passes for transactional memory support.
-Copyright (C) 2008-2018 Free Software Foundation, Inc.
+Copyright (C) 2008-2020 Free Software Foundation, Inc.
 Contributed by Richard Henderson <rth@redhat.com>
 and Aldy Hernandez <aldyh@redhat.com>.
 This file is part of GCC.
 #include "tree-into-ssa.h"
 #include "tree-inline.h"
 #include "demangle.h"
 #include "output.h"
 #include "trans-mem.h"
-#include "params.h"
 #include "langhooks.h"
 #include "cfgloop.h"
 #include "tree-ssa-address.h"
 #include "stringpool.h"
 #include "attribs.h"
 /* Return true if CALL is const, or tm_pure.  */
 static bool
 is_tm_pure_call (gimple *call)
 {
-if (gimple_call_internal_p (call))
+return (gimple_call_flags (call) & (ECF_CONST | ECF_TM_PURE)) != 0;
-return (gimple_call_flags (call) & (ECF_CONST | ECF_TM_PURE)) != 0;
-tree fn = gimple_call_fn (call);
-if (TREE_CODE (fn) == ADDR_EXPR)
-{
-fn = TREE_OPERAND (fn, 0);
-gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
-}
-else
-fn = TREE_TYPE (fn);
-return is_tm_pure (fn);
 }
 /* Return true if X has been marked TM_CALLABLE.  */
 static bool
 /* ??? We ought to come up with a way to add attributes to
 	 asm statements, and then add "transaction_safe" to it.
 	 Either that or get the language spec to resurrect __tm_waiver.  */
 if (d->block_flags & DIAG_TM_SAFE)
 	error_at (gimple_location (stmt),
-		  "asm not allowed in atomic transaction");
+		  "%<asm%> not allowed in atomic transaction");
 else if (d->func_flags & DIAG_TM_SAFE)
 	error_at (gimple_location (stmt),
-		  "asm not allowed in %<transaction_safe%> function");
+		  "%<asm%> not allowed in %<transaction_safe%> function");
 break;
 case GIMPLE_TRANSACTION:
 {
 	gtransaction *trans_stmt = as_a <gtransaction *> (stmt);
 if (entry_block
 	  && transaction_invariant_address_p (lp->addr, entry_block)
 	  && TYPE_SIZE_UNIT (type) != NULL
 	  && tree_fits_uhwi_p (TYPE_SIZE_UNIT (type))
 	  && ((HOST_WIDE_INT) tree_to_uhwi (TYPE_SIZE_UNIT (type))
-	      < PARAM_VALUE (PARAM_TM_MAX_AGGREGATE_SIZE))
+	      < param_tm_max_aggregate_size)
 	  /* We must be able to copy this type normally.  I.e., no
 	     special constructors and the like.  */
 	  && !TREE_ADDRESSABLE (type))
 	{
 	  lp->save_var = create_tmp_reg (TREE_TYPE (lp->addr), "tm_save");
 if (repl)
 	{
 	  gimple_call_set_fndecl (stmt, repl);
 	  update_stmt (stmt);
 	  node = cgraph_node::create (repl);
-	  node->local.tm_may_enter_irr = false;
+	  node->tm_may_enter_irr = false;
 	  return expand_call_tm (region, gsi);
 	}
 gcc_unreachable ();
 }
-if (node->local.tm_may_enter_irr)
+if (node->tm_may_enter_irr)
 transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
 if (is_tm_abort (fn_decl))
 {
 transaction_subcode_ior (region, GTMA_HAVE_ABORT);
 call_stmt = dyn_cast <gcall *> (stmt);
 if ((!call_stmt)
 	  || (gimple_call_flags (call_stmt) & ECF_TM_BUILTIN) == 0)
 	continue;
-if (DECL_FUNCTION_CODE (gimple_call_fndecl (call_stmt))
+if (gimple_call_builtin_p (call_stmt, BUILT_IN_TM_ABORT))
-	  == BUILT_IN_TM_ABORT)
 	{
 	  // If we have a ``_transaction_cancel [[outer]]'', there is only
 	  // one abnormal edge: to the transaction marked OUTER.
 	  // All compiler-generated instances of BUILT_IN_TM_ABORT have a
 	  // constant argument, which we can examine here.  Users invoking
 bool changed;
 /* Allocate a worklist array/queue.  Entries are only added to the
 list if they were not already on the list.  So the size is
 bounded by the number of basic blocks in the region.  */
+gcc_assert (!blocks.is_empty ());
 qlen = blocks.length () - 1;
-qin = qout = worklist =
+qin = qout = worklist = XNEWVEC (basic_block, qlen);
-XNEWVEC (basic_block, qlen);
 /* Put every block in the region on the worklist.  */
 for (i = 0; blocks.iterate (i, &bb); ++i)
 {
 /* Seed AVAIL_OUT with the LOCAL set.  */
 	     yet implemented, so we can't check for it.  */
 	  if (is_tm_safe (current_function_decl))
 	    {
 	      tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
 	      SET_EXPR_LOCATION (t, gimple_location (stmt));
-	      error ("%Kasm not allowed in %<transaction_safe%> function", t);
+	      error ("%K%<asm%> not allowed in %<transaction_safe%> function",
+		     t);
 	    }
 	  return true;
 	default:
 	  break;
 if (d->irrevocable_blocks_clone)
 return true;
 /* We may have previously marked this function as tm_may_enter_irr;
 see pass_diagnose_tm_blocks.  */
-if (node->local.tm_may_enter_irr)
+if (node->tm_may_enter_irr)
 return true;
 /* Recurse on the main body for aliases.  In general, this will
 result in one of the bits above being set so that we will not
 have to recurse next time.  */
 {
 struct cgraph_edge *e;
 for (e = node->callees; e ; e = e->next_callee)
 if (!is_tm_callable (e->callee->decl)
-	&& e->callee->local.tm_may_enter_irr)
+	&& e->callee->tm_may_enter_irr)
 error_at (gimple_location (e->call_stmt),
 		"unsafe function call %qD within "
 		"%<transaction_safe%> function", e->callee->decl);
 }
 	      tree fndecl;
 	      if (gimple_code (stmt) == GIMPLE_ASM)
 		{
 		  error_at (gimple_location (stmt),
-			    "asm not allowed in atomic transaction");
+			    "%<asm%> not allowed in atomic transaction");
 		  continue;
 		}
 	      if (!is_gimple_call (stmt))
 		continue;
 	      if (is_tm_pure_call (stmt))
 		continue;
 	      if (is_tm_callable (fndecl))
 		continue;
-	      if (cgraph_node::local_info (fndecl)->tm_may_enter_irr)
+	      if (cgraph_node::local_info_node (fndecl)->tm_may_enter_irr)
 		error_at (gimple_location (stmt),
 			  "unsafe function call %qD within "
 			  "atomic transaction", fndecl);
 	    }
 old_asm_name = IDENTIFIER_POINTER (old_asm_id);
 dc = cplus_demangle_v3_components (old_asm_name, DMGL_NO_OPTS, &alloc);
 if (dc == NULL)
 {
-char length[8];
+char length[12];
 do_unencoded:
 sprintf (length, "%u", IDENTIFIER_LENGTH (old_asm_id));
 tm_name = concat ("_ZGTt", length, old_asm_name, NULL);
 }
 varpool_node::get (new_decl)->set_comdat_group
 (tm_mangle (DECL_COMDAT_GROUP (old_decl)));
 gcc_assert (!old_node->ipa_transforms_to_apply.exists ());
 new_node = old_node->create_version_clone (new_decl, vNULL, NULL);
-new_node->local.local = false;
+new_node->local = false;
 new_node->externally_visible = old_node->externally_visible;
 new_node->lowered = true;
 new_node->tm_clone = 1;
 if (!old_node->implicit_section)
 new_node->set_section (old_node->get_section ());
 	  TREE_PUBLIC (new_decl) = 0;
 	  DECL_WEAK (new_decl) = 0;
 	}
 tree_function_versioning (old_decl, new_decl,
-				NULL, false, NULL,
+				NULL,  NULL, false, NULL, NULL);
-				false, NULL, NULL);
 }
 record_tm_clone_pair (old_decl, new_decl);
 symtab->call_cgraph_insertion_hooks (new_node);
 /* ??? This seems broken.  How is it that we're marking the
 	 CALLEE as may_enter_irr?  Surely we should be marking the
 	 CALLER.  Also note that find_tm_replacement_function also
 	 contains mappings into the TM runtime, e.g. memcpy.  These
 	 we know won't go irrevocable.  */
-new_node->local.tm_may_enter_irr = 1;
+new_node->tm_may_enter_irr = 1;
 }
 else
 {
 struct tm_ipa_cg_data *d;
 struct cgraph_node *tnode = e->callee;
 	/* ... marked tm_pure, record that fact for the runtime by
 	   indicating that the pure function is its own tm_callable.
 	   No need to do this if the function's address can't be taken.  */
 	if (is_tm_pure (node->decl))
 	  {
-	    if (!node->local.local)
+	    if (!node->local)
 	      record_tm_clone_pair (node->decl, node->decl);
 	    continue;
 	  }
 	push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 	}
 node = irr_worklist[i];
 d = get_cg_data (&node, true);
 d->in_worklist = false;
-node->local.tm_may_enter_irr = true;
+node->tm_may_enter_irr = true;
 /* Propagate back to normal callers.  */
 for (e = node->callers; e ; e = e->next_caller)
 	{
 	  caller = e->caller;
 	  if (!is_tm_safe_or_pure (caller->decl)
-	      && !caller->local.tm_may_enter_irr)
+	      && !caller->tm_may_enter_irr)
 	    {
 	      d = get_cg_data (&caller, true);
 	      maybe_push_queue (caller, &irr_worklist, &d->in_worklist);
 	    }
 	}
 /* Propagate back to referring aliases as well.  */
 FOR_EACH_ALIAS (node, ref)
 	{
 	  caller = dyn_cast<cgraph_node *> (ref->referring);
-	  if (!caller->local.tm_may_enter_irr)
+	  if (!caller->tm_may_enter_irr)
 	    {
 	      /* ?? Do not traverse aliases here.  */
 	      d = get_cg_data (&caller, false);
 	      maybe_push_queue (caller, &irr_worklist, &d->in_worklist);
 	    }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/trans-mem.c @ 145:1830386684a0