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

comparison gcc/tree-ssa-sccvn.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	58ad6c70ea60
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 return vn_constant_eq_with_type (vc1->constant, vc2->constant);
 }
 /* Hash table hash function for vn_constant_t.  */
 static hashval_t
 vn_constant_hash (const void *p1)
 {
 const struct vn_constant_s *vc1 = (const struct vn_constant_s *) p1;
 return vc1->hashcode;
 unsigned int
 get_or_alloc_constant_value_id (tree constant)
 {
 void **slot;
 vn_constant_t vc = XNEW (struct vn_constant_s);
 vc->hashcode = vn_hash_constant_with_type (constant);
 vc->constant = constant;
 slot = htab_find_slot_with_hash (constant_to_value_id, vc,
 				   vc->hashcode, INSERT);
 if (*slot)
 {
 free (vc);
 return ((vn_constant_t)*slot)->value_id;
 }
 /* Return true if V is a value id for a constant.  */
 bool
 value_id_constant_p (unsigned int v)
 {
 return bitmap_bit_p (constant_value_ids, v);
 }
 /* Compare two reference operands P1 and P2 for equality.  Return true if
 they are equal, and false otherwise.  */
 /* Compute a hash for the reference operation VR1 and return it.  */
 hashval_t
 vn_reference_compute_hash (const vn_reference_t vr1)
 {
-hashval_t result = 0;
+hashval_t result;
-tree v;
 int i;
 vn_reference_op_t vro;
-for (i = 0; VEC_iterate (tree, vr1->vuses, i, v); i++)
+result = iterative_hash_expr (vr1->vuse, 0);
-result += iterative_hash_expr (v, 0);
 for (i = 0; VEC_iterate (vn_reference_op_s, vr1->operands, i, vro); i++)
 result += vn_reference_op_compute_hash (vro);
 return result;
 }
 means they have the same set of operands and vuses.  */
 int
 vn_reference_eq (const void *p1, const void *p2)
 {
-tree v;
 int i;
 vn_reference_op_t vro;
 const_vn_reference_t const vr1 = (const_vn_reference_t) p1;
 const_vn_reference_t const vr2 = (const_vn_reference_t) p2;
 if (vr1->hashcode != vr2->hashcode)
 return false;
-if (vr1->vuses == vr2->vuses
+/* Early out if this is not a hash collision.  */
-&& vr1->operands == vr2->operands)
+if (vr1->hashcode != vr2->hashcode)
+return false;
+/* The VOP needs to be the same.  */
+if (vr1->vuse != vr2->vuse)
+return false;
+/* If the operands are the same we are done.  */
+if (vr1->operands == vr2->operands)
 return true;
-/* Impossible for them to be equivalent if they have different
-number of vuses.  */
-if (VEC_length (tree, vr1->vuses) != VEC_length (tree, vr2->vuses))
-return false;
 /* We require that address operands be canonicalized in a way that
 two memory references will have the same operands if they are
 equivalent.  */
 if (VEC_length (vn_reference_op_s, vr1->operands)
 != VEC_length (vn_reference_op_s, vr2->operands))
 return false;
-/* The memory state is more often different than the address of the
-store/load, so check it first.  */
-for (i = 0; VEC_iterate (tree, vr1->vuses, i, v); i++)
-{
-if (VEC_index (tree, vr2->vuses, i) != v)
-	return false;
-}
 for (i = 0; VEC_iterate (vn_reference_op_s, vr1->operands, i, vro); i++)
-{
+if (!vn_reference_op_eq (VEC_index (vn_reference_op_s, vr2->operands, i),
-if (!vn_reference_op_eq (VEC_index (vn_reference_op_s, vr2->operands, i),
+			     vro))
-			       vro))
+return false;
-	return false;
-}
 return true;
-}
-/* Place the vuses from STMT into *result.  */
-static inline void
-vuses_to_vec (gimple stmt, VEC (tree, gc) **result)
-{
-ssa_op_iter iter;
-tree vuse;
-if (!stmt)
-return;
-VEC_reserve_exact (tree, gc, *result,
-		     num_ssa_operands (stmt, SSA_OP_VIRTUAL_USES));
-FOR_EACH_SSA_TREE_OPERAND (vuse, stmt, iter, SSA_OP_VIRTUAL_USES)
-VEC_quick_push (tree, *result, vuse);
-}
-/* Copy the VUSE names in STMT into a vector, and return
-the vector.  */
-static VEC (tree, gc) *
-copy_vuses_from_stmt (gimple stmt)
-{
-VEC (tree, gc) *vuses = NULL;
-vuses_to_vec (stmt, &vuses);
-return vuses;
-}
-/* Place the vdefs from STMT into *result.  */
-static inline void
-vdefs_to_vec (gimple stmt, VEC (tree, gc) **result)
-{
-ssa_op_iter iter;
-tree vdef;
-if (!stmt)
-return;
-*result = VEC_alloc (tree, gc, num_ssa_operands (stmt, SSA_OP_VIRTUAL_DEFS));
-FOR_EACH_SSA_TREE_OPERAND (vdef, stmt, iter, SSA_OP_VIRTUAL_DEFS)
-VEC_quick_push (tree, *result, vdef);
-}
-/* Copy the names of vdef results in STMT into a vector, and return
-the vector.  */
-static VEC (tree, gc) *
-copy_vdefs_from_stmt (gimple stmt)
-{
-VEC (tree, gc) *vdefs = NULL;
-vdefs_to_vec (stmt, &vdefs);
-return vdefs;
-}
-/* Place for shared_v{uses/defs}_from_stmt to shove vuses/vdefs.  */
-static VEC (tree, gc) *shared_lookup_vops;
-/* Copy the virtual uses from STMT into SHARED_LOOKUP_VOPS.
-This function will overwrite the current SHARED_LOOKUP_VOPS
-variable.  */
-VEC (tree, gc) *
-shared_vuses_from_stmt (gimple stmt)
-{
-VEC_truncate (tree, shared_lookup_vops, 0);
-vuses_to_vec (stmt, &shared_lookup_vops);
-return shared_lookup_vops;
 }
 /* Copy the operations present in load/store REF into RESULT, a vector of
 vn_reference_op_s's.  */
 copy_reference_ops_from_ref (tree ref, VEC(vn_reference_op_s, heap) **result)
 {
 if (TREE_CODE (ref) == TARGET_MEM_REF)
 {
 vn_reference_op_s temp;
+tree base;
+base = TMR_SYMBOL (ref) ? TMR_SYMBOL (ref) : TMR_BASE (ref);
+if (!base)
+	base = build_int_cst (ptr_type_node, 0);
 memset (&temp, 0, sizeof (temp));
 /* We do not care for spurious type qualifications.  */
 temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
 temp.opcode = TREE_CODE (ref);
-temp.op0 = TMR_SYMBOL (ref) ? TMR_SYMBOL (ref) : TMR_BASE (ref);
+temp.op0 = TMR_INDEX (ref);
-temp.op1 = TMR_INDEX (ref);
+temp.op1 = TMR_STEP (ref);
+temp.op2 = TMR_OFFSET (ref);
 VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
 memset (&temp, 0, sizeof (temp));
 temp.type = NULL_TREE;
-temp.opcode = TREE_CODE (ref);
+temp.opcode = TREE_CODE (base);
-temp.op0 = TMR_STEP (ref);
+temp.op0 = base;
-temp.op1 = TMR_OFFSET (ref);
+temp.op1 = TMR_ORIGINAL (ref);
 VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
 return;
 }
 /* For non-calls, store the information that makes up the address.  */
 	case COMPONENT_REF:
 	  /* The field decl is enough to unambiguously specify the field,
 	     a matching type is not necessary and a mismatching type
 	     is always a spurious difference.  */
 	  temp.type = NULL_TREE;
+	  temp.op0 = TREE_OPERAND (ref, 1);
+	  temp.op1 = TREE_OPERAND (ref, 2);
 	  /* If this is a reference to a union member, record the union
 	     member size as operand.  Do so only if we are doing
 	     expression insertion (during FRE), as PRE currently gets
 	     confused with this.  */
 	  if (may_insert
-	      && TREE_OPERAND (ref, 2) == NULL_TREE
+	      && temp.op1 == NULL_TREE
-	      && TREE_CODE (DECL_CONTEXT (TREE_OPERAND (ref, 1))) == UNION_TYPE
+	      && TREE_CODE (DECL_CONTEXT (temp.op0)) == UNION_TYPE
-	      && integer_zerop (DECL_FIELD_OFFSET (TREE_OPERAND (ref, 1)))
+	      && integer_zerop (DECL_FIELD_OFFSET (temp.op0))
-	      && integer_zerop (DECL_FIELD_BIT_OFFSET (TREE_OPERAND (ref, 1))))
+	      && integer_zerop (DECL_FIELD_BIT_OFFSET (temp.op0))
-	    temp.op0 = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (ref, 1)));
+	      && host_integerp (DECL_SIZE (temp.op0), 0))
-	  else
+	    temp.op0 = DECL_SIZE (temp.op0);
-	    {
-	      /* Record field as operand.  */
-	      temp.op0 = TREE_OPERAND (ref, 1);
-	      temp.op1 = TREE_OPERAND (ref, 2);
-	    }
 	  break;
 	case ARRAY_RANGE_REF:
 	case ARRAY_REF:
 	  /* Record index as operand.  */
 	  temp.op0 = TREE_OPERAND (ref, 1);
-	  temp.op1 = TREE_OPERAND (ref, 2);
+	  /* Always record lower bounds and element size.  */
-	  temp.op2 = TREE_OPERAND (ref, 3);
+	  temp.op1 = array_ref_low_bound (ref);
+	  temp.op2 = array_ref_element_size (ref);
 	  break;
 	case STRING_CST:
 	case INTEGER_CST:
 	case COMPLEX_CST:
 	case VECTOR_CST:
 else
 	ref = NULL_TREE;
 }
 }
-/* Re-create a reference tree from the reference ops OPS.
+/* Build a alias-oracle reference abstraction in *REF from the vn_reference
-Returns NULL_TREE if the ops were not handled.
+operands in *OPS, the reference alias set SET and the reference type TYPE.
-This routine needs to be kept in sync with copy_reference_ops_from_ref.  */
+Return true if something useful was produced.  */
-static tree
+bool
-get_ref_from_reference_ops (VEC(vn_reference_op_s, heap) *ops)
+ao_ref_init_from_vn_reference (ao_ref *ref,
+			       alias_set_type set, tree type,
+			       VEC (vn_reference_op_s, heap) *ops)
 {
 vn_reference_op_t op;
 unsigned i;
-tree ref, *op0_p = &ref;
+tree base = NULL_TREE;
+tree *op0_p = &base;
+HOST_WIDE_INT offset = 0;
+HOST_WIDE_INT max_size;
+HOST_WIDE_INT size = -1;
+tree size_tree = NULL_TREE;
+/* First get the final access size from just the outermost expression.  */
+op = VEC_index (vn_reference_op_s, ops, 0);
+if (op->opcode == COMPONENT_REF)
+{
+if (TREE_CODE (op->op0) == INTEGER_CST)
+	size_tree = op->op0;
+else
+	size_tree = DECL_SIZE (op->op0);
+}
+else if (op->opcode == BIT_FIELD_REF)
+size_tree = op->op0;
+else
+{
+enum machine_mode mode = TYPE_MODE (type);
+if (mode == BLKmode)
+	size_tree = TYPE_SIZE (type);
+else
+size = GET_MODE_BITSIZE (mode);
+}
+if (size_tree != NULL_TREE)
+{
+if (!host_integerp (size_tree, 1))
+	size = -1;
+else
+	size = TREE_INT_CST_LOW (size_tree);
+}
+/* Initially, maxsize is the same as the accessed element size.
+In the following it will only grow (or become -1).  */
+max_size = size;
+/* Compute cumulative bit-offset for nested component-refs and array-refs,
+and find the ultimate containing object.  */
 for (i = 0; VEC_iterate (vn_reference_op_s, ops, i, op); ++i)
 {
 switch (op->opcode)
 	{
+	/* These may be in the reference ops, but we cannot do anything
+	   sensible with them here.  */
 	case CALL_EXPR:
-	  return NULL_TREE;
+	case ADDR_EXPR:
+	  return false;
+	/* Record the base objects.  */
 	case ALIGN_INDIRECT_REF:
 	case INDIRECT_REF:
 	  *op0_p = build1 (op->opcode, op->type, NULL_TREE);
 	  op0_p = &TREE_OPERAND (*op0_p, 0);
 	  break;
 	  *op0_p = build2 (MISALIGNED_INDIRECT_REF, op->type,
 			   NULL_TREE, op->op0);
 	  op0_p = &TREE_OPERAND (*op0_p, 0);
 	  break;
+	case VAR_DECL:
+	case PARM_DECL:
+	case RESULT_DECL:
+	case SSA_NAME:
+	  *op0_p = op->op0;
+	  break;
+	/* And now the usual component-reference style ops.  */
 	case BIT_FIELD_REF:
-	  *op0_p = build3 (BIT_FIELD_REF, op->type, NULL_TREE,
+	  offset += tree_low_cst (op->op1, 0);
-			   op->op0, op->op1);
-	  op0_p = &TREE_OPERAND (*op0_p, 0);
 	  break;
 	case COMPONENT_REF:
-	  *op0_p = build3 (COMPONENT_REF, TREE_TYPE (op->op0), NULL_TREE,
+	  {
-			   op->op0, op->op1);
+	    tree field = op->op0;
-	  op0_p = &TREE_OPERAND (*op0_p, 0);
+	    /* We do not have a complete COMPONENT_REF tree here so we
-	  break;
+	       cannot use component_ref_field_offset.  Do the interesting
+	       parts manually.  */
+	    /* Our union trick, done for offset zero only.  */
+	    if (TREE_CODE (field) == INTEGER_CST)
+	      ;
+	    else if (op->op1
+		     || !host_integerp (DECL_FIELD_OFFSET (field), 1))
+	      max_size = -1;
+	    else
+	      {
+		offset += (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
+			   * BITS_PER_UNIT);
+		offset += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field));
+	      }
+	    break;
+	  }
 	case ARRAY_RANGE_REF:
 	case ARRAY_REF:
-	  *op0_p = build4 (op->opcode, op->type, NULL_TREE,
+	  /* We recorded the lower bound and the element size.  */
-			   op->op0, op->op1, op->op2);
+	  if (!host_integerp (op->op0, 0)
-	  op0_p = &TREE_OPERAND (*op0_p, 0);
+	      || !host_integerp (op->op1, 0)
+	      || !host_integerp (op->op2, 0))
+	    max_size = -1;
+	  else
+	    {
+	      HOST_WIDE_INT hindex = TREE_INT_CST_LOW (op->op0);
+	      hindex -= TREE_INT_CST_LOW (op->op1);
+	      hindex *= TREE_INT_CST_LOW (op->op2);
+	      hindex *= BITS_PER_UNIT;
+	      offset += hindex;
+	    }
+	  break;
+	case REALPART_EXPR:
+	  break;
+	case IMAGPART_EXPR:
+	  offset += size;
+	  break;
+	case VIEW_CONVERT_EXPR:
 	  break;
 	case STRING_CST:
 	case INTEGER_CST:
 	case COMPLEX_CST:
 	case VECTOR_CST:
 	case REAL_CST:
 	case CONSTRUCTOR:
-	case VAR_DECL:
-	case PARM_DECL:
 	case CONST_DECL:
-	case RESULT_DECL:
+	  return false;
-	case SSA_NAME:
-	  *op0_p = op->op0;
-	  break;
-	case ADDR_EXPR:
-	  if (op->op0 != NULL_TREE)
-	    {
-	      gcc_assert (is_gimple_min_invariant (op->op0));
-	      *op0_p = op->op0;
-	      break;
-	    }
-	  /* Fallthrough.  */
-	case IMAGPART_EXPR:
-	case REALPART_EXPR:
-	case VIEW_CONVERT_EXPR:
-	  *op0_p = build1 (op->opcode, op->type, NULL_TREE);
-	  op0_p = &TREE_OPERAND (*op0_p, 0);
-	  break;
 	default:
-	  return NULL_TREE;
+	  return false;
 	}
 }
-return ref;
+if (base == NULL_TREE)
+return false;
+ref->ref = NULL_TREE;
+ref->base = base;
+ref->offset = offset;
+ref->size = size;
+ref->max_size = max_size;
+ref->ref_alias_set = set;
+ref->base_alias_set = -1;
+return true;
 }
 /* Copy the operations present in load/store/call REF into RESULT, a vector of
 vn_reference_op_s's.  */
 copy_reference_ops_from_call (call, &result);
 return result;
 }
-static VEC(vn_reference_op_s, heap) *shared_lookup_references;
+/* Fold *& at position *I_P in a vn_reference_op_s vector *OPS.  Updates
+*I_P to point to the last element of the replacement.  */
-/* Create a vector of vn_reference_op_s structures from REF, a
+void
-REFERENCE_CLASS_P tree.  The vector is shared among all callers of
+vn_reference_fold_indirect (VEC (vn_reference_op_s, heap) **ops,
-this function.  */
+			    unsigned int *i_p)
+{
-static VEC(vn_reference_op_s, heap) *
+VEC(vn_reference_op_s, heap) *mem = NULL;
-shared_reference_ops_from_ref (tree ref)
+vn_reference_op_t op;
-{
+unsigned int i = *i_p;
-if (!ref)
+unsigned int j;
-return NULL;
-VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
+/* Get ops for the addressed object.  */
-copy_reference_ops_from_ref (ref, &shared_lookup_references);
+op = VEC_index (vn_reference_op_s, *ops, i);
-return shared_lookup_references;
+/* ???  If this is our usual typeof &ARRAY vs. &ARRAY[0] problem, work
-}
+around it to avoid later ICEs.  */
+if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op->op0, 0))) == ARRAY_TYPE
-/* Create a vector of vn_reference_op_s structures from CALL, a
+&& TREE_CODE (TREE_TYPE (TREE_TYPE (op->op0))) != ARRAY_TYPE)
-call statement.  The vector is shared among all callers of
+{
-this function.  */
+vn_reference_op_s aref;
+tree dom;
-static VEC(vn_reference_op_s, heap) *
+aref.type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (op->op0)));
-shared_reference_ops_from_call (gimple call)
+aref.opcode = ARRAY_REF;
-{
+aref.op0 = integer_zero_node;
-if (!call)
+if ((dom = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (op->op0, 0))))
-return NULL;
+	  && TYPE_MIN_VALUE (dom))
-VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
+	aref.op0 = TYPE_MIN_VALUE (dom);
-copy_reference_ops_from_call (call, &shared_lookup_references);
+aref.op1 = aref.op0;
-return shared_lookup_references;
+aref.op2 = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (op->op0)));
-}
+VEC_safe_push (vn_reference_op_s, heap, mem, &aref);
+}
+copy_reference_ops_from_ref (TREE_OPERAND (op->op0, 0), &mem);
+/* Do the replacement - we should have at least one op in mem now.  */
+if (VEC_length (vn_reference_op_s, mem) == 1)
+{
+VEC_replace (vn_reference_op_s, *ops, i - 1,
+		   VEC_index (vn_reference_op_s, mem, 0));
+VEC_ordered_remove (vn_reference_op_s, *ops, i);
+i--;
+}
+else if (VEC_length (vn_reference_op_s, mem) == 2)
+{
+VEC_replace (vn_reference_op_s, *ops, i - 1,
+		   VEC_index (vn_reference_op_s, mem, 0));
+VEC_replace (vn_reference_op_s, *ops, i,
+		   VEC_index (vn_reference_op_s, mem, 1));
+}
+else if (VEC_length (vn_reference_op_s, mem) > 2)
+{
+VEC_replace (vn_reference_op_s, *ops, i - 1,
+		   VEC_index (vn_reference_op_s, mem, 0));
+VEC_replace (vn_reference_op_s, *ops, i,
+		   VEC_index (vn_reference_op_s, mem, 1));
+/* ???  There is no VEC_splice.  */
+for (j = 2; VEC_iterate (vn_reference_op_s, mem, j, op); j++)
+	VEC_safe_insert (vn_reference_op_s, heap, *ops, ++i, op);
+}
+else
+gcc_unreachable ();
+VEC_free (vn_reference_op_s, heap, mem);
+*i_p = i;
+}
 /* Transform any SSA_NAME's in a vector of vn_reference_op_s
 structures into their value numbers.  This is done in-place, and
 the vector passed in is returned.  */
 static VEC (vn_reference_op_s, heap) *
 valueize_refs (VEC (vn_reference_op_s, heap) *orig)
 {
 vn_reference_op_t vro;
-int i;
+unsigned int i;
 for (i = 0; VEC_iterate (vn_reference_op_s, orig, i, vro); i++)
 {
 if (vro->opcode == SSA_NAME
 	  || (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME))
 	  vro->op0 = SSA_VAL (vro->op0);
 	  /* If it transforms from an SSA_NAME to a constant, update
 	     the opcode.  */
 	  if (TREE_CODE (vro->op0) != SSA_NAME && vro->opcode == SSA_NAME)
 	    vro->opcode = TREE_CODE (vro->op0);
+	  /* If it transforms from an SSA_NAME to an address, fold with
+	     a preceding indirect reference.  */
+	  if (i > 0 && TREE_CODE (vro->op0) == ADDR_EXPR
+	      && VEC_index (vn_reference_op_s,
+			    orig, i - 1)->opcode == INDIRECT_REF)
+	    {
+	      vn_reference_fold_indirect (&orig, &i);
+	      continue;
+	    }
 	}
-/* TODO: Do we want to valueize op2 and op1 of
+if (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
-	 ARRAY_REF/COMPONENT_REF for Ada */
+	vro->op1 = SSA_VAL (vro->op1);
+if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
+	vro->op2 = SSA_VAL (vro->op2);
 }
 return orig;
 }
-/* Transform any SSA_NAME's in ORIG, a vector of vuse trees, into
+static VEC(vn_reference_op_s, heap) *shared_lookup_references;
-their value numbers. This is done in-place, and the vector passed
-in is returned.  */
+/* Create a vector of vn_reference_op_s structures from REF, a
+REFERENCE_CLASS_P tree.  The vector is shared among all callers of
-static VEC (tree, gc) *
+this function.  */
-valueize_vuses (VEC (tree, gc) *orig)
-{
+static VEC(vn_reference_op_s, heap) *
-bool made_replacement = false;
+valueize_shared_reference_ops_from_ref (tree ref)
-tree vuse;
+{
-int i;
+if (!ref)
+return NULL;
-for (i = 0; VEC_iterate (tree, orig, i, vuse); i++)
+VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
-{
+copy_reference_ops_from_ref (ref, &shared_lookup_references);
-if (vuse != SSA_VAL (vuse))
+shared_lookup_references = valueize_refs (shared_lookup_references);
-	{
+return shared_lookup_references;
-	  made_replacement = true;
+}
-	  VEC_replace (tree, orig, i, SSA_VAL (vuse));
-	}
+/* Create a vector of vn_reference_op_s structures from CALL, a
-}
+call statement.  The vector is shared among all callers of
+this function.  */
-if (made_replacement && VEC_length (tree, orig) > 1)
-sort_vuses (orig);
+static VEC(vn_reference_op_s, heap) *
+valueize_shared_reference_ops_from_call (gimple call)
-return orig;
+{
-}
+if (!call)
+return NULL;
-/* Return the single reference statement defining all virtual uses
+VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
-in VUSES or NULL_TREE, if there are multiple defining statements.
+copy_reference_ops_from_call (call, &shared_lookup_references);
-Take into account only definitions that alias REF if following
+shared_lookup_references = valueize_refs (shared_lookup_references);
-back-edges.  */
+return shared_lookup_references;
-static gimple
-get_def_ref_stmt_vuses (tree ref, VEC (tree, gc) *vuses)
-{
-gimple def_stmt;
-tree vuse;
-unsigned int i;
-gcc_assert (VEC_length (tree, vuses) >= 1);
-def_stmt = SSA_NAME_DEF_STMT (VEC_index (tree, vuses, 0));
-if (gimple_code (def_stmt) == GIMPLE_PHI)
-{
-/* We can only handle lookups over PHI nodes for a single
-	 virtual operand.  */
-if (VEC_length (tree, vuses) == 1)
-	{
-	  def_stmt = get_single_def_stmt_from_phi (ref, def_stmt);
-	  goto cont;
-	}
-else
-	return NULL;
-}
-/* Verify each VUSE reaches the same defining stmt.  */
-for (i = 1; VEC_iterate (tree, vuses, i, vuse); ++i)
-{
-gimple tmp = SSA_NAME_DEF_STMT (vuse);
-if (tmp != def_stmt)
-	return NULL;
-}
-/* Now see if the definition aliases ref, and loop until it does.  */
-cont:
-while (def_stmt
-	 && is_gimple_assign (def_stmt)
-	 && !refs_may_alias_p (ref, gimple_get_lhs (def_stmt)))
-def_stmt = get_single_def_stmt_with_phi (ref, def_stmt);
-return def_stmt;
 }
 /* Lookup a SCCVN reference operation VR in the current hash table.
 Returns the resulting value number if it exists in the hash table,
 NULL_TREE otherwise.  VNRESULT will be filled in with the actual
 {
 if (vnresult)
 	*vnresult = (vn_reference_t)*slot;
 return ((vn_reference_t)*slot)->result;
 }
 return NULL_TREE;
 }
+static tree *last_vuse_ptr;
+/* Callback for walk_non_aliased_vuses.  Adjusts the vn_reference_t VR_
+with the current VUSE and performs the expression lookup.  */
+static void *
+vn_reference_lookup_2 (ao_ref *op ATTRIBUTE_UNUSED, tree vuse, void *vr_)
+{
+vn_reference_t vr = (vn_reference_t)vr_;
+void **slot;
+hashval_t hash;
+if (last_vuse_ptr)
+*last_vuse_ptr = vuse;
+/* Fixup vuse and hash.  */
+vr->hashcode = vr->hashcode - iterative_hash_expr (vr->vuse, 0);
+vr->vuse = SSA_VAL (vuse);
+vr->hashcode = vr->hashcode + iterative_hash_expr (vr->vuse, 0);
+hash = vr->hashcode;
+slot = htab_find_slot_with_hash (current_info->references, vr,
+				   hash, NO_INSERT);
+if (!slot && current_info == optimistic_info)
+slot = htab_find_slot_with_hash (valid_info->references, vr,
+				     hash, NO_INSERT);
+if (slot)
+return *slot;
+return NULL;
+}
+/* Callback for walk_non_aliased_vuses.  Tries to perform a lookup
+from the statement defining VUSE and if not successful tries to
+translate *REFP and VR_ through an aggregate copy at the defintion
+of VUSE.  */
+static void *
+vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_)
+{
+vn_reference_t vr = (vn_reference_t)vr_;
+gimple def_stmt = SSA_NAME_DEF_STMT (vuse);
+tree fndecl;
+tree base;
+HOST_WIDE_INT offset, maxsize;
+base = ao_ref_base (ref);
+offset = ref->offset;
+maxsize = ref->max_size;
+/* If we cannot constrain the size of the reference we cannot
+test if anything kills it.  */
+if (maxsize == -1)
+return (void *)-1;
+/* def_stmt may-defs *ref.  See if we can derive a value for *ref
+from that defintion.
+1) Memset.  */
+if (is_gimple_reg_type (vr->type)
+&& is_gimple_call (def_stmt)
+&& (fndecl = gimple_call_fndecl (def_stmt))
+&& DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
+&& DECL_FUNCTION_CODE (fndecl) == BUILT_IN_MEMSET
+&& integer_zerop (gimple_call_arg (def_stmt, 1))
+&& host_integerp (gimple_call_arg (def_stmt, 2), 1)
+&& TREE_CODE (gimple_call_arg (def_stmt, 0)) == ADDR_EXPR)
+{
+tree ref2 = TREE_OPERAND (gimple_call_arg (def_stmt, 0), 0);
+tree base2;
+HOST_WIDE_INT offset2, size2, maxsize2;
+base2 = get_ref_base_and_extent (ref2, &offset2, &size2, &maxsize2);
+size2 = TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2)) * 8;
+if ((unsigned HOST_WIDE_INT)size2 / 8
+	  == TREE_INT_CST_LOW (gimple_call_arg (def_stmt, 2))
+	  && operand_equal_p (base, base2, 0)
+	  && offset2 <= offset
+	  && offset2 + size2 >= offset + maxsize)
+	{
+	  tree val = fold_convert (vr->type, integer_zero_node);
+	  unsigned int value_id = get_or_alloc_constant_value_id (val);
+	  return vn_reference_insert_pieces (vuse, vr->set, vr->type,
+					     VEC_copy (vn_reference_op_s,
+						       heap, vr->operands),
+					     val, value_id);
+	}
+}
+/* 2) Assignment from an empty CONSTRUCTOR.  */
+else if (is_gimple_reg_type (vr->type)
+	   && gimple_assign_single_p (def_stmt)
+	   && gimple_assign_rhs_code (def_stmt) == CONSTRUCTOR
+	   && CONSTRUCTOR_NELTS (gimple_assign_rhs1 (def_stmt)) == 0)
+{
+tree base2;
+HOST_WIDE_INT offset2, size2, maxsize2;
+base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt),
+				       &offset2, &size2, &maxsize2);
+if (operand_equal_p (base, base2, 0)
+	  && offset2 <= offset
+	  && offset2 + size2 >= offset + maxsize)
+	{
+	  tree val = fold_convert (vr->type, integer_zero_node);
+	  unsigned int value_id = get_or_alloc_constant_value_id (val);
+	  return vn_reference_insert_pieces (vuse, vr->set, vr->type,
+					     VEC_copy (vn_reference_op_s,
+						       heap, vr->operands),
+					     val, value_id);
+	}
+}
+/* For aggregate copies translate the reference through them if
+the copy kills ref.  */
+else if (gimple_assign_single_p (def_stmt)
+	   && (DECL_P (gimple_assign_rhs1 (def_stmt))
+	       || INDIRECT_REF_P (gimple_assign_rhs1 (def_stmt))
+	       || handled_component_p (gimple_assign_rhs1 (def_stmt))))
+{
+tree base2;
+HOST_WIDE_INT offset2, size2, maxsize2;
+int i, j;
+VEC (vn_reference_op_s, heap) *lhs = NULL, *rhs = NULL;
+vn_reference_op_t vro;
+ao_ref r;
+/* See if the assignment kills REF.  */
+base2 = get_ref_base_and_extent (gimple_assign_lhs (def_stmt),
+				       &offset2, &size2, &maxsize2);
+if (!operand_equal_p (base, base2, 0)
+	  || offset2 > offset
+	  || offset2 + size2 < offset + maxsize)
+	return (void *)-1;
+/* Find the common base of ref and the lhs.  */
+copy_reference_ops_from_ref (gimple_assign_lhs (def_stmt), &lhs);
+i = VEC_length (vn_reference_op_s, vr->operands) - 1;
+j = VEC_length (vn_reference_op_s, lhs) - 1;
+while (j >= 0 && i >= 0
+	     && vn_reference_op_eq (VEC_index (vn_reference_op_s,
+					       vr->operands, i),
+				    VEC_index (vn_reference_op_s, lhs, j)))
+	{
+	  i--;
+	  j--;
+	}
+VEC_free (vn_reference_op_s, heap, lhs);
+/* i now points to the first additional op.
+	 ???  LHS may not be completely contained in VR, one or more
+	 VIEW_CONVERT_EXPRs could be in its way.  We could at least
+	 try handling outermost VIEW_CONVERT_EXPRs.  */
+if (j != -1)
+	return (void *)-1;
+/* Now re-write REF to be based on the rhs of the assignment.  */
+copy_reference_ops_from_ref (gimple_assign_rhs1 (def_stmt), &rhs);
+/* We need to pre-pend vr->operands[0..i] to rhs.  */
+if (i + 1 + VEC_length (vn_reference_op_s, rhs)
+	  > VEC_length (vn_reference_op_s, vr->operands))
+	{
+	  VEC (vn_reference_op_s, heap) *old = vr->operands;
+	  VEC_safe_grow (vn_reference_op_s, heap, vr->operands,
+			 i + 1 + VEC_length (vn_reference_op_s, rhs));
+	  if (old == shared_lookup_references
+	      && vr->operands != old)
+	    shared_lookup_references = NULL;
+	}
+else
+	VEC_truncate (vn_reference_op_s, vr->operands,
+		      i + 1 + VEC_length (vn_reference_op_s, rhs));
+for (j = 0; VEC_iterate (vn_reference_op_s, rhs, j, vro); ++j)
+	VEC_replace (vn_reference_op_s, vr->operands, i + 1 + j, vro);
+VEC_free (vn_reference_op_s, heap, rhs);
+vr->hashcode = vn_reference_compute_hash (vr);
+/* Adjust *ref from the new operands.  */
+if (!ao_ref_init_from_vn_reference (&r, vr->set, vr->type, vr->operands))
+	return (void *)-1;
+/* This can happen with bitfields.  */
+if (ref->size != r.size)
+	return (void *)-1;
+*ref = r;
+/* Do not update last seen VUSE after translating.  */
+last_vuse_ptr = NULL;
+/* Keep looking for the adjusted *REF / VR pair.  */
+return NULL;
+}
+/* Bail out and stop walking.  */
+return (void *)-1;
+}
 /* Lookup a reference operation by it's parts, in the current hash table.
 Returns the resulting value number if it exists in the hash table,
 NULL_TREE otherwise.  VNRESULT will be filled in with the actual
 vn_reference_t stored in the hashtable if something is found.  */
 tree
-vn_reference_lookup_pieces (VEC (tree, gc) *vuses,
+vn_reference_lookup_pieces (tree vuse, alias_set_type set, tree type,
 			    VEC (vn_reference_op_s, heap) *operands,
 			    vn_reference_t *vnresult, bool maywalk)
 {
 struct vn_reference_s vr1;
-tree result;
+vn_reference_t tmp;
-if (vnresult)
-*vnresult = NULL;
+if (!vnresult)
+vnresult = &tmp;
-vr1.vuses = valueize_vuses (vuses);
+*vnresult = NULL;
-vr1.operands = valueize_refs (operands);
+vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
+VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
+VEC_safe_grow (vn_reference_op_s, heap, shared_lookup_references,
+		 VEC_length (vn_reference_op_s, operands));
+memcpy (VEC_address (vn_reference_op_s, shared_lookup_references),
+	  VEC_address (vn_reference_op_s, operands),
+	  sizeof (vn_reference_op_s)
+	  * VEC_length (vn_reference_op_s, operands));
+vr1.operands = operands = shared_lookup_references
+= valueize_refs (shared_lookup_references);
+vr1.type = type;
+vr1.set = set;
 vr1.hashcode = vn_reference_compute_hash (&vr1);
-result = vn_reference_lookup_1 (&vr1, vnresult);
+vn_reference_lookup_1 (&vr1, vnresult);
-/* If there is a single defining statement for all virtual uses, we can
+if (!*vnresult
-use that, following virtual use-def chains.  */
-if (!result
 && maywalk
-&& vr1.vuses
+&& vr1.vuse)
-&& VEC_length (tree, vr1.vuses) >= 1)
+{
-{
+ao_ref r;
-tree ref = get_ref_from_reference_ops (operands);
+if (ao_ref_init_from_vn_reference (&r, set, type, vr1.operands))
-gimple def_stmt;
+	*vnresult =
-if (ref
+	  (vn_reference_t)walk_non_aliased_vuses (&r, vr1.vuse,
-	  && (def_stmt = get_def_ref_stmt_vuses (ref, vr1.vuses))
+						  vn_reference_lookup_2,
-	  && is_gimple_assign (def_stmt))
+						  vn_reference_lookup_3, &vr1);
-	{
+if (vr1.operands != operands)
-	  /* We are now at an aliasing definition for the vuses we want to
+	VEC_free (vn_reference_op_s, heap, vr1.operands);
-	     look up.  Re-do the lookup with the vdefs for this stmt.  */
+}
-	  vdefs_to_vec (def_stmt, &vuses);
-	  vr1.vuses = valueize_vuses (vuses);
+if (*vnresult)
-	  vr1.hashcode = vn_reference_compute_hash (&vr1);
+return (*vnresult)->result;
-	  result = vn_reference_lookup_1 (&vr1, vnresult);
-	}
+return NULL_TREE;
-}
-return result;
 }
 /* Lookup OP in the current hash table, and return the resulting value
 number if it exists in the hash table.  Return NULL_TREE if it does
 not exist in the hash table or if the result field of the structure
 was NULL..  VNRESULT will be filled in with the vn_reference_t
 stored in the hashtable if one exists.  */
 tree
-vn_reference_lookup (tree op, VEC (tree, gc) *vuses, bool maywalk,
+vn_reference_lookup (tree op, tree vuse, bool maywalk,
 		     vn_reference_t *vnresult)
 {
+VEC (vn_reference_op_s, heap) *operands;
 struct vn_reference_s vr1;
-tree result;
-gimple def_stmt;
 if (vnresult)
 *vnresult = NULL;
-vr1.vuses = valueize_vuses (vuses);
+vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
-vr1.operands = valueize_refs (shared_reference_ops_from_ref (op));
+vr1.operands = operands = valueize_shared_reference_ops_from_ref (op);
+vr1.type = TREE_TYPE (op);
+vr1.set = get_alias_set (op);
 vr1.hashcode = vn_reference_compute_hash (&vr1);
-result = vn_reference_lookup_1 (&vr1, vnresult);
+if (maywalk
-/* If there is a single defining statement for all virtual uses, we can
+&& vr1.vuse)
-use that, following virtual use-def chains.  */
+{
-if (!result
+vn_reference_t wvnresult;
-&& maywalk
+ao_ref r;
-&& vr1.vuses
+ao_ref_init (&r, op);
-&& VEC_length (tree, vr1.vuses) >= 1
+wvnresult =
-&& (def_stmt = get_def_ref_stmt_vuses (op, vr1.vuses))
+	(vn_reference_t)walk_non_aliased_vuses (&r, vr1.vuse,
-&& is_gimple_assign (def_stmt))
+						vn_reference_lookup_2,
-{
+						vn_reference_lookup_3, &vr1);
-/* We are now at an aliasing definition for the vuses we want to
+if (vr1.operands != operands)
-	 look up.  Re-do the lookup with the vdefs for this stmt.  */
+	VEC_free (vn_reference_op_s, heap, vr1.operands);
-vdefs_to_vec (def_stmt, &vuses);
+if (wvnresult)
-vr1.vuses = valueize_vuses (vuses);
+	{
-vr1.hashcode = vn_reference_compute_hash (&vr1);
+	  if (vnresult)
-result = vn_reference_lookup_1 (&vr1, vnresult);
+	    *vnresult = wvnresult;
-}
+	  return wvnresult->result;
+	}
-return result;
+return NULL_TREE;
+}
+return vn_reference_lookup_1 (&vr1, vnresult);
 }
 /* Insert OP into the current hash table with a value number of
 RESULT, and return the resulting reference structure we created.  */
 vn_reference_t
-vn_reference_insert (tree op, tree result, VEC (tree, gc) *vuses)
+vn_reference_insert (tree op, tree result, tree vuse)
 {
 void **slot;
 vn_reference_t vr1;
 vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
 if (TREE_CODE (result) == SSA_NAME)
 vr1->value_id = VN_INFO (result)->value_id;
 else
 vr1->value_id = get_or_alloc_constant_value_id (result);
-vr1->vuses = valueize_vuses (vuses);
+vr1->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
 vr1->operands = valueize_refs (create_reference_ops_from_ref (op));
+vr1->type = TREE_TYPE (op);
+vr1->set = get_alias_set (op);
 vr1->hashcode = vn_reference_compute_hash (vr1);
 vr1->result = TREE_CODE (result) == SSA_NAME ? SSA_VAL (result) : result;
 slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
 				   INSERT);
 /* Insert a reference by it's pieces into the current hash table with
 a value number of RESULT.  Return the resulting reference
 structure we created.  */
 vn_reference_t
-vn_reference_insert_pieces (VEC (tree, gc) *vuses,
+vn_reference_insert_pieces (tree vuse, alias_set_type set, tree type,
 			    VEC (vn_reference_op_s, heap) *operands,
 			    tree result, unsigned int value_id)
 {
 void **slot;
 vn_reference_t vr1;
 vr1 = (vn_reference_t) pool_alloc (current_info->references_pool);
-vr1->value_id =  value_id;
+vr1->value_id = value_id;
-vr1->vuses = valueize_vuses (vuses);
+vr1->vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
 vr1->operands = valueize_refs (operands);
+vr1->type = type;
+vr1->set = set;
 vr1->hashcode = vn_reference_compute_hash (vr1);
 if (result && TREE_CODE (result) == SSA_NAME)
 result = SSA_VAL (result);
 vr1->result = result;
 slot = htab_find_slot_with_hash (current_info->references, vr1, vr1->hashcode,
 				   INSERT);
 /* At this point we should have all the things inserted that we have
 seen before, and we should never try inserting something that
 already exists.  */
 gcc_assert (!*slot);
 if (*slot)
 free_reference (*slot);
 *slot = vr1;
 return vr1;
 }
 /* Compute and return the hash value for nary operation VBO1.  */
-inline hashval_t
+hashval_t
 vn_nary_op_compute_hash (const vn_nary_op_t vno1)
 {
 hashval_t hash = 0;
 unsigned i;
 if it exists.  */
 tree
 vn_nary_op_lookup_pieces (unsigned int length, enum tree_code code,
 			  tree type, tree op0, tree op1, tree op2,
 			  tree op3, vn_nary_op_t *vnresult)
 {
 void **slot;
 struct vn_nary_op_s vno1;
 if (vnresult)
 *vnresult = NULL;
 vn_nary_op_t
 vn_nary_op_insert_pieces (unsigned int length, enum tree_code code,
 			  tree type, tree op0,
 			  tree op1, tree op2, tree op3,
 			  tree result,
 			  unsigned int value_id)
 {
 void **slot;
 vn_nary_op_t vno1;
 vno1 = (vn_nary_op_t) obstack_alloc (&current_info->nary_obstack,
 				   INSERT);
 gcc_assert (!*slot);
 *slot = vno1;
 return vno1;
 }
 /* Insert OP into the current hash table with a value number of
 RESULT.  Return the vn_nary_op_t structure we created and put in
 the hashtable.  */
 currval = SSA_VAL (from);
 if (currval != to  && !operand_equal_p (currval, to, OEP_PURE_SAME))
 {
-SSA_VAL (from) = to;
+VN_INFO (from)->valnum = to;
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, " (changed)\n");
 return true;
 }
 if (dump_file && (dump_flags & TDF_DETAILS))
 visit_reference_op_call (tree lhs, gimple stmt)
 {
 bool changed = false;
 struct vn_reference_s vr1;
 tree result;
+tree vuse = gimple_vuse (stmt);
-vr1.vuses = valueize_vuses (shared_vuses_from_stmt (stmt));
-vr1.operands = valueize_refs (shared_reference_ops_from_call (stmt));
+vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
+vr1.operands = valueize_shared_reference_ops_from_call (stmt);
+vr1.type = gimple_expr_type (stmt);
+vr1.set = 0;
 vr1.hashcode = vn_reference_compute_hash (&vr1);
 result = vn_reference_lookup_1 (&vr1, NULL);
 if (result)
 {
 changed = set_ssa_val_to (lhs, result);
 {
 void **slot;
 vn_reference_t vr2;
 changed = set_ssa_val_to (lhs, lhs);
 vr2 = (vn_reference_t) pool_alloc (current_info->references_pool);
-vr2->vuses = valueize_vuses (copy_vuses_from_stmt (stmt));
+vr2->vuse = vr1.vuse;
 vr2->operands = valueize_refs (create_reference_ops_from_call (stmt));
+vr2->type = vr1.type;
+vr2->set = vr1.set;
 vr2->hashcode = vr1.hashcode;
 vr2->result = lhs;
 slot = htab_find_slot_with_hash (current_info->references,
 				       vr2, vr2->hashcode, INSERT);
 if (*slot)
 static bool
 visit_reference_op_load (tree lhs, tree op, gimple stmt)
 {
 bool changed = false;
-tree result = vn_reference_lookup (op, shared_vuses_from_stmt (stmt), true,
+tree last_vuse;
-				     NULL);
+tree result;
+last_vuse = gimple_vuse (stmt);
+last_vuse_ptr = &last_vuse;
+result = vn_reference_lookup (op, gimple_vuse (stmt), true, NULL);
+last_vuse_ptr = NULL;
+/* If we have a VCE, try looking up its operand as it might be stored in
+a different type.  */
+if (!result && TREE_CODE (op) == VIEW_CONVERT_EXPR)
+result = vn_reference_lookup (TREE_OPERAND (op, 0), gimple_vuse (stmt),
+				  true, NULL);
 /* We handle type-punning through unions by value-numbering based
 on offset and size of the access.  Be prepared to handle a
 type-mismatch here via creating a VIEW_CONVERT_EXPR.  */
 if (result
 	}
 }
 else
 {
 changed = set_ssa_val_to (lhs, lhs);
-vn_reference_insert (op, lhs, copy_vuses_from_stmt (stmt));
+vn_reference_insert (op, lhs, last_vuse);
 }
 return changed;
 }
 this store.
 Otherwise, the vdefs for the store are used when inserting into
 the table, since the store generates a new memory state.  */
-result = vn_reference_lookup (lhs, shared_vuses_from_stmt (stmt), false,
+result = vn_reference_lookup (lhs, gimple_vuse (stmt), false, NULL);
-				NULL);
 if (result)
 {
 if (TREE_CODE (result) == SSA_NAME)
 	result = SSA_VAL (result);
 resultsame = expressions_equal_p (result, op);
 }
 if (!result || !resultsame)
 {
-VEC(tree, gc) *vdefs = copy_vdefs_from_stmt (stmt);
-int i;
 tree vdef;
 if (dump_file && (dump_flags & TDF_DETAILS))
 	{
 	  fprintf (dump_file, "No store match\n");
 	  print_generic_expr (dump_file, op, 0);
 	  fprintf (dump_file, "\n");
 	}
 /* Have to set value numbers before insert, since insert is
 	 going to valueize the references in-place.  */
-for (i = 0; VEC_iterate (tree, vdefs, i, vdef); i++)
+if ((vdef = gimple_vdef (stmt)))
 	{
 	  VN_INFO (vdef)->use_processed = true;
 	  changed |= set_ssa_val_to (vdef, vdef);
 	}
 /* Do not insert structure copies into the tables.  */
 if (is_gimple_min_invariant (op)
 	  || is_gimple_reg (op))
-vn_reference_insert (lhs, op, vdefs);
+vn_reference_insert (lhs, op, vdef);
 }
 else
 {
-/* We had a match, so value number the vdefs to have the value
+/* We had a match, so value number the vdef to have the value
-	 number of the vuses they came from.  */
+	 number of the vuse it came from.  */
-ssa_op_iter op_iter;
+tree def, use;
-def_operand_p var;
-vuse_vec_p vv;
 if (dump_file && (dump_flags & TDF_DETAILS))
 	fprintf (dump_file, "Store matched earlier value,"
 		 "value numbering store vdefs to matching vuses.\n");
-FOR_EACH_SSA_VDEF_OPERAND (var, vv, stmt, op_iter)
+def = gimple_vdef (stmt);
-	{
+use = gimple_vuse (stmt);
-	  tree def = DEF_FROM_PTR (var);
-	  tree use;
+VN_INFO (def)->use_processed = true;
+changed |= set_ssa_val_to (def, SSA_VAL (use));
-	  /* Uh, if the vuse is a multiuse, we can't really do much
-	     here, sadly, since we don't know which value number of
-	     which vuse to use.  */
-	  if (VUSE_VECT_NUM_ELEM (*vv) != 1)
-	    use = def;
-	  else
-	    use = VUSE_ELEMENT_VAR (*vv, 0);
-	  VN_INFO (def)->use_processed = true;
-	  changed |= set_ssa_val_to (def, SSA_VAL (use));
-	}
 }
 return changed;
 }
 gimple opstmtb = SSA_NAME_DEF_STMT (opb);
 basic_block bba;
 basic_block bbb;
 if (gimple_nop_p (opstmta) && gimple_nop_p (opstmtb))
-return 0;
+return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
 else if (gimple_nop_p (opstmta))
 return -1;
 else if (gimple_nop_p (opstmtb))
 return 1;
 bba = gimple_bb (opstmta);
 bbb = gimple_bb (opstmtb);
 if (!bba && !bbb)
-return 0;
+return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
 else if (!bba)
 return -1;
 else if (!bbb)
 return 1;
 if (bba == bbb)
 {
 if (gimple_code (opstmta) == GIMPLE_PHI
 	  && gimple_code (opstmtb) == GIMPLE_PHI)
-	return 0;
+	return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
 else if (gimple_code (opstmta) == GIMPLE_PHI)
 	return -1;
 else if (gimple_code (opstmtb) == GIMPLE_PHI)
 	return 1;
-return gimple_uid (opstmta) - gimple_uid (opstmtb);
+else if (gimple_uid (opstmta) != gimple_uid (opstmtb))
+return gimple_uid (opstmta) - gimple_uid (opstmtb);
+else
+	return SSA_NAME_VERSION (opa) - SSA_NAME_VERSION (opb);
 }
 return rpo_numbers[bba->index] - rpo_numbers[bbb->index];
 }
 /* Sort an array containing members of a strongly connected component
 {
 qsort (VEC_address (tree, scc),
 	 VEC_length (tree, scc),
 	 sizeof (tree),
 	 compare_ops);
+}
+/* Insert the no longer used nary *ENTRY to the current hash.  */
+static int
+copy_nary (void **entry, void *data ATTRIBUTE_UNUSED)
+{
+vn_nary_op_t onary = (vn_nary_op_t) *entry;
+size_t size = (sizeof (struct vn_nary_op_s)
+		 - sizeof (tree) * (4 - onary->length));
+vn_nary_op_t nary = (vn_nary_op_t) obstack_alloc (&current_info->nary_obstack,
+						    size);
+void **slot;
+memcpy (nary, onary, size);
+slot = htab_find_slot_with_hash (current_info->nary, nary, nary->hashcode,
+				   INSERT);
+gcc_assert (!*slot);
+*slot = nary;
+return 1;
+}
+/* Insert the no longer used phi *ENTRY to the current hash.  */
+static int
+copy_phis (void **entry, void *data ATTRIBUTE_UNUSED)
+{
+vn_phi_t ophi = (vn_phi_t) *entry;
+vn_phi_t phi = (vn_phi_t) pool_alloc (current_info->phis_pool);
+void **slot;
+memcpy (phi, ophi, sizeof (*phi));
+ophi->phiargs = NULL;
+slot = htab_find_slot_with_hash (current_info->phis, phi, phi->hashcode,
+				   INSERT);
+*slot = phi;
+return 1;
+}
+/* Insert the no longer used reference *ENTRY to the current hash.  */
+static int
+copy_references (void **entry, void *data ATTRIBUTE_UNUSED)
+{
+vn_reference_t oref = (vn_reference_t) *entry;
+vn_reference_t ref;
+void **slot;
+ref = (vn_reference_t) pool_alloc (current_info->references_pool);
+memcpy (ref, oref, sizeof (*ref));
+oref->operands = NULL;
+slot = htab_find_slot_with_hash (current_info->references, ref, ref->hashcode,
+				   INSERT);
+if (*slot)
+free_reference (*slot);
+*slot = ref;
+return 1;
 }
 /* Process a strongly connected component in the SSA graph.  */
 static void
 	    changed |= visit_use (var);
 	}
 statistics_histogram_event (cfun, "SCC iterations", iterations);
-/* Finally, visit the SCC once using the valid table.  */
+/* Finally, copy the contents of the no longer used optimistic
+	 table to the valid table.  */
 current_info = valid_info;
-for (i = 0; VEC_iterate (tree, scc, i, var); i++)
+htab_traverse (optimistic_info->nary, copy_nary, NULL);
-	visit_use (var);
+htab_traverse (optimistic_info->phis, copy_phis, NULL);
+htab_traverse (optimistic_info->references, copy_references, NULL);
 }
 }
 DEF_VEC_O(ssa_op_iter);
 DEF_VEC_ALLOC_O(ssa_op_iter,heap);
 calculate_dominance_info (CDI_DOMINATORS);
 sccstack = NULL;
 constant_to_value_id = htab_create (23, vn_constant_hash, vn_constant_eq,
 				  free);
 constant_value_ids = BITMAP_ALLOC (NULL);
 next_dfs_num = 1;
 next_value_id = 1;
 vn_ssa_aux_table = VEC_alloc (vn_ssa_aux_t, heap, num_ssa_names + 1);
 /* VEC_alloc doesn't actually grow it to the right size, it just
 preallocates the space to do so.  */
 VEC_safe_grow_cleared (vn_ssa_aux_t, heap, vn_ssa_aux_table, num_ssa_names + 1);
 gcc_obstack_init (&vn_ssa_aux_obstack);
 shared_lookup_phiargs = NULL;
-shared_lookup_vops = NULL;
 shared_lookup_references = NULL;
 rpo_numbers = XCNEWVEC (int, last_basic_block + NUM_FIXED_BLOCKS);
 rpo_numbers_temp = XCNEWVEC (int, last_basic_block + NUM_FIXED_BLOCKS);
 pre_and_rev_post_order_compute (NULL, rpo_numbers_temp, false);
 size_t i;
 htab_delete (constant_to_value_id);
 BITMAP_FREE (constant_value_ids);
 VEC_free (tree, heap, shared_lookup_phiargs);
-VEC_free (tree, gc, shared_lookup_vops);
 VEC_free (vn_reference_op_s, heap, shared_lookup_references);
 XDELETEVEC (rpo_numbers);
 for (i = 0; i < num_ssa_names; i++)
 {
 /* Now set the value ids of the things we had put in the hash
 table.  */
 FOR_EACH_HTAB_ELEMENT (valid_info->nary,
 			 vno, vn_nary_op_t, hi)
 {
 if (vno->result)
 	{
 	  if (TREE_CODE (vno->result) == SSA_NAME)
 	    vno->value_id = VN_INFO (vno->result)->value_id;
 	    vno->value_id = get_or_alloc_constant_value_id (vno->result);
 	}
 }
 FOR_EACH_HTAB_ELEMENT (valid_info->phis,
 			 vp, vn_phi_t, hi)
 {
 if (vp->result)
 	{
 	  if (TREE_CODE (vp->result) == SSA_NAME)
 	    vp->value_id = VN_INFO (vp->result)->value_id;
 	    vp->value_id = get_or_alloc_constant_value_id (vp->result);
 	}
 }
 FOR_EACH_HTAB_ELEMENT (valid_info->references,
 			 vr, vn_reference_t, hi)
 {
 if (vr->result)
 	{
 	  if (TREE_CODE (vr->result) == SSA_NAME)
 	    vr->value_id = VN_INFO (vr->result)->value_id;
 run_scc_vn (bool may_insert_arg)
 {
 size_t i;
 tree param;
 bool changed = true;
 may_insert = may_insert_arg;
 init_scc_vn ();
 current_info = valid_info;
 param = TREE_CHAIN (param))
 {
 if (gimple_default_def (cfun, param) != NULL)
 	{
 	  tree def = gimple_default_def (cfun, param);
-	  SSA_VAL (def) = def;
+	  VN_INFO (def)->valnum = def;
 	}
 }
 for (i = 1; i < num_ssa_names; ++i)
 {
 	    return false;
 	  }
 }
 /* Initialize the value ids.  */
 for (i = 1; i < num_ssa_names; ++i)
 {
 tree name = ssa_name (i);
 vn_ssa_aux_t info;
 if (!name)
 	continue;
 info = VN_INFO (name);
-if (info->valnum == name)
+if (info->valnum == name
+	  || info->valnum == VN_TOP)
 	info->value_id = get_next_value_id ();
 else if (is_gimple_min_invariant (info->valnum))
 	info->value_id = get_or_alloc_constant_value_id (info->valnum);
 }
 /* Propagate until they stop changing.  */
 while (changed)
 {
 changed = false;
 for (i = 1; i < num_ssa_names; ++i)
 	      changed = true;
 	      info->value_id = VN_INFO (info->valnum)->value_id;
 	    }
 	}
 }
 set_hashtable_value_ids ();
 if (dump_file && (dump_flags & TDF_DETAILS))
 {
 fprintf (dump_file, "Value numbers:\n");
 for (i = 0; i < num_ssa_names; i++)
 	{
 }
 /* Return the maximum value id we have ever seen.  */
 unsigned int
 get_max_value_id (void)
 {
 return next_value_id;
 }
 /* Return the next unique value id.  */
 return true;
 return false;
 }
-/* Sort the VUSE array so that we can do equality comparisons
-quicker on two vuse vecs.  */
-void
-sort_vuses (VEC (tree,gc) *vuses)
-{
-if (VEC_length (tree, vuses) > 1)
-qsort (VEC_address (tree, vuses),
-	   VEC_length (tree, vuses),
-	   sizeof (tree),
-	   operand_build_cmp);
-}
-/* Sort the VUSE array so that we can do equality comparisons
-quicker on two vuse vecs.  */
-void
-sort_vuses_heap (VEC (tree,heap) *vuses)
-{
-if (VEC_length (tree, vuses) > 1)
-qsort (VEC_address (tree, vuses),
-	   VEC_length (tree, vuses),
-	   sizeof (tree),
-	   operand_build_cmp);
-}
 /* Return true if the nary operation NARY may trap.  This is a copy
 of stmt_could_throw_1_p adjusted to the SCCVN IL.  */
 bool

Mercurial > hg > CbC > CbC_gcc

comparison gcc/tree-ssa-sccvn.c @ 55:77e2b8dfacca gcc-4.4.5