vn_ssa_aux_t vn = VN_INFO (name);
gimple def_stmt;
tree expr = NULL_TREE;
+ enum tree_code code;
if (vn->valnum == VN_TOP)
return name;
/* Otherwise use the defining statement to build the expression. */
def_stmt = SSA_NAME_DEF_STMT (vn->valnum);
- /* If the value number is a default-definition or a PHI result
- use it directly. */
- if (gimple_nop_p (def_stmt)
- || gimple_code (def_stmt) == GIMPLE_PHI)
- return vn->valnum;
-
+ /* If the value number is not an assignment use it directly. */
if (!is_gimple_assign (def_stmt))
return vn->valnum;
/* FIXME tuples. This is incomplete and likely will miss some
simplifications. */
- switch (TREE_CODE_CLASS (gimple_assign_rhs_code (def_stmt)))
+ code = gimple_assign_rhs_code (def_stmt);
+ switch (TREE_CODE_CLASS (code))
{
case tcc_reference:
- if ((gimple_assign_rhs_code (def_stmt) == VIEW_CONVERT_EXPR
- || gimple_assign_rhs_code (def_stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (def_stmt) == IMAGPART_EXPR)
- && TREE_CODE (gimple_assign_rhs1 (def_stmt)) == SSA_NAME)
- expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
+ if ((code == REALPART_EXPR
+ || code == IMAGPART_EXPR
+ || code == VIEW_CONVERT_EXPR)
+ && TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (def_stmt),
+ 0)) == SSA_NAME)
+ expr = fold_build1 (code,
gimple_expr_type (def_stmt),
TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0));
break;
case tcc_unary:
- expr = fold_build1 (gimple_assign_rhs_code (def_stmt),
+ expr = fold_build1 (code,
gimple_expr_type (def_stmt),
gimple_assign_rhs1 (def_stmt));
break;
case tcc_binary:
- expr = fold_build2 (gimple_assign_rhs_code (def_stmt),
+ expr = fold_build2 (code,
gimple_expr_type (def_stmt),
gimple_assign_rhs1 (def_stmt),
gimple_assign_rhs2 (def_stmt));
const_vn_reference_op_t const vro1 = (const_vn_reference_op_t) p1;
const_vn_reference_op_t const vro2 = (const_vn_reference_op_t) p2;
- return vro1->opcode == vro2->opcode
- && types_compatible_p (vro1->type, vro2->type)
- && expressions_equal_p (vro1->op0, vro2->op0)
- && expressions_equal_p (vro1->op1, vro2->op1)
- && expressions_equal_p (vro1->op2, vro2->op2);
+ return (vro1->opcode == vro2->opcode
+ /* We do not care for differences in type qualification. */
+ && (vro1->type == vro2->type
+ || (vro1->type && vro2->type
+ && types_compatible_p (TYPE_MAIN_VARIANT (vro1->type),
+ TYPE_MAIN_VARIANT (vro2->type))))
+ && expressions_equal_p (vro1->op0, vro2->op0)
+ && expressions_equal_p (vro1->op1, vro2->op1)
+ && expressions_equal_p (vro1->op2, vro2->op2));
}
/* Compute the hash for a reference operand VRO1. */
vn_reference_op_s temp;
memset (&temp, 0, sizeof (temp));
- /* We do not care for spurious type qualifications. */
- temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
+ temp.type = TREE_TYPE (ref);
temp.opcode = TREE_CODE (ref);
temp.op0 = TMR_INDEX (ref);
temp.op1 = TMR_STEP (ref);
vn_reference_op_s temp;
memset (&temp, 0, sizeof (temp));
- /* We do not care for spurious type qualifications. */
- temp.type = TYPE_MAIN_VARIANT (TREE_TYPE (ref));
+ temp.type = TREE_TYPE (ref);
temp.opcode = TREE_CODE (ref);
temp.off = -1;
temp.off = off.low;
}
break;
+ case VAR_DECL:
+ if (DECL_HARD_REGISTER (ref))
+ {
+ temp.op0 = ref;
+ break;
+ }
+ /* Fallthru. */
+ case PARM_DECL:
+ case CONST_DECL:
+ case RESULT_DECL:
+ /* Canonicalize decls to MEM[&decl] which is what we end up with
+ when valueizing MEM[ptr] with ptr = &decl. */
+ temp.opcode = MEM_REF;
+ temp.op0 = build_int_cst (build_pointer_type (TREE_TYPE (ref)), 0);
+ temp.off = 0;
+ VEC_safe_push (vn_reference_op_s, heap, *result, &temp);
+ temp.opcode = ADDR_EXPR;
+ temp.op0 = build_fold_addr_expr (ref);
+ temp.type = TREE_TYPE (temp.op0);
+ temp.off = -1;
+ break;
case STRING_CST:
case INTEGER_CST:
case COMPLEX_CST:
case VECTOR_CST:
case REAL_CST:
+ case FIXED_CST:
case CONSTRUCTOR:
- case VAR_DECL:
- case PARM_DECL:
- case CONST_DECL:
- case RESULT_DECL:
case SSA_NAME:
temp.op0 = ref;
break;
/* 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. */
+ the vector passed in is returned. *VALUEIZED_ANYTHING will specify
+ whether any operands were valueized. */
static VEC (vn_reference_op_s, heap) *
-valueize_refs (VEC (vn_reference_op_s, heap) *orig)
+valueize_refs_1 (VEC (vn_reference_op_s, heap) *orig, bool *valueized_anything)
{
vn_reference_op_t vro;
unsigned int i;
+ *valueized_anything = false;
+
FOR_EACH_VEC_ELT (vn_reference_op_s, orig, i, vro)
{
if (vro->opcode == SSA_NAME
|| (vro->op0 && TREE_CODE (vro->op0) == SSA_NAME))
{
- vro->op0 = SSA_VAL (vro->op0);
+ tree tem = SSA_VAL (vro->op0);
+ if (tem != vro->op0)
+ {
+ *valueized_anything = true;
+ vro->op0 = tem;
+ }
/* 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 (vro->op1 && TREE_CODE (vro->op1) == SSA_NAME)
- vro->op1 = SSA_VAL (vro->op1);
+ {
+ tree tem = SSA_VAL (vro->op1);
+ if (tem != vro->op1)
+ {
+ *valueized_anything = true;
+ vro->op1 = tem;
+ }
+ }
if (vro->op2 && TREE_CODE (vro->op2) == SSA_NAME)
- vro->op2 = SSA_VAL (vro->op2);
+ {
+ tree tem = SSA_VAL (vro->op2);
+ if (tem != vro->op2)
+ {
+ *valueized_anything = true;
+ vro->op2 = tem;
+ }
+ }
/* If it transforms from an SSA_NAME to an address, fold with
a preceding indirect reference. */
if (i > 0
return orig;
}
+static VEC (vn_reference_op_s, heap) *
+valueize_refs (VEC (vn_reference_op_s, heap) *orig)
+{
+ bool tem;
+ return valueize_refs_1 (orig, &tem);
+}
+
static VEC(vn_reference_op_s, heap) *shared_lookup_references;
/* Create a vector of vn_reference_op_s structures from REF, a
REFERENCE_CLASS_P tree. The vector is shared among all callers of
- this function. */
+ this function. *VALUEIZED_ANYTHING will specify whether any
+ operands were valueized. */
static VEC(vn_reference_op_s, heap) *
-valueize_shared_reference_ops_from_ref (tree ref)
+valueize_shared_reference_ops_from_ref (tree ref, bool *valueized_anything)
{
if (!ref)
return NULL;
VEC_truncate (vn_reference_op_s, shared_lookup_references, 0);
copy_reference_ops_from_ref (ref, &shared_lookup_references);
- shared_lookup_references = valueize_refs (shared_lookup_references);
+ shared_lookup_references = valueize_refs_1 (shared_lookup_references,
+ valueized_anything);
return shared_lookup_references;
}
{
VEC (vn_reference_op_s, heap) *tem;
tree lhs = gimple_assign_lhs (def_stmt);
+ bool valueized_anything = false;
/* Avoid re-allocation overhead. */
VEC_truncate (vn_reference_op_s, lhs_ops, 0);
copy_reference_ops_from_ref (lhs, &lhs_ops);
tem = lhs_ops;
- lhs_ops = valueize_refs (lhs_ops);
+ lhs_ops = valueize_refs_1 (lhs_ops, &valueized_anything);
gcc_assert (lhs_ops == tem);
- lhs_ref_ok = ao_ref_init_from_vn_reference (&lhs_ref, get_alias_set (lhs),
- TREE_TYPE (lhs), lhs_ops);
- if (lhs_ref_ok
- && !refs_may_alias_p_1 (ref, &lhs_ref, true))
- return NULL;
+ if (valueized_anything)
+ {
+ lhs_ref_ok = ao_ref_init_from_vn_reference (&lhs_ref,
+ get_alias_set (lhs),
+ TREE_TYPE (lhs), lhs_ops);
+ if (lhs_ref_ok
+ && !refs_may_alias_p_1 (ref, &lhs_ref, true))
+ return NULL;
+ }
+ else
+ {
+ ao_ref_init (&lhs_ref, lhs);
+ lhs_ref_ok = true;
+ }
}
base = ao_ref_base (ref);
j--;
}
+ /* ??? The innermost op should always be a MEM_REF and we already
+ checked that the assignment to the lhs kills vr. Thus for
+ aggregate copies using char[] types the vn_reference_op_eq
+ may fail when comparing types for compatibility. But we really
+ don't care here - further lookups with the rewritten operands
+ will simply fail if we messed up types too badly. */
+ if (j == 0 && i >= 0
+ && VEC_index (vn_reference_op_s, lhs_ops, 0)->opcode == MEM_REF
+ && VEC_index (vn_reference_op_s, lhs_ops, 0)->off != -1
+ && (VEC_index (vn_reference_op_s, lhs_ops, 0)->off
+ == VEC_index (vn_reference_op_s, vr->operands, i)->off))
+ i--, j--;
+
/* 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
op.op0 = build_int_cst (ptr_type_node, at - rhs_offset);
op.off = at - lhs_offset + rhs_offset;
VEC_replace (vn_reference_op_s, vr->operands, 0, &op);
- op.type = TYPE_MAIN_VARIANT (TREE_TYPE (rhs));
+ op.type = TREE_TYPE (rhs);
op.opcode = TREE_CODE (rhs);
op.op0 = rhs;
op.off = -1;
VEC (vn_reference_op_s, heap) *operands;
struct vn_reference_s vr1;
tree cst;
+ bool valuezied_anything;
if (vnresult)
*vnresult = NULL;
vr1.vuse = vuse ? SSA_VAL (vuse) : NULL_TREE;
- vr1.operands = operands = valueize_shared_reference_ops_from_ref (op);
+ vr1.operands = operands
+ = valueize_shared_reference_ops_from_ref (op, &valuezied_anything);
vr1.type = TREE_TYPE (op);
vr1.set = get_alias_set (op);
vr1.hashcode = vn_reference_compute_hash (&vr1);
{
vn_reference_t wvnresult;
ao_ref r;
- ao_ref_init (&r, op);
+ /* Make sure to use a valueized reference if we valueized anything.
+ Otherwise preserve the full reference for advanced TBAA. */
+ if (!valuezied_anything
+ || !ao_ref_init_from_vn_reference (&r, vr1.set, vr1.type,
+ vr1.operands))
+ ao_ref_init (&r, op);
vn_walk_kind = kind;
wvnresult =
(vn_reference_t)walk_non_aliased_vuses (&r, vr1.vuse,
if (vno1->hashcode != vno2->hashcode)
return false;
+ if (vno1->length != vno2->length)
+ return false;
+
if (vno1->opcode != vno2->opcode
|| !types_compatible_p (vno1->type, vno2->type))
return false;
static void
init_vn_nary_op_from_pieces (vn_nary_op_t vno, unsigned int length,
- enum tree_code code, tree type, tree op0,
- tree op1, tree op2, tree op3)
+ enum tree_code code, tree type, tree *ops)
{
vno->opcode = code;
vno->length = length;
vno->type = type;
- switch (length)
- {
- /* The fallthrus here are deliberate. */
- case 4: vno->op[3] = op3;
- case 3: vno->op[2] = op2;
- case 2: vno->op[1] = op1;
- case 1: vno->op[0] = op0;
- default:
- break;
- }
+ memcpy (&vno->op[0], ops, sizeof (tree) * length);
}
/* Initialize VNO from OP. */
vno->op[i] = TREE_OPERAND (op, i);
}
+/* Return the number of operands for a vn_nary ops structure from STMT. */
+
+static unsigned int
+vn_nary_length_from_stmt (gimple stmt)
+{
+ switch (gimple_assign_rhs_code (stmt))
+ {
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ case VIEW_CONVERT_EXPR:
+ return 1;
+
+ case CONSTRUCTOR:
+ return CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt));
+
+ default:
+ return gimple_num_ops (stmt) - 1;
+ }
+}
+
/* Initialize VNO from STMT. */
static void
unsigned i;
vno->opcode = gimple_assign_rhs_code (stmt);
- vno->length = gimple_num_ops (stmt) - 1;
vno->type = gimple_expr_type (stmt);
- for (i = 0; i < vno->length; ++i)
- vno->op[i] = gimple_op (stmt, i + 1);
- if (vno->opcode == REALPART_EXPR
- || vno->opcode == IMAGPART_EXPR
- || vno->opcode == VIEW_CONVERT_EXPR)
- vno->op[0] = TREE_OPERAND (vno->op[0], 0);
+ switch (vno->opcode)
+ {
+ case REALPART_EXPR:
+ case IMAGPART_EXPR:
+ case VIEW_CONVERT_EXPR:
+ vno->length = 1;
+ vno->op[0] = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
+ break;
+
+ case CONSTRUCTOR:
+ vno->length = CONSTRUCTOR_NELTS (gimple_assign_rhs1 (stmt));
+ for (i = 0; i < vno->length; ++i)
+ vno->op[i] = CONSTRUCTOR_ELT (gimple_assign_rhs1 (stmt), i)->value;
+ break;
+
+ default:
+ vno->length = gimple_num_ops (stmt) - 1;
+ for (i = 0; i < vno->length; ++i)
+ vno->op[i] = gimple_op (stmt, i + 1);
+ }
}
/* Compute the hashcode for VNO and look for it in the hash table;
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)
+ tree type, tree *ops, vn_nary_op_t *vnresult)
{
- struct vn_nary_op_s vno1;
- init_vn_nary_op_from_pieces (&vno1, length, code, type, op0, op1, op2, op3);
- return vn_nary_op_lookup_1 (&vno1, vnresult);
+ vn_nary_op_t vno1 = XALLOCAVAR (struct vn_nary_op_s,
+ sizeof_vn_nary_op (length));
+ init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
+ return vn_nary_op_lookup_1 (vno1, vnresult);
}
/* Lookup OP in the current hash table, and return the resulting value
tree
vn_nary_op_lookup (tree op, vn_nary_op_t *vnresult)
{
- struct vn_nary_op_s vno1;
- init_vn_nary_op_from_op (&vno1, op);
- return vn_nary_op_lookup_1 (&vno1, vnresult);
+ vn_nary_op_t vno1
+ = XALLOCAVAR (struct vn_nary_op_s,
+ sizeof_vn_nary_op (TREE_CODE_LENGTH (TREE_CODE (op))));
+ init_vn_nary_op_from_op (vno1, op);
+ return vn_nary_op_lookup_1 (vno1, vnresult);
}
/* Lookup the rhs of STMT in the current hash table, and return the resulting
tree
vn_nary_op_lookup_stmt (gimple stmt, vn_nary_op_t *vnresult)
{
- struct vn_nary_op_s vno1;
- init_vn_nary_op_from_stmt (&vno1, stmt);
- return vn_nary_op_lookup_1 (&vno1, vnresult);
-}
-
-/* Return the size of a vn_nary_op_t with LENGTH operands. */
-
-static size_t
-sizeof_vn_nary_op (unsigned int length)
-{
- return sizeof (struct vn_nary_op_s) - sizeof (tree) * (4 - length);
+ vn_nary_op_t vno1
+ = XALLOCAVAR (struct vn_nary_op_s,
+ sizeof_vn_nary_op (vn_nary_length_from_stmt (stmt)));
+ init_vn_nary_op_from_stmt (vno1, stmt);
+ return vn_nary_op_lookup_1 (vno1, vnresult);
}
/* Allocate a vn_nary_op_t with LENGTH operands on STACK. */
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)
+ tree type, tree *ops,
+ tree result, unsigned int value_id)
{
- vn_nary_op_t vno1;
-
- vno1 = alloc_vn_nary_op (length, result, value_id);
- init_vn_nary_op_from_pieces (vno1, length, code, type, op0, op1, op2, op3);
+ vn_nary_op_t vno1 = alloc_vn_nary_op (length, result, value_id);
+ init_vn_nary_op_from_pieces (vno1, length, code, type, ops);
return vn_nary_op_insert_into (vno1, current_info->nary, true);
}
vn_nary_op_t
vn_nary_op_insert_stmt (gimple stmt, tree result)
{
- unsigned length = gimple_num_ops (stmt) - 1;
- vn_nary_op_t vno1;
-
- vno1 = alloc_vn_nary_op (length, result, VN_INFO (result)->value_id);
+ vn_nary_op_t vno1
+ = alloc_vn_nary_op (vn_nary_length_from_stmt (stmt),
+ result, VN_INFO (result)->value_id);
init_vn_nary_op_from_stmt (vno1, stmt);
return vn_nary_op_insert_into (vno1, current_info->nary, true);
}
return false;
}
+/* Valueize NAME if it is an SSA name, otherwise just return it. */
+
+static inline tree
+vn_valueize (tree name)
+{
+ if (TREE_CODE (name) == SSA_NAME)
+ {
+ tree tem = SSA_VAL (name);
+ return tem == VN_TOP ? name : tem;
+ }
+ return name;
+}
+
/* Replace SSA_NAMES in expr with their value numbers, and return the
result.
This is performed in place. */
{
switch (TREE_CODE_CLASS (TREE_CODE (expr)))
{
- case tcc_unary:
- if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
- && SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
- TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
- break;
case tcc_binary:
- if (TREE_CODE (TREE_OPERAND (expr, 0)) == SSA_NAME
- && SSA_VAL (TREE_OPERAND (expr, 0)) != VN_TOP)
- TREE_OPERAND (expr, 0) = SSA_VAL (TREE_OPERAND (expr, 0));
- if (TREE_CODE (TREE_OPERAND (expr, 1)) == SSA_NAME
- && SSA_VAL (TREE_OPERAND (expr, 1)) != VN_TOP)
- TREE_OPERAND (expr, 1) = SSA_VAL (TREE_OPERAND (expr, 1));
- break;
- default:
+ TREE_OPERAND (expr, 1) = vn_valueize (TREE_OPERAND (expr, 1));
+ /* Fallthru. */
+ case tcc_unary:
+ TREE_OPERAND (expr, 0) = vn_valueize (TREE_OPERAND (expr, 0));
break;
+ default:;
}
return expr;
}
tree result = NULL_TREE;
tree op0 = gimple_assign_rhs1 (stmt);
tree op1 = gimple_assign_rhs2 (stmt);
+ enum tree_code code = gimple_assign_rhs_code (stmt);
/* This will not catch every single case we could combine, but will
catch those with constants. The goal here is to simultaneously
if (TREE_CODE (op0) == SSA_NAME)
{
if (VN_INFO (op0)->has_constants
- || TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)) == tcc_comparison)
+ || TREE_CODE_CLASS (code) == tcc_comparison
+ || code == COMPLEX_EXPR)
op0 = valueize_expr (vn_get_expr_for (op0));
- else if (SSA_VAL (op0) != VN_TOP && SSA_VAL (op0) != op0)
- op0 = SSA_VAL (op0);
+ else
+ op0 = vn_valueize (op0);
}
if (TREE_CODE (op1) == SSA_NAME)
{
- if (VN_INFO (op1)->has_constants)
+ if (VN_INFO (op1)->has_constants
+ || code == COMPLEX_EXPR)
op1 = valueize_expr (vn_get_expr_for (op1));
- else if (SSA_VAL (op1) != VN_TOP && SSA_VAL (op1) != op1)
- op1 = SSA_VAL (op1);
+ else
+ op1 = vn_valueize (op1);
}
/* Pointer plus constant can be represented as invariant address.
Do so to allow further propatation, see also tree forwprop. */
- if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR
+ if (code == POINTER_PLUS_EXPR
&& host_integerp (op1, 1)
&& TREE_CODE (op0) == ADDR_EXPR
&& is_gimple_min_invariant (op0))
fold_defer_overflow_warnings ();
- result = fold_binary (gimple_assign_rhs_code (stmt),
- gimple_expr_type (stmt), op0, op1);
+ result = fold_binary (code, gimple_expr_type (stmt), op0, op1);
if (result)
STRIP_USELESS_TYPE_CONVERSION (result);
{
tree result = NULL_TREE;
tree orig_op0, op0 = gimple_assign_rhs1 (stmt);
+ enum tree_code code = gimple_assign_rhs_code (stmt);
/* We handle some tcc_reference codes here that are all
GIMPLE_ASSIGN_SINGLE codes. */
- if (gimple_assign_rhs_code (stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
- || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
+ if (code == REALPART_EXPR
+ || code == IMAGPART_EXPR
+ || code == VIEW_CONVERT_EXPR)
op0 = TREE_OPERAND (op0, 0);
if (TREE_CODE (op0) != SSA_NAME)
orig_op0 = op0;
if (VN_INFO (op0)->has_constants)
op0 = valueize_expr (vn_get_expr_for (op0));
- else if (gimple_assign_cast_p (stmt)
- || gimple_assign_rhs_code (stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
- || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
+ else if (CONVERT_EXPR_CODE_P (code)
+ || code == REALPART_EXPR
+ || code == IMAGPART_EXPR
+ || code == VIEW_CONVERT_EXPR)
{
/* We want to do tree-combining on conversion-like expressions.
Make sure we feed only SSA_NAMEs or constants to fold though. */
if (op0 == orig_op0)
return NULL_TREE;
- result = fold_unary_ignore_overflow (gimple_assign_rhs_code (stmt),
- gimple_expr_type (stmt), op0);
+ result = fold_unary_ignore_overflow (code, gimple_expr_type (stmt), op0);
if (result)
{
STRIP_USELESS_TYPE_CONVERSION (result);
return NULL_TREE;
}
-/* Valueize NAME if it is an SSA name, otherwise just return it. */
-
-static inline tree
-vn_valueize (tree name)
-{
- if (TREE_CODE (name) == SSA_NAME)
- {
- tree tem = SSA_VAL (name);
- return tem == VN_TOP ? name : tem;
- }
- return name;
-}
-
/* Try to simplify RHS using equivalences and constant folding. */
static tree
changed = defs_to_varying (stmt);
else if (is_gimple_assign (stmt))
{
+ enum tree_code code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
+ tree rhs1 = gimple_assign_rhs1 (stmt);
tree simplified;
/* Shortcut for copies. Simplifying copies is pointless,
since we copy the expression and value they represent. */
- if (gimple_assign_copy_p (stmt)
- && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
+ if (code == SSA_NAME
&& TREE_CODE (lhs) == SSA_NAME)
{
- changed = visit_copy (lhs, gimple_assign_rhs1 (stmt));
+ changed = visit_copy (lhs, rhs1);
goto done;
}
simplified = try_to_simplify (stmt);
/* We can substitute SSA_NAMEs that are live over
abnormal edges with their constant value. */
&& !(gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
+ && is_gimple_min_invariant (rhs1))
&& !(simplified
&& is_gimple_min_invariant (simplified))
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (lhs))
/* Stores or copies from SSA_NAMEs that are live over
abnormal edges are a problem. */
- || (gimple_assign_single_p (stmt)
- && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME
- && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (gimple_assign_rhs1 (stmt))))
+ || (code == SSA_NAME
+ && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (rhs1)))
changed = defs_to_varying (stmt);
- else if (REFERENCE_CLASS_P (lhs) || DECL_P (lhs))
- {
- changed = visit_reference_op_store (lhs, gimple_assign_rhs1 (stmt), stmt);
- }
+ else if (REFERENCE_CLASS_P (lhs)
+ || DECL_P (lhs))
+ changed = visit_reference_op_store (lhs, rhs1, stmt);
else if (TREE_CODE (lhs) == SSA_NAME)
{
if ((gimple_assign_copy_p (stmt)
- && is_gimple_min_invariant (gimple_assign_rhs1 (stmt)))
+ && is_gimple_min_invariant (rhs1))
|| (simplified
&& is_gimple_min_invariant (simplified)))
{
if (simplified)
changed = set_ssa_val_to (lhs, simplified);
else
- changed = set_ssa_val_to (lhs, gimple_assign_rhs1 (stmt));
+ changed = set_ssa_val_to (lhs, rhs1);
}
else
{
- switch (get_gimple_rhs_class (gimple_assign_rhs_code (stmt)))
+ switch (get_gimple_rhs_class (code))
{
case GIMPLE_UNARY_RHS:
case GIMPLE_BINARY_RHS:
changed = visit_nary_op (lhs, stmt);
break;
case GIMPLE_SINGLE_RHS:
- switch (TREE_CODE_CLASS (gimple_assign_rhs_code (stmt)))
+ switch (TREE_CODE_CLASS (code))
{
case tcc_reference:
/* VOP-less references can go through unary case. */
- if ((gimple_assign_rhs_code (stmt) == REALPART_EXPR
- || gimple_assign_rhs_code (stmt) == IMAGPART_EXPR
- || gimple_assign_rhs_code (stmt) == VIEW_CONVERT_EXPR)
- && TREE_CODE (TREE_OPERAND (gimple_assign_rhs1 (stmt), 0)) == SSA_NAME)
+ if ((code == REALPART_EXPR
+ || code == IMAGPART_EXPR
+ || code == VIEW_CONVERT_EXPR)
+ && TREE_CODE (TREE_OPERAND (rhs1, 0)) == SSA_NAME)
{
changed = visit_nary_op (lhs, stmt);
break;
}
/* Fallthrough. */
case tcc_declaration:
- changed = visit_reference_op_load
- (lhs, gimple_assign_rhs1 (stmt), stmt);
+ changed = visit_reference_op_load (lhs, rhs1, stmt);
break;
- case tcc_expression:
- if (gimple_assign_rhs_code (stmt) == ADDR_EXPR)
+ default:
+ if (code == ADDR_EXPR)
+ {
+ changed = visit_nary_op (lhs, stmt);
+ break;
+ }
+ else if (code == CONSTRUCTOR)
{
changed = visit_nary_op (lhs, stmt);
break;
}
- /* Fallthrough. */
- default:
changed = defs_to_varying (stmt);
}
break;
OSDN Git Service
