From c5830edf8594b13767b8282856b01f0f9be9dd20 Mon Sep 17 00:00:00 2001 From: Daniel Berlin Date: Thu, 12 Jul 2007 02:20:04 +0000 Subject: re PR tree-optimization/32663 (revision 126369 went into an infinite loop) 2007-07-11 Daniel Berlin PR tree-optimization/32663 * tree.h (VALUE_HANDLE_VUSES): Remove. (struct tree_value_handle): Remove vuses. * tree-vn.c (create_value_handle_for_expr): Don't set VALUE_HANDLE_VUSES. * tree-ssa-pre.c (expression_vuses): New. (alloc_expression_id): Set up expression_vuses. (get_expression_vuses): New. (set_expression_vuses): Ditto. (clear_expression_ids): Modify for expression_vuses. (phi_translate_1): Ditto. (phi_translate_set): Ditto. (value_dies_in_block_x): Ditto (valid_in_sets): Ditto. (add_to_sets): Ditto. (find_existing_value_expr): Ditto. (create_value_handle_for_expr): Ditto. (make_values_for_stmt): Ditto. (vuse_equiv): Remove. From-SVN: r126568 --- gcc/ChangeLog | 25 ++++ gcc/testsuite/ChangeLog | 4 + gcc/testsuite/gcc.dg/tree-ssa/pr21559.c | 2 +- .../gfortran.fortran-torture/compile/pr32663.f | 147 +++++++++++++++++++++ gcc/tree-ssa-pre.c | 121 +++++++++-------- gcc/tree-ssa-sccvn.c | 8 ++ gcc/tree-vn.c | 7 +- gcc/tree.h | 6 - 8 files changed, 250 insertions(+), 70 deletions(-) create mode 100644 gcc/testsuite/gfortran.fortran-torture/compile/pr32663.f (limited to 'gcc') diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 66a6919..da5976d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,28 @@ +2007-07-11 Daniel Berlin + + PR tree-optimization/32663 + + * tree.h (VALUE_HANDLE_VUSES): Remove. + (struct tree_value_handle): Remove vuses. + + * tree-vn.c (create_value_handle_for_expr): Don't set + VALUE_HANDLE_VUSES. + + * tree-ssa-pre.c (expression_vuses): New. + (alloc_expression_id): Set up expression_vuses. + (get_expression_vuses): New. + (set_expression_vuses): Ditto. + (clear_expression_ids): Modify for expression_vuses. + (phi_translate_1): Ditto. + (phi_translate_set): Ditto. + (value_dies_in_block_x): Ditto + (valid_in_sets): Ditto. + (add_to_sets): Ditto. + (find_existing_value_expr): Ditto. + (create_value_handle_for_expr): Ditto. + (make_values_for_stmt): Ditto. + (vuse_equiv): Remove. + 2007-07-11 Alexandre Oliva * Makefile.in (mostlyclean): Remove object files. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 1f5bdf4..54b392f 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,7 @@ +2007-07-11 Daniel Berlin + + * gfortran.fortran-torture/compile/pr32663.f90: New test. + 2007-07-11 Paolo Carlini PR c++/31027 diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr21559.c b/gcc/testsuite/gcc.dg/tree-ssa/pr21559.c index 402c102..34f4a01 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/pr21559.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr21559.c @@ -37,7 +37,7 @@ void foo (void) /* Second, we should thread the edge out of the loop via the break statement. We also realize that the final bytes == 0 test is useless, and thread over it. */ -/* { dg-final { scan-tree-dump-times "Threaded jump" 2 "vrp1" } } */ +/* { dg-final { scan-tree-dump-times "Threaded jump" 3 "vrp1" } } */ /* { dg-final { cleanup-tree-dump "vrp1" } } */ diff --git a/gcc/testsuite/gfortran.fortran-torture/compile/pr32663.f b/gcc/testsuite/gfortran.fortran-torture/compile/pr32663.f new file mode 100644 index 0000000..03896ad --- /dev/null +++ b/gcc/testsuite/gfortran.fortran-torture/compile/pr32663.f @@ -0,0 +1,147 @@ + SUBROUTINE DIMOID(DEN,RLMO,SSQU,STRI,ATMU,IATM,IWHI,MAPT,INAT, + * IATB,L1,L2,M1,M2,NATS,NOSI,NCAT,NSWE) +C + IMPLICIT DOUBLE PRECISION(A-H,O-Z) +C + DIMENSION RLMO(L1,L1),SSQU(L1,L1),STRI(L2),ATMU(NATS),DEN(M2) + DIMENSION IATM(NATS,M1),IWHI(M1+NATS),MAPT(M1),INAT(M1+NATS) + DIMENSION IATB(NATS,M1) +C + PARAMETER (MXATM=500, MXSH=1000, MXGTOT=5000, MXAO=2047) +C + LOGICAL GOPARR,DSKWRK,MASWRK +C + COMMON /INFOA / NAT,ICH,MUL,NUM,NQMT,NE,NA,NB, + * ZAN(MXATM),C(3,MXATM) + COMMON /IOFILE/ IR,IW,IP,IJKO,IJKT,IDAF,NAV,IODA(400) + COMMON /NSHEL / EX(MXGTOT),CS(MXGTOT),CP(MXGTOT),CD(MXGTOT), + * CF(MXGTOT),CG(MXGTOT), + * KSTART(MXSH),KATOM(MXSH),KTYPE(MXSH), + * KNG(MXSH),KLOC(MXSH),KMIN(MXSH), + * KMAX(MXSH),NSHELL + COMMON /OPTLOC/ CVGLOC,MAXLOC,IPRTLO,ISYMLO,IFCORE,NOUTA,NOUTB, + * MOOUTA(MXAO),MOOUTB(MXAO) + COMMON /PAR / ME,MASTER,NPROC,IBTYP,IPTIM,GOPARR,DSKWRK,MASWRK + COMMON /RUNLAB/ TITLE(10),A(MXATM),B(MXATM),BFLAB(MXAO) +C +C + DO 920 II=1,M1 + INAT(II) = 0 + 920 CONTINUE +C + + DO 900 IO = NOUTA+1,NUMLOC + IZ = IO - NOUTA + DO 895 II=NST,NEND + ATMU(II) = 0.0D+00 + IATM(II,IZ) = 0 + 895 CONTINUE + IFUNC = 0 + DO 890 ISHELL = 1,NSHELL + IAT = KATOM(ISHELL) + IST = KMIN(ISHELL) + IEN = KMAX(ISHELL) + DO 880 INO = IST,IEN + IFUNC = IFUNC + 1 + IF (IAT.LT.NST.OR.IAT.GT.NEND) GOTO 880 + ZINT = 0.0D+00 + DO 870 II = 1,L1 + ZINT = ZINT + RLMO(II,IO)*SSQU(II,IFUNC) + 870 CONTINUE + ATMU(IAT) = ATMU(IAT) + RLMO(IFUNC,IO)*ZINT + 880 CONTINUE + 890 CONTINUE + IF (MASWRK) WRITE(IW,9010) IZ,(ATMU(II),II=NST,NEND) + 900 CONTINUE +C + NOSI = 0 + DO 700 II=1,M1 + NO=0 + DO 720 JJ=1,NAT + NO = NO + 1 + 720 CONTINUE + 740 CONTINUE + IF (NO.GT.1.OR.NO.EQ.0) THEN + NOSI = NOSI + 1 + IWHI(NOSI) = II + ENDIF + IF (MASWRK) + * WRITE(IW,9030) II,(IATM(J,II),A(IATM(J,II)),J=1,NO) + 700 CONTINUE +C + IF (MASWRK) THEN + WRITE(IW,9035) NOSI + IF (NOSI.GT.0) THEN + WRITE(IW,9040) (IWHI(I),I=1,NOSI) + WRITE(IW,9040) + ELSE + WRITE(IW,9040) + ENDIF + ENDIF +C + CALL DCOPY(L1*L1,RLMO,1,SSQU,1) + CALL DCOPY(M2,DEN,1,STRI,1) +C + IP2 = NOUTA + IS2 = M1+NOUTA-NOSI + DO 695 II=1,NAT + INAT(II) = 0 + 695 CONTINUE +C + DO 690 IAT=1,NAT + DO 680 IORB=1,M1 + IP1 = IORB + NOUTA + IF (IATM(1,IORB).NE.IAT) GOTO 680 + IF (IATM(2,IORB).NE.0) GOTO 680 + INAT(IAT) = INAT(IAT) + 1 + IP2 = IP2 + 1 + CALL DCOPY(L1,SSQU(1,IP1),1,RLMO(1,IP2),1) + CALL ICOPY(NAT,IATM(1,IORB),1,IATB(1,IP2-NOUTA),1) + MAPT(IORB) = IP2-NOUTA + 680 CONTINUE + DO 670 IORB=1,NOSI + IS1 = IWHI(IORB) + NOUTA + IF (IAT.EQ.NAT.AND.IATM(1,IWHI(IORB)).EQ.0) GOTO 675 + IF (IATM(1,IWHI(IORB)).NE.IAT) GOTO 670 + 675 CONTINUE + IS2 = IS2 + 1 + MAPT(IWHI(IORB)) = IS2-NOUTA + 670 CONTINUE + 690 CONTINUE +C + NSWE = 0 + NCAT = 0 + LASP = 1 + NLAST = 0 + DO 620 II=1,NAT + NSWE = NSWE + (IWHI(II)*(IWHI(II)-1))/2 + NCAT = NCAT + 1 + INAT(NCAT) = LASP + NLAST + LASP = INAT(NCAT) + NLAST = IWHI(II) + IWHI(NCAT) = II + 620 CONTINUE +C + DO 610 II=1,NOSI + NCAT = NCAT + 1 + INAT(NCAT) = LASP + NLAST + LASP = INAT(NCAT) + NLAST = 1 + IWHI(NCAT) = 0 + 610 CONTINUE +C + RETURN +C + 8000 FORMAT(/1X,'** MULLIKEN ATOMIC POPULATIONS FOR EACH NON-FROZEN ', + * 'LOCALIZED ORBITAL **') + 9000 FORMAT(/3X,'ATOM',2X,100(I2,1X,A4)) + 9005 FORMAT(1X,'LMO') + 9010 FORMAT(1X,I3,3X,100F7.3) + 9015 FORMAT(/1X,'** ATOMIC POPULATIONS GREATER THAN ',F4.2, + * ' ARE CONSIDERED MAJOR **') + 9020 FORMAT(/2X,'LMO',3X,'MAJOR CONTRIBUTIONS FROM ATOM(S)') + 9030 FORMAT(2X,I3,2X,100(I2,1X,A2,2X)) + 9035 FORMAT(/1X,'NO OF LMOS INVOLVING MORE THAN ONE ATOM =',I3) + 9040 FORMAT(1X,'THESE ARE LMOS :',100I3) +C + END diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index ce70a26..c37ab533 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -185,6 +185,12 @@ Boston, MA 02110-1301, USA. */ /* Next global expression id number. */ static unsigned int next_expression_id; +typedef VEC(tree, gc) *vuse_vec; +DEF_VEC_P (vuse_vec); +DEF_VEC_ALLOC_P (vuse_vec, heap); + +static VEC(vuse_vec, heap) *expression_vuses; + /* Mapping from expression to id number we can use in bitmap sets. */ static VEC(tree, heap) *expressions; @@ -203,6 +209,7 @@ alloc_expression_id (tree expr) ann->aux = XNEW (unsigned int); * ((unsigned int *)ann->aux) = next_expression_id++; VEC_safe_push (tree, heap, expressions, expr); + VEC_safe_push (vuse_vec, heap, expression_vuses, NULL); return next_expression_id - 1; } @@ -240,6 +247,25 @@ expression_for_id (unsigned int id) return VEC_index (tree, expressions, id); } +/* Return the expression vuses for EXPR, if there are any. */ + +static inline vuse_vec +get_expression_vuses (tree expr) +{ + return VEC_index (vuse_vec, expression_vuses, + get_or_alloc_expression_id (expr)); +} + +/* Set the expression vuses for EXPR to VUSES. */ + +static inline void +set_expression_vuses (tree expr, vuse_vec vuses) +{ + VEC_replace (vuse_vec, expression_vuses, + get_or_alloc_expression_id (expr), vuses); +} + + /* Free the expression id field in all of our expressions, and then destroy the expressions array. */ @@ -255,6 +281,7 @@ clear_expression_ids (void) tree_common_ann (expr)->aux = NULL; } VEC_free (tree, heap, expressions); + VEC_free (vuse_vec, heap, expression_vuses); } static bool in_fre = false; @@ -956,13 +983,7 @@ phi_translate_1 (tree expr, bitmap_set_t set1, bitmap_set_t set2, /* Phi translations of a given expression don't change. */ if (EXPR_P (expr) || GIMPLE_STMT_P (expr)) { - tree vh; - - vh = get_value_handle (expr); - if (vh && TREE_CODE (vh) == VALUE_HANDLE) - phitrans = phi_trans_lookup (expr, pred, VALUE_HANDLE_VUSES (vh)); - else - phitrans = phi_trans_lookup (expr, pred, NULL); + phitrans = phi_trans_lookup (expr, pred, get_expression_vuses (expr)); } else phitrans = phi_trans_lookup (expr, pred, NULL); @@ -995,10 +1016,9 @@ phi_translate_1 (tree expr, bitmap_set_t set1, bitmap_set_t set2, tree oldsc = CALL_EXPR_STATIC_CHAIN (expr); tree newfn, newsc = NULL; tree newexpr = NULL_TREE; - tree vh = get_value_handle (expr); bool invariantarg = false; int i, nargs; - VEC (tree, gc) *vuses = VALUE_HANDLE_VUSES (vh); + VEC (tree, gc) *vuses = get_expression_vuses (expr); VEC (tree, gc) *tvuses; newfn = phi_translate_1 (find_leader_in_sets (oldfn, set1, set2), @@ -1084,6 +1104,7 @@ phi_translate_1 (tree expr, bitmap_set_t set1, bitmap_set_t set2, newexpr->base.ann = NULL; vn_lookup_or_add_with_vuses (newexpr, tvuses); expr = newexpr; + set_expression_vuses (newexpr, tvuses); } phi_trans_add (oldexpr, expr, pred, tvuses); } @@ -1095,14 +1116,16 @@ phi_translate_1 (tree expr, bitmap_set_t set1, bitmap_set_t set2, VEC (tree, gc) * oldvuses = NULL; VEC (tree, gc) * newvuses = NULL; - oldvuses = VALUE_HANDLE_VUSES (get_value_handle (expr)); + oldvuses = get_expression_vuses (expr); if (oldvuses) newvuses = translate_vuses_through_block (oldvuses, phiblock, pred); if (oldvuses != newvuses) - vn_lookup_or_add_with_vuses (expr, newvuses); - + { + vn_lookup_or_add_with_vuses (expr, newvuses); + set_expression_vuses (expr, newvuses); + } phi_trans_add (oldexpr, expr, pred, newvuses); } return expr; @@ -1160,7 +1183,7 @@ phi_translate_1 (tree expr, bitmap_set_t set1, bitmap_set_t set2, } } - oldvuses = VALUE_HANDLE_VUSES (get_value_handle (expr)); + oldvuses = get_expression_vuses (expr); if (oldvuses) newvuses = translate_vuses_through_block (oldvuses, phiblock, pred); @@ -1195,6 +1218,7 @@ phi_translate_1 (tree expr, bitmap_set_t set1, bitmap_set_t set2, { newexpr->base.ann = NULL; vn_lookup_or_add_with_vuses (newexpr, newvuses); + set_expression_vuses (newexpr, newvuses); } expr = newexpr; } @@ -1360,14 +1384,8 @@ phi_translate_set (bitmap_set_t dest, bitmap_set_t set, basic_block pred, we won't look them up that way, or use the result, anyway. */ if (translated && !is_gimple_min_invariant (translated)) { - tree vh = get_value_handle (translated); - VEC (tree, gc) *vuses; - - /* The value handle itself may also be an invariant, in - which case, it has no vuses. */ - vuses = !is_gimple_min_invariant (vh) - ? VALUE_HANDLE_VUSES (vh) : NULL; - phi_trans_add (expr, translated, pred, vuses); + phi_trans_add (expr, translated, pred, + get_expression_vuses (translated)); } if (translated != NULL) @@ -1413,7 +1431,7 @@ bitmap_find_leader (bitmap_set_t set, tree val) return NULL; } -/* Determine if VALUE, a memory operation, is ANTIC_IN at the top of +/* Determine if EXPR, a memory expressionn, is ANTIC_IN at the top of BLOCK by seeing if it is not killed in the block. Note that we are only determining whether there is a store that kills it. Because of the order in which clean iterates over values, we are guaranteed @@ -1421,11 +1439,11 @@ bitmap_find_leader (bitmap_set_t set, tree val) ANTIC_IN set already. */ static bool -value_dies_in_block_x (tree vh, basic_block block) +value_dies_in_block_x (tree expr, basic_block block) { int i; tree vuse; - VEC (tree, gc) *vuses = VALUE_HANDLE_VUSES (vh); + VEC (tree, gc) *vuses = get_expression_vuses (expr); /* Conservatively, a value dies if it's vuses are defined in this block, unless they come from phi nodes (which are merge operations, @@ -1462,7 +1480,6 @@ static bool valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, tree expr, basic_block block) { - tree vh = get_value_handle (expr); switch (TREE_CODE_CLASS (TREE_CODE (expr))) { case tcc_binary: @@ -1504,7 +1521,7 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, tree expr, if (!union_contains_value (set1, set2, arg)) return false; } - return !value_dies_in_block_x (vh, block); + return !value_dies_in_block_x (expr, block); } return false; } @@ -1540,7 +1557,7 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, tree expr, && !union_contains_value (set1, set2, op3)) return false; } - return !value_dies_in_block_x (vh, block); + return !value_dies_in_block_x (expr, block); } } return false; @@ -1552,7 +1569,7 @@ valid_in_sets (bitmap_set_t set1, bitmap_set_t set2, tree expr, } case tcc_declaration: - return !value_dies_in_block_x (vh, block); + return !value_dies_in_block_x (expr, block); default: /* No other cases should be encountered. */ @@ -2905,11 +2922,11 @@ add_to_exp_gen (basic_block block, tree op) any). */ static inline void -add_to_sets (tree var, tree expr, tree stmt, bitmap_set_t s1, +add_to_sets (tree var, tree expr, VEC(tree, gc) *vuses, bitmap_set_t s1, bitmap_set_t s2) { tree val; - val = vn_lookup_or_add_with_stmt (expr, stmt); + val = vn_lookup_or_add_with_vuses (expr, vuses); /* VAR and EXPR may be the same when processing statements for which we are not computing value numbers (e.g., non-assignments, or @@ -2928,7 +2945,7 @@ add_to_sets (tree var, tree expr, tree stmt, bitmap_set_t s1, and return it if it exists. */ static inline tree -find_existing_value_expr (tree t, tree stmt) +find_existing_value_expr (tree t, VEC (tree, gc) *vuses) { bitmap_iterator bi; unsigned int bii; @@ -2936,7 +2953,7 @@ find_existing_value_expr (tree t, tree stmt) bitmap_set_t exprset; if (REFERENCE_CLASS_P (t) || TREE_CODE (t) == CALL_EXPR || DECL_P (t)) - vh = vn_lookup_with_stmt (t, stmt); + vh = vn_lookup_with_vuses (t, vuses); else vh = vn_lookup (t); @@ -2960,7 +2977,7 @@ find_existing_value_expr (tree t, tree stmt) any). Insert EXPR's operands into the EXP_GEN set for BLOCK. */ static inline tree -create_value_expr_from (tree expr, basic_block block, tree stmt) +create_value_expr_from (tree expr, basic_block block, VEC (tree, gc) *vuses) { int i; enum tree_code code = TREE_CODE (expr); @@ -3008,9 +3025,10 @@ create_value_expr_from (tree expr, basic_block block, tree stmt) /* Recursively value-numberize reference ops and tree lists. */ if (REFERENCE_CLASS_P (op)) { - tree tempop = create_value_expr_from (op, block, stmt); + tree tempop = create_value_expr_from (op, block, vuses); op = tempop ? tempop : op; - val = vn_lookup_or_add_with_stmt (op, stmt); + val = vn_lookup_or_add_with_vuses (op, vuses); + set_expression_vuses (op, vuses); } else { @@ -3024,7 +3042,7 @@ create_value_expr_from (tree expr, basic_block block, tree stmt) TREE_OPERAND (vexpr, i) = val; } - efi = find_existing_value_expr (vexpr, stmt); + efi = find_existing_value_expr (vexpr, vuses); if (efi) return efi; get_or_alloc_expression_id (vexpr); @@ -3289,22 +3307,6 @@ make_values_for_phi (tree phi, basic_block block) } } -/* Return true if both the statement and the value handles have no - vuses, or both the statement and the value handle do have vuses. - - Unlike SCCVN, PRE needs not only to know equivalence, but what the - actual vuses are so it can translate them through blocks. Thus, - we have to make a new value handle if the existing one has no - vuses but needs them. */ - -static bool -vuse_equiv (tree vh1, tree stmt) -{ - bool stmt_has_vuses = !ZERO_SSA_OPERANDS (stmt, SSA_OP_VIRTUAL_USES); - return (VALUE_HANDLE_VUSES (vh1) && stmt_has_vuses) - || (!VALUE_HANDLE_VUSES (vh1) && !stmt_has_vuses); -} - /* Create value handles for STMT in BLOCK. Return true if we handled the statement. */ @@ -3316,8 +3318,10 @@ make_values_for_stmt (tree stmt, basic_block block) tree rhs = GIMPLE_STMT_OPERAND (stmt, 1); tree valvh = NULL_TREE; tree lhsval; + VEC (tree, gc) *vuses = NULL; valvh = get_sccvn_value (lhs); + if (valvh) { vn_add (lhs, valvh); @@ -3340,7 +3344,7 @@ make_values_for_stmt (tree stmt, basic_block block) } lhsval = valvh ? valvh : get_value_handle (lhs); - + vuses = copy_vuses_from_stmt (stmt); STRIP_USELESS_TYPE_CONVERSION (rhs); if (can_value_number_operation (rhs) && (!lhsval || !is_gimple_min_invariant (lhsval))) @@ -3348,12 +3352,13 @@ make_values_for_stmt (tree stmt, basic_block block) /* For value numberable operation, create a duplicate expression with the operands replaced with the value handles of the original RHS. */ - tree newt = create_value_expr_from (rhs, block, stmt); + tree newt = create_value_expr_from (rhs, block, vuses); if (newt) { + set_expression_vuses (newt, vuses); /* If we already have a value number for the LHS, reuse it rather than creating a new one. */ - if (lhsval && vuse_equiv (lhsval, stmt)) + if (lhsval) { set_value_handle (newt, lhsval); if (!is_gimple_min_invariant (lhsval)) @@ -3361,7 +3366,7 @@ make_values_for_stmt (tree stmt, basic_block block) } else { - tree val = vn_lookup_or_add_with_stmt (newt, stmt); + tree val = vn_lookup_or_add_with_vuses (newt, vuses); vn_add (lhs, val); } @@ -3382,6 +3387,7 @@ make_values_for_stmt (tree stmt, basic_block block) if (lhsval) { + set_expression_vuses (rhs, vuses); set_value_handle (rhs, lhsval); if (!is_gimple_min_invariant (lhsval)) add_to_value (lhsval, rhs); @@ -3393,7 +3399,8 @@ make_values_for_stmt (tree stmt, basic_block block) /* Compute a value number for the RHS of the statement and add its value to the AVAIL_OUT set for the block. Add the LHS to TMP_GEN. */ - add_to_sets (lhs, rhs, stmt, TMP_GEN (block), + set_expression_vuses (rhs, vuses); + add_to_sets (lhs, rhs, vuses, TMP_GEN (block), AVAIL_OUT (block)); } /* None of the rest of these can be PRE'd. */ diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c index 37442b8b..a04bb21 100644 --- a/gcc/tree-ssa-sccvn.c +++ b/gcc/tree-ssa-sccvn.c @@ -1431,6 +1431,14 @@ try_to_simplify (tree stmt, tree rhs) /* For references, see if we find a result for the lookup, and use it if we do. */ case tcc_declaration: + /* Pull out any truly constant values. */ + if (TREE_READONLY (rhs) + && TREE_STATIC (rhs) + && DECL_INITIAL (rhs) + && is_gimple_min_invariant (DECL_INITIAL (rhs))) + return DECL_INITIAL (rhs); + + /* Fallthrough. */ case tcc_reference: { tree result = vn_reference_lookup (rhs, diff --git a/gcc/tree-vn.c b/gcc/tree-vn.c index d62aeea..3a22df0 100644 --- a/gcc/tree-vn.c +++ b/gcc/tree-vn.c @@ -108,9 +108,6 @@ set_value_handle (tree e, tree v) gcc_assert (is_gimple_min_invariant (e)); } - - - /* A comparison function for use in qsort to compare vuses. Simply subtracts version numbers. */ @@ -329,7 +326,7 @@ vn_lookup_with_vuses (tree expr, VEC (tree, gc) *vuses) } static tree -create_value_handle_for_expr (tree expr, VEC (tree, gc) *vuses) +create_value_handle_for_expr (tree expr, VEC(tree, gc) *vuses) { tree v; @@ -337,8 +334,6 @@ create_value_handle_for_expr (tree expr, VEC (tree, gc) *vuses) if (dump_file && (dump_flags & TDF_DETAILS)) print_creation_to_file (v, expr, vuses); - if (vuses) - VALUE_HANDLE_VUSES (v) = vuses; return v; } diff --git a/gcc/tree.h b/gcc/tree.h index 318980c..7b051eb 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -3340,9 +3340,6 @@ struct tree_statement_list #define VALUE_HANDLE_EXPR_SET(NODE) \ (VALUE_HANDLE_CHECK (NODE)->value_handle.expr_set) -#define VALUE_HANDLE_VUSES(NODE) \ - (VALUE_HANDLE_CHECK (NODE)->value_handle.vuses) - /* Defined and used in tree-ssa-pre.c. */ struct tree_value_handle GTY(()) @@ -3356,9 +3353,6 @@ struct tree_value_handle GTY(()) conveniently dense form starting at 0, so that we can make bitmaps of value handles. */ unsigned int id; - - /* Set of virtual uses represented by this handle. */ - VEC (tree, gc) *vuses; }; /* Define the overall contents of a tree node. -- cgit v1.1