diff options
Diffstat (limited to 'gcc/tree-ssa-sccvn.c')
| -rw-r--r-- | gcc/tree-ssa-sccvn.c | 114 |
1 files changed, 112 insertions, 2 deletions
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index f502440b46f..26a65f126e1 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -595,11 +595,13 @@ copy_reference_ops_from_ref (tree ref, VEC(vn_reference_op_s, heap) **result) switch (temp.opcode) { case ALIGN_INDIRECT_REF: - case MISALIGNED_INDIRECT_REF: case INDIRECT_REF: /* The only operand is the address, which gets its own vn_reference_op_s structure. */ break; + case MISALIGNED_INDIRECT_REF: + temp.op0 = TREE_OPERAND (ref, 1); + break; case BIT_FIELD_REF: /* Record bits and position. */ temp.op0 = TREE_OPERAND (ref, 1); @@ -676,6 +678,92 @@ copy_reference_ops_from_ref (tree ref, VEC(vn_reference_op_s, heap) **result) } } +/* Re-create a reference tree from the reference ops OPS. + Returns NULL_TREE if the ops were not handled. + This routine needs to be kept in sync with copy_reference_ops_from_ref. */ + +static tree +get_ref_from_reference_ops (VEC(vn_reference_op_s, heap) *ops) +{ + vn_reference_op_t op; + unsigned i; + tree ref, *op0_p = &ref; + + for (i = 0; VEC_iterate (vn_reference_op_s, ops, i, op); ++i) + { + switch (op->opcode) + { + case CALL_EXPR: + return NULL_TREE; + + case ALIGN_INDIRECT_REF: + case INDIRECT_REF: + *op0_p = build1 (op->opcode, op->type, NULL_TREE); + op0_p = &TREE_OPERAND (*op0_p, 0); + break; + + case MISALIGNED_INDIRECT_REF: + *op0_p = build2 (MISALIGNED_INDIRECT_REF, op->type, + NULL_TREE, op->op0); + op0_p = &TREE_OPERAND (*op0_p, 0); + break; + + case BIT_FIELD_REF: + *op0_p = build3 (BIT_FIELD_REF, op->type, NULL_TREE, + 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); + op0_p = &TREE_OPERAND (*op0_p, 0); + break; + + case ARRAY_RANGE_REF: + case ARRAY_REF: + *op0_p = build4 (op->opcode, op->type, NULL_TREE, + op->op0, op->op1, op->op2); + op0_p = &TREE_OPERAND (*op0_p, 0); + 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: + 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 ref; +} + /* Copy the operations present in load/store/call REF into RESULT, a vector of vn_reference_op_s's. */ @@ -895,7 +983,7 @@ vn_reference_lookup_1 (vn_reference_t vr, vn_reference_t *vnresult) tree vn_reference_lookup_pieces (VEC (tree, gc) *vuses, VEC (vn_reference_op_s, heap) *operands, - vn_reference_t *vnresult) + vn_reference_t *vnresult, bool maywalk) { struct vn_reference_s vr1; tree result; @@ -907,6 +995,28 @@ vn_reference_lookup_pieces (VEC (tree, gc) *vuses, vr1.hashcode = vn_reference_compute_hash (&vr1); result = vn_reference_lookup_1 (&vr1, vnresult); + /* If there is a single defining statement for all virtual uses, we can + use that, following virtual use-def chains. */ + if (!result + && maywalk + && vr1.vuses + && VEC_length (tree, vr1.vuses) >= 1) + { + tree ref = get_ref_from_reference_ops (operands); + gimple def_stmt; + if (ref + && (def_stmt = get_def_ref_stmt_vuses (ref, vr1.vuses)) + && is_gimple_assign (def_stmt)) + { + /* We are now at an aliasing definition for the vuses we want to + look up. Re-do the lookup with the vdefs for this stmt. */ + vdefs_to_vec (def_stmt, &vuses); + vr1.vuses = valueize_vuses (vuses); + vr1.hashcode = vn_reference_compute_hash (&vr1); + result = vn_reference_lookup_1 (&vr1, vnresult); + } + } + return result; } |