[backport r171640 to fix PR48203 regression from r171033 ] gcc/ 2011-03-29 Jakub Jelinek PR debug/48203 * cfgexpand.c (expand_debug_expr) : Only create ENTRY_VALUE if incoming or address of incoming's MEM is a hard REG. * dwarf2out.c (mem_loc_descriptor): Don't emit DW_OP_GNU_entry_value of DW_OP_fbreg. * var-tracking.c (vt_add_function_parameter): Ensure cselib_lookup on ENTRY_VALUE is able to find the canonical parameter VALUE. * cselib.c (rtx_equal_for_cselib_1) : Use rtx_equal_p instead of rtx_equal_for_cselib_1 to compare ENTRY_VALUE_EXPs. (cselib_hash_rtx) : If ENTRY_VALUE_EXP is a REG_P or MEM_P with REG_P address, compute hash directly instead of calling cselib_hash_rtx on ENTRY_VALUE_EXP. (preserve_only_constants): Don't clear VALUES forwaring ENTRY_VALUE to some other VALUE. gcc/testsuite/ 2011-03-29 Jakub Jelinek PR debug/48203 * gcc.dg/pr48203.c: New test. --- gcc-4.7-20110319/gcc/cfgexpand.c.~1~ 2011-03-16 09:35:31.000000000 +0100 +++ gcc-4.7-20110319/gcc/cfgexpand.c 2011-08-27 15:51:15.000000000 +0200 @@ -3182,8 +3182,10 @@ expand_debug_expr (tree exp) rtx incoming = DECL_INCOMING_RTL (SSA_NAME_VAR (exp)); if (incoming && GET_MODE (incoming) != BLKmode - && (REG_P (incoming) - || (MEM_P (incoming) && REG_P (XEXP (incoming, 0))))) + && ((REG_P (incoming) && HARD_REGISTER_P (incoming)) + || (MEM_P (incoming) + && REG_P (XEXP (incoming, 0)) + && HARD_REGISTER_P (XEXP (incoming, 0))))) { op0 = gen_rtx_ENTRY_VALUE (GET_MODE (incoming)); ENTRY_VALUE_EXP (op0) = incoming; --- gcc-4.7-20110319/gcc/cselib.c.~1~ 2011-03-16 09:35:31.000000000 +0100 +++ gcc-4.7-20110319/gcc/cselib.c 2011-08-27 15:51:15.000000000 +0200 @@ -305,7 +305,8 @@ cselib_clear_table (void) cselib_reset_table (1); } -/* Remove from hash table all VALUEs except constants. */ +/* Remove from hash table all VALUEs except constants + and function invariants. */ static int preserve_only_constants (void **x, void *info ATTRIBUTE_UNUSED) @@ -329,6 +330,14 @@ preserve_only_constants (void **x, void return 1; } } + /* Keep around VALUEs that forward function invariant ENTRY_VALUEs + to corresponding parameter VALUEs. */ + if (v->locs != NULL + && v->locs->next != NULL + && v->locs->next->next == NULL + && GET_CODE (v->locs->next->loc) == ENTRY_VALUE + && GET_CODE (v->locs->loc) == VALUE) + return 1; htab_clear_slot (cselib_hash_table, x); return 1; @@ -804,8 +813,9 @@ rtx_equal_for_cselib_1 (rtx x, rtx y, en == DEBUG_IMPLICIT_PTR_DECL (y); case ENTRY_VALUE: - return rtx_equal_for_cselib_1 (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y), - memmode); + /* ENTRY_VALUEs are function invariant, it is thus undesirable to + use rtx_equal_for_cselib_1 to compare the operands. */ + return rtx_equal_p (ENTRY_VALUE_EXP (x), ENTRY_VALUE_EXP (y)); case LABEL_REF: return XEXP (x, 0) == XEXP (y, 0); @@ -954,7 +964,22 @@ cselib_hash_rtx (rtx x, int create, enum return hash ? hash : (unsigned int) DEBUG_IMPLICIT_PTR; case ENTRY_VALUE: - hash += cselib_hash_rtx (ENTRY_VALUE_EXP (x), create, memmode); + /* ENTRY_VALUEs are function invariant, thus try to avoid + recursing on argument if ENTRY_VALUE is one of the + forms emitted by expand_debug_expr, otherwise + ENTRY_VALUE hash would depend on the current value + in some register or memory. */ + if (REG_P (ENTRY_VALUE_EXP (x))) + hash += (unsigned int) REG + + (unsigned int) GET_MODE (ENTRY_VALUE_EXP (x)) + + (unsigned int) REGNO (ENTRY_VALUE_EXP (x)); + else if (MEM_P (ENTRY_VALUE_EXP (x)) + && REG_P (XEXP (ENTRY_VALUE_EXP (x), 0))) + hash += (unsigned int) MEM + + (unsigned int) GET_MODE (XEXP (ENTRY_VALUE_EXP (x), 0)) + + (unsigned int) REGNO (XEXP (ENTRY_VALUE_EXP (x), 0)); + else + hash += cselib_hash_rtx (ENTRY_VALUE_EXP (x), create, memmode); return hash ? hash : (unsigned int) ENTRY_VALUE; case CONST_INT: --- gcc-4.7-20110319/gcc/dwarf2out.c.~1~ 2011-03-18 17:18:05.000000000 +0100 +++ gcc-4.7-20110319/gcc/dwarf2out.c 2011-08-27 15:51:15.000000000 +0200 @@ -13877,7 +13877,7 @@ mem_loc_descriptor (rtx rtl, enum machin dw_loc_descr_ref ref = mem_loc_descriptor (ENTRY_VALUE_EXP (rtl), GET_MODE (rtl), VAR_INIT_STATUS_INITIALIZED); - if (ref == NULL) + if (ref == NULL || ref->dw_loc_opc == DW_OP_fbreg) return NULL; mem_loc_result->dw_loc_oprnd1.v.val_loc = ref; } --- gcc-4.7-20110319/gcc/testsuite/gcc.dg/pr48203.c.~1~ 1970-01-01 01:00:00.000000000 +0100 +++ gcc-4.7-20110319/gcc/testsuite/gcc.dg/pr48203.c 2011-08-27 15:51:15.000000000 +0200 @@ -0,0 +1,51 @@ +/* PR debug/48203 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -g" } */ + +volatile int v; + +void +foo (long a, long b, long c, long d, long e, long f, long g, long h, + long i, long j, long k, long l, long m, long n, long o, long p) +{ + long a2 = a; + long b2 = b; + long c2 = c; + long d2 = d; + long e2 = e; + long f2 = f; + long g2 = g; + long h2 = h; + long i2 = i; + long j2 = j; + long k2 = k; + long l2 = l; + long m2 = m; + long n2 = n; + long o2 = o; + long p2 = p; + v++; +} + +void +bar (int a, int b, int c, int d, int e, int f, int g, int h, + int i, int j, int k, int l, int m, int n, int o, int p) +{ + int a2 = a; + int b2 = b; + int c2 = c; + int d2 = d; + int e2 = e; + int f2 = f; + int g2 = g; + int h2 = h; + int i2 = i; + int j2 = j; + int k2 = k; + int l2 = l; + int m2 = m; + int n2 = n; + int o2 = o; + int p2 = p; + v++; +} --- gcc-4.7-20110319/gcc/var-tracking.c.~1~ 2011-03-17 21:34:59.000000000 +0100 +++ gcc-4.7-20110319/gcc/var-tracking.c 2011-08-27 15:51:15.000000000 +0200 @@ -8472,7 +8472,7 @@ vt_add_function_parameter (tree parm) VAR_INIT_STATUS_INITIALIZED, NULL, INSERT); if (dv_is_value_p (dv)) { - cselib_val *val = CSELIB_VAL_PTR (dv_as_value (dv)); + cselib_val *val = CSELIB_VAL_PTR (dv_as_value (dv)), *val2; struct elt_loc_list *el; el = (struct elt_loc_list *) ggc_alloc_cleared_atomic (sizeof (*el)); @@ -8481,6 +8481,23 @@ vt_add_function_parameter (tree parm) ENTRY_VALUE_EXP (el->loc) = incoming; el->setting_insn = get_insns (); val->locs = el; + val2 = cselib_lookup_from_insn (el->loc, GET_MODE (incoming), + true, VOIDmode, get_insns ()); + if (val2 + && val2 != val + && val2->locs + && rtx_equal_p (val2->locs->loc, el->loc)) + { + struct elt_loc_list *el2; + + preserve_value (val2); + el2 = (struct elt_loc_list *) + ggc_alloc_cleared_atomic (sizeof (*el2)); + el2->next = val2->locs; + el2->loc = dv_as_value (dv); + el2->setting_insn = get_insns (); + val2->locs = el2; + } if (TREE_CODE (TREE_TYPE (parm)) == REFERENCE_TYPE && INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (parm)))) { @@ -8499,6 +8516,24 @@ vt_add_function_parameter (tree parm) ENTRY_VALUE_EXP (el->loc) = mem; el->setting_insn = get_insns (); val->locs = el; + val2 = cselib_lookup_from_insn (el->loc, GET_MODE (mem), + true, VOIDmode, + get_insns ()); + if (val2 + && val2 != val + && val2->locs + && rtx_equal_p (val2->locs->loc, el->loc)) + { + struct elt_loc_list *el2; + + preserve_value (val2); + el2 = (struct elt_loc_list *) + ggc_alloc_cleared_atomic (sizeof (*el2)); + el2->next = val2->locs; + el2->loc = val->val_rtx; + el2->setting_insn = get_insns (); + val2->locs = el2; + } } } }