CbC/CbC_gcc: gcc/tree-ssa-pre.c comparison

comparison gcc/tree-ssa-pre.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 "system.h"
 #include "coretypes.h"
 #include "tm.h"
 #include "tree.h"
 #include "basic-block.h"
-#include "diagnostic.h"
 #include "tree-pretty-print.h"
 #include "gimple-pretty-print.h"
 #include "tree-inline.h"
 #include "tree-flow.h"
 #include "gimple.h"
 /* An unordered bitmap set.  One bitmap tracks values, the other,
 expressions.  */
 typedef struct bitmap_set
 {
-bitmap expressions;
+bitmap_head expressions;
-bitmap values;
+bitmap_head values;
 } *bitmap_set_t;
 #define FOR_EACH_EXPR_ID_IN_SET(set, id, bi)		\
-EXECUTE_IF_SET_IN_BITMAP((set)->expressions, 0, (id), (bi))
+EXECUTE_IF_SET_IN_BITMAP(&(set)->expressions, 0, (id), (bi))
 #define FOR_EACH_VALUE_ID_IN_SET(set, id, bi)		\
-EXECUTE_IF_SET_IN_BITMAP((set)->values, 0, (id), (bi))
+EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi))
 /* Mapping from value id to expressions with that value_id.  */
 DEF_VEC_P (bitmap_set_t);
 DEF_VEC_ALLOC_P (bitmap_set_t, heap);
 static VEC(bitmap_set_t, heap) *value_expressions;
 match the current variable's type.  */
 static tree pretemp;
 static tree storetemp;
 static tree prephitemp;
-/* Set of blocks with statements that have had its EH information
+/* Set of blocks with statements that have had their EH properties changed.  */
-cleaned up.  */
 static bitmap need_eh_cleanup;
+/* Set of blocks with statements that have had their AB properties changed.  */
+static bitmap need_ab_cleanup;
 /* The phi_translate_table caches phi translations for a given
 expression and predecessor.  */
 static htab_t phi_translate_table;
 static bitmap_set_t
 bitmap_set_new (void)
 {
 bitmap_set_t ret = (bitmap_set_t) pool_alloc (bitmap_set_pool);
-ret->expressions = BITMAP_ALLOC (&grand_bitmap_obstack);
+bitmap_initialize (&ret->expressions, &grand_bitmap_obstack);
-ret->values = BITMAP_ALLOC (&grand_bitmap_obstack);
+bitmap_initialize (&ret->values, &grand_bitmap_obstack);
 return ret;
 }
 /* Return the value id for a PRE expression EXPR.  */
 bitmap_remove_from_set (bitmap_set_t set, pre_expr expr)
 {
 unsigned int val  = get_expr_value_id (expr);
 if (!value_id_constant_p (val))
 {
-bitmap_clear_bit (set->values, val);
+bitmap_clear_bit (&set->values, val);
-bitmap_clear_bit (set->expressions, get_expression_id (expr));
+bitmap_clear_bit (&set->expressions, get_expression_id (expr));
 }
 }
 static void
 bitmap_insert_into_set_1 (bitmap_set_t set, pre_expr expr,
 {
 if (allow_constants || !value_id_constant_p (val))
 {
 /* We specifically expect this and only this function to be able to
 	 insert constants into a set.  */
-bitmap_set_bit (set->values, val);
+bitmap_set_bit (&set->values, val);
-bitmap_set_bit (set->expressions, get_or_alloc_expression_id (expr));
+bitmap_set_bit (&set->expressions, get_or_alloc_expression_id (expr));
 }
 }
 /* Insert an expression EXPR into a bitmapped set.  */
 /* Copy a bitmapped set ORIG, into bitmapped set DEST.  */
 static void
 bitmap_set_copy (bitmap_set_t dest, bitmap_set_t orig)
 {
-bitmap_copy (dest->expressions, orig->expressions);
+bitmap_copy (&dest->expressions, &orig->expressions);
-bitmap_copy (dest->values, orig->values);
+bitmap_copy (&dest->values, &orig->values);
 }
 /* Free memory used up by SET.  */
 static void
 bitmap_set_free (bitmap_set_t set)
 {
-BITMAP_FREE (set->expressions);
+bitmap_clear (&set->expressions);
-BITMAP_FREE (set->values);
+bitmap_clear (&set->values);
 }
 /* Generate an topological-ordered array of bitmap set SET.  */
 unsigned int i, j;
 bitmap_iterator bi, bj;
 VEC(pre_expr, heap) *result;
 /* Pre-allocate roughly enough space for the array.  */
-result = VEC_alloc (pre_expr, heap, bitmap_count_bits (set->values));
+result = VEC_alloc (pre_expr, heap, bitmap_count_bits (&set->values));
 FOR_EACH_VALUE_ID_IN_SET (set, i, bi)
 {
 /* The number of expressions having a given value is usually
 	 relatively small.  Thus, rather than making a vector of all
 	 If this is somehow a significant lose for some cases, we can
 	 choose which set to walk based on the set size.  */
 bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, i);
 FOR_EACH_EXPR_ID_IN_SET (exprset, j, bj)
 	{
-	  if (bitmap_bit_p (set->expressions, j))
+	  if (bitmap_bit_p (&set->expressions, j))
 	    VEC_safe_push (pre_expr, heap, result, expression_for_id (j));
 }
 }
 return result;
 bitmap_iterator bi;
 unsigned int i;
 if (dest != orig)
 {
-bitmap temp = BITMAP_ALLOC (&grand_bitmap_obstack);
+bitmap_head temp;
+bitmap_initialize (&temp, &grand_bitmap_obstack);
-bitmap_and_into (dest->values, orig->values);
-bitmap_copy (temp, dest->expressions);
+bitmap_and_into (&dest->values, &orig->values);
-EXECUTE_IF_SET_IN_BITMAP (temp, 0, i, bi)
+bitmap_copy (&temp, &dest->expressions);
+EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
 	{
 	  pre_expr expr = expression_for_id (i);
 	  unsigned int value_id = get_expr_value_id (expr);
-	  if (!bitmap_bit_p (dest->values, value_id))
+	  if (!bitmap_bit_p (&dest->values, value_id))
-	    bitmap_clear_bit (dest->expressions, i);
+	    bitmap_clear_bit (&dest->expressions, i);
 	}
-BITMAP_FREE (temp);
+bitmap_clear (&temp);
 }
 }
 /* Subtract all values and expressions contained in ORIG from DEST.  */
 {
 bitmap_set_t result = bitmap_set_new ();
 bitmap_iterator bi;
 unsigned int i;
-bitmap_and_compl (result->expressions, dest->expressions,
+bitmap_and_compl (&result->expressions, &dest->expressions,
-		    orig->expressions);
+		    &orig->expressions);
 FOR_EACH_EXPR_ID_IN_SET (result, i, bi)
 {
 pre_expr expr = expression_for_id (i);
 unsigned int value_id = get_expr_value_id (expr);
-bitmap_set_bit (result->values, value_id);
+bitmap_set_bit (&result->values, value_id);
 }
 return result;
 }
 static void
 bitmap_set_subtract_values (bitmap_set_t a, bitmap_set_t b)
 {
 unsigned int i;
 bitmap_iterator bi;
-bitmap temp = BITMAP_ALLOC (&grand_bitmap_obstack);
+bitmap_head temp;
-bitmap_copy (temp, a->expressions);
+bitmap_initialize (&temp, &grand_bitmap_obstack);
-EXECUTE_IF_SET_IN_BITMAP (temp, 0, i, bi)
+bitmap_copy (&temp, &a->expressions);
+EXECUTE_IF_SET_IN_BITMAP (&temp, 0, i, bi)
 {
 pre_expr expr = expression_for_id (i);
 if (bitmap_set_contains_value (b, get_expr_value_id (expr)))
 	bitmap_remove_from_set (a, expr);
 }
-BITMAP_FREE (temp);
+bitmap_clear (&temp);
 }
 /* Return true if bitmapped set SET contains the value VALUE_ID.  */
 bitmap_set_contains_value (bitmap_set_t set, unsigned int value_id)
 {
 if (value_id_constant_p (value_id))
 return true;
-if (!set || bitmap_empty_p (set->expressions))
+if (!set || bitmap_empty_p (&set->expressions))
 return false;
-return bitmap_bit_p (set->values, value_id);
+return bitmap_bit_p (&set->values, value_id);
 }
 static inline bool
 bitmap_set_contains_expr (bitmap_set_t set, const pre_expr expr)
 {
-return bitmap_bit_p (set->expressions, get_expression_id (expr));
+return bitmap_bit_p (&set->expressions, get_expression_id (expr));
 }
 /* Replace an instance of value LOOKFOR with expression EXPR in SET.  */
 static void
 significant lose for some cases, we can choose which set to walk
 based on the set size.  */
 exprset = VEC_index (bitmap_set_t, value_expressions, lookfor);
 FOR_EACH_EXPR_ID_IN_SET (exprset, i, bi)
 {
-if (bitmap_bit_p (set->expressions, i))
+if (bitmap_clear_bit (&set->expressions, i))
 	{
-	  bitmap_clear_bit (set->expressions, i);
+	  bitmap_set_bit (&set->expressions, get_expression_id (expr));
-	  bitmap_set_bit (set->expressions, get_expression_id (expr));
 	  return;
 	}
 }
 }
 /* Return true if two bitmap sets are equal.  */
 static bool
 bitmap_set_equal (bitmap_set_t a, bitmap_set_t b)
 {
-return bitmap_equal_p (a->values, b->values);
+return bitmap_equal_p (&a->values, &b->values);
 }
 /* Replace an instance of EXPR's VALUE with EXPR in SET if it exists,
 and add it otherwise.  */
 static void
 bitmap_value_insert_into_set (bitmap_set_t set, pre_expr expr)
 {
 unsigned int val = get_expr_value_id (expr);
-#ifdef ENABLE_CHECKING
+gcc_checking_assert (expr->id == get_or_alloc_expression_id (expr));
-gcc_assert (expr->id == get_or_alloc_expression_id (expr));
-#endif
 /* Constant values are always considered to be part of the set.  */
 if (value_id_constant_p (val))
 return;
 /* If the value membership changed, add the expression.  */
-if (bitmap_set_bit (set->values, val))
+if (bitmap_set_bit (&set->values, val))
-bitmap_set_bit (set->expressions, expr->id);
+bitmap_set_bit (&set->expressions, expr->id);
 }
 /* Print out EXPR to outfile.  */
 static void
 }
 }
 void debug_pre_expr (pre_expr);
 /* Like print_pre_expr but always prints to stderr.  */
-void
+DEBUG_FUNCTION void
 debug_pre_expr (pre_expr e)
 {
 print_pre_expr (stderr, e);
 fprintf (stderr, "\n");
 }
 fprintf (outfile, " }\n");
 }
 void debug_bitmap_set (bitmap_set_t);
-void
+DEBUG_FUNCTION void
 debug_bitmap_set (bitmap_set_t set)
 {
 print_bitmap_set (stderr, set, "debug", 0);
 }
 print_bitmap_set (outfile, set, s, 0);
 }
 }
-void
+DEBUG_FUNCTION void
 debug_value_expressions (unsigned int val)
 {
 print_value_expressions (stderr, val);
 }
 	      newop.opcode = TREE_CODE (op0);
 	    newop.type = type;
 	    newop.op0 = op0;
 	    newop.op1 = op1;
 	    newop.op2 = op2;
+	    /* If it transforms a non-constant ARRAY_REF into a constant
+	       one, adjust the constant offset.  */
+	    if (newop.opcode == ARRAY_REF
+		&& newop.off == -1
+		&& TREE_CODE (op0) == INTEGER_CST
+		&& TREE_CODE (op1) == INTEGER_CST
+		&& TREE_CODE (op2) == INTEGER_CST)
+	      {
+		double_int off = tree_to_double_int (op0);
+		off = double_int_add (off,
+				      double_int_neg
+				        (tree_to_double_int (op1)));
+		off = double_int_mul (off, tree_to_double_int (op2));
+		if (double_int_fits_in_shwi_p (off))
+		  newop.off = off.low;
+	      }
 	    VEC_replace (vn_reference_op_s, newoperands, j, &newop);
 	    /* If it transforms from an SSA_NAME to an address, fold with
 	       a preceding indirect reference.  */
 	    if (j > 0 && op0 && TREE_CODE (op0) == ADDR_EXPR
 		&& VEC_index (vn_reference_op_s,
-			      newoperands, j - 1)->opcode == INDIRECT_REF)
+			      newoperands, j - 1)->opcode == MEM_REF)
 	      vn_reference_fold_indirect (&newoperands, &j);
 	  }
 	if (i != VEC_length (vn_reference_op_s, operands))
 	  {
 	    if (newoperands)
 	if (changed || newvuse != vuse)
 	  {
 	    unsigned int new_val_id;
 	    pre_expr constant;
+	    bool converted = false;
 	    tree result = vn_reference_lookup_pieces (newvuse, ref->set,
 						      ref->type,
 						      newoperands,
-						      &newref, true);
+						      &newref, VN_WALK);
 	    if (result)
 	      VEC_free (vn_reference_op_s, heap, newoperands);
+	    if (result
+		&& !useless_type_conversion_p (ref->type, TREE_TYPE (result)))
+	      {
+		result = fold_build1 (VIEW_CONVERT_EXPR, ref->type, result);
+		converted = true;
+	      }
+	    else if (!result && newref
+		     && !useless_type_conversion_p (ref->type, newref->type))
+	      {
+		VEC_free (vn_reference_op_s, heap, newoperands);
+		return NULL;
+	      }
 	    if (result && is_gimple_min_invariant (result))
 	      {
 	        gcc_assert (!newoperands);
 	        return get_or_alloc_expr_for_constant (result);
 	    expr = (pre_expr) pool_alloc (pre_expr_pool);
 	    expr->kind = REFERENCE;
 	    expr->id = 0;
-	    if (newref)
+	    if (converted)
+	      {
+		vn_nary_op_t nary;
+		tree nresult;
+		gcc_assert (CONVERT_EXPR_P (result)
+			    || TREE_CODE (result) == VIEW_CONVERT_EXPR);
+		nresult = vn_nary_op_lookup_pieces (1, TREE_CODE (result),
+						    TREE_TYPE (result),
+						    TREE_OPERAND (result, 0),
+						    NULL_TREE, NULL_TREE,
+						    NULL_TREE,
+						    &nary);
+		if (nresult && is_gimple_min_invariant (nresult))
+		  return get_or_alloc_expr_for_constant (nresult);
+		expr->kind = NARY;
+		if (nary)
+		  {
+		    PRE_EXPR_NARY (expr) = nary;
+		    constant = fully_constant_expression (expr);
+		    if (constant != expr)
+		      return constant;
+		    new_val_id = nary->value_id;
+		    get_or_alloc_expression_id (expr);
+		  }
+		else
+		  {
+		    new_val_id = get_next_value_id ();
+		    VEC_safe_grow_cleared (bitmap_set_t, heap,
+					   value_expressions,
+					   get_max_value_id() + 1);
+		    nary = vn_nary_op_insert_pieces (1, TREE_CODE (result),
+						     TREE_TYPE (result),
+						     TREE_OPERAND (result, 0),
+						     NULL_TREE, NULL_TREE,
+						     NULL_TREE, NULL_TREE,
+						     new_val_id);
+		    PRE_EXPR_NARY (expr) = nary;
+		    constant = fully_constant_expression (expr);
+		    if (constant != expr)
+		      return constant;
+		    get_or_alloc_expression_id (expr);
+		  }
+	      }
+	    else if (newref)
 	      {
 		PRE_EXPR_REFERENCE (expr) = newref;
 		constant = fully_constant_expression (expr);
 		if (constant != expr)
 		  return constant;
 bitmap_set_copy (dest, set);
 return;
 }
 exprs = sorted_array_from_bitmap_set (set);
-for (i = 0; VEC_iterate (pre_expr, exprs, i, expr); i++)
+FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
 {
 pre_expr translated;
 translated = phi_translate (expr, set, NULL, pred, phiblock);
 if (!translated)
 	continue;
 	 choose which set to walk based on which set is smaller.  */
 unsigned int i;
 bitmap_iterator bi;
 bitmap_set_t exprset = VEC_index (bitmap_set_t, value_expressions, val);
-EXECUTE_IF_AND_IN_BITMAP (exprset->expressions,
+EXECUTE_IF_AND_IN_BITMAP (&exprset->expressions,
-				set->expressions, 0, i, bi)
+				&set->expressions, 0, i, bi)
 	{
 	  pre_expr val = expression_for_id (i);
 	  /* At the point where stmt is not null, there should always
 	     be an SSA_NAME first in the list of expressions.  */
 	  if (stmt)
 	    {
 	      gimple def_stmt = SSA_NAME_DEF_STMT (PRE_EXPR_NAME (val));
 	      if (gimple_code (def_stmt) != GIMPLE_PHI
 		  && gimple_bb (def_stmt) == gimple_bb (stmt)
-		  && gimple_uid (def_stmt) >= gimple_uid (stmt))
+		  /* PRE insertions are at the end of the basic-block
+		     and have UID 0.  */
+		  && (gimple_uid (def_stmt) == 0
+		      || gimple_uid (def_stmt) >= gimple_uid (stmt)))
 		continue;
 	    }
 	  return val;
 	}
 }
 {
 	vn_reference_t ref = PRE_EXPR_REFERENCE (expr);
 	vn_reference_op_t vro;
 	unsigned int i;
-	for (i = 0; VEC_iterate (vn_reference_op_s, ref->operands, i, vro); i++)
+	FOR_EACH_VEC_ELT (vn_reference_op_s, ref->operands, i, vro)
 	  {
 	    if (!vro_valid_in_sets (set1, set2, vro))
 	      return false;
 	  }
 	if (ref->vuse)
 {
 VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set1);
 pre_expr expr;
 int i;
-for (i = 0; VEC_iterate (pre_expr, exprs, i, expr); i++)
+FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
 {
 if (!valid_in_sets (set1, set2, expr, block))
 	bitmap_remove_from_set (set1, expr);
 }
 VEC_free (pre_expr, heap, exprs);
 {
 VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (set);
 pre_expr expr;
 int i;
-for (i = 0; VEC_iterate (pre_expr, exprs, i, expr); i++)
+FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
 {
 if (!valid_in_sets (set, NULL, expr, block))
 	bitmap_remove_from_set (set, expr);
 }
 VEC_free (pre_expr, heap, exprs);
 if (!gimple_seq_empty_p (phi_nodes (first)))
 	phi_translate_set (ANTIC_OUT, ANTIC_IN (first), block, first);
 else
 	bitmap_set_copy (ANTIC_OUT, ANTIC_IN (first));
-for (i = 0; VEC_iterate (basic_block, worklist, i, bprime); i++)
+FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
 	{
 	  if (!gimple_seq_empty_p (phi_nodes (bprime)))
 	    {
 	      bitmap_set_t tmp = bitmap_set_new ();
 	      phi_translate_set (tmp, ANTIC_IN (bprime), block, bprime);
 bitmap_value_insert_into_set (ANTIC_IN (block),
 				  expression_for_id (bii));
 clean (ANTIC_IN (block), block);
-/* !old->expressions can happen when we deferred a block.  */
+if (!bitmap_set_equal (old, ANTIC_IN (block)))
-if (!old->expressions || !bitmap_set_equal (old, ANTIC_IN (block)))
 {
 changed = true;
 SET_BIT (changed_blocks, block->index);
 FOR_EACH_EDGE (e, ei, block->preds)
 	SET_BIT (changed_blocks, e->src->index);
 /* If there are too many partially anticipatable values in the
 block, phi_translate_set can take an exponential time: stop
 before the translation starts.  */
 if (max_pa
 && single_succ_p (block)
-&& bitmap_count_bits (PA_IN (single_succ (block))->values) > max_pa)
+&& bitmap_count_bits (&PA_IN (single_succ (block))->values) > max_pa)
 goto maybe_dump_sets;
 old_PA_IN = PA_IN (block);
 PA_OUT = bitmap_set_new ();
 	    continue;
 	  VEC_quick_push (basic_block, worklist, e->dest);
 	}
 if (VEC_length (basic_block, worklist) > 0)
 	{
-	  for (i = 0; VEC_iterate (basic_block, worklist, i, bprime); i++)
+	  FOR_EACH_VEC_ELT (basic_block, worklist, i, bprime)
 	    {
 	      unsigned int i;
 	      bitmap_iterator bi;
 	      FOR_EACH_EXPR_ID_IN_SET (ANTIC_IN (bprime), i, bi)
 Then we subtract things from ANTIC_IN.  */
 PA_IN (block) = bitmap_set_subtract (PA_OUT, TMP_GEN (block));
 /* For partial antic, we want to put back in the phi results, since
 we will properly avoid making them partially antic over backedges.  */
-bitmap_ior_into (PA_IN (block)->values, PHI_GEN (block)->values);
+bitmap_ior_into (&PA_IN (block)->values, &PHI_GEN (block)->values);
-bitmap_ior_into (PA_IN (block)->expressions, PHI_GEN (block)->expressions);
+bitmap_ior_into (&PA_IN (block)->expressions, &PHI_GEN (block)->expressions);
 /* PA_IN[block] = PA_IN[block] - ANTIC_IN[block] */
 bitmap_set_subtract_values (PA_IN (block), ANTIC_IN (block));
 dependent_clean (PA_IN (block), ANTIC_IN (block), block);
 sbitmap_ones (changed_blocks);
 while (changed)
 {
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "Starting iteration %d\n", num_iterations);
+/* ???  We need to clear our PHI translation cache here as the
+ANTIC sets shrink and we restrict valid translations to
+	 those having operands with leaders in ANTIC.  Same below
+	 for PA ANTIC computation.  */
 num_iterations++;
 changed = false;
 for (i = n_basic_blocks - NUM_FIXED_BLOCKS - 1; i >= 0; i--)
 	{
 	  if (TEST_BIT (changed_blocks, postorder[i]))
 	      changed |= compute_antic_aux (block,
 					    TEST_BIT (has_abnormal_preds,
 						      block->index));
 	    }
 	}
-#ifdef ENABLE_CHECKING
 /* Theoretically possible, but *highly* unlikely.  */
-gcc_assert (num_iterations < 500);
+gcc_checking_assert (num_iterations < 500);
-#endif
 }
 statistics_histogram_event (cfun, "compute_antic iterations",
 			      num_iterations);
 		    |= compute_partial_antic_aux (block,
 						  TEST_BIT (has_abnormal_preds,
 							    block->index));
 		}
 	    }
-#ifdef ENABLE_CHECKING
 	  /* Theoretically possible, but *highly* unlikely.  */
-	  gcc_assert (num_iterations < 500);
+	  gcc_checking_assert (num_iterations < 500);
-#endif
 	}
 statistics_histogram_event (cfun, "compute_partial_antic iterations",
 				  num_iterations);
 }
 sbitmap_free (has_abnormal_preds);
 can_PRE_operation (tree op)
 {
 return UNARY_CLASS_P (op)
 || BINARY_CLASS_P (op)
 || COMPARISON_CLASS_P (op)
-|| TREE_CODE (op) == INDIRECT_REF
+|| TREE_CODE (op) == MEM_REF
 || TREE_CODE (op) == COMPONENT_REF
 || TREE_CODE (op) == VIEW_CONVERT_EXPR
 || TREE_CODE (op) == CALL_EXPR
 || TREE_CODE (op) == ARRAY_REF;
 }
 	if (sc)
 	  CALL_EXPR_STATIC_CHAIN (folded) = sc;
 	return folded;
 }
 break;
+case MEM_REF:
+{
+	tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
+							stmts, domstmt);
+	tree offset = currop->op0;
+	if (!baseop)
+	  return NULL_TREE;
+	if (TREE_CODE (baseop) == ADDR_EXPR
+	    && handled_component_p (TREE_OPERAND (baseop, 0)))
+	  {
+	    HOST_WIDE_INT off;
+	    tree base;
+	    base = get_addr_base_and_unit_offset (TREE_OPERAND (baseop, 0),
+						  &off);
+	    gcc_assert (base);
+	    offset = int_const_binop (PLUS_EXPR, offset,
+				      build_int_cst (TREE_TYPE (offset),
+						     off), 0);
+	    baseop = build_fold_addr_expr (base);
+	  }
+	return fold_build2 (MEM_REF, currop->type, baseop, offset);
+}
+break;
 case TARGET_MEM_REF:
 {
+	pre_expr op0expr, op1expr;
+	tree genop0 = NULL_TREE, genop1 = NULL_TREE;
 	vn_reference_op_t nextop = VEC_index (vn_reference_op_s, ref->operands,
-					      *operand);
+					      ++*operand);
-	pre_expr op0expr;
-	tree genop0 = NULL_TREE;
 	tree baseop = create_component_ref_by_pieces_1 (block, ref, operand,
 							stmts, domstmt);
 	if (!baseop)
 	  return NULL_TREE;
 	if (currop->op0)
 	    genop0 = find_or_generate_expression (block, op0expr,
 						  stmts, domstmt);
 	    if (!genop0)
 	      return NULL_TREE;
 	  }
-	if (DECL_P (baseop))
+	if (nextop->op0)
-	  return build6 (TARGET_MEM_REF, currop->type,
+	  {
-			 baseop, NULL_TREE,
+	    op1expr = get_or_alloc_expr_for (nextop->op0);
-			 genop0, currop->op1, currop->op2,
+	    genop1 = find_or_generate_expression (block, op1expr,
-			 unshare_expr (nextop->op1));
+						  stmts, domstmt);
-	else
+	    if (!genop1)
-	  return build6 (TARGET_MEM_REF, currop->type,
+	      return NULL_TREE;
-			 NULL_TREE, baseop,
+	  }
-			 genop0, currop->op1, currop->op2,
+	return build5 (TARGET_MEM_REF, currop->type,
-			 unshare_expr (nextop->op1));
+		       baseop, currop->op2, genop0, currop->op1, genop1);
 }
 break;
 case ADDR_EXPR:
 if (currop->op0)
 	{
 							stmts, domstmt);
 	if (!genop0)
 	  return NULL_TREE;
 	folded = fold_build1 (currop->opcode, currop->type,
 			      genop0);
-	return folded;
-}
-break;
-case ALIGN_INDIRECT_REF:
-case MISALIGNED_INDIRECT_REF:
-case INDIRECT_REF:
-{
-	tree folded;
-	tree genop1 = create_component_ref_by_pieces_1 (block, ref,
-							operand,
-							stmts, domstmt);
-	if (!genop1)
-	  return NULL_TREE;
-	genop1 = fold_convert (build_pointer_type (currop->type),
-			       genop1);
-	if (currop->opcode == MISALIGNED_INDIRECT_REF)
-	  folded = fold_build2 (currop->opcode, currop->type,
-				genop1, currop->op1);
-	else
-	  folded = fold_build1 (currop->opcode, currop->type,
-				genop1);
 	return folded;
 }
 break;
 case BIT_FIELD_REF:
 {
 gcc_unreachable ();
 }
 }
 /* For COMPONENT_REF's and ARRAY_REF's, we can't have any intermediates for the
-COMPONENT_REF or INDIRECT_REF or ARRAY_REF portion, because we'd end up with
+COMPONENT_REF or MEM_REF or ARRAY_REF portion, because we'd end up with
 trying to rename aggregates into ssa form directly, which is a no no.
 Thus, this routine doesn't create temporaries, it just builds a
 single access expression for the array, calling
 find_or_generate_expression to build the innermost pieces.
 else if (leader->kind == CONSTANT)
 	genop = PRE_EXPR_CONSTANT (leader);
 }
 /* If it's still NULL, it must be a complex expression, so generate
-it recursively.  Not so for FRE though.  */
+it recursively.  Not so if inserting expressions for values generated
+by SCCVN.  */
 if (genop == NULL
-&& !in_fre)
+&& !domstmt)
 {
 bitmap_set_t exprset;
 unsigned int lookfor = get_expr_value_id (expr);
 bool handled = false;
 bitmap_iterator bi;
 VN_INFO_GET (name)->valnum = name;
 value_id = get_expr_value_id (expr);
 VN_INFO (name)->value_id = value_id;
 nameexpr = get_or_alloc_expr_for_name (name);
 add_to_value (value_id, nameexpr);
-if (!in_fre)
+if (NEW_SETS (block))
 bitmap_value_replace_in_set (NEW_SETS (block), nameexpr);
 bitmap_value_replace_in_set (AVAIL_OUT (block), nameexpr);
 pre_stats.insertions++;
 if (dump_file && (dump_flags & TDF_DETAILS))
 /* Otherwise we inhibit the insertion when the address of the
 memory reference is a simple induction variable.  In other
 cases the vectorizer won't do anything anyway (either it's
 loop invariant or a complicated expression).  */
-for (i = 0; VEC_iterate (vn_reference_op_s, ops, i, op); ++i)
+FOR_EACH_VEC_ELT (vn_reference_op_s, ops, i, op)
 {
 switch (op->opcode)
 	{
 	case ARRAY_REF:
 	case ARRAY_RANGE_REF:
 			  gsi_insert_seq_on_edge (pred, stmts);
 			}
 		      avail[bprime->index] = get_or_alloc_expr_for_name (forcedexpr);
 		    }
 		}
+	      else
+		avail[bprime->index] = get_or_alloc_expr_for_constant (builtexpr);
 	    }
 	}
 else if (eprime->kind == NAME)
 	{
 	  /* We may have to do a conversion because our value
 bool new_stuff = false;
 VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (ANTIC_IN (block));
 pre_expr expr;
 int i;
-for (i = 0; VEC_iterate (pre_expr, exprs, i, expr); i++)
+FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
 {
 if (expr->kind != NAME)
 	{
 	  pre_expr *avail;
 	  unsigned int val;
 	    }
 	  /* If we can insert it, it's not the same value
 	     already existing along every predecessor, and
 	     it's defined by some predecessor, it is
 	     partially redundant.  */
-	  if (!cant_insert && !all_same && by_some && do_insertion
+	  if (!cant_insert && !all_same && by_some)
-	      && dbg_cnt (treepre_insert))
 	    {
-	      if (insert_into_preds_of_block (block, get_expression_id (expr),
+	      if (!do_insertion)
-					      avail))
+		{
+		  if (dump_file && (dump_flags & TDF_DETAILS))
+		    {
+		      fprintf (dump_file, "Skipping partial redundancy for "
+			       "expression ");
+		      print_pre_expr (dump_file, expr);
+		      fprintf (dump_file, " (%04d), no redundancy on to be "
+			       "optimized for speed edge\n", val);
+		    }
+		}
+	      else if (dbg_cnt (treepre_insert)
+		       && insert_into_preds_of_block (block,
+						      get_expression_id (expr),
+						      avail))
 		new_stuff = true;
 	    }
 	  /* If all edges produce the same value and that value is
 	     an invariant, then the PHI has the same value on all
 	     edges.  Note this.  */
 bool new_stuff = false;
 VEC (pre_expr, heap) *exprs = sorted_array_from_bitmap_set (PA_IN (block));
 pre_expr expr;
 int i;
-for (i = 0; VEC_iterate (pre_expr, exprs, i, expr); i++)
+FOR_EACH_VEC_ELT (pre_expr, exprs, i, expr)
 {
 if (expr->kind != NAME)
 	{
 	  pre_expr *avail;
 	  unsigned int val;
 		  continue;
 		copy_reference_ops_from_call (stmt, &ops);
 		vn_reference_lookup_pieces (gimple_vuse (stmt), 0,
 					    gimple_expr_type (stmt),
-					    ops, &ref, false);
+					    ops, &ref, VN_NOWALK);
 		VEC_free (vn_reference_op_s, heap, ops);
 		if (!ref)
 		  continue;
 		for (i = 0; VEC_iterate (vn_reference_op_s,
 		      unsigned int i;
 		      vn_reference_op_t vro;
 		      vn_reference_lookup (gimple_assign_rhs1 (stmt),
 					   gimple_vuse (stmt),
-					   true, &ref);
+					   VN_WALK, &ref);
 		      if (!ref)
 			continue;
 		      for (i = 0; VEC_iterate (vn_reference_op_s,
 					       ref->operands, i,
 		  && sprime != lhs
 		  && (rhs == NULL_TREE
 		      || TREE_CODE (rhs) != SSA_NAME
 		      || may_propagate_copy (rhs, sprime)))
 		{
+		  bool can_make_abnormal_goto
+		    = is_gimple_call (stmt)
+		      && stmt_can_make_abnormal_goto (stmt);
 		  gcc_assert (sprime != rhs);
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    {
 		      fprintf (dump_file, "Replaced ");
 		  pre_stats.eliminations++;
 		  propagate_tree_value_into_stmt (&gsi, sprime);
 		  stmt = gsi_stmt (gsi);
 		  update_stmt (stmt);
-		  /* If we removed EH side effects from the statement, clean
+		  /* If we removed EH side-effects from the statement, clean
 		     its EH information.  */
 		  if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
 		    {
 		      bitmap_set_bit (need_eh_cleanup,
 				      gimple_bb (stmt)->index);
 		      if (dump_file && (dump_flags & TDF_DETAILS))
-			fprintf (dump_file, "  Removed EH side effects.\n");
+			fprintf (dump_file, "  Removed EH side-effects.\n");
+		    }
+		  /* Likewise for AB side-effects.  */
+		  if (can_make_abnormal_goto
+		      && !stmt_can_make_abnormal_goto (stmt))
+		    {
+		      bitmap_set_bit (need_ab_cleanup,
+				      gimple_bb (stmt)->index);
+		      if (dump_file && (dump_flags & TDF_DETAILS))
+			fprintf (dump_file, "  Removed AB side-effects.\n");
 		    }
 		}
 	    }
 	  /* If the statement is a scalar store, see if the expression
 	     has the same value number as its rhs.  If so, the store is
 		       || is_gimple_min_invariant (gimple_assign_rhs1 (stmt))))
 	    {
 	      tree rhs = gimple_assign_rhs1 (stmt);
 	      tree val;
 	      val = vn_reference_lookup (gimple_assign_lhs (stmt),
-					 gimple_vuse (stmt), true, NULL);
+					 gimple_vuse (stmt), VN_WALK, NULL);
 	      if (TREE_CODE (rhs) == SSA_NAME)
 		rhs = VN_INFO (rhs)->valnum;
 	      if (val
 		  && operand_equal_p (val, rhs, 0))
 		{
 		  todo = TODO_cleanup_cfg;
 		}
 	    }
 	  /* Visit indirect calls and turn them into direct calls if
 	     possible.  */
-	  if (gimple_code (stmt) == GIMPLE_CALL
+	  if (is_gimple_call (stmt)
 	      && TREE_CODE (gimple_call_fn (stmt)) == SSA_NAME)
 	    {
 	      tree fn = VN_INFO (gimple_call_fn (stmt))->valnum;
 	      if (TREE_CODE (fn) == ADDR_EXPR
 		  && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL)
 		{
+		  bool can_make_abnormal_goto
+		    = stmt_can_make_abnormal_goto (stmt);
+		  bool was_noreturn = gimple_call_noreturn_p (stmt);
 		  if (dump_file && (dump_flags & TDF_DETAILS))
 		    {
 		      fprintf (dump_file, "Replacing call target with ");
 		      print_generic_expr (dump_file, fn, 0);
 		      fprintf (dump_file, " in ");
 		      print_gimple_stmt (dump_file, stmt, 0, 0);
 		    }
 		  gimple_call_set_fn (stmt, fn);
 		  update_stmt (stmt);
+		  /* When changing a call into a noreturn call, cfg cleanup
+		     is needed to fix up the noreturn call.  */
+		  if (!was_noreturn && gimple_call_noreturn_p (stmt))
+		    todo |= TODO_cleanup_cfg;
+		  /* If we removed EH side-effects from the statement, clean
+		     its EH information.  */
 		  if (maybe_clean_or_replace_eh_stmt (stmt, stmt))
 		    {
 		      bitmap_set_bit (need_eh_cleanup,
 				      gimple_bb (stmt)->index);
 		      if (dump_file && (dump_flags & TDF_DETAILS))
-			fprintf (dump_file, "  Removed EH side effects.\n");
+			fprintf (dump_file, "  Removed EH side-effects.\n");
+		    }
+		  /* Likewise for AB side-effects.  */
+		  if (can_make_abnormal_goto
+		      && !stmt_can_make_abnormal_goto (stmt))
+		    {
+		      bitmap_set_bit (need_ab_cleanup,
+				      gimple_bb (stmt)->index);
+		      if (dump_file && (dump_flags & TDF_DETAILS))
+			fprintf (dump_file, "  Removed AB side-effects.\n");
 		    }
 		  /* Changing an indirect call to a direct call may
 		     have exposed different semantics.  This may
 		     require an SSA update.  */
 	      else if (sprimeexpr->kind == NAME)
 		sprime = PRE_EXPR_NAME (sprimeexpr);
 	      else
 		gcc_unreachable ();
 	    }
-	  if (!sprimeexpr
+	  if (!sprime && is_gimple_min_invariant (VN_INFO (res)->valnum))
+	    {
+	      sprime = VN_INFO (res)->valnum;
+	      if (!useless_type_conversion_p (TREE_TYPE (res),
+					      TREE_TYPE (sprime)))
+		sprime = fold_convert (TREE_TYPE (res), sprime);
+	    }
+	  if (!sprime
 	      || sprime == res)
 	    {
 	      gsi_next (&gsi);
 	      continue;
 	    }
 }
 /* We cannot remove stmts during BB walk, especially not release SSA
 names there as this confuses the VN machinery.  The stmts ending
 up in to_remove are either stores or simple copies.  */
-for (i = 0; VEC_iterate (gimple, to_remove, i, stmt); ++i)
+FOR_EACH_VEC_ELT (gimple, to_remove, i, stmt)
 {
 tree lhs = gimple_assign_lhs (stmt);
 tree rhs = gimple_assign_rhs1 (stmt);
 use_operand_p use_p;
 gimple use_stmt;
 /* If this is a store or a now unused copy, remove it.  */
 if (TREE_CODE (lhs) != SSA_NAME
 	  || has_zero_uses (lhs))
 	{
+	  basic_block bb = gimple_bb (stmt);
 	  gsi = gsi_for_stmt (stmt);
 	  unlink_stmt_vdef (stmt);
 	  gsi_remove (&gsi, true);
+	  if (gimple_purge_dead_eh_edges (bb))
+	    todo |= TODO_cleanup_cfg;
 	  if (TREE_CODE (lhs) == SSA_NAME)
 	    bitmap_clear_bit (inserted_exprs, SSA_NAME_VERSION (lhs));
 	  release_defs (stmt);
 	}
 }
 postorder = XNEWVEC (int, n_basic_blocks - NUM_FIXED_BLOCKS);
 my_rev_post_order_compute (postorder, false);
-FOR_ALL_BB (bb)
+alloc_aux_for_blocks (sizeof (struct bb_bitmap_sets));
-bb->aux = XCNEWVEC (struct bb_bitmap_sets, 1);
 calculate_dominance_info (CDI_POST_DOMINATORS);
 calculate_dominance_info (CDI_DOMINATORS);
 bitmap_obstack_initialize (&grand_bitmap_obstack);
 TMP_GEN (bb) = bitmap_set_new ();
 AVAIL_OUT (bb) = bitmap_set_new ();
 }
 need_eh_cleanup = BITMAP_ALLOC (NULL);
+need_ab_cleanup = BITMAP_ALLOC (NULL);
 }
 /* Deallocate data structures used by PRE.  */
 static void
 fini_pre (bool do_fre)
 {
-basic_block bb;
 free (postorder);
 VEC_free (bitmap_set_t, heap, value_expressions);
 BITMAP_FREE (inserted_exprs);
 VEC_free (gimple, heap, need_creation);
 bitmap_obstack_release (&grand_bitmap_obstack);
 free_alloc_pool (pre_expr_pool);
 htab_delete (phi_translate_table);
 htab_delete (expression_to_id);
 VEC_free (unsigned, heap, name_to_id);
-FOR_ALL_BB (bb)
+free_aux_for_blocks ();
-{
-free (bb->aux);
-bb->aux = NULL;
-}
 free_dominance_info (CDI_POST_DOMINATORS);
 if (!bitmap_empty_p (need_eh_cleanup))
 {
 gimple_purge_all_dead_eh_edges (need_eh_cleanup);
 cleanup_tree_cfg ();
 }
 BITMAP_FREE (need_eh_cleanup);
+if (!bitmap_empty_p (need_ab_cleanup))
+{
+gimple_purge_all_dead_abnormal_call_edges (need_ab_cleanup);
+cleanup_tree_cfg ();
+}
+BITMAP_FREE (need_ab_cleanup);
 if (!do_fre)
 loop_optimizer_finalize ();
 }
 /* This has to happen before SCCVN runs because
 loop_optimizer_init may create new phis, etc.  */
 if (!do_fre)
 loop_optimizer_init (LOOPS_NORMAL);
-if (!run_scc_vn (do_fre))
+if (!run_scc_vn (do_fre ? VN_WALKREWRITE : VN_WALK))
 {
 if (!do_fre)
 	loop_optimizer_finalize ();
 return 0;
 statistics_counter_event (cfun, "Constified", pre_stats.constified);
 clear_expression_ids ();
 free_scc_vn ();
 if (!do_fre)
-remove_dead_inserted_code ();
+{
+remove_dead_inserted_code ();
+todo |= TODO_verify_flow;
+}
 scev_finalize ();
 fini_pre (do_fre);
 return todo;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-pre.c @ 67:f6334be47118