diff options
Diffstat (limited to 'gcc/df-scan.c')
| -rw-r--r-- | gcc/df-scan.c | 282 |
1 files changed, 202 insertions, 80 deletions
diff --git a/gcc/df-scan.c b/gcc/df-scan.c index 3dc759cedb3..b5d88f3aa58 100644 --- a/gcc/df-scan.c +++ b/gcc/df-scan.c @@ -95,7 +95,7 @@ static struct df_mw_hardreg * df_null_mw_rec[1]; static void df_ref_record (struct df_collection_rec *, rtx, rtx *, basic_block, rtx, enum df_ref_type, - enum df_ref_flags); + enum df_ref_flags, int, int); static void df_def_record_1 (struct df_collection_rec *, rtx, basic_block, rtx, enum df_ref_flags); @@ -104,11 +104,11 @@ static void df_defs_record (struct df_collection_rec *, enum df_ref_flags); static void df_uses_record (struct df_collection_rec *, rtx *, enum df_ref_type, - basic_block, rtx, enum df_ref_flags); + basic_block, rtx, enum df_ref_flags, int, int); static struct df_ref *df_ref_create_structure (struct df_collection_rec *, rtx, rtx *, basic_block, rtx, enum df_ref_type, - enum df_ref_flags); + enum df_ref_flags, int, int); static void df_insn_refs_collect (struct df_collection_rec*, basic_block, rtx); @@ -160,6 +160,7 @@ static bool regs_ever_live[FIRST_PSEUDO_REGISTER]; struct df_scan_problem_data { alloc_pool ref_pool; + alloc_pool ref_extract_pool; alloc_pool insn_pool; alloc_pool reg_pool; alloc_pool mw_reg_pool; @@ -214,6 +215,7 @@ df_scan_free_internal (void) free_alloc_pool (df_scan->block_pool); free_alloc_pool (problem_data->ref_pool); + free_alloc_pool (problem_data->ref_extract_pool); free_alloc_pool (problem_data->insn_pool); free_alloc_pool (problem_data->reg_pool); free_alloc_pool (problem_data->mw_reg_pool); @@ -296,6 +298,9 @@ df_scan_alloc (bitmap all_blocks ATTRIBUTE_UNUSED) problem_data->ref_pool = create_alloc_pool ("df_scan_ref pool", sizeof (struct df_ref), block_size); + problem_data->ref_extract_pool + = create_alloc_pool ("df_scan_ref extract pool", + sizeof (struct df_ref_extract), block_size); problem_data->insn_pool = create_alloc_pool ("df_scan_insn pool", sizeof (struct df_insn_info), block_size); @@ -608,13 +613,19 @@ df_scan_blocks (void) /* Create a new ref of type DF_REF_TYPE for register REG at address - LOC within INSN of BB. */ + LOC within INSN of BB. This function is only used externally. + + If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or + DF_REF_ZERO_EXTRACT. WIDTH and OFFSET are used to access the fields + if they were constants. Otherwise they should be -1 if those flags + were set. */ struct df_ref * df_ref_create (rtx reg, rtx *loc, rtx insn, basic_block bb, enum df_ref_type ref_type, - enum df_ref_flags ref_flags) + enum df_ref_flags ref_flags, + int width, int offset) { struct df_ref *ref; struct df_reg_info **reg_info; @@ -629,7 +640,7 @@ df_ref_create (rtx reg, rtx *loc, rtx insn, /* You cannot hack artificial refs. */ gcc_assert (insn); ref = df_ref_create_structure (NULL, reg, loc, bb, insn, - ref_type, ref_flags); + ref_type, ref_flags, width, offset); if (DF_REF_TYPE (ref) == DF_REF_REG_DEF) { @@ -727,6 +738,18 @@ df_ref_create (rtx reg, rtx *loc, rtx insn, UTILITIES TO CREATE AND DESTROY REFS AND CHAINS. ----------------------------------------------------------------------------*/ +static void +df_free_ref (struct df_ref *ref) +{ + struct df_scan_problem_data *problem_data + = (struct df_scan_problem_data *) df_scan->problem_data; + + if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT)) + pool_free (problem_data->ref_extract_pool, (struct df_ref_extract *)ref); + else + pool_free (problem_data->ref_pool, ref); +} + /* Unlink and delete REF at the reg_use, reg_eq_use or reg_def chain. Also delete the def-use or use-def chain if it exists. */ @@ -736,8 +759,6 @@ df_reg_chain_unlink (struct df_ref *ref) { struct df_ref *next = DF_REF_NEXT_REG (ref); struct df_ref *prev = DF_REF_PREV_REG (ref); - struct df_scan_problem_data *problem_data - = (struct df_scan_problem_data *) df_scan->problem_data; int id = DF_REF_ID (ref); struct df_reg_info *reg_info; struct df_ref **refs = NULL; @@ -808,7 +829,7 @@ df_reg_chain_unlink (struct df_ref *ref) if (next) DF_REF_PREV_REG (next) = prev; - pool_free (problem_data->ref_pool, ref); + df_free_ref (ref); } @@ -1058,13 +1079,13 @@ df_free_collection_rec (struct df_collection_rec *collection_rec) if (collection_rec->def_vec) for (ref = collection_rec->def_vec; *ref; ref++) - pool_free (problem_data->ref_pool, *ref); + df_free_ref (*ref); if (collection_rec->use_vec) for (ref = collection_rec->use_vec; *ref; ref++) - pool_free (problem_data->ref_pool, *ref); + df_free_ref (*ref); if (collection_rec->eq_use_vec) for (ref = collection_rec->eq_use_vec; *ref; ref++) - pool_free (problem_data->ref_pool, *ref); + df_free_ref (*ref); if (collection_rec->mw_vec) for (mw = collection_rec->mw_vec; *mw; mw++) pool_free (problem_data->mw_reg_pool, *mw); @@ -2045,7 +2066,7 @@ df_notes_rescan (rtx insn) case REG_EQUAL: df_uses_record (&collection_rec, &XEXP (note, 0), DF_REF_REG_USE, - bb, insn, DF_REF_IN_NOTE); + bb, insn, DF_REF_IN_NOTE, -1, -1); default: break; } @@ -2115,6 +2136,16 @@ df_ref_equal_p (struct df_ref *ref1, struct df_ref *ref2) { if (!ref2) return false; + + /* The two flag tests here are only to make sure we do not look at + the offset and width if they are not there. The flags are + compared in the next set of tests. */ + if ((DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT)) + && (DF_REF_FLAGS_IS_SET (ref2, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT)) + && ((DF_REF_OFFSET (ref1) != DF_REF_OFFSET (ref2)) + || (DF_REF_WIDTH (ref1) != DF_REF_WIDTH (ref2)))) + return false; + return (ref1 == ref2) || (DF_REF_REG (ref1) == DF_REF_REG (ref2) && DF_REF_REGNO (ref1) == DF_REF_REGNO (ref2) @@ -2163,6 +2194,16 @@ df_ref_compare (const void *r1, const void *r2) else return 1; } + + /* The flags are the same at this point so it is safe to only look + at ref1. */ + if (DF_REF_FLAGS_IS_SET (ref1, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT)) + { + if (DF_REF_OFFSET (ref1) != DF_REF_OFFSET (ref2)) + return DF_REF_OFFSET (ref1) - DF_REF_OFFSET (ref2); + if (DF_REF_WIDTH (ref1) != DF_REF_WIDTH (ref2)) + return DF_REF_WIDTH (ref1) - DF_REF_WIDTH (ref2); + } return 0; } @@ -2179,8 +2220,6 @@ df_swap_refs (struct df_ref **ref_vec, int i, int j) static unsigned int df_sort_and_compress_refs (struct df_ref **ref_vec, unsigned int count) { - struct df_scan_problem_data *problem_data - = (struct df_scan_problem_data *) df_scan->problem_data; unsigned int i; unsigned int dist = 0; @@ -2215,7 +2254,7 @@ df_sort_and_compress_refs (struct df_ref **ref_vec, unsigned int count) /* Find the next ref that is not equal to the current ref. */ while (df_ref_equal_p (ref_vec[i], ref_vec[i + dist + 1])) { - pool_free (problem_data->ref_pool, ref_vec[i + dist + 1]); + df_free_ref (ref_vec[i + dist + 1]); dist++; } /* Copy it down to the next position. */ @@ -2541,21 +2580,34 @@ df_refs_add_to_chains (struct df_collection_rec *collection_rec, } -/* Allocate a ref and initialize its fields. */ +/* Allocate a ref and initialize its fields. + + If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or + DF_REF_ZERO_EXTRACT. WIDTH and OFFSET are used to access the fields + if they were constants. Otherwise they should be -1 if those flags + were set. */ static struct df_ref * df_ref_create_structure (struct df_collection_rec *collection_rec, rtx reg, rtx *loc, basic_block bb, rtx insn, enum df_ref_type ref_type, - enum df_ref_flags ref_flags) + enum df_ref_flags ref_flags, + int width, int offset) { struct df_ref *this_ref; int regno = REGNO (GET_CODE (reg) == SUBREG ? SUBREG_REG (reg) : reg); struct df_scan_problem_data *problem_data = (struct df_scan_problem_data *) df_scan->problem_data; - this_ref = pool_alloc (problem_data->ref_pool); + if (ref_flags & (DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT)) + { + this_ref = pool_alloc (problem_data->ref_extract_pool); + DF_REF_WIDTH (this_ref) = width; + DF_REF_OFFSET (this_ref) = offset; + } + else + this_ref = pool_alloc (problem_data->ref_pool); DF_REF_ID (this_ref) = -1; DF_REF_REG (this_ref) = reg; DF_REF_REGNO (this_ref) = regno; @@ -2604,14 +2656,21 @@ df_ref_create_structure (struct df_collection_rec *collection_rec, /* Create new references of type DF_REF_TYPE for each part of register REG - at address LOC within INSN of BB. */ + at address LOC within INSN of BB. + + If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or + DF_REF_ZERO_EXTRACT. WIDTH and OFFSET are used to access the fields + if they were constants. Otherwise they should be -1 if those flags + were set. */ + static void df_ref_record (struct df_collection_rec *collection_rec, rtx reg, rtx *loc, basic_block bb, rtx insn, enum df_ref_type ref_type, - enum df_ref_flags ref_flags) + enum df_ref_flags ref_flags, + int width, int offset) { unsigned int regno; @@ -2660,7 +2719,7 @@ df_ref_record (struct df_collection_rec *collection_rec, for (i = regno; i < endregno; i++) { ref = df_ref_create_structure (collection_rec, regno_reg_rtx[i], loc, - bb, insn, ref_type, ref_flags); + bb, insn, ref_type, ref_flags, width, offset); gcc_assert (ORIGINAL_REGNO (DF_REF_REG (ref)) == i); } @@ -2669,7 +2728,7 @@ df_ref_record (struct df_collection_rec *collection_rec, { struct df_ref *ref; ref = df_ref_create_structure (collection_rec, reg, loc, bb, insn, - ref_type, ref_flags); + ref_type, ref_flags, width, offset); } } @@ -2703,6 +2762,8 @@ df_def_record_1 (struct df_collection_rec *collection_rec, { rtx *loc; rtx dst; + int offset = -1; + int width = -1; /* We may recursively call ourselves on EXPR_LIST when dealing with PARALLEL construct. */ @@ -2730,16 +2791,24 @@ df_def_record_1 (struct df_collection_rec *collection_rec, return; } - /* Maybe, we should flag the use of STRICT_LOW_PART somehow. It might - be handy for the reg allocator. */ - while (GET_CODE (dst) == STRICT_LOW_PART - || GET_CODE (dst) == ZERO_EXTRACT) + if (GET_CODE (dst) == STRICT_LOW_PART) { - flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL; - if (GET_CODE (dst) == ZERO_EXTRACT) - flags |= DF_REF_EXTRACT; - else - flags |= DF_REF_STRICT_LOWER_PART; + flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_STRICT_LOW_PART; + + loc = &XEXP (dst, 0); + dst = *loc; + } + + if (GET_CODE (dst) == ZERO_EXTRACT) + { + flags |= DF_REF_READ_WRITE | DF_REF_PARTIAL | DF_REF_ZERO_EXTRACT; + + if (GET_CODE (XEXP (dst, 1)) == CONST_INT + && GET_CODE (XEXP (dst, 2)) == CONST_INT) + { + width = INTVAL (XEXP (dst, 1)); + offset = INTVAL (XEXP (dst, 2)); + } loc = &XEXP (dst, 0); dst = *loc; @@ -2749,13 +2818,13 @@ df_def_record_1 (struct df_collection_rec *collection_rec, if (REG_P (dst)) { df_ref_record (collection_rec, - dst, loc, bb, insn, DF_REF_REG_DEF, flags); + dst, loc, bb, insn, DF_REF_REG_DEF, flags, width, offset); /* We want to keep sp alive everywhere - by making all writes to sp also use of sp. */ if (REGNO (dst) == STACK_POINTER_REGNUM) df_ref_record (collection_rec, - dst, NULL, bb, insn, DF_REF_REG_USE, flags); + dst, NULL, bb, insn, DF_REF_REG_USE, flags, width, offset); } else if (GET_CODE (dst) == SUBREG && REG_P (SUBREG_REG (dst))) { @@ -2765,7 +2834,7 @@ df_def_record_1 (struct df_collection_rec *collection_rec, flags |= DF_REF_SUBREG; df_ref_record (collection_rec, - dst, loc, bb, insn, DF_REF_REG_DEF, flags); + dst, loc, bb, insn, DF_REF_REG_DEF, flags, width, offset); } } @@ -2801,12 +2870,18 @@ df_defs_record (struct df_collection_rec *collection_rec, } -/* Process all the registers used in the rtx at address LOC. */ +/* Process all the registers used in the rtx at address LOC. + + If the REF_FLAGS field contain DF_REF_SIGN_EXTRACT or + DF_REF_ZERO_EXTRACT. WIDTH and LOWER are used to access the fields + if they were constants. Otherwise they should be -1 if those flags + were set. */ static void df_uses_record (struct df_collection_rec *collection_rec, rtx *loc, enum df_ref_type ref_type, - basic_block bb, rtx insn, enum df_ref_flags flags) + basic_block bb, rtx insn, enum df_ref_flags flags, + int width, int offset) { RTX_CODE code; rtx x; @@ -2837,7 +2912,7 @@ df_uses_record (struct df_collection_rec *collection_rec, if (MEM_P (XEXP (x, 0))) df_uses_record (collection_rec, &XEXP (XEXP (x, 0), 0), - DF_REF_REG_MEM_STORE, bb, insn, flags); + DF_REF_REG_MEM_STORE, bb, insn, flags, width, offset); /* If we're clobbering a REG then we have a def so ignore. */ return; @@ -2845,7 +2920,7 @@ df_uses_record (struct df_collection_rec *collection_rec, case MEM: df_uses_record (collection_rec, &XEXP (x, 0), DF_REF_REG_MEM_LOAD, - bb, insn, flags & DF_REF_IN_NOTE); + bb, insn, flags & DF_REF_IN_NOTE, width, offset); return; case SUBREG: @@ -2855,22 +2930,46 @@ df_uses_record (struct df_collection_rec *collection_rec, if (!REG_P (SUBREG_REG (x))) { loc = &SUBREG_REG (x); - df_uses_record (collection_rec, loc, ref_type, bb, insn, flags); + df_uses_record (collection_rec, loc, ref_type, bb, insn, flags, width, offset); return; } /* ... Fall through ... */ case REG: df_ref_record (collection_rec, - x, loc, bb, insn, ref_type, flags); + x, loc, bb, insn, ref_type, flags, width, offset); return; + case SIGN_EXTRACT: + case ZERO_EXTRACT: + { + /* If the parameters to the zero or sign extract are + constants, strip them off and recurse, otherwise there is + no information that we can gain from this operation. */ + if (GET_CODE (XEXP (x, 1)) == CONST_INT + && GET_CODE (XEXP (x, 2)) == CONST_INT) + { + width = INTVAL (XEXP (x, 1)); + offset = INTVAL (XEXP (x, 2)); + + if (code == ZERO_EXTRACT) + flags |= DF_REF_ZERO_EXTRACT; + else + flags |= DF_REF_SIGN_EXTRACT; + + df_uses_record (collection_rec, + &XEXP (x, 0), ref_type, bb, insn, flags, width, offset); + return; + } + } + break; + case SET: { rtx dst = SET_DEST (x); gcc_assert (!(flags & DF_REF_IN_NOTE)); df_uses_record (collection_rec, - &SET_SRC (x), DF_REF_REG_USE, bb, insn, flags); + &SET_SRC (x), DF_REF_REG_USE, bb, insn, flags, width, offset); switch (GET_CODE (dst)) { @@ -2879,7 +2978,7 @@ df_uses_record (struct df_collection_rec *collection_rec, { df_uses_record (collection_rec, &SUBREG_REG (dst), DF_REF_REG_USE, bb, insn, - flags | DF_REF_READ_WRITE | DF_REF_SUBREG); + flags | DF_REF_READ_WRITE | DF_REF_SUBREG, width, offset); break; } /* Fall through. */ @@ -2891,7 +2990,7 @@ df_uses_record (struct df_collection_rec *collection_rec, break; case MEM: df_uses_record (collection_rec, &XEXP (dst, 0), - DF_REF_REG_MEM_STORE, bb, insn, flags); + DF_REF_REG_MEM_STORE, bb, insn, flags, width, offset); break; case STRICT_LOW_PART: { @@ -2902,20 +3001,31 @@ df_uses_record (struct df_collection_rec *collection_rec, df_uses_record (collection_rec, (GET_CODE (dst) == SUBREG) ? &SUBREG_REG (dst) : temp, DF_REF_REG_USE, bb, insn, - DF_REF_READ_WRITE | DF_REF_STRICT_LOWER_PART); + DF_REF_READ_WRITE | DF_REF_STRICT_LOW_PART, width, offset); } break; case ZERO_EXTRACT: - case SIGN_EXTRACT: - df_uses_record (collection_rec, &XEXP (dst, 0), - DF_REF_REG_USE, bb, insn, - DF_REF_READ_WRITE | DF_REF_EXTRACT); - df_uses_record (collection_rec, &XEXP (dst, 1), - DF_REF_REG_USE, bb, insn, flags); - df_uses_record (collection_rec, &XEXP (dst, 2), - DF_REF_REG_USE, bb, insn, flags); - dst = XEXP (dst, 0); + { + if (GET_CODE (XEXP (dst, 1)) == CONST_INT + && GET_CODE (XEXP (dst, 2)) == CONST_INT) + { + width = INTVAL (XEXP (dst, 1)); + offset = INTVAL (XEXP (dst, 2)); + } + else + { + df_uses_record (collection_rec, &XEXP (dst, 1), + DF_REF_REG_USE, bb, insn, flags, width, offset); + df_uses_record (collection_rec, &XEXP (dst, 2), + DF_REF_REG_USE, bb, insn, flags, width, offset); + } + + df_uses_record (collection_rec, &XEXP (dst, 0), + DF_REF_REG_USE, bb, insn, + DF_REF_READ_WRITE | DF_REF_ZERO_EXTRACT, width, offset); + } break; + default: gcc_unreachable (); } @@ -2962,7 +3072,7 @@ df_uses_record (struct df_collection_rec *collection_rec, for (j = 0; j < ASM_OPERANDS_INPUT_LENGTH (x); j++) df_uses_record (collection_rec, &ASM_OPERANDS_INPUT (x, j), - DF_REF_REG_USE, bb, insn, flags); + DF_REF_REG_USE, bb, insn, flags, width, offset); return; } break; @@ -2977,7 +3087,7 @@ df_uses_record (struct df_collection_rec *collection_rec, /* Catch the def of the register being modified. */ df_ref_record (collection_rec, XEXP (x, 0), &XEXP (x, 0), bb, insn, DF_REF_REG_DEF, - flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY); + flags | DF_REF_READ_WRITE | DF_REF_PRE_POST_MODIFY, width, offset); /* ... Fall through to handle uses ... */ @@ -3000,14 +3110,16 @@ df_uses_record (struct df_collection_rec *collection_rec, loc = &XEXP (x, 0); goto retry; } - df_uses_record (collection_rec, &XEXP (x, i), ref_type, bb, insn, flags); + df_uses_record (collection_rec, &XEXP (x, i), ref_type, + bb, insn, flags, width, offset); } else if (fmt[i] == 'E') { int j; for (j = 0; j < XVECLEN (x, i); j++) df_uses_record (collection_rec, - &XVECEXP (x, i, j), ref_type, bb, insn, flags); + &XVECEXP (x, i, j), ref_type, + bb, insn, flags, width, offset); } } } @@ -3027,11 +3139,21 @@ df_get_conditional_uses (struct df_collection_rec *collection_rec) struct df_ref *ref = collection_rec->def_vec[i]; if (DF_REF_FLAGS_IS_SET (ref, DF_REF_CONDITIONAL)) { - struct df_ref *use - = df_ref_create_structure (collection_rec, DF_REF_REG (ref), - DF_REF_LOC (ref), DF_REF_BB (ref), - DF_REF_INSN (ref), DF_REF_REG_USE, - DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL); + int width = -1; + int offset = -1; + struct df_ref *use; + + if (DF_REF_FLAGS_IS_SET (ref, DF_REF_SIGN_EXTRACT | DF_REF_ZERO_EXTRACT)) + { + width = DF_REF_WIDTH (ref); + offset = DF_REF_OFFSET (ref); + } + + use = df_ref_create_structure (collection_rec, DF_REF_REG (ref), + DF_REF_LOC (ref), DF_REF_BB (ref), + DF_REF_INSN (ref), DF_REF_REG_USE, + DF_REF_FLAGS (ref) & ~DF_REF_CONDITIONAL, + width, offset); DF_REF_REGNO (use) = DF_REF_REGNO (ref); } } @@ -3069,7 +3191,7 @@ df_get_call_refs (struct df_collection_rec * collection_rec, { if (GET_CODE (XEXP (note, 0)) == USE) df_uses_record (collection_rec, &XEXP (XEXP (note, 0), 0), - DF_REF_REG_USE, bb, insn, flags); + DF_REF_REG_USE, bb, insn, flags, -1, -1); else if (GET_CODE (XEXP (note, 0)) == CLOBBER) { if (REG_P (XEXP (XEXP (note, 0), 0))) @@ -3081,13 +3203,13 @@ df_get_call_refs (struct df_collection_rec * collection_rec, } else df_uses_record (collection_rec, &XEXP (note, 0), - DF_REF_REG_USE, bb, insn, flags); + DF_REF_REG_USE, bb, insn, flags, -1, -1); } } /* The stack ptr is used (honorarily) by a CALL insn. */ df_ref_record (collection_rec, regno_reg_rtx[STACK_POINTER_REGNUM], - NULL, bb, insn, DF_REF_REG_USE, DF_REF_CALL_STACK_USAGE | flags); + NULL, bb, insn, DF_REF_REG_USE, DF_REF_CALL_STACK_USAGE | flags, -1, -1); /* Calls may also reference any of the global registers, so they are recorded as used. */ @@ -3095,9 +3217,9 @@ df_get_call_refs (struct df_collection_rec * collection_rec, if (global_regs[i]) { df_ref_record (collection_rec, regno_reg_rtx[i], - NULL, bb, insn, DF_REF_REG_USE, flags); + NULL, bb, insn, DF_REF_REG_USE, flags, -1, -1); df_ref_record (collection_rec, regno_reg_rtx[i], - NULL, bb, insn, DF_REF_REG_DEF, flags); + NULL, bb, insn, DF_REF_REG_DEF, flags, -1, -1); } is_sibling_call = SIBLING_CALL_P (insn); @@ -3110,7 +3232,7 @@ df_get_call_refs (struct df_collection_rec * collection_rec, || refers_to_regno_p (ui, ui+1, current_function_return_rtx, NULL))) df_ref_record (collection_rec, regno_reg_rtx[ui], - NULL, bb, insn, DF_REF_REG_DEF, DF_REF_MAY_CLOBBER | flags); + NULL, bb, insn, DF_REF_REG_DEF, DF_REF_MAY_CLOBBER | flags, -1, -1); } BITMAP_FREE (defs_generated); @@ -3148,7 +3270,7 @@ df_insn_refs_collect (struct df_collection_rec* collection_rec, case REG_EQUAL: df_uses_record (collection_rec, &XEXP (note, 0), DF_REF_REG_USE, - bb, insn, DF_REF_IN_NOTE); + bb, insn, DF_REF_IN_NOTE, -1, -1); break; case REG_NON_LOCAL_GOTO: /* The frame ptr is used by a non-local goto. */ @@ -3156,13 +3278,13 @@ df_insn_refs_collect (struct df_collection_rec* collection_rec, regno_reg_rtx[FRAME_POINTER_REGNUM], NULL, bb, insn, - DF_REF_REG_USE, 0); + DF_REF_REG_USE, 0, -1, -1); #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM df_ref_record (collection_rec, regno_reg_rtx[HARD_FRAME_POINTER_REGNUM], NULL, bb, insn, - DF_REF_REG_USE, 0); + DF_REF_REG_USE, 0, -1, -1); #endif break; default: @@ -3176,7 +3298,7 @@ df_insn_refs_collect (struct df_collection_rec* collection_rec, /* Record the register uses. */ df_uses_record (collection_rec, - &PATTERN (insn), DF_REF_REG_USE, bb, insn, 0); + &PATTERN (insn), DF_REF_REG_USE, bb, insn, 0, -1, -1); /* DF_REF_CONDITIONAL needs corresponding USES. */ if (is_cond_exec) @@ -3259,7 +3381,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb) if (regno == INVALID_REGNUM) break; df_ref_record (collection_rec, regno_reg_rtx[regno], NULL, - bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP); + bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1); } } #endif @@ -3283,7 +3405,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb) for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) if (EH_USES (i)) df_ref_record (collection_rec, regno_reg_rtx[i], NULL, - bb, NULL, DF_REF_REG_USE, DF_REF_AT_TOP); + bb, NULL, DF_REF_REG_USE, DF_REF_AT_TOP, -1, -1); } #endif @@ -3291,7 +3413,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb) non-local goto. */ if (bb->flags & BB_NON_LOCAL_GOTO_TARGET) df_ref_record (collection_rec, hard_frame_pointer_rtx, NULL, - bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP); + bb, NULL, DF_REF_REG_DEF, DF_REF_AT_TOP, -1, -1); /* Add the artificial uses. */ if (bb->index >= NUM_FIXED_BLOCKS) @@ -3305,7 +3427,7 @@ df_bb_refs_collect (struct df_collection_rec *collection_rec, basic_block bb) EXECUTE_IF_SET_IN_BITMAP (au, 0, regno, bi) { df_ref_record (collection_rec, regno_reg_rtx[regno], NULL, - bb, NULL, DF_REF_REG_USE, 0); + bb, NULL, DF_REF_REG_USE, 0, -1, -1); } } @@ -3598,7 +3720,7 @@ df_entry_block_defs_collect (struct df_collection_rec *collection_rec, EXECUTE_IF_SET_IN_BITMAP (entry_block_defs, 0, i, bi) { df_ref_record (collection_rec, regno_reg_rtx[i], NULL, - ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0); + ENTRY_BLOCK_PTR, NULL, DF_REF_REG_DEF, 0, -1, -1); } df_canonize_collection_rec (collection_rec); @@ -3759,7 +3881,7 @@ df_exit_block_uses_collect (struct df_collection_rec *collection_rec, bitmap exi EXECUTE_IF_SET_IN_BITMAP (exit_block_uses, 0, i, bi) df_ref_record (collection_rec, regno_reg_rtx[i], NULL, - EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0); + EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1); #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM /* It is deliberate that this is not put in the exit block uses but @@ -3769,7 +3891,7 @@ df_exit_block_uses_collect (struct df_collection_rec *collection_rec, bitmap exi && bb_has_eh_pred (EXIT_BLOCK_PTR) && fixed_regs[ARG_POINTER_REGNUM]) df_ref_record (collection_rec, regno_reg_rtx[ARG_POINTER_REGNUM], NULL, - EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0); + EXIT_BLOCK_PTR, NULL, DF_REF_REG_USE, 0, -1, -1); #endif df_canonize_collection_rec (collection_rec); |