CbC/CbC_gcc: gcc/omp-low.c comparison

comparison gcc/omp-low.c @ 67:f6334be47118

update gcc from gcc-4.6-20100522 to gcc-4.6-20110318

author	nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date	Tue, 22 Mar 2011 17:18:12 +0900
parents	b7f97abdc517
children	04ced10e8804

comparison

equal deleted inserted replaced

-:65488c3d617d
+:f6334be47118
 #include "rtl.h"
 #include "gimple.h"
 #include "tree-iterator.h"
 #include "tree-inline.h"
 #include "langhooks.h"
-#include "diagnostic.h"
+#include "diagnostic-core.h"
 #include "tree-flow.h"
 #include "timevar.h"
 #include "flags.h"
 #include "function.h"
 #include "expr.h"
-#include "toplev.h"
 #include "tree-pass.h"
 #include "ggc.h"
 #include "except.h"
 #include "splay-tree.h"
 #include "optabs.h"
 /* Collect additional arguments needed to emit a combined
 parallel+workshare call.  WS_STMT is the workshare directive being
 expanded.  */
-static tree
+static VEC(tree,gc) *
 get_ws_args_for (gimple ws_stmt)
 {
 tree t;
 location_t loc = gimple_location (ws_stmt);
+VEC(tree,gc) *ws_args;
 if (gimple_code (ws_stmt) == GIMPLE_OMP_FOR)
 {
 struct omp_for_data fd;
-tree ws_args;
 extract_omp_for_data (ws_stmt, &fd, NULL);
-ws_args = NULL_TREE;
+ws_args = VEC_alloc (tree, gc, 3 + (fd.chunk_size != 0));
+t = fold_convert_loc (loc, long_integer_type_node, fd.loop.n1);
+VEC_quick_push (tree, ws_args, t);
+t = fold_convert_loc (loc, long_integer_type_node, fd.loop.n2);
+VEC_quick_push (tree, ws_args, t);
+t = fold_convert_loc (loc, long_integer_type_node, fd.loop.step);
+VEC_quick_push (tree, ws_args, t);
 if (fd.chunk_size)
 	{
 	  t = fold_convert_loc (loc, long_integer_type_node, fd.chunk_size);
-	  ws_args = tree_cons (NULL, t, ws_args);
+	  VEC_quick_push (tree, ws_args, t);
 	}
-t = fold_convert_loc (loc, long_integer_type_node, fd.loop.step);
-ws_args = tree_cons (NULL, t, ws_args);
-t = fold_convert_loc (loc, long_integer_type_node, fd.loop.n2);
-ws_args = tree_cons (NULL, t, ws_args);
-t = fold_convert_loc (loc, long_integer_type_node, fd.loop.n1);
-ws_args = tree_cons (NULL, t, ws_args);
 return ws_args;
 }
 else if (gimple_code (ws_stmt) == GIMPLE_OMP_SECTIONS)
 {
 /* Number of sections is equal to the number of edges from the
 	 GIMPLE_OMP_SECTIONS_SWITCH statement, except for the one to
 	 the exit of the sections region.  */
 basic_block bb = single_succ (gimple_bb (ws_stmt));
 t = build_int_cst (unsigned_type_node, EDGE_COUNT (bb->succs) - 1);
-t = tree_cons (NULL, t, NULL);
+ws_args = VEC_alloc (tree, gc, 1);
-return t;
+VEC_quick_push (tree, ws_args, t);
+return ws_args;
 }
 gcc_unreachable ();
 }
 omp_copy_decl_2 (tree var, tree name, tree type, omp_context *ctx)
 {
 tree copy = copy_var_decl (var, name, type);
 DECL_CONTEXT (copy) = current_function_decl;
-TREE_CHAIN (copy) = ctx->block_vars;
+DECL_CHAIN (copy) = ctx->block_vars;
 ctx->block_vars = copy;
 return copy;
 }
 remap the field into the new record type.  */
 x = maybe_lookup_field (field, ctx);
 if (x != NULL)
 field = x;
-x = build_fold_indirect_ref (ctx->receiver_decl);
+x = build_simple_mem_ref (ctx->receiver_decl);
 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL);
 if (by_ref)
-x = build_fold_indirect_ref (x);
+x = build_simple_mem_ref (x);
 return x;
 }
 /* Build tree nodes to access VAR in the scope outer to CTX.  In the case
 x = var;
 else if (is_variable_sized (var))
 {
 x = TREE_OPERAND (DECL_VALUE_EXPR (var), 0);
 x = build_outer_var_ref (x, ctx);
-x = build_fold_indirect_ref (x);
+x = build_simple_mem_ref (x);
 }
 else if (is_taskreg_ctx (ctx))
 {
 bool by_ref = use_pointer_for_field (var, NULL);
 x = build_receiver_ref (var, by_ref, ctx);
 x = var;
 else
 gcc_unreachable ();
 if (is_reference (var))
-x = build_fold_indirect_ref (x);
+x = build_simple_mem_ref (x);
 return x;
 }
 /* Build tree nodes to access the field for VAR on the sender side.  */
 if (region->next)
 dump_omp_region (file, region->next, indent);
 }
-void
+DEBUG_FUNCTION void
 debug_omp_region (struct omp_region *region)
 {
 dump_omp_region (stderr, region, 0);
 }
-void
+DEBUG_FUNCTION void
 debug_all_omp_regions (void)
 {
 dump_omp_region (stderr, root_omp_region, 0);
 }
 /* We hijacked DECL_ABSTRACT_ORIGIN earlier.  We need to clear it before
 it produces corrupt debug information.  */
 if (ctx->record_type)
 {
 tree t;
-for (t = TYPE_FIELDS (ctx->record_type); t ; t = TREE_CHAIN (t))
+for (t = TYPE_FIELDS (ctx->record_type); t ; t = DECL_CHAIN (t))
 	DECL_ABSTRACT_ORIGIN (t) = NULL;
 }
 if (ctx->srecord_type)
 {
 tree t;
-for (t = TYPE_FIELDS (ctx->srecord_type); t ; t = TREE_CHAIN (t))
+for (t = TYPE_FIELDS (ctx->srecord_type); t ; t = DECL_CHAIN (t))
 	DECL_ABSTRACT_ORIGIN (t) = NULL;
 }
 if (is_task_ctx (ctx))
 finalize_task_copyfn (ctx->stmt);
 /* ??? It isn't sufficient to just call remap_type here, because
 variably_modified_type_p doesn't work the way we expect for
 record types.  Testing each field for whether it needs remapping
 and creating a new record by hand works, however.  */
-for (f = TYPE_FIELDS (type); f ; f = TREE_CHAIN (f))
+for (f = TYPE_FIELDS (type); f ; f = DECL_CHAIN (f))
 if (variably_modified_type_p (TREE_TYPE (f), ctx->cb.src_fn))
 break;
 if (f)
 {
 tree name, new_fields = NULL;
 name = DECL_NAME (TYPE_NAME (ctx->record_type));
 name = build_decl (DECL_SOURCE_LOCATION (ctx->receiver_decl),
 			 TYPE_DECL, name, type);
 TYPE_NAME (type) = name;
-for (f = TYPE_FIELDS (ctx->record_type); f ; f = TREE_CHAIN (f))
+for (f = TYPE_FIELDS (ctx->record_type); f ; f = DECL_CHAIN (f))
 	{
 	  tree new_f = copy_node (f);
 	  DECL_CONTEXT (new_f) = type;
 	  TREE_TYPE (new_f) = remap_type (TREE_TYPE (f), &ctx->cb);
-	  TREE_CHAIN (new_f) = new_fields;
+	  DECL_CHAIN (new_f) = new_fields;
 	  walk_tree (&DECL_SIZE (new_f), copy_tree_body_r, &ctx->cb, NULL);
 	  walk_tree (&DECL_SIZE_UNIT (new_f), copy_tree_body_r,
 		     &ctx->cb, NULL);
 	  walk_tree (&DECL_FIELD_OFFSET (new_f), copy_tree_body_r,
 		     &ctx->cb, NULL);
 static GTY(()) unsigned int tmp_ompfn_id_num;
 static tree
 create_omp_child_function_name (bool task_copy)
 {
-tree name = DECL_ASSEMBLER_NAME (current_function_decl);
+return (clone_function_name (current_function_decl,
-size_t len = IDENTIFIER_LENGTH (name);
+			       task_copy ? "_omp_cpyfn" : "_omp_fn"));
-char *tmp_name, *prefix;
-const char *suffix;
-suffix = task_copy ? "_omp_cpyfn" : "_omp_fn";
-prefix = XALLOCAVEC (char, len + strlen (suffix) + 1);
-memcpy (prefix, IDENTIFIER_POINTER (name), len);
-strcpy (prefix + len, suffix);
-#ifndef NO_DOT_IN_LABEL
-prefix[len] = '.';
-#elif !defined NO_DOLLAR_IN_LABEL
-prefix[len] = '$';
-#endif
-ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix, tmp_ompfn_id_num++);
-return get_identifier (tmp_name);
 }
 /* Build a decl for the omp child function.  It'll not contain a body
 yet, just the bare decl.  */
 gimple_omp_task_set_copy_fn (ctx->stmt, decl);
 TREE_STATIC (decl) = 1;
 TREE_USED (decl) = 1;
 DECL_ARTIFICIAL (decl) = 1;
+DECL_NAMELESS (decl) = 1;
 DECL_IGNORED_P (decl) = 0;
 TREE_PUBLIC (decl) = 0;
 DECL_UNINLINABLE (decl) = 1;
 DECL_EXTERNAL (decl) = 0;
 DECL_CONTEXT (decl) = NULL_TREE;
 DECL_RESULT (decl) = t;
 t = build_decl (DECL_SOURCE_LOCATION (decl),
 		  PARM_DECL, get_identifier (".omp_data_i"), ptr_type_node);
 DECL_ARTIFICIAL (t) = 1;
+DECL_NAMELESS (t) = 1;
 DECL_ARG_TYPE (t) = ptr_type_node;
 DECL_CONTEXT (t) = current_function_decl;
 TREE_USED (t) = 1;
 DECL_ARGUMENTS (decl) = t;
 if (!task_copy)
 {
 t = build_decl (DECL_SOURCE_LOCATION (decl),
 		      PARM_DECL, get_identifier (".omp_data_o"),
 		      ptr_type_node);
 DECL_ARTIFICIAL (t) = 1;
+DECL_NAMELESS (t) = 1;
 DECL_ARG_TYPE (t) = ptr_type_node;
 DECL_CONTEXT (t) = current_function_decl;
 TREE_USED (t) = 1;
 TREE_ADDRESSABLE (t) = 1;
-TREE_CHAIN (t) = DECL_ARGUMENTS (decl);
+DECL_CHAIN (t) = DECL_ARGUMENTS (decl);
 DECL_ARGUMENTS (decl) = t;
 }
 /* Allocate memory for the function structure.  The call to
 allocate_struct_function clobbers CFUN, so we need to restore
 ctx->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
 ctx->record_type = lang_hooks.types.make_type (RECORD_TYPE);
 name = create_tmp_var_name (".omp_data_s");
 name = build_decl (gimple_location (stmt),
 		     TYPE_DECL, name, ctx->record_type);
+DECL_ARTIFICIAL (name) = 1;
+DECL_NAMELESS (name) = 1;
 TYPE_NAME (ctx->record_type) = name;
 create_omp_child_function (ctx, false);
 gimple_omp_parallel_set_child_fn (stmt, ctx->cb.dst_fn);
 scan_sharing_clauses (gimple_omp_parallel_clauses (stmt), ctx);
 ctx->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
 ctx->record_type = lang_hooks.types.make_type (RECORD_TYPE);
 name = create_tmp_var_name (".omp_data_s");
 name = build_decl (gimple_location (stmt),
 		     TYPE_DECL, name, ctx->record_type);
+DECL_ARTIFICIAL (name) = 1;
+DECL_NAMELESS (name) = 1;
 TYPE_NAME (ctx->record_type) = name;
 create_omp_child_function (ctx, false);
 gimple_omp_task_set_child_fn (stmt, ctx->cb.dst_fn);
 scan_sharing_clauses (gimple_omp_task_clauses (stmt), ctx);
 if (ctx->srecord_type)
 {
 name = create_tmp_var_name (".omp_data_a");
 name = build_decl (gimple_location (stmt),
 			 TYPE_DECL, name, ctx->srecord_type);
+DECL_ARTIFICIAL (name) = 1;
+DECL_NAMELESS (name) = 1;
 TYPE_NAME (ctx->srecord_type) = name;
 create_omp_child_function (ctx, true);
 }
 scan_omp (gimple_omp_body (stmt), ctx);
 	    *p = TREE_CHAIN (*p);
 	    TREE_CHAIN (*q) = NULL_TREE;
 	    q = &TREE_CHAIN (*q);
 	  }
 	else
-	  p = &TREE_CHAIN (*p);
+	  p = &DECL_CHAIN (*p);
 *p = vla_fields;
 layout_type (ctx->record_type);
 fixup_child_record_type (ctx);
 if (ctx->srecord_type)
 	layout_type (ctx->srecord_type);
 	*tp = remap_type (t, &ctx->cb);
 else if (!DECL_P (t))
 	{
 	  *walk_subtrees = 1;
 	  if (ctx)
-	    TREE_TYPE (t) = remap_type (TREE_TYPE (t), &ctx->cb);
+	    {
+	      tree tem = remap_type (TREE_TYPE (t), &ctx->cb);
+	      if (tem != TREE_TYPE (t))
+		{
+		  if (TREE_CODE (t) == INTEGER_CST)
+		    *tp = build_int_cst_wide (tem,
+					      TREE_INT_CST_LOW (t),
+					      TREE_INT_CST_HIGH (t));
+		  else
+		    TREE_TYPE (t) = tem;
+		}
+	    }
 	}
 break;
 }
 return NULL_TREE;
 {
 	tree var;
 	*handled_ops_p = false;
 	if (ctx)
-	  for (var = gimple_bind_vars (stmt); var ; var = TREE_CHAIN (var))
+	  for (var = gimple_bind_vars (stmt); var ; var = DECL_CHAIN (var))
 	    insert_decl_map (&ctx->cb, var, var);
 }
 break;
 default:
 *handled_ops_p = false;
 case BIT_XOR_EXPR:
 case TRUTH_OR_EXPR:
 case TRUTH_ORIF_EXPR:
 case TRUTH_XOR_EXPR:
 case NE_EXPR:
-return fold_convert_loc (loc, type, integer_zero_node);
+return build_zero_cst (type);
 case MULT_EXPR:
 case TRUTH_AND_EXPR:
 case TRUTH_ANDIF_EXPR:
 case EQ_EXPR:
 		}
 	      x = fold_convert_loc (clause_loc, TREE_TYPE (new_var), x);
 	      gimplify_assign (new_var, x, ilist);
-	      new_var = build_fold_indirect_ref_loc (clause_loc, new_var);
+	      new_var = build_simple_mem_ref_loc (clause_loc, new_var);
 	    }
 	  else if (c_kind == OMP_CLAUSE_REDUCTION
 		   && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
 	    {
 	      if (pass == 0)
 	    }
 	  OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) = NULL;
 	  x = build_outer_var_ref (var, ctx);
 	  if (is_reference (var))
-	    new_var = build_fold_indirect_ref_loc (clause_loc, new_var);
+	    new_var = build_simple_mem_ref_loc (clause_loc, new_var);
 	  x = lang_hooks.decls.omp_clause_assign_op (c, x, new_var);
 	  gimplify_and_add (x, stmt_list);
 	}
 c = OMP_CLAUSE_CHAIN (c);
 if (c == NULL && !par_clauses)
 	continue;
 var = OMP_CLAUSE_DECL (c);
 new_var = lookup_decl (var, ctx);
 if (is_reference (var))
-	new_var = build_fold_indirect_ref_loc (clause_loc, new_var);
+	new_var = build_simple_mem_ref_loc (clause_loc, new_var);
 ref = build_outer_var_ref (var, ctx);
 code = OMP_CLAUSE_REDUCTION_CODE (c);
 /* reduction(-:var) sums up the partial results, so it acts
 	 identically to reduction(+:var).  */
 	  ref = build_fold_indirect_ref_loc (clause_loc, ref);
 	}
 if (is_reference (var))
 	{
 	  ref = fold_convert_loc (clause_loc, TREE_TYPE (new_var), ref);
-	  ref = build_fold_indirect_ref_loc (clause_loc, ref);
+	  ref = build_simple_mem_ref_loc (clause_loc, ref);
-	  new_var = build_fold_indirect_ref_loc (clause_loc, new_var);
+	  new_var = build_simple_mem_ref_loc (clause_loc, new_var);
 	}
 x = lang_hooks.decls.omp_clause_assign_op (c, new_var, ref);
 gimplify_and_add (x, rlist);
 }
 }
 if (ctx->record_type == NULL)
 return;
 record_type = ctx->srecord_type ? ctx->srecord_type : ctx->record_type;
-for (f = TYPE_FIELDS (record_type); f ; f = TREE_CHAIN (f))
+for (f = TYPE_FIELDS (record_type); f ; f = DECL_CHAIN (f))
 {
 ovar = DECL_ABSTRACT_ORIGIN (f);
 nvar = maybe_lookup_decl (ovar, ctx);
 if (!nvar || !DECL_HAS_VALUE_EXPR_P (nvar))
 	continue;
 construct, it contains the list of additional arguments needed by
 the workshare construct.  */
 static void
 expand_parallel_call (struct omp_region *region, basic_block bb,
-		      gimple entry_stmt, tree ws_args)
+		      gimple entry_stmt, VEC(tree,gc) *ws_args)
 {
 tree t, t1, t2, val, cond, c, clauses;
 gimple_stmt_iterator gsi;
 gimple stmt;
 int start_ix;
 location_t clause_loc;
+VEC(tree,gc) *args;
 clauses = gimple_omp_parallel_clauses (entry_stmt);
 /* Determine what flavor of GOMP_parallel_start we will be
 emitting.  */
 t1 = null_pointer_node;
 else
 t1 = build_fold_addr_expr (t);
 t2 = build_fold_addr_expr (gimple_omp_parallel_child_fn (entry_stmt));
-if (ws_args)
+args = VEC_alloc (tree, gc, 3 + VEC_length (tree, ws_args));
-{
+VEC_quick_push (tree, args, t2);
-tree args = tree_cons (NULL, t2,
+VEC_quick_push (tree, args, t1);
-			     tree_cons (NULL, t1,
+VEC_quick_push (tree, args, val);
-					tree_cons (NULL, val, ws_args)));
+VEC_splice (tree, args, ws_args);
-t = build_function_call_expr (UNKNOWN_LOCATION,
-				    built_in_decls[start_ix], args);
+t = build_call_expr_loc_vec (UNKNOWN_LOCATION,
-}
+			       built_in_decls[start_ix], args);
-else
-t = build_call_expr (built_in_decls[start_ix], 3, t2, t1, val);
 force_gimple_operand_gsi (&gsi, t, true, NULL_TREE,
 			    false, GSI_CONTINUE_LINKING);
 t = gimple_omp_parallel_data_arg (entry_stmt);
 tree decl;
 if (!flag_exceptions)
 return body;
-if (lang_protect_cleanup_actions)
+if (lang_hooks.eh_protect_cleanup_actions != NULL)
-decl = lang_protect_cleanup_actions ();
+decl = lang_hooks.eh_protect_cleanup_actions ();
 else
 decl = built_in_decls[BUILT_IN_TRAP];
 g = gimple_build_eh_must_not_throw (decl);
 g = gimple_build_try (body, gimple_seq_alloc_with_stmt (g),
 }
 /* Chain all the DECLs in LIST by their TREE_CHAIN fields.  */
 static tree
-list2chain (tree list)
+vec2chain (VEC(tree,gc) *v)
 {
-tree t;
+tree chain = NULL_TREE, t;
+unsigned ix;
-for (t = list; t; t = TREE_CHAIN (t))
-{
+FOR_EACH_VEC_ELT_REVERSE (tree, v, ix, t)
-tree var = TREE_VALUE (t);
+{
-if (TREE_CHAIN (t))
+DECL_CHAIN (t) = chain;
-	TREE_CHAIN (var) = TREE_VALUE (TREE_CHAIN (t));
+chain = t;
-else
+}
-	TREE_CHAIN (var) = NULL_TREE;
-}
+return chain;
-return list ? TREE_VALUE (list) : NULL_TREE;
 }
 /* Remove barriers in REGION->EXIT's block.  Note that this is only
 valid for GIMPLE_OMP_PARALLEL regions.  Since the end of a parallel region
 	     of such a variable.  */
 	  if (any_addressable_vars < 0)
 	    {
 	      gimple parallel_stmt = last_stmt (region->entry);
 	      tree child_fun = gimple_omp_parallel_child_fn (parallel_stmt);
-	      tree local_decls = DECL_STRUCT_FUNCTION (child_fun)->local_decls;
+	      tree local_decls, block, decl;
-	      tree block;
+	      unsigned ix;
 	      any_addressable_vars = 0;
-	      for (; local_decls; local_decls = TREE_CHAIN (local_decls))
+	      FOR_EACH_LOCAL_DECL (DECL_STRUCT_FUNCTION (child_fun), ix, decl)
-		if (TREE_ADDRESSABLE (TREE_VALUE (local_decls)))
+		if (TREE_ADDRESSABLE (decl))
 		  {
 		    any_addressable_vars = 1;
 		    break;
 		  }
 	      for (block = gimple_block (stmt);
 		   && TREE_CODE (block) == BLOCK;
 		   block = BLOCK_SUPERCONTEXT (block))
 		{
 		  for (local_decls = BLOCK_VARS (block);
 		       local_decls;
-		       local_decls = TREE_CHAIN (local_decls))
+		       local_decls = DECL_CHAIN (local_decls))
 		    if (TREE_ADDRESSABLE (local_decls))
 		      {
 			any_addressable_vars = 1;
 			break;
 		      }
 static void
 expand_omp_taskreg (struct omp_region *region)
 {
 basic_block entry_bb, exit_bb, new_bb;
 struct function *child_cfun;
-tree child_fn, block, t, ws_args, *tp;
+tree child_fn, block, t;
 tree save_current;
 gimple_stmt_iterator gsi;
 gimple entry_stmt, stmt;
 edge e;
+VEC(tree,gc) *ws_args;
 entry_stmt = last_stmt (region->entry);
 child_fn = gimple_omp_taskreg_child_fn (entry_stmt);
 child_cfun = DECL_STRUCT_FUNCTION (child_fn);
 /* If this function has been already instrumented, make sure
 exit_bb = region->exit;
 if (is_combined_parallel (region))
 ws_args = region->ws_args;
 else
-ws_args = NULL_TREE;
+ws_args = NULL;
 if (child_cfun->cfg)
 {
 /* Due to inlining, it may happen that we have already outlined
 	 the region, in which case all we need to do is make the
 	}
 remove_edge_and_dominated_blocks (entry_succ_e);
 }
 else
 {
+unsigned srcidx, dstidx, num;
 /* If the parallel region needs data sent from the parent
 	 function, then the very first statement (except possible
 	 tree profile counter updates) of the parallel body
 	 is a copy assignment .OMP_DATA_I = &.OMP_DATA_O.  Since
 	 &.OMP_DATA_O is passed as an argument to the child function,
 	    }
 	}
 /* Declare local variables needed in CHILD_CFUN.  */
 block = DECL_INITIAL (child_fn);
-BLOCK_VARS (block) = list2chain (child_cfun->local_decls);
+BLOCK_VARS (block) = vec2chain (child_cfun->local_decls);
 /* The gimplifier could record temporaries in parallel/task block
 	 rather than in containing function's local_decls chain,
 	 which would mean cgraph missed finalizing them.  Do it now.  */
-for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))
+for (t = BLOCK_VARS (block); t; t = DECL_CHAIN (t))
 	if (TREE_CODE (t) == VAR_DECL
 	    && TREE_STATIC (t)
 	    && !DECL_EXTERNAL (t))
 	  varpool_finalize_decl (t);
 DECL_SAVED_TREE (child_fn) = NULL;
 gimple_set_body (child_fn, bb_seq (single_succ (entry_bb)));
 TREE_USED (block) = 1;
 /* Reset DECL_CONTEXT on function arguments.  */
-for (t = DECL_ARGUMENTS (child_fn); t; t = TREE_CHAIN (t))
+for (t = DECL_ARGUMENTS (child_fn); t; t = DECL_CHAIN (t))
 	DECL_CONTEXT (t) = child_fn;
 /* Split ENTRY_BB at GIMPLE_OMP_PARALLEL or GIMPLE_OMP_TASK,
 	 so that it can be moved to the child function.  */
 gsi = gsi_last_bb (entry_bb);
 new_bb = move_sese_region_to_fn (child_cfun, entry_bb, exit_bb, block);
 if (exit_bb)
 	single_succ_edge (new_bb)->flags = EDGE_FALLTHRU;
 /* Remove non-local VAR_DECLs from child_cfun->local_decls list.  */
-for (tp = &child_cfun->local_decls; *tp; )
+num = VEC_length (tree, child_cfun->local_decls);
-	if (DECL_CONTEXT (TREE_VALUE (*tp)) != cfun->decl)
+for (srcidx = 0, dstidx = 0; srcidx < num; srcidx++)
-	  tp = &TREE_CHAIN (*tp);
+	{
-	else
+	  t = VEC_index (tree, child_cfun->local_decls, srcidx);
-	  *tp = TREE_CHAIN (*tp);
+	  if (DECL_CONTEXT (t) == cfun->decl)
+	    continue;
+	  if (srcidx != dstidx)
+	    VEC_replace (tree, child_cfun->local_decls, dstidx, t);
+	  dstidx++;
+	}
+if (dstidx != num)
+	VEC_truncate (tree, child_cfun->local_decls, dstidx);
 /* Inform the callgraph about the new function.  */
 DECL_STRUCT_FUNCTION (child_fn)->curr_properties
 	= cfun->curr_properties;
 cgraph_add_new_function (child_fn, true);
 			    tree addr, tree loaded_val,
 			    tree stored_val, int index)
 {
 enum built_in_function base;
 tree decl, itype, call;
-enum insn_code *optab;
+direct_optab optab;
 tree rhs;
 basic_block store_bb = single_succ (load_bb);
 gimple_stmt_iterator gsi;
 gimple stmt;
 location_t loc;
 return false;
 decl = built_in_decls[base + index + 1];
 itype = TREE_TYPE (TREE_TYPE (decl));
-if (optab[TYPE_MODE (itype)] == CODE_FOR_nothing)
+if (direct_optab_handler (optab, TYPE_MODE (itype)) == CODE_FOR_nothing)
 return false;
 gsi = gsi_last_bb (load_bb);
 gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_ATOMIC_LOAD);
 call = build_call_expr_loc (loc,
 cmpxchg = built_in_decls[BUILT_IN_VAL_COMPARE_AND_SWAP_N + index + 1];
 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
 itype = TREE_TYPE (TREE_TYPE (cmpxchg));
-if (sync_compare_and_swap[TYPE_MODE (itype)] == CODE_FOR_nothing)
+if (direct_optab_handler (sync_compare_and_swap_optab, TYPE_MODE (itype))
+== CODE_FOR_nothing)
 return false;
 /* Load the initial value, replacing the GIMPLE_OMP_ATOMIC_LOAD.  */
 si = gsi_last_bb (load_bb);
 gcc_assert (gimple_code (gsi_stmt (si)) == GIMPLE_OMP_ATOMIC_LOAD);
 {
 iaddr = addr;
 loadedi = loaded_val;
 }
-initial = force_gimple_operand_gsi (&si, build_fold_indirect_ref (iaddr),
+initial
-				      true, NULL_TREE, true, GSI_SAME_STMT);
+= force_gimple_operand_gsi (&si,
+				build2 (MEM_REF, TREE_TYPE (TREE_TYPE (iaddr)),
+					iaddr,
+					build_int_cst (TREE_TYPE (iaddr), 0)),
+				true, NULL_TREE, true, GSI_SAME_STMT);
 /* Move the value to the LOADEDI temporary.  */
 if (gimple_in_ssa_p (cfun))
 {
 gcc_assert (gimple_seq_empty_p (phi_nodes (loop_header)));
 si = gsi_last_bb (load_bb);
 gcc_assert (gimple_code (gsi_stmt (si)) == GIMPLE_OMP_ATOMIC_LOAD);
 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_START];
-t = build_function_call_expr (UNKNOWN_LOCATION, t, 0);
+t = build_call_expr (t, 0);
 force_gimple_operand_gsi (&si, t, true, NULL_TREE, true, GSI_SAME_STMT);
-stmt = gimple_build_assign (loaded_val, build_fold_indirect_ref (addr));
+stmt = gimple_build_assign (loaded_val, build_simple_mem_ref (addr));
 gsi_insert_before (&si, stmt, GSI_SAME_STMT);
 gsi_remove (&si, true);
 si = gsi_last_bb (store_bb);
 gcc_assert (gimple_code (gsi_stmt (si)) == GIMPLE_OMP_ATOMIC_STORE);
-stmt = gimple_build_assign (build_fold_indirect_ref (unshare_expr (addr)),
+stmt = gimple_build_assign (build_simple_mem_ref (unshare_expr (addr)),
-				stored_val);
+			      stored_val);
 gsi_insert_before (&si, stmt, GSI_SAME_STMT);
 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_END];
-t = build_function_call_expr (UNKNOWN_LOCATION, t, 0);
+t = build_call_expr (t, 0);
 force_gimple_operand_gsi (&si, t, true, NULL_TREE, true, GSI_SAME_STMT);
 gsi_remove (&si, true);
 if (gimple_in_ssa_p (cfun))
 update_ssa (TODO_update_ssa_no_phi);
 /* OMP expansion -- the default pass, run before creation of SSA form.  */
 static bool
 gate_expand_omp (void)
 {
-return (flag_openmp != 0 && errorcount == 0);
+return (flag_openmp != 0 && !seen_error ());
 }
 struct gimple_opt_pass pass_expand_omp =
 {
 {
 tree decl;
 splay_tree_node n;
 if (!critical_name_mutexes)
 	critical_name_mutexes
-	  = splay_tree_new_ggc (splay_tree_compare_pointers);
+	  = splay_tree_new_ggc (splay_tree_compare_pointers,
+				ggc_alloc_splay_tree_tree_node_tree_node_splay_tree_s,
+				ggc_alloc_splay_tree_tree_node_tree_node_splay_tree_node_s);
 n = splay_tree_lookup (critical_name_mutexes, (splay_tree_key) name);
 if (n == NULL)
 	{
 	  char *new_str;
 gcc_assert (child_cfun->cfg == NULL);
 child_cfun->dont_save_pending_sizes_p = 1;
 DECL_SAVED_TREE (child_fn) = alloc_stmt_list ();
 /* Reset DECL_CONTEXT on function arguments.  */
-for (t = DECL_ARGUMENTS (child_fn); t; t = TREE_CHAIN (t))
+for (t = DECL_ARGUMENTS (child_fn); t; t = DECL_CHAIN (t))
 DECL_CONTEXT (t) = child_fn;
 /* Populate the function.  */
 push_gimplify_context (&gctx);
 current_function_decl = child_fn;
 DECL_SOURCE_LOCATION (child_fn) = gimple_location (task_stmt);
 /* Remap src and dst argument types if needed.  */
 record_type = ctx->record_type;
 srecord_type = ctx->srecord_type;
-for (f = TYPE_FIELDS (record_type); f ; f = TREE_CHAIN (f))
+for (f = TYPE_FIELDS (record_type); f ; f = DECL_CHAIN (f))
 if (variably_modified_type_p (TREE_TYPE (f), ctx->cb.src_fn))
 {
 	record_needs_remap = true;
 	break;
 }
-for (f = TYPE_FIELDS (srecord_type); f ; f = TREE_CHAIN (f))
+for (f = TYPE_FIELDS (srecord_type); f ; f = DECL_CHAIN (f))
 if (variably_modified_type_p (TREE_TYPE (f), ctx->cb.src_fn))
 {
 	srecord_needs_remap = true;
 	break;
 }
 push_cfun (child_cfun);
 arg = DECL_ARGUMENTS (child_fn);
 TREE_TYPE (arg) = build_pointer_type (record_type);
-sarg = TREE_CHAIN (arg);
+sarg = DECL_CHAIN (arg);
 TREE_TYPE (sarg) = build_pointer_type (srecord_type);
 /* First pass: initialize temporaries used in record_type and srecord_type
 sizes and field offsets.  */
 if (tcctx.cb.decl_map)
 	  if (p == NULL)
 	    continue;
 	  n = splay_tree_lookup (ctx->sfield_map, (splay_tree_key) decl);
 	  sf = (tree) n->value;
 	  sf = *(tree *) pointer_map_contains (tcctx.cb.decl_map, sf);
-	  src = build_fold_indirect_ref_loc (loc, sarg);
+	  src = build_simple_mem_ref_loc (loc, sarg);
 	  src = build3 (COMPONENT_REF, TREE_TYPE (sf), src, sf, NULL);
 	  t = build2 (MODIFY_EXPR, TREE_TYPE (*p), *p, src);
 	  append_to_statement_list (t, &list);
 	}
 	  f = *(tree *) pointer_map_contains (tcctx.cb.decl_map, f);
 	n = splay_tree_lookup (ctx->sfield_map, (splay_tree_key) decl);
 	sf = (tree) n->value;
 	if (tcctx.cb.decl_map)
 	  sf = *(tree *) pointer_map_contains (tcctx.cb.decl_map, sf);
-	src = build_fold_indirect_ref_loc (loc, sarg);
+	src = build_simple_mem_ref_loc (loc, sarg);
 	src = build3 (COMPONENT_REF, TREE_TYPE (sf), src, sf, NULL);
-	dst = build_fold_indirect_ref_loc (loc, arg);
+	dst = build_simple_mem_ref_loc (loc, arg);
 	dst = build3 (COMPONENT_REF, TREE_TYPE (f), dst, f, NULL);
 	t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
 	append_to_statement_list (t, &list);
 	break;
 case OMP_CLAUSE_FIRSTPRIVATE:
 	if (n != NULL)
 	  {
 	    sf = (tree) n->value;
 	    if (tcctx.cb.decl_map)
 	      sf = *(tree *) pointer_map_contains (tcctx.cb.decl_map, sf);
-	    src = build_fold_indirect_ref_loc (loc, sarg);
+	    src = build_simple_mem_ref_loc (loc, sarg);
 	    src = build3 (COMPONENT_REF, TREE_TYPE (sf), src, sf, NULL);
 	    if (use_pointer_for_field (decl, NULL) || is_reference (decl))
-	      src = build_fold_indirect_ref_loc (loc, src);
+	      src = build_simple_mem_ref_loc (loc, src);
 	  }
 	else
 	  src = decl;
-	dst = build_fold_indirect_ref_loc (loc, arg);
+	dst = build_simple_mem_ref_loc (loc, arg);
 	dst = build3 (COMPONENT_REF, TREE_TYPE (f), dst, f, NULL);
 	t = lang_hooks.decls.omp_clause_copy_ctor (c, dst, src);
 	append_to_statement_list (t, &list);
 	break;
 case OMP_CLAUSE_PRIVATE:
 	if (n != NULL)
 	  {
 	    sf = (tree) n->value;
 	    if (tcctx.cb.decl_map)
 	      sf = *(tree *) pointer_map_contains (tcctx.cb.decl_map, sf);
-	    src = build_fold_indirect_ref_loc (loc, sarg);
+	    src = build_simple_mem_ref_loc (loc, sarg);
 	    src = build3 (COMPONENT_REF, TREE_TYPE (sf), src, sf, NULL);
 	    if (use_pointer_for_field (decl, NULL))
-	      src = build_fold_indirect_ref_loc (loc, src);
+	      src = build_simple_mem_ref_loc (loc, src);
 	  }
 	else
 	  src = decl;
-	dst = build_fold_indirect_ref_loc (loc, arg);
+	dst = build_simple_mem_ref_loc (loc, arg);
 	dst = build3 (COMPONENT_REF, TREE_TYPE (f), dst, f, NULL);
 	t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
 	append_to_statement_list (t, &list);
 	break;
 default:
 	  gcc_assert (DECL_P (TREE_OPERAND (ind, 0)));
 	  n = splay_tree_lookup (ctx->sfield_map,
 				 (splay_tree_key) TREE_OPERAND (ind, 0));
 	  sf = (tree) n->value;
 	  sf = *(tree *) pointer_map_contains (tcctx.cb.decl_map, sf);
-	  src = build_fold_indirect_ref_loc (loc, sarg);
+	  src = build_simple_mem_ref_loc (loc, sarg);
 	  src = build3 (COMPONENT_REF, TREE_TYPE (sf), src, sf, NULL);
-	  src = build_fold_indirect_ref_loc (loc, src);
+	  src = build_simple_mem_ref_loc (loc, src);
-	  dst = build_fold_indirect_ref_loc (loc, arg);
+	  dst = build_simple_mem_ref_loc (loc, arg);
 	  dst = build3 (COMPONENT_REF, TREE_TYPE (f), dst, f, NULL);
 	  t = lang_hooks.decls.omp_clause_copy_ctor (c, dst, src);
 	  append_to_statement_list (t, &list);
 	  n = splay_tree_lookup (ctx->field_map,
 				 (splay_tree_key) TREE_OPERAND (ind, 0));
 	  df = (tree) n->value;
 	  df = *(tree *) pointer_map_contains (tcctx.cb.decl_map, df);
-	  ptr = build_fold_indirect_ref_loc (loc, arg);
+	  ptr = build_simple_mem_ref_loc (loc, arg);
 	  ptr = build3 (COMPONENT_REF, TREE_TYPE (df), ptr, df, NULL);
 	  t = build2 (MODIFY_EXPR, TREE_TYPE (ptr), ptr,
 		      build_fold_addr_expr_loc (loc, dst));
 	  append_to_statement_list (t, &list);
 	}
 if (ctx->record_type)
 {
 ctx->sender_decl
 	= create_tmp_var (ctx->srecord_type ? ctx->srecord_type
 			  : ctx->record_type, ".omp_data_o");
+DECL_NAMELESS (ctx->sender_decl) = 1;
 TREE_ADDRESSABLE (ctx->sender_decl) = 1;
 gimple_omp_taskreg_set_data_arg (stmt, ctx->sender_decl);
 }
 olist = NULL;
 memset (&wi, '\0', sizeof (wi));
 /* If we have issued syntax errors, avoid doing any heavy lifting.
 Just replace the OpenMP directives with a NOP to avoid
 confusing RTL expansion.  */
-if (errorcount && is_gimple_omp (stmt))
+if (seen_error () && is_gimple_omp (stmt))
 {
 gsi_replace (gsi_p, gimple_build_nop (), true);
 return;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/omp-low.c @ 67:f6334be47118