CbC/CbC_gcc: gcc/tree-nested.c comparison

comparison gcc/tree-nested.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 "tree-inline.h"
 #include "gimple.h"
 #include "tree-iterator.h"
 #include "tree-flow.h"
 #include "cgraph.h"
-#include "expr.h"
+#include "expr.h"	/* FIXME: For STACK_SAVEAREA_MODE and SAVE_NONLOCAL.  */
 #include "langhooks.h"
 #include "pointer-set.h"
 /* The object of this pass is to lower the representation of a set of nested
 struct nesting_info *inner;
 struct nesting_info *next;
 struct pointer_map_t *field_map;
 struct pointer_map_t *var_map;
+struct pointer_set_t *mem_refs;
 bitmap suppress_expansion;
 tree context;
 tree new_local_var_chain;
 tree debug_var_chain;
 gcc_assert (!TYPE_SIZE_UNIT (type)
 	      || TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
 tmp_var = create_tmp_var_raw (type, prefix);
 DECL_CONTEXT (tmp_var) = info->context;
-TREE_CHAIN (tmp_var) = info->new_local_var_chain;
+DECL_CHAIN (tmp_var) = info->new_local_var_chain;
 DECL_SEEN_IN_BIND_EXPR_P (tmp_var) = 1;
 if (TREE_CODE (type) == COMPLEX_TYPE
 || TREE_CODE (type) == VECTOR_TYPE)
 DECL_GIMPLE_REG_P (tmp_var) = 1;
 Temporarily set CURRENT_FUNCTION_DECL to the desired context,
 build the ADDR_EXPR, then restore CURRENT_FUNCTION_DECL.  That
 way the properties are for the ADDR_EXPR are computed properly.  */
 save_context = current_function_decl;
 current_function_decl = context;
-retval = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
+retval = build_fold_addr_expr (exp);
 current_function_decl = save_context;
 return retval;
 }
 /* Insert FIELD into TYPE, sorted by alignment requirements.  */
 {
 tree *p;
 DECL_CONTEXT (field) = type;
-for (p = &TYPE_FIELDS (type); *p ; p = &TREE_CHAIN (*p))
+for (p = &TYPE_FIELDS (type); *p ; p = &DECL_CHAIN (*p))
 if (DECL_ALIGN (field) >= DECL_ALIGN (*p))
 break;
-TREE_CHAIN (field) = *p;
+DECL_CHAIN (field) = *p;
 *p = field;
 /* Set correct alignment for frame struct type.  */
 if (TYPE_ALIGN (type) < DECL_ALIGN (field))
 TYPE_ALIGN (type) = DECL_ALIGN (field);
 struct cgraph_node *cgn = cgraph_node (fndecl);
 tree arg;
 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 {
-for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = TREE_CHAIN (arg))
+for (arg = DECL_ARGUMENTS (cgn->decl); arg; arg = DECL_CHAIN (arg))
 	if (variably_modified_type_p (TREE_TYPE (arg), orig_fndecl))
 	  return true;
 if (check_for_nested_with_variably_modified (cgn->decl, orig_fndecl))
 	return true;
 create_nesting_tree (struct cgraph_node *cgn)
 {
 struct nesting_info *info = XCNEW (struct nesting_info);
 info->field_map = pointer_map_create ();
 info->var_map = pointer_map_create ();
+info->mem_refs = pointer_set_create ();
 info->suppress_expansion = BITMAP_ALLOC (&nesting_info_bitmap_obstack);
 info->context = cgn->decl;
 for (cgn = cgn->nested; cgn ; cgn = cgn->next_nested)
 {
 for (i = info->outer; i->context != target_context; i = i->outer)
 	{
 	  tree field = get_chain_field (i);
-	  x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
+	  x = build_simple_mem_ref (x);
 	  x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 	  x = init_tmp_var (info, x, gsi);
 	}
 }
 for (i = info->outer; i->context != target_context; i = i->outer)
 	{
 	  tree field = get_chain_field (i);
-	  x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
+	  x = build_simple_mem_ref (x);
 	  x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 	  x = init_tmp_var (info, x, gsi);
 	}
-x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
+x = build_simple_mem_ref (x);
 }
 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 return x;
 }
 {
 x = get_chain_decl (info);
 for (i = info->outer; i->context != target_context; i = i->outer)
 	{
 	  field = get_chain_field (i);
-	  x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
+	  x = build_simple_mem_ref (x);
 	  x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 	}
-x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
+x = build_simple_mem_ref (x);
 }
 field = lookup_field_for_decl (i, decl, INSERT);
 x = build3 (COMPONENT_REF, TREE_TYPE (field), x, field, NULL_TREE);
 if (use_pointer_in_frame (decl))
-x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
+x = build_simple_mem_ref (x);
 /* ??? We should be remapping types as well, surely.  */
 new_decl = build_decl (DECL_SOURCE_LOCATION (decl),
 			 VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
 DECL_CONTEXT (new_decl) = info->context;
 SET_DECL_VALUE_EXPR (new_decl, x);
 DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
 *slot = new_decl;
-TREE_CHAIN (new_decl) = info->debug_var_chain;
+DECL_CHAIN (new_decl) = info->debug_var_chain;
 info->debug_var_chain = new_decl;
 if (!optimize
 && info->context != target_context
 && variably_modified_type_p (TREE_TYPE (decl), NULL))
 	      x = lookup_field_for_decl (i, t, INSERT);
 	      x = get_frame_field (info, target_context, x, &wi->gsi);
 	      if (use_pointer_in_frame (t))
 		{
 		  x = init_tmp_var (info, x, &wi->gsi);
-		  x = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (x)), x);
+		  x = build_simple_mem_ref (x);
 		}
 	    }
 	  if (wi->val_only)
 	    {
 static void
 note_nonlocal_block_vlas (struct nesting_info *info, tree block)
 {
 tree var;
-for (var = BLOCK_VARS (block); var; var = TREE_CHAIN (var))
+for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
 if (TREE_CODE (var) == VAR_DECL
 	&& variably_modified_type_p (TREE_TYPE (var), NULL)
 	&& DECL_HAS_VALUE_EXPR_P (var)
 	&& decl_function_context (var) != info->context)
 note_nonlocal_vla_type (info, TREE_TYPE (var));
 SET_DECL_VALUE_EXPR (new_decl, x);
 DECL_HAS_VALUE_EXPR_P (new_decl) = 1;
 *slot = new_decl;
-TREE_CHAIN (new_decl) = info->debug_var_chain;
+DECL_CHAIN (new_decl) = info->debug_var_chain;
 info->debug_var_chain = new_decl;
 /* Do not emit debug info twice.  */
 DECL_IGNORED_P (decl) = 1;
 wi->val_only = false;
 walk_tree (tp, convert_local_reference_op, wi, NULL);
 wi->val_only = save_val_only;
 break;
+case MEM_REF:
+save_val_only = wi->val_only;
+wi->val_only = true;
+wi->is_lhs = false;
+walk_tree (&TREE_OPERAND (t, 0), convert_local_reference_op,
+		 wi, NULL);
+/* We need to re-fold the MEM_REF as component references as
+	 part of a ADDR_EXPR address are not allowed.  But we cannot
+	 fold here, as the chain record type is not yet finalized.  */
+if (TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR
+	  && !DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0)))
+	pointer_set_insert (info->mem_refs, tp);
+wi->val_only = save_val_only;
+break;
 case VIEW_CONVERT_EXPR:
 /* Just request to look at the subtrees, leaving val_only and lhs
 	 untouched.  This might actually be for !val_only + lhs, in which
 	 case we don't want to force a replacement by a temporary.  */
 *walk_subtrees = 1;
 actually uses its static chain; if not, remember that.  */
 static void
 convert_all_function_calls (struct nesting_info *root)
 {
+unsigned int chain_count = 0, old_chain_count, iter_count;
 struct nesting_info *n;
-int iter_count;
-bool any_changed;
 /* First, optimistically clear static_chain for all decls that haven't
 used the static chain already for variable access.  */
 FOR_EACH_NEST_INFO (n, root)
 {
 	    fprintf (dump_file, "Guessing no static-chain for %s\n",
 		     lang_hooks.decl_printable_name (decl, 2));
 	}
 else
 	DECL_STATIC_CHAIN (decl) = 1;
+chain_count += DECL_STATIC_CHAIN (decl);
 }
 /* Walk the functions and perform transformations.  Note that these
 transformations can induce new uses of the static chain, which in turn
 require re-examining all users of the decl.  */
 would still need to iterate in this loop since address-of references
 wouldn't show up in the callgraph anyway.  */
 iter_count = 0;
 do
 {
-any_changed = false;
+old_chain_count = chain_count;
+chain_count = 0;
 iter_count++;
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fputc ('\n', dump_file);
 FOR_EACH_NEST_INFO (n, root)
 	{
 	  tree decl = n->context;
-	  bool old_static_chain = DECL_STATIC_CHAIN (decl);
 	  walk_function (convert_tramp_reference_stmt,
 			 convert_tramp_reference_op, n);
 	  walk_function (convert_gimple_call, NULL, n);
+	  chain_count += DECL_STATIC_CHAIN (decl);
-	  /* If a call to another function created the use of a chain
-	     within this function, we'll have to continue iteration.  */
-	  if (!old_static_chain && DECL_STATIC_CHAIN (decl))
-	    any_changed = true;
 	}
 }
-while (any_changed);
+while (chain_count != old_chain_count);
 if (dump_file && (dump_flags & TDF_DETAILS))
-fprintf (dump_file, "convert_all_function_calls iterations: %d\n\n",
+fprintf (dump_file, "convert_all_function_calls iterations: %u\n\n",
 	     iter_count);
 }
 struct nesting_copy_body_data
 {
 for (subblock = BLOCK_SUBBLOCKS (block);
 subblock;
 subblock = BLOCK_CHAIN (subblock))
 remap_vla_decls (subblock, root);
-for (var = BLOCK_VARS (block); var; var = TREE_CHAIN (var))
+for (var = BLOCK_VARS (block); var; var = DECL_CHAIN (var))
-{
+if (TREE_CODE (var) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (var))
-if (TREE_CODE (var) == VAR_DECL
+{
-	  && variably_modified_type_p (TREE_TYPE (var), NULL)
+	val = DECL_VALUE_EXPR (var);
-	  && DECL_HAS_VALUE_EXPR_P (var))
+	type = TREE_TYPE (var);
-	{
-	  type = TREE_TYPE (var);
+	if (!(TREE_CODE (val) == INDIRECT_REF
-	  val = DECL_VALUE_EXPR (var);
+	      && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
-	  if (walk_tree (&type, contains_remapped_vars, root, NULL) != NULL
+	      && variably_modified_type_p (type, NULL)))
-	      ||  walk_tree (&val, contains_remapped_vars, root, NULL) != NULL)
+	  continue;
-	    break;
-	}
+	if (pointer_map_contains (root->var_map, TREE_OPERAND (val, 0))
-}
+	    || walk_tree (&type, contains_remapped_vars, root, NULL))
+	  break;
+}
 if (var == NULL_TREE)
 return;
 memset (&id, 0, sizeof (id));
 id.cb.copy_decl = nesting_copy_decl;
 id.cb.decl_map = pointer_map_create ();
 id.root = root;
-for (; var; var = TREE_CHAIN (var))
+for (; var; var = DECL_CHAIN (var))
-if (TREE_CODE (var) == VAR_DECL
+if (TREE_CODE (var) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (var))
-	&& variably_modified_type_p (TREE_TYPE (var), NULL)
-	&& DECL_HAS_VALUE_EXPR_P (var))
 {
 	struct nesting_info *i;
-	tree newt, t, context;
+	tree newt, context;
+	void **slot;
-	t = type = TREE_TYPE (var);
 	val = DECL_VALUE_EXPR (var);
-	if (walk_tree (&type, contains_remapped_vars, root, NULL) == NULL
+	type = TREE_TYPE (var);
-	    && walk_tree (&val, contains_remapped_vars, root, NULL) == NULL)
+	if (!(TREE_CODE (val) == INDIRECT_REF
+	      && TREE_CODE (TREE_OPERAND (val, 0)) == VAR_DECL
+	      && variably_modified_type_p (type, NULL)))
+	  continue;
+	slot = pointer_map_contains (root->var_map, TREE_OPERAND (val, 0));
+	if (!slot && !walk_tree (&type, contains_remapped_vars, root, NULL))
 	  continue;
 	context = decl_function_context (var);
 	for (i = root; i; i = i->outer)
 	  if (i->context == context)
 	    break;
 	if (i == NULL)
 	  continue;
+	/* Fully expand value expressions.  This avoids having debug variables
+	   only referenced from them and that can be swept during GC.  */
+if (slot)
+	  {
+	    tree t = (tree) *slot;
+	    gcc_assert (DECL_P (t) && DECL_HAS_VALUE_EXPR_P (t));
+	    val = build1 (INDIRECT_REF, TREE_TYPE (val), DECL_VALUE_EXPR (t));
+	  }
 	id.cb.src_fn = i->context;
 	id.cb.dst_fn = i->context;
 	id.cb.src_cfun = DECL_STRUCT_FUNCTION (root->context);
 	TREE_TYPE (var) = newt = remap_type (type, &id.cb);
 	while (POINTER_TYPE_P (newt) && !TYPE_NAME (newt))
 	  {
 	    newt = TREE_TYPE (newt);
-	    t = TREE_TYPE (t);
+	    type = TREE_TYPE (type);
 	  }
 	if (TYPE_NAME (newt)
 	    && TREE_CODE (TYPE_NAME (newt)) == TYPE_DECL
 	    && DECL_ORIGINAL_TYPE (TYPE_NAME (newt))
-	    && newt != t
+	    && newt != type
-	    && TYPE_NAME (newt) == TYPE_NAME (t))
+	    && TYPE_NAME (newt) == TYPE_NAME (type))
 	  TYPE_NAME (newt) = remap_decl (TYPE_NAME (newt), &id.cb);
 	walk_tree (&val, copy_tree_body_r, &id.cb, NULL);
 	if (val != DECL_VALUE_EXPR (var))
 	  SET_DECL_VALUE_EXPR (var, val);
 }
 pointer_map_destroy (id.cb.decl_map);
+}
+/* Fold the MEM_REF *E.  */
+static bool
+fold_mem_refs (const void *e, void *data ATTRIBUTE_UNUSED)
+{
+tree *ref_p = CONST_CAST2(tree *, const tree *, (const tree *)e);
+*ref_p = fold (*ref_p);
+return true;
 }
 /* Do "everything else" to clean up or complete state collected by the
 various walking passes -- lay out the types and decls, generate code
 to initialize the frame decl, store critical expressions in the
 	 that we can declare it also in the lexical blocks, which
 	 helps ensure virtual regs that end up appearing in its RTL
 	 expression get substituted in instantiate_virtual_regs().  */
 for (adjust = &root->new_local_var_chain;
 	   *adjust != root->frame_decl;
-	   adjust = &TREE_CHAIN (*adjust))
+	   adjust = &DECL_CHAIN (*adjust))
-	gcc_assert (TREE_CHAIN (*adjust));
+	gcc_assert (DECL_CHAIN (*adjust));
-*adjust = TREE_CHAIN (*adjust);
+*adjust = DECL_CHAIN (*adjust);
-TREE_CHAIN (root->frame_decl) = NULL_TREE;
+DECL_CHAIN (root->frame_decl) = NULL_TREE;
 declare_vars (root->frame_decl,
 		    gimple_seq_first_stmt (gimple_body (context)), true);
 }
 /* If any parameters were referenced non-locally, then we need to
 insert a copy.  Likewise, if any variables were referenced by
 pointer, we need to initialize the address.  */
 if (root->any_parm_remapped)
 {
 tree p;
-for (p = DECL_ARGUMENTS (context); p ; p = TREE_CHAIN (p))
+for (p = DECL_ARGUMENTS (context); p ; p = DECL_CHAIN (p))
 	{
 	  tree field, x, y;
 	  field = lookup_field_for_decl (root, p, NO_INSERT);
 	  if (!field)
 gimple scope;
 remap_vla_decls (DECL_INITIAL (root->context), root);
 for (debug_var = root->debug_var_chain; debug_var;
-	   debug_var = TREE_CHAIN (debug_var))
+	   debug_var = DECL_CHAIN (debug_var))
 	if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
 	  break;
 /* If there are any debug decls with variable length types,
 	 remap those types using other debug_var_chain variables.  */
 	  memset (&id, 0, sizeof (id));
 	  id.cb.copy_decl = nesting_copy_decl;
 	  id.cb.decl_map = pointer_map_create ();
 	  id.root = root;
-	  for (; debug_var; debug_var = TREE_CHAIN (debug_var))
+	  for (; debug_var; debug_var = DECL_CHAIN (debug_var))
 	    if (variably_modified_type_p (TREE_TYPE (debug_var), NULL))
 	      {
 		tree type = TREE_TYPE (debug_var);
 		tree newt, t = type;
 		struct nesting_info *i;
 	BLOCK_VARS (DECL_INITIAL (root->context))
 	  = chainon (BLOCK_VARS (DECL_INITIAL (root->context)),
 		     root->debug_var_chain);
 }
+/* Fold the rewritten MEM_REF trees.  */
+pointer_set_traverse (root->mem_refs, fold_mem_refs, NULL);
 /* Dump the translated tree function.  */
 if (dump_file)
 {
 fputs ("\n\n", dump_file);
 dump_function_to_file (root->context, dump_file, dump_flags);
 do
 {
 next = iter_nestinfo_next (node);
 pointer_map_destroy (node->var_map);
 pointer_map_destroy (node->field_map);
+pointer_set_destroy (node->mem_refs);
 free (node);
 node = next;
 }
 while (node);
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-nested.c @ 67:f6334be47118