tiny mark_reg_set speedup
Jan Hubicka
jh@suse.cz
Mon Feb 2 00:16:00 GMT 2004
> Jan Hubicka <jh@suse.cz> writes:
>
> > Hi,
> > second hottest line is line checking HARD_REGNO_NREGS inside flow.c...
> > I updated only the uses in flow.c and the benefits seems to be somewhere
> > in between 0.8-1.6 seconds per 2m compilation. If this seem worthwhile,
> > I can update rest of the uses.
> >
> > Bootstrapped/regtested i686-pc-gnu-linux (as all the previous patches
> > today, I think I forgot it to mention, sorry)
> > OK?
>
> This is OK, but please:
>
> - Change the rest of the cases; and then
Hi,
this is the patch changing all the uses I am about to commit. I will
prepare the hooks next.
Bootstrapped/regtested i686-pc-gnu-linux.
Honza
2004-02-02 Jan Hubicka <jh@suse.cz>
* alias.c (record_set): Use hard_regno_nregs.
* bt-load.c (find_btr_reference, note_btr_set): Likewise.
* builtins.c (apply_args_size): Likewise.
* caller-save.c (setup_save_areas, save_call_clobbered_regs,
mark_set_regs, add_stored_regs, mark_referenced_regs,
insert_restore, insert_save, insert_one_insn): Likewise.
* cfgcleanup.c: Include regs.h
(mark_effect, mentions_nonequal_regs): Likewise.
* cfgrtl.c (mark_killed_regs): Likewise
* combine.c (update_table_tick, record_value_for_reg,
record_dead_and_set_regs, get_last_value_validate, use_crosses_set_p,
reg_dead_at_p_1, reg_dead_at_p, mark_used_regs_combine, move_deaths,
reg_bitfield_target_p, distribute_notes): Likewise.
* cse.c (mention_regs, insert, invalidate, invalidate_for_call,
exp_equiv_p, cse_insn): Likewise.
* cselib.c (cselib_lookup): Likewise.
(cselib_invalidate_regno, cselib_record_set): Likewise.
* df.c (df_ref_record): Likewise.
* dwarf2out.c (reg_loc_descriptor, multiple_reg_loc_descriptor):
Likewise.
* flow.c (mark_reg, insn_dead_p, mark_set_1, mark_used_reg,
count_or_remove_death_notes_bb): Likewise.
* function.c (aggregate_value_p, keep_stack_depressed): Likewise.
* gloval.c (global_alloc, find_reg, mark_reg_store, mark_reg_conflicts,
mark_reg_death, set_preference, reg_becomes_live, reg_dies): Likewise.
* integrate.c (mark_stores): Likewise.
* jump.c (delete_prior_computation): Likewise.
* lcm.c (reg_dies, reg_becomes_live): Likewise.
* local-alloc.c (combine_regs, find_free_reg, post_mark_life): Likewise.
* loop.c (LOOP_REGNO_NREGS): Likewise.
* postreload.c (reload_combine, reload_combine_note_store,
reload_combine_note_use, reload_cse_move2add, move2add_note_store): Likewise.
* ra-colorize.c (combine, color_usable_p, get_free_reg,
calculate_dont_begin, calculate_dont_begin, colorize_one_web,
try_recolor_web, insert_coalesced_conflicts, check_colors,
break_precolored_alias): Likewise.
* ra-debug.c: Include regs.h
(ra_print_rtx_object): Likewise.
* ra-rewrite (choose_spill_colors): Likewise.
(spill_same_color_p, update_spill_colors, spill_is_free): Likewise.
* ra.c (init_ra): Likewise.
* recog.c (reg_fits_class_p, peep2_reg_dead_p,
peep2_find_free_register): Likewise.
* reg-stack.c (subst_stack_regs_pat, convert_regs_exit): Likewise.
* regclass.c (hard_regno_nregs): New array.
(init_reg_modes_once): Initialize it.
(choose_hard_reg_mode): Use it.
(record_reg_classes): Likewise.
* regmove.c (mark_flags_life_zones): Likewise.
* regrename.c (note_sets, clear_dead_regs, regrename_optimize,
scan_rtx_reg, dump_def_use_chain, kill_value, set_value_regno,
copy_value, maybe_mode_change, find_oldest_value_reg,
copyprop_hardreg_forward_1):
* regs.h (hard_regno_nregs): Declare.
* realod.c (reload_inner_reg_of_subreg): Use it.
(push_reload, combine_reloads, find_dummy_reload,
hard_reg_set_here_p, operands_match_p, decompose, find_reloads,
refers_to_regno_for_reload_p, find_equiv_reg, regno_clobbered_p,
reload_adjust_reg_for_mode): Likewise.
* reload1.c (compute_use_by_pseudos, count_pseudo,
count_spilled_pseudo, find_reg, find_reload_regs, mark_home_live,
spill_hard_reg, forget_old_reloads_1, mark_reload_reg_in_use,
clear_reload_reg_in_use, reload_reg_free_for_value_p, free_for_value_p
allocate_reload_reg, choose_reload_regs, emit_reload_insns,
delete_output_reload): Likewise.
* resource.c (update_live_status, mark_referenced_resources,
mark_set_resources, mark_target_live_regs): Likewise.
* rtlanal.c: Include regs.h
(refers_to_regno_p, reg_overlap_mentioned_p, dead_or_set_p,
dead_or_set_regno_p, find_regno_note, find_reg_fusage,
subreg_regno_offset, subreg_offset_representable_p,
hoist_test_store): Likewise.
* sched-deps.c (sched_analyze_1, sched_analyze_2): Likewise.
* sched-rgn.c (check_live_1, update_live_1): Likewise.
* stmt.c: Include regs.h
(decl_conflicts_with_clobbers_p): Likewise.
* varasm.c (make_decl_rtl): Likewise.
* Makefile.in (cfgcleanup.o, rtlanal.o, ra-debug.o): Add regs.h dependnecy.
Index: alias.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/alias.c,v
retrieving revision 1.212
diff -c -3 -p -r1.212 alias.c
*** alias.c 22 Jan 2004 11:35:58 -0000 1.212
--- alias.c 1 Feb 2004 23:36:09 -0000
*************** record_set (rtx dest, rtx set, void *dat
*** 942,948 ****
/* If this spans multiple hard registers, then we must indicate that every
register has an unusable value. */
if (regno < FIRST_PSEUDO_REGISTER)
! n = HARD_REGNO_NREGS (regno, GET_MODE (dest));
else
n = 1;
if (n != 1)
--- 942,948 ----
/* If this spans multiple hard registers, then we must indicate that every
register has an unusable value. */
if (regno < FIRST_PSEUDO_REGISTER)
! n = hard_regno_nregs[regno][GET_MODE (dest)];
else
n = 1;
if (n != 1)
Index: bt-load.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/bt-load.c,v
retrieving revision 2.14
diff -c -3 -p -r2.14 bt-load.c
*** bt-load.c 31 Jan 2004 08:02:47 -0000 2.14
--- bt-load.c 1 Feb 2004 23:36:09 -0000
*************** find_btr_reference (rtx *px, void *preg)
*** 198,204 ****
if (GET_CODE (x) != REG)
return 0;
regno = REGNO (x);
! for (i = HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1; i >= 0; i--)
if (TEST_HARD_REG_BIT (all_btrs, regno+i))
{
btr_reference_found = px;
--- 198,204 ----
if (GET_CODE (x) != REG)
return 0;
regno = REGNO (x);
! for (i = hard_regno_nregs[regno][GET_MODE (x)] - 1; i >= 0; i--)
if (TEST_HARD_REG_BIT (all_btrs, regno+i))
{
btr_reference_found = px;
*************** note_btr_set (rtx dest, rtx set ATTRIBUT
*** 430,436 ****
if (GET_CODE (dest) != REG)
return;
regno = REGNO (dest);
! end_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (dest));
for (; regno < end_regno; regno++)
if (TEST_HARD_REG_BIT (all_btrs, regno))
{
--- 430,436 ----
if (GET_CODE (dest) != REG)
return;
regno = REGNO (dest);
! end_regno = regno + hard_regno_nregs[regno][GET_MODE (dest)];
for (; regno < end_regno; regno++)
if (TEST_HARD_REG_BIT (all_btrs, regno))
{
Index: builtins.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/builtins.c,v
retrieving revision 1.280
diff -c -3 -p -r1.280 builtins.c
*** builtins.c 1 Feb 2004 15:03:15 -0000 1.280
--- builtins.c 1 Feb 2004 23:36:09 -0000
*************** apply_args_size (void)
*** 941,947 ****
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
if (HARD_REGNO_MODE_OK (regno, mode)
! && HARD_REGNO_NREGS (regno, mode) == 1)
best_mode = mode;
if (best_mode == VOIDmode)
--- 941,947 ----
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
if (HARD_REGNO_MODE_OK (regno, mode)
! && hard_regno_nregs[regno][mode] == 1)
best_mode = mode;
if (best_mode == VOIDmode)
Index: caller-save.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/caller-save.c,v
retrieving revision 1.60
diff -c -3 -p -r1.60 caller-save.c
*** caller-save.c 21 Dec 2003 14:08:32 -0000 1.60
--- caller-save.c 1 Feb 2004 23:36:09 -0000
*************** setup_save_areas (void)
*** 300,306 ****
{
unsigned int regno = reg_renumber[i];
unsigned int endregno
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (regno_reg_rtx[i]));
for (r = regno; r < endregno; r++)
if (call_used_regs[r])
--- 300,306 ----
{
unsigned int regno = reg_renumber[i];
unsigned int endregno
! = regno + hard_regno_nregs[regno][GET_MODE (regno_reg_rtx[i])];
for (r = regno; r < endregno; r++)
if (call_used_regs[r])
*************** save_call_clobbered_regs (void)
*** 436,442 ****
{
enum machine_mode mode;
! nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (regno));
mode = HARD_REGNO_CALLER_SAVE_MODE
(r, nregs, PSEUDO_REGNO_MODE (regno));
if (GET_MODE_BITSIZE (mode)
--- 436,442 ----
{
enum machine_mode mode;
! nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
mode = HARD_REGNO_CALLER_SAVE_MODE
(r, nregs, PSEUDO_REGNO_MODE (regno));
if (GET_MODE_BITSIZE (mode)
*************** mark_set_regs (rtx reg, rtx setter ATTRI
*** 515,521 ****
else
return;
! endregno = regno + HARD_REGNO_NREGS (regno, mode);
for (i = regno; i < endregno; i++)
SET_HARD_REG_BIT (this_insn_sets, i);
--- 515,521 ----
else
return;
! endregno = regno + hard_regno_nregs[regno][mode];
for (i = regno; i < endregno; i++)
SET_HARD_REG_BIT (this_insn_sets, i);
*************** add_stored_regs (rtx reg, rtx setter, vo
*** 548,554 ****
return;
regno = REGNO (reg) + offset;
! endregno = regno + HARD_REGNO_NREGS (regno, mode);
for (i = regno; i < endregno; i++)
SET_REGNO_REG_SET ((regset) data, i);
--- 548,554 ----
return;
regno = REGNO (reg) + offset;
! endregno = regno + hard_regno_nregs[regno][mode];
for (i = regno; i < endregno; i++)
SET_REGNO_REG_SET ((regset) data, i);
*************** mark_referenced_regs (rtx x)
*** 595,601 ****
if (hardregno >= 0)
{
! int nregs = HARD_REGNO_NREGS (hardregno, GET_MODE (x));
while (nregs-- > 0)
SET_HARD_REG_BIT (referenced_regs, hardregno + nregs);
}
--- 595,601 ----
if (hardregno >= 0)
{
! int nregs = hard_regno_nregs[hardregno][GET_MODE (x)];
while (nregs-- > 0)
SET_HARD_REG_BIT (referenced_regs, hardregno + nregs);
}
*************** insert_restore (struct insn_chain *chain
*** 683,689 ****
mem = regno_save_mem [regno][numregs];
if (save_mode [regno] != VOIDmode
&& save_mode [regno] != GET_MODE (mem)
! && numregs == (unsigned int) HARD_REGNO_NREGS (regno, save_mode [regno]))
mem = adjust_address (mem, save_mode[regno], 0);
pat = gen_rtx_SET (VOIDmode,
gen_rtx_REG (GET_MODE (mem),
--- 683,689 ----
mem = regno_save_mem [regno][numregs];
if (save_mode [regno] != VOIDmode
&& save_mode [regno] != GET_MODE (mem)
! && numregs == (unsigned int) hard_regno_nregs[regno][save_mode [regno]])
mem = adjust_address (mem, save_mode[regno], 0);
pat = gen_rtx_SET (VOIDmode,
gen_rtx_REG (GET_MODE (mem),
*************** insert_save (struct insn_chain *chain, i
*** 755,761 ****
mem = regno_save_mem [regno][numregs];
if (save_mode [regno] != VOIDmode
&& save_mode [regno] != GET_MODE (mem)
! && numregs == (unsigned int) HARD_REGNO_NREGS (regno, save_mode [regno]))
mem = adjust_address (mem, save_mode[regno], 0);
pat = gen_rtx_SET (VOIDmode, mem,
gen_rtx_REG (GET_MODE (mem),
--- 755,761 ----
mem = regno_save_mem [regno][numregs];
if (save_mode [regno] != VOIDmode
&& save_mode [regno] != GET_MODE (mem)
! && numregs == (unsigned int) hard_regno_nregs[regno][save_mode [regno]])
mem = adjust_address (mem, save_mode[regno], 0);
pat = gen_rtx_SET (VOIDmode, mem,
gen_rtx_REG (GET_MODE (mem),
*************** insert_one_insn (struct insn_chain *chai
*** 828,834 ****
regno = reg_renumber[regno];
if (regno < 0)
continue;
! for (i = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1;
i >= 0; i--)
SET_REGNO_REG_SET (&new->live_throughout, regno + i);
}
--- 828,834 ----
regno = reg_renumber[regno];
if (regno < 0)
continue;
! for (i = hard_regno_nregs[regno][GET_MODE (reg)] - 1;
i >= 0; i--)
SET_REGNO_REG_SET (&new->live_throughout, regno + i);
}
Index: cfgcleanup.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfgcleanup.c,v
retrieving revision 1.105
diff -c -3 -p -r1.105 cfgcleanup.c
*** cfgcleanup.c 29 Jan 2004 07:47:54 -0000 1.105
--- cfgcleanup.c 1 Feb 2004 23:36:09 -0000
*************** Software Foundation, 59 Temple Place - S
*** 48,53 ****
--- 48,54 ----
#include "params.h"
#include "tm_p.h"
#include "target.h"
+ #include "regs.h"
/* cleanup_cfg maintains following flags for each basic block. */
*************** mark_effect (rtx exp, regset nonequal)
*** 220,226 ****
CLEAR_REGNO_REG_SET (nonequal, regno);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = HARD_REGNO_NREGS (regno, GET_MODE (dest));
while (--n > 0)
CLEAR_REGNO_REG_SET (nonequal, regno + n);
}
--- 221,227 ----
CLEAR_REGNO_REG_SET (nonequal, regno);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = hard_regno_nregs[regno][GET_MODE (dest)];
while (--n > 0)
CLEAR_REGNO_REG_SET (nonequal, regno + n);
}
*************** mark_effect (rtx exp, regset nonequal)
*** 239,245 ****
SET_REGNO_REG_SET (nonequal, regno);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = HARD_REGNO_NREGS (regno, GET_MODE (dest));
while (--n > 0)
SET_REGNO_REG_SET (nonequal, regno + n);
}
--- 240,246 ----
SET_REGNO_REG_SET (nonequal, regno);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = hard_regno_nregs[regno][GET_MODE (dest)];
while (--n > 0)
SET_REGNO_REG_SET (nonequal, regno + n);
}
*************** mentions_nonequal_regs (rtx *x, void *da
*** 265,271 ****
return 1;
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = HARD_REGNO_NREGS (regno, GET_MODE (*x));
while (--n > 0)
if (REGNO_REG_SET_P (nonequal, regno + n))
return 1;
--- 266,272 ----
return 1;
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = hard_regno_nregs[regno][GET_MODE (*x)];
while (--n > 0)
if (REGNO_REG_SET_P (nonequal, regno + n))
return 1;
Index: cfgrtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cfgrtl.c,v
retrieving revision 1.107
diff -c -3 -p -r1.107 cfgrtl.c
*** cfgrtl.c 29 Jan 2004 07:47:54 -0000 1.107
--- cfgrtl.c 1 Feb 2004 23:36:10 -0000
*************** mark_killed_regs (rtx reg, rtx set ATTRI
*** 1352,1358 ****
SET_REGNO_REG_SET (killed, regno);
else
{
! for (i = 0; i < (int) HARD_REGNO_NREGS (regno, GET_MODE (reg)); i++)
SET_REGNO_REG_SET (killed, regno + i);
}
}
--- 1352,1358 ----
SET_REGNO_REG_SET (killed, regno);
else
{
! for (i = 0; i < (int) hard_regno_nregs[regno][GET_MODE (reg)]; i++)
SET_REGNO_REG_SET (killed, regno + i);
}
}
Index: combine.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/combine.c,v
retrieving revision 1.406
diff -c -3 -p -r1.406 combine.c
*** combine.c 31 Jan 2004 09:21:13 -0000 1.406
--- combine.c 1 Feb 2004 23:36:11 -0000
*************** update_table_tick (rtx x)
*** 11368,11374 ****
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
unsigned int r;
for (r = regno; r < endregno; r++)
--- 11368,11374 ----
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
unsigned int r;
for (r = regno; r < endregno; r++)
*************** record_value_for_reg (rtx reg, rtx insn,
*** 11433,11439 ****
unsigned int regno = REGNO (reg);
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1);
unsigned int i;
/* If VALUE contains REG and we have a previous value for REG, substitute
--- 11433,11439 ----
unsigned int regno = REGNO (reg);
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (reg)] : 1);
unsigned int i;
/* If VALUE contains REG and we have a previous value for REG, substitute
*************** record_dead_and_set_regs (rtx insn)
*** 11590,11596 ****
unsigned int regno = REGNO (XEXP (link, 0));
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (XEXP (link, 0)))
: 1);
for (i = regno; i < endregno; i++)
--- 11590,11596 ----
unsigned int regno = REGNO (XEXP (link, 0));
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (XEXP (link, 0))]
: 1);
for (i = regno; i < endregno; i++)
*************** get_last_value_validate (rtx *loc, rtx i
*** 11726,11732 ****
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
unsigned int j;
for (j = regno; j < endregno; j++)
--- 11726,11732 ----
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
unsigned int j;
for (j = regno; j < endregno; j++)
*************** use_crosses_set_p (rtx x, int from_cuid)
*** 11888,11894 ****
{
unsigned int regno = REGNO (x);
unsigned endreg = regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
#ifdef PUSH_ROUNDING
/* Don't allow uses of the stack pointer to be moved,
--- 11888,11894 ----
{
unsigned int regno = REGNO (x);
unsigned endreg = regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
#ifdef PUSH_ROUNDING
/* Don't allow uses of the stack pointer to be moved,
*************** reg_dead_at_p_1 (rtx dest, rtx x, void *
*** 11945,11951 ****
regno = REGNO (dest);
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (dest)) : 1);
if (reg_dead_endregno > regno && reg_dead_regno < endregno)
reg_dead_flag = (GET_CODE (x) == CLOBBER) ? 1 : -1;
--- 11945,11951 ----
regno = REGNO (dest);
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (dest)] : 1);
if (reg_dead_endregno > regno && reg_dead_regno < endregno)
reg_dead_flag = (GET_CODE (x) == CLOBBER) ? 1 : -1;
*************** reg_dead_at_p (rtx reg, rtx insn)
*** 11968,11975 ****
/* Set variables for reg_dead_at_p_1. */
reg_dead_regno = REGNO (reg);
reg_dead_endregno = reg_dead_regno + (reg_dead_regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (reg_dead_regno,
! GET_MODE (reg))
: 1);
reg_dead_flag = 0;
--- 11968,11975 ----
/* Set variables for reg_dead_at_p_1. */
reg_dead_regno = REGNO (reg);
reg_dead_endregno = reg_dead_regno + (reg_dead_regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[reg_dead_regno]
! [GET_MODE (reg)]
: 1);
reg_dead_flag = 0;
*************** mark_used_regs_combine (rtx x)
*** 12070,12076 ****
|| regno == FRAME_POINTER_REGNUM)
return;
! endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
for (r = regno; r < endregno; r++)
SET_HARD_REG_BIT (newpat_used_regs, r);
}
--- 12070,12076 ----
|| regno == FRAME_POINTER_REGNUM)
return;
! endregno = regno + hard_regno_nregs[regno][GET_MODE (x)];
for (r = regno; r < endregno; r++)
SET_HARD_REG_BIT (newpat_used_regs, r);
}
*************** move_deaths (rtx x, rtx maybe_kill_insn,
*** 12199,12208 ****
{
unsigned int deadregno = REGNO (XEXP (note, 0));
unsigned int deadend
! = (deadregno + HARD_REGNO_NREGS (deadregno,
! GET_MODE (XEXP (note, 0))));
unsigned int ourend
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
unsigned int i;
for (i = deadregno; i < deadend; i++)
--- 12199,12208 ----
{
unsigned int deadregno = REGNO (XEXP (note, 0));
unsigned int deadend
! = (deadregno + hard_regno_nregs[deadregno]
! [GET_MODE (XEXP (note, 0))]);
unsigned int ourend
! = regno + hard_regno_nregs[regno][GET_MODE (x)];
unsigned int i;
for (i = deadregno; i < deadend; i++)
*************** move_deaths (rtx x, rtx maybe_kill_insn,
*** 12223,12237 ****
&& (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
< GET_MODE_SIZE (GET_MODE (x)))))
&& regno < FIRST_PSEUDO_REGISTER
! && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1)
{
unsigned int ourend
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
unsigned int i, offset;
rtx oldnotes = 0;
if (note)
! offset = HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0)));
else
offset = 1;
--- 12223,12237 ----
&& (GET_MODE_SIZE (GET_MODE (XEXP (note, 0)))
< GET_MODE_SIZE (GET_MODE (x)))))
&& regno < FIRST_PSEUDO_REGISTER
! && hard_regno_nregs[regno][GET_MODE (x)] > 1)
{
unsigned int ourend
! = regno + hard_regno_nregs[regno][GET_MODE (x)];
unsigned int i, offset;
rtx oldnotes = 0;
if (note)
! offset = hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))];
else
offset = 1;
*************** reg_bitfield_target_p (rtx x, rtx body)
*** 12344,12351 ****
if (tregno >= FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
return target == x;
! endtregno = tregno + HARD_REGNO_NREGS (tregno, GET_MODE (target));
! endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
return endregno > tregno && regno < endtregno;
}
--- 12344,12351 ----
if (tregno >= FIRST_PSEUDO_REGISTER || regno >= FIRST_PSEUDO_REGISTER)
return target == x;
! endtregno = tregno + hard_regno_nregs[tregno][GET_MODE (target)];
! endregno = regno + hard_regno_nregs[regno][GET_MODE (x)];
return endregno > tregno && regno < endtregno;
}
*************** distribute_notes (rtx notes, rtx from_in
*** 12821,12831 ****
the previous insn that used this register. */
if (place && regno < FIRST_PSEUDO_REGISTER
! && HARD_REGNO_NREGS (regno, GET_MODE (XEXP (note, 0))) > 1)
{
unsigned int endregno
! = regno + HARD_REGNO_NREGS (regno,
! GET_MODE (XEXP (note, 0)));
int all_used = 1;
unsigned int i;
--- 12821,12831 ----
the previous insn that used this register. */
if (place && regno < FIRST_PSEUDO_REGISTER
! && hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))] > 1)
{
unsigned int endregno
! = regno + hard_regno_nregs[regno]
! [GET_MODE (XEXP (note, 0))];
int all_used = 1;
unsigned int i;
*************** distribute_notes (rtx notes, rtx from_in
*** 12841,12847 ****
not already dead or set. */
for (i = regno; i < endregno;
! i += HARD_REGNO_NREGS (i, reg_raw_mode[i]))
{
rtx piece = regno_reg_rtx[i];
basic_block bb = this_basic_block;
--- 12841,12847 ----
not already dead or set. */
for (i = regno; i < endregno;
! i += hard_regno_nregs[i][reg_raw_mode[i]])
{
rtx piece = regno_reg_rtx[i];
basic_block bb = this_basic_block;
Index: cse.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cse.c,v
retrieving revision 1.284
diff -c -3 -p -r1.284 cse.c
*** cse.c 31 Jan 2004 09:21:18 -0000 1.284
--- cse.c 1 Feb 2004 23:36:11 -0000
*************** mention_regs (rtx x)
*** 1162,1168 ****
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
! : HARD_REGNO_NREGS (regno, GET_MODE (x)));
unsigned int i;
for (i = regno; i < endregno; i++)
--- 1162,1168 ----
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
! : hard_regno_nregs[regno][GET_MODE (x)]);
unsigned int i;
for (i = regno; i < endregno; i++)
*************** insert (rtx x, struct table_elt *classp,
*** 1529,1535 ****
if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
{
unsigned int regno = REGNO (x);
! unsigned int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
unsigned int i;
for (i = regno; i < endregno; i++)
--- 1529,1535 ----
if (GET_CODE (x) == REG && REGNO (x) < FIRST_PSEUDO_REGISTER)
{
unsigned int regno = REGNO (x);
! unsigned int endregno = regno + hard_regno_nregs[regno][GET_MODE (x)];
unsigned int i;
for (i = regno; i < endregno; i++)
*************** invalidate (rtx x, enum machine_mode ful
*** 1842,1848 ****
HOST_WIDE_INT in_table
= TEST_HARD_REG_BIT (hard_regs_in_table, regno);
unsigned int endregno
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
unsigned int tregno, tendregno, rn;
struct table_elt *p, *next;
--- 1842,1848 ----
HOST_WIDE_INT in_table
= TEST_HARD_REG_BIT (hard_regs_in_table, regno);
unsigned int endregno
! = regno + hard_regno_nregs[regno][GET_MODE (x)];
unsigned int tregno, tendregno, rn;
struct table_elt *p, *next;
*************** invalidate (rtx x, enum machine_mode ful
*** 1869,1875 ****
tregno = REGNO (p->exp);
tendregno
! = tregno + HARD_REGNO_NREGS (tregno, GET_MODE (p->exp));
if (tendregno > regno && tregno < endregno)
remove_from_table (p, hash);
}
--- 1869,1875 ----
tregno = REGNO (p->exp);
tendregno
! = tregno + hard_regno_nregs[tregno][GET_MODE (p->exp)];
if (tendregno > regno && tregno < endregno)
remove_from_table (p, hash);
}
*************** invalidate_for_call (void)
*** 2081,2087 ****
continue;
regno = REGNO (p->exp);
! endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (p->exp));
for (i = regno; i < endregno; i++)
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
--- 2081,2087 ----
continue;
regno = REGNO (p->exp);
! endregno = regno + hard_regno_nregs[regno][GET_MODE (p->exp)];
for (i = regno; i < endregno; i++)
if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
*************** exp_equiv_p (rtx x, rtx y, int validate,
*** 2540,2546 ****
unsigned int regno = REGNO (y);
unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
! : HARD_REGNO_NREGS (regno, GET_MODE (y)));
unsigned int i;
/* If the quantities are not the same, the expressions are not
--- 2540,2546 ----
unsigned int regno = REGNO (y);
unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
! : hard_regno_nregs[regno][GET_MODE (y)]);
unsigned int i;
/* If the quantities are not the same, the expressions are not
*************** cse_insn (rtx insn, rtx libcall_insn)
*** 5974,5980 ****
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
! : HARD_REGNO_NREGS (regno, GET_MODE (x)));
unsigned int i;
for (i = regno; i < endregno; i++)
--- 5974,5980 ----
unsigned int regno = REGNO (x);
unsigned int endregno
= regno + (regno >= FIRST_PSEUDO_REGISTER ? 1
! : hard_regno_nregs[regno][GET_MODE (x)]);
unsigned int i;
for (i = regno; i < endregno; i++)
Index: cselib.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cselib.c,v
retrieving revision 1.37
diff -c -3 -p -r1.37 cselib.c
*** cselib.c 26 Jan 2004 20:38:54 -0000 1.37
--- cselib.c 1 Feb 2004 23:36:11 -0000
*************** cselib_lookup (rtx x, enum machine_mode
*** 900,906 ****
if (i < FIRST_PSEUDO_REGISTER)
{
! unsigned int n = HARD_REGNO_NREGS (i, mode);
if (n > max_value_regs)
max_value_regs = n;
--- 900,906 ----
if (i < FIRST_PSEUDO_REGISTER)
{
! unsigned int n = hard_regno_nregs[i][mode];
if (n > max_value_regs)
max_value_regs = n;
*************** cselib_invalidate_regno (unsigned int re
*** 980,986 ****
else
i = regno - max_value_regs;
! endregno = regno + HARD_REGNO_NREGS (regno, mode);
}
else
{
--- 980,986 ----
else
i = regno - max_value_regs;
! endregno = regno + hard_regno_nregs[regno][mode];
}
else
{
*************** cselib_invalidate_regno (unsigned int re
*** 1001,1007 ****
unsigned int this_last = i;
if (i < FIRST_PSEUDO_REGISTER && v != NULL)
! this_last += HARD_REGNO_NREGS (i, GET_MODE (v->u.val_rtx)) - 1;
if (this_last < regno || v == NULL)
{
--- 1001,1007 ----
unsigned int this_last = i;
if (i < FIRST_PSEUDO_REGISTER && v != NULL)
! this_last += hard_regno_nregs[i][GET_MODE (v->u.val_rtx)] - 1;
if (this_last < regno || v == NULL)
{
*************** cselib_record_set (rtx dest, cselib_val
*** 1177,1183 ****
{
if (dreg < FIRST_PSEUDO_REGISTER)
{
! unsigned int n = HARD_REGNO_NREGS (dreg, GET_MODE (dest));
if (n > max_value_regs)
max_value_regs = n;
--- 1177,1183 ----
{
if (dreg < FIRST_PSEUDO_REGISTER)
{
! unsigned int n = hard_regno_nregs[dreg][GET_MODE (dest)];
if (n > max_value_regs)
max_value_regs = n;
Index: df.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/df.c,v
retrieving revision 1.60
diff -c -3 -p -r1.60 df.c
*** df.c 21 Jan 2004 20:39:53 -0000 1.60
--- df.c 1 Feb 2004 23:36:11 -0000
*************** df_ref_record (struct df *df, rtx reg, r
*** 819,825 ****
are really referenced. E.g., a (subreg:SI (reg:DI 0) 0) does _not_
reference the whole reg 0 in DI mode (which would also include
reg 1, at least, if 0 and 1 are SImode registers). */
! endregno = HARD_REGNO_NREGS (regno, GET_MODE (reg));
if (GET_CODE (reg) == SUBREG)
regno += subreg_regno_offset (regno, GET_MODE (SUBREG_REG (reg)),
SUBREG_BYTE (reg), GET_MODE (reg));
--- 819,825 ----
are really referenced. E.g., a (subreg:SI (reg:DI 0) 0) does _not_
reference the whole reg 0 in DI mode (which would also include
reg 1, at least, if 0 and 1 are SImode registers). */
! endregno = hard_regno_nregs[regno][GET_MODE (reg)];
if (GET_CODE (reg) == SUBREG)
regno += subreg_regno_offset (regno, GET_MODE (SUBREG_REG (reg)),
SUBREG_BYTE (reg), GET_MODE (reg));
Index: dwarf2out.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/dwarf2out.c,v
retrieving revision 1.483
diff -c -3 -p -r1.483 dwarf2out.c
*** dwarf2out.c 29 Jan 2004 18:42:56 -0000 1.483
--- dwarf2out.c 1 Feb 2004 23:36:12 -0000
*************** reg_loc_descriptor (rtx rtl)
*** 8080,8086 ****
reg = reg_number (rtl);
regs = (*targetm.dwarf_register_span) (rtl);
! if (HARD_REGNO_NREGS (reg, GET_MODE (rtl)) > 1
|| regs)
return multiple_reg_loc_descriptor (rtl, regs);
else
--- 8080,8086 ----
reg = reg_number (rtl);
regs = (*targetm.dwarf_register_span) (rtl);
! if (hard_regno_nregs[reg][GET_MODE (rtl)] > 1
|| regs)
return multiple_reg_loc_descriptor (rtl, regs);
else
*************** multiple_reg_loc_descriptor (rtx rtl, rt
*** 8110,8116 ****
dw_loc_descr_ref loc_result = NULL;
reg = reg_number (rtl);
! nregs = HARD_REGNO_NREGS (reg, GET_MODE (rtl));
/* Simple, contiguous registers. */
if (regs == NULL_RTX)
--- 8110,8116 ----
dw_loc_descr_ref loc_result = NULL;
reg = reg_number (rtl);
! nregs = hard_regno_nregs[reg][GET_MODE (rtl)];
/* Simple, contiguous registers. */
if (regs == NULL_RTX)
Index: flow.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/flow.c,v
retrieving revision 1.575
diff -c -3 -p -r1.575 flow.c
*** flow.c 31 Jan 2004 02:06:45 -0000 1.575
--- flow.c 1 Feb 2004 23:36:12 -0000
*************** mark_reg (rtx reg, void *xset)
*** 928,934 ****
SET_REGNO_REG_SET (set, regno);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (--n > 0)
SET_REGNO_REG_SET (set, regno + n);
}
--- 928,934 ----
SET_REGNO_REG_SET (set, regno);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = hard_regno_nregs[regno][GET_MODE (reg)];
while (--n > 0)
SET_REGNO_REG_SET (set, regno + n);
}
*************** insn_dead_p (struct propagate_block_info
*** 2163,2169 ****
words are not needed. */
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = HARD_REGNO_NREGS (regno, GET_MODE (r));
while (--n > 0)
if (REGNO_REG_SET_P (pbi->reg_live, regno+n))
--- 2163,2169 ----
words are not needed. */
if (regno < FIRST_PSEUDO_REGISTER)
{
! int n = hard_regno_nregs[regno][GET_MODE (r)];
while (--n > 0)
if (REGNO_REG_SET_P (pbi->reg_live, regno+n))
*************** mark_set_1 (struct propagate_block_info
*** 2560,2566 ****
case REG:
regno_last = regno_first = REGNO (reg);
if (regno_first < FIRST_PSEUDO_REGISTER)
! regno_last += HARD_REGNO_NREGS (regno_first, GET_MODE (reg)) - 1;
break;
case SUBREG:
--- 2560,2566 ----
case REG:
regno_last = regno_first = REGNO (reg);
if (regno_first < FIRST_PSEUDO_REGISTER)
! regno_last += hard_regno_nregs[regno_first][GET_MODE (reg)] - 1;
break;
case SUBREG:
*************** mark_set_1 (struct propagate_block_info
*** 2579,2585 ****
SUBREG_BYTE (reg),
outer_mode);
regno_last = (regno_first
! + HARD_REGNO_NREGS (regno_first, outer_mode) - 1);
/* Since we've just adjusted the register number ranges, make
sure REG matches. Otherwise some_was_live will be clear
--- 2579,2585 ----
SUBREG_BYTE (reg),
outer_mode);
regno_last = (regno_first
! + hard_regno_nregs[regno_first][outer_mode] - 1);
/* Since we've just adjusted the register number ranges, make
sure REG matches. Otherwise some_was_live will be clear
*************** mark_used_reg (struct propagate_block_in
*** 3491,3497 ****
regno_last = regno_first = REGNO (reg);
if (regno_first < FIRST_PSEUDO_REGISTER)
! regno_last += HARD_REGNO_NREGS (regno_first, GET_MODE (reg)) - 1;
/* Find out if any of this register is live after this instruction. */
some_was_live = some_was_dead = 0;
--- 3491,3497 ----
regno_last = regno_first = REGNO (reg);
if (regno_first < FIRST_PSEUDO_REGISTER)
! regno_last += hard_regno_nregs[regno_first][GET_MODE (reg)] - 1;
/* Find out if any of this register is live after this instruction. */
some_was_live = some_was_dead = 0;
*************** count_or_remove_death_notes_bb (basic_bl
*** 4247,4253 ****
if (REGNO (reg) >= FIRST_PSEUDO_REGISTER)
n = 1;
else
! n = HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg));
count += n;
}
--- 4247,4253 ----
if (REGNO (reg) >= FIRST_PSEUDO_REGISTER)
n = 1;
else
! n = hard_regno_nregs[REGNO (reg)][GET_MODE (reg)];
count += n;
}
Index: function.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/function.c,v
retrieving revision 1.488
diff -c -3 -p -r1.488 function.c
*** function.c 31 Jan 2004 08:02:47 -0000 1.488
--- function.c 1 Feb 2004 23:36:13 -0000
*************** aggregate_value_p (tree exp, tree fntype
*** 4260,4266 ****
return 0;
regno = REGNO (reg);
! nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type));
for (i = 0; i < nregs; i++)
if (! call_used_regs[regno + i])
return 1;
--- 4260,4266 ----
return 0;
regno = REGNO (reg);
! nregs = hard_regno_nregs[regno][TYPE_MODE (type)];
for (i = 0; i < nregs; i++)
if (! call_used_regs[regno + i])
return 1;
*************** keep_stack_depressed (rtx insns)
*** 7489,7496 ****
&& !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start,
regno)
&& !refers_to_regno_p (regno,
! regno + HARD_REGNO_NREGS (regno,
! Pmode),
info.equiv_reg_src, NULL)
&& info.const_equiv[regno] == 0)
break;
--- 7489,7496 ----
&& !REGNO_REG_SET_P (EXIT_BLOCK_PTR->global_live_at_start,
regno)
&& !refers_to_regno_p (regno,
! regno + hard_regno_nregs[regno]
! [Pmode],
info.equiv_reg_src, NULL)
&& info.const_equiv[regno] == 0)
break;
Index: global.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/global.c,v
retrieving revision 1.98
diff -c -3 -p -r1.98 global.c
*** global.c 20 Dec 2003 02:39:43 -0000 1.98
--- global.c 1 Feb 2004 23:36:13 -0000
*************** global_alloc (FILE *file)
*** 485,491 ****
if (reg_renumber[i] >= 0)
{
int regno = reg_renumber[i];
! int endregno = regno + HARD_REGNO_NREGS (regno, PSEUDO_REGNO_MODE (i));
int j;
for (j = regno; j < endregno; j++)
--- 485,491 ----
if (reg_renumber[i] >= 0)
{
int regno = reg_renumber[i];
! int endregno = regno + hard_regno_nregs[regno][PSEUDO_REGNO_MODE (i)];
int j;
for (j = regno; j < endregno; j++)
*************** find_reg (int num, HARD_REG_SET losers,
*** 1072,1078 ****
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
{
int j;
! int lim = regno + HARD_REGNO_NREGS (regno, mode);
for (j = regno + 1;
(j < lim
&& ! TEST_HARD_REG_BIT (used, j));
--- 1072,1078 ----
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
{
int j;
! int lim = regno + hard_regno_nregs[regno][mode];
for (j = regno + 1;
(j < lim
&& ! TEST_HARD_REG_BIT (used, j));
*************** find_reg (int num, HARD_REG_SET losers,
*** 1119,1125 ****
REGNO_REG_CLASS (i))))
{
int j;
! int lim = i + HARD_REGNO_NREGS (i, mode);
for (j = i + 1;
(j < lim
&& ! TEST_HARD_REG_BIT (used, j)
--- 1119,1125 ----
REGNO_REG_CLASS (i))))
{
int j;
! int lim = i + hard_regno_nregs[i][mode];
for (j = i + 1;
(j < lim
&& ! TEST_HARD_REG_BIT (used, j)
*************** find_reg (int num, HARD_REG_SET losers,
*** 1158,1164 ****
REGNO_REG_CLASS (i))))
{
int j;
! int lim = i + HARD_REGNO_NREGS (i, mode);
for (j = i + 1;
(j < lim
&& ! TEST_HARD_REG_BIT (used, j)
--- 1158,1164 ----
REGNO_REG_CLASS (i))))
{
int j;
! int lim = i + hard_regno_nregs[i][mode];
for (j = i + 1;
(j < lim
&& ! TEST_HARD_REG_BIT (used, j)
*************** find_reg (int num, HARD_REG_SET losers,
*** 1235,1241 ****
register, but the check of allocno[num].size above
was not enough. Sometimes we need more than one
register for a single-word value. */
! && HARD_REGNO_NREGS (regno, mode) == 1
&& (allocno[num].calls_crossed == 0
|| accept_call_clobbered
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode))
--- 1235,1241 ----
register, but the check of allocno[num].size above
was not enough. Sometimes we need more than one
register for a single-word value. */
! && hard_regno_nregs[regno][mode] == 1
&& (allocno[num].calls_crossed == 0
|| accept_call_clobbered
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode))
*************** find_reg (int num, HARD_REG_SET losers,
*** 1268,1274 ****
{
int r = reg_renumber[k];
int endregno
! = r + HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (k));
if (regno >= r && regno < endregno)
reg_renumber[k] = -1;
--- 1268,1274 ----
{
int r = reg_renumber[k];
int endregno
! = r + hard_regno_nregs[r][PSEUDO_REGNO_MODE (k)];
if (regno >= r && regno < endregno)
reg_renumber[k] = -1;
*************** find_reg (int num, HARD_REG_SET losers,
*** 1298,1304 ****
/* Make a set of the hard regs being allocated. */
CLEAR_HARD_REG_SET (this_reg);
! lim = best_reg + HARD_REGNO_NREGS (best_reg, mode);
for (j = best_reg; j < lim; j++)
{
SET_HARD_REG_BIT (this_reg, j);
--- 1298,1304 ----
/* Make a set of the hard regs being allocated. */
CLEAR_HARD_REG_SET (this_reg);
! lim = best_reg + hard_regno_nregs[best_reg][mode];
for (j = best_reg; j < lim; j++)
{
SET_HARD_REG_BIT (this_reg, j);
*************** mark_reg_store (rtx reg, rtx setter, voi
*** 1490,1496 ****
/* Handle hardware regs (and pseudos allocated to hard regs). */
if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
{
! int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (regno < last)
{
record_one_conflict (regno);
--- 1490,1496 ----
/* Handle hardware regs (and pseudos allocated to hard regs). */
if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
{
! int last = regno + hard_regno_nregs[regno][GET_MODE (reg)];
while (regno < last)
{
record_one_conflict (regno);
*************** mark_reg_conflicts (rtx reg)
*** 1539,1545 ****
/* Handle hardware regs (and pseudos allocated to hard regs). */
if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
{
! int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (regno < last)
{
record_one_conflict (regno);
--- 1539,1545 ----
/* Handle hardware regs (and pseudos allocated to hard regs). */
if (regno < FIRST_PSEUDO_REGISTER && ! fixed_regs[regno])
{
! int last = regno + hard_regno_nregs[regno][GET_MODE (reg)];
while (regno < last)
{
record_one_conflict (regno);
*************** mark_reg_death (rtx reg)
*** 1573,1579 ****
{
/* Pseudo regs already assigned hardware regs are treated
almost the same as explicit hardware regs. */
! int last = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (regno < last)
{
CLEAR_HARD_REG_BIT (hard_regs_live, regno);
--- 1573,1579 ----
{
/* Pseudo regs already assigned hardware regs are treated
almost the same as explicit hardware regs. */
! int last = regno + hard_regno_nregs[regno][GET_MODE (reg)];
while (regno < last)
{
CLEAR_HARD_REG_BIT (hard_regs_live, regno);
*************** mark_reg_death (rtx reg)
*** 1590,1596 ****
static void
mark_reg_live_nc (int regno, enum machine_mode mode)
{
! int last = regno + HARD_REGNO_NREGS (regno, mode);
while (regno < last)
{
SET_HARD_REG_BIT (hard_regs_live, regno);
--- 1590,1596 ----
static void
mark_reg_live_nc (int regno, enum machine_mode mode)
{
! int last = regno + hard_regno_nregs[regno][mode];
while (regno < last)
{
SET_HARD_REG_BIT (hard_regs_live, regno);
*************** set_preference (rtx dest, rtx src)
*** 1683,1689 ****
SET_REGBIT (hard_reg_preferences,
reg_allocno[src_regno], dest_regno);
for (i = dest_regno;
! i < dest_regno + HARD_REGNO_NREGS (dest_regno, GET_MODE (dest));
i++)
SET_REGBIT (hard_reg_full_preferences, reg_allocno[src_regno], i);
}
--- 1683,1689 ----
SET_REGBIT (hard_reg_preferences,
reg_allocno[src_regno], dest_regno);
for (i = dest_regno;
! i < dest_regno + hard_regno_nregs[dest_regno][GET_MODE (dest)];
i++)
SET_REGBIT (hard_reg_full_preferences, reg_allocno[src_regno], i);
}
*************** set_preference (rtx dest, rtx src)
*** 1702,1708 ****
SET_REGBIT (hard_reg_preferences,
reg_allocno[dest_regno], src_regno);
for (i = src_regno;
! i < src_regno + HARD_REGNO_NREGS (src_regno, GET_MODE (src));
i++)
SET_REGBIT (hard_reg_full_preferences, reg_allocno[dest_regno], i);
}
--- 1702,1708 ----
SET_REGBIT (hard_reg_preferences,
reg_allocno[dest_regno], src_regno);
for (i = src_regno;
! i < src_regno + hard_regno_nregs[src_regno][GET_MODE (src)];
i++)
SET_REGBIT (hard_reg_full_preferences, reg_allocno[dest_regno], i);
}
*************** reg_becomes_live (rtx reg, rtx setter AT
*** 1750,1756 ****
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (nregs-- > 0)
{
SET_REGNO_REG_SET (live_relevant_regs, regno);
--- 1750,1756 ----
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
while (nregs-- > 0)
{
SET_REGNO_REG_SET (live_relevant_regs, regno);
*************** reg_dies (int regno, enum machine_mode m
*** 1772,1778 ****
{
if (regno < FIRST_PSEUDO_REGISTER)
{
! int nregs = HARD_REGNO_NREGS (regno, mode);
while (nregs-- > 0)
{
CLEAR_REGNO_REG_SET (live_relevant_regs, regno);
--- 1772,1778 ----
{
if (regno < FIRST_PSEUDO_REGISTER)
{
! int nregs = hard_regno_nregs[regno][mode];
while (nregs-- > 0)
{
CLEAR_REGNO_REG_SET (live_relevant_regs, regno);
Index: integrate.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/integrate.c,v
retrieving revision 1.246
diff -c -3 -p -r1.246 integrate.c
*** integrate.c 25 Jan 2004 03:52:42 -0000 1.246
--- integrate.c 1 Feb 2004 23:36:13 -0000
*************** mark_stores (rtx dest, rtx x ATTRIBUTE_U
*** 2830,2836 ****
{
unsigned int uregno = regno;
unsigned int last_reg = (uregno >= FIRST_PSEUDO_REGISTER ? uregno
! : uregno + HARD_REGNO_NREGS (uregno, mode) - 1);
unsigned int i;
/* Ignore virtual stack var or virtual arg register since those
--- 2830,2836 ----
{
unsigned int uregno = regno;
unsigned int last_reg = (uregno >= FIRST_PSEUDO_REGISTER ? uregno
! : uregno + hard_regno_nregs[uregno][mode] - 1);
unsigned int i;
/* Ignore virtual stack var or virtual arg register since those
Index: jump.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/jump.c,v
retrieving revision 1.238
diff -c -3 -p -r1.238 jump.c
*** jump.c 31 Jan 2004 02:06:47 -0000 1.238
--- jump.c 1 Feb 2004 23:36:13 -0000
*************** delete_prior_computation (rtx note, rtx
*** 1551,1563 ****
int dest_endregno
= (dest_regno
+ (dest_regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (dest_regno,
! GET_MODE (SET_DEST (pat))) : 1));
int regno = REGNO (reg);
int endregno
= (regno
+ (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (reg)) : 1));
if (dest_regno >= regno
&& dest_endregno <= endregno)
--- 1551,1563 ----
int dest_endregno
= (dest_regno
+ (dest_regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[dest_regno]
! [GET_MODE (SET_DEST (pat))] : 1));
int regno = REGNO (reg);
int endregno
= (regno
+ (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (reg)] : 1));
if (dest_regno >= regno
&& dest_endregno <= endregno)
Index: lcm.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/lcm.c,v
retrieving revision 1.58
diff -c -3 -p -r1.58 lcm.c
*** lcm.c 11 Dec 2003 00:20:45 -0000 1.58
--- lcm.c 1 Feb 2004 23:36:14 -0000
*************** reg_dies (rtx reg, HARD_REG_SET live)
*** 932,938 ****
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
! for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
nregs--)
CLEAR_HARD_REG_BIT (live, regno + nregs);
}
--- 932,938 ----
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
! for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
nregs--)
CLEAR_HARD_REG_BIT (live, regno + nregs);
}
*************** reg_becomes_live (rtx reg, rtx setter AT
*** 953,959 ****
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
! for (nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1; nregs >= 0;
nregs--)
SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
}
--- 953,959 ----
regno = REGNO (reg);
if (regno < FIRST_PSEUDO_REGISTER)
! for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
nregs--)
SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
}
Index: local-alloc.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/local-alloc.c,v
retrieving revision 1.127
diff -c -3 -p -r1.127 local-alloc.c
*** local-alloc.c 21 Jan 2004 20:40:02 -0000 1.127
--- local-alloc.c 1 Feb 2004 23:36:14 -0000
*************** combine_regs (rtx usedreg, rtx setreg, i
*** 1799,1805 ****
ureg = REGNO (usedreg);
if (ureg < FIRST_PSEUDO_REGISTER)
! usize = HARD_REGNO_NREGS (ureg, GET_MODE (usedreg));
else
usize = ((GET_MODE_SIZE (GET_MODE (usedreg))
+ (REGMODE_NATURAL_SIZE (GET_MODE (usedreg)) - 1))
--- 1799,1805 ----
ureg = REGNO (usedreg);
if (ureg < FIRST_PSEUDO_REGISTER)
! usize = hard_regno_nregs[ureg][GET_MODE (usedreg)];
else
usize = ((GET_MODE_SIZE (GET_MODE (usedreg))
+ (REGMODE_NATURAL_SIZE (GET_MODE (usedreg)) - 1))
*************** combine_regs (rtx usedreg, rtx setreg, i
*** 1832,1838 ****
sreg = REGNO (setreg);
if (sreg < FIRST_PSEUDO_REGISTER)
! ssize = HARD_REGNO_NREGS (sreg, GET_MODE (setreg));
else
ssize = ((GET_MODE_SIZE (GET_MODE (setreg))
+ (REGMODE_NATURAL_SIZE (GET_MODE (setreg)) - 1))
--- 1832,1838 ----
sreg = REGNO (setreg);
if (sreg < FIRST_PSEUDO_REGISTER)
! ssize = hard_regno_nregs[sreg][GET_MODE (setreg)];
else
ssize = ((GET_MODE_SIZE (GET_MODE (setreg))
+ (REGMODE_NATURAL_SIZE (GET_MODE (setreg)) - 1))
*************** find_free_reg (enum reg_class class, enu
*** 2217,2223 ****
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
{
int j;
! int size1 = HARD_REGNO_NREGS (regno, mode);
for (j = 1; j < size1 && ! TEST_HARD_REG_BIT (used, regno + j); j++);
if (j == size1)
{
--- 2217,2223 ----
|| ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
{
int j;
! int size1 = hard_regno_nregs[regno][mode];
for (j = 1; j < size1 && ! TEST_HARD_REG_BIT (used, regno + j); j++);
if (j == size1)
{
*************** find_free_reg (enum reg_class class, enu
*** 2275,2281 ****
static void
mark_life (int regno, enum machine_mode mode, int life)
{
! int j = HARD_REGNO_NREGS (regno, mode);
if (life)
while (--j >= 0)
SET_HARD_REG_BIT (regs_live, regno + j);
--- 2275,2281 ----
static void
mark_life (int regno, enum machine_mode mode, int life)
{
! int j = hard_regno_nregs[regno][mode];
if (life)
while (--j >= 0)
SET_HARD_REG_BIT (regs_live, regno + j);
*************** static void
*** 2292,2298 ****
post_mark_life (int regno, enum machine_mode mode, int life, int birth,
int death)
{
! int j = HARD_REGNO_NREGS (regno, mode);
HARD_REG_SET this_reg;
CLEAR_HARD_REG_SET (this_reg);
--- 2292,2298 ----
post_mark_life (int regno, enum machine_mode mode, int life, int birth,
int death)
{
! int j = hard_regno_nregs[regno][mode];
HARD_REG_SET this_reg;
CLEAR_HARD_REG_SET (this_reg);
Index: loop.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/loop.c,v
retrieving revision 1.489
diff -c -3 -p -r1.489 loop.c
*** loop.c 20 Jan 2004 16:55:56 -0000 1.489
--- loop.c 1 Feb 2004 23:36:14 -0000
*************** Software Foundation, 59 Temple Place - S
*** 163,169 ****
#define LOOP_REGNO_NREGS(REGNO, SET_DEST) \
((REGNO) < FIRST_PSEUDO_REGISTER \
! ? (int) HARD_REGNO_NREGS ((REGNO), GET_MODE (SET_DEST)) : 1)
/* Vector mapping INSN_UIDs to luids.
--- 163,169 ----
#define LOOP_REGNO_NREGS(REGNO, SET_DEST) \
((REGNO) < FIRST_PSEUDO_REGISTER \
! ? (int) hard_regno_nregs[(REGNO)][GET_MODE (SET_DEST)] : 1)
/* Vector mapping INSN_UIDs to luids.
Index: postreload.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/postreload.c,v
retrieving revision 2.12
diff -c -3 -p -r2.12 postreload.c
*** postreload.c 25 Jan 2004 03:52:42 -0000 2.12
--- postreload.c 1 Feb 2004 23:36:15 -0000
*************** reload_combine (void)
*** 780,787 ****
set = single_set (insn);
if (set != NULL_RTX
&& GET_CODE (SET_DEST (set)) == REG
! && (HARD_REGNO_NREGS (REGNO (SET_DEST (set)),
! GET_MODE (SET_DEST (set)))
== 1)
&& GET_CODE (SET_SRC (set)) == PLUS
&& GET_CODE (XEXP (SET_SRC (set), 1)) == REG
--- 780,787 ----
set = single_set (insn);
if (set != NULL_RTX
&& GET_CODE (SET_DEST (set)) == REG
! && (hard_regno_nregs[REGNO (SET_DEST (set))]
! [GET_MODE (SET_DEST (set))]
== 1)
&& GET_CODE (SET_SRC (set)) == PLUS
&& GET_CODE (XEXP (SET_SRC (set), 1)) == REG
*************** reload_combine (void)
*** 825,831 ****
i)
&& reg_state[i].use_index == RELOAD_COMBINE_MAX_USES
&& reg_state[i].store_ruid <= reg_state[regno].use_ruid
! && HARD_REGNO_NREGS (i, GET_MODE (reg)) == 1)
{
rtx index_reg = gen_rtx_REG (GET_MODE (reg), i);
--- 825,831 ----
i)
&& reg_state[i].use_index == RELOAD_COMBINE_MAX_USES
&& reg_state[i].store_ruid <= reg_state[regno].use_ruid
! && hard_regno_nregs[i][GET_MODE (reg)] == 1)
{
rtx index_reg = gen_rtx_REG (GET_MODE (reg), i);
*************** reload_combine (void)
*** 918,924 ****
unsigned int i;
unsigned int start_reg = REGNO (usage_rtx);
unsigned int num_regs =
! HARD_REGNO_NREGS (start_reg, GET_MODE (usage_rtx));
unsigned int end_reg = start_reg + num_regs - 1;
for (i = start_reg; i <= end_reg; i++)
if (GET_CODE (XEXP (link, 0)) == CLOBBER)
--- 918,924 ----
unsigned int i;
unsigned int start_reg = REGNO (usage_rtx);
unsigned int num_regs =
! hard_regno_nregs[start_reg][GET_MODE (usage_rtx)];
unsigned int end_reg = start_reg + num_regs - 1;
for (i = start_reg; i <= end_reg; i++)
if (GET_CODE (XEXP (link, 0)) == CLOBBER)
*************** reload_combine_note_store (rtx dst, rtx
*** 999,1005 ****
|| GET_CODE (SET_DEST (set)) == SIGN_EXTRACT
|| GET_CODE (SET_DEST (set)) == STRICT_LOW_PART)
{
! for (i = HARD_REGNO_NREGS (regno, mode) - 1 + regno; i >= regno; i--)
{
reg_state[i].use_index = -1;
reg_state[i].store_ruid = reload_combine_ruid;
--- 999,1005 ----
|| GET_CODE (SET_DEST (set)) == SIGN_EXTRACT
|| GET_CODE (SET_DEST (set)) == STRICT_LOW_PART)
{
! for (i = hard_regno_nregs[regno][mode] - 1 + regno; i >= regno; i--)
{
reg_state[i].use_index = -1;
reg_state[i].store_ruid = reload_combine_ruid;
*************** reload_combine_note_store (rtx dst, rtx
*** 1007,1013 ****
}
else
{
! for (i = HARD_REGNO_NREGS (regno, mode) - 1 + regno; i >= regno; i--)
{
reg_state[i].store_ruid = reload_combine_ruid;
reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
--- 1007,1013 ----
}
else
{
! for (i = hard_regno_nregs[regno][mode] - 1 + regno; i >= regno; i--)
{
reg_state[i].store_ruid = reload_combine_ruid;
reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
*************** reload_combine_note_use (rtx *xp, rtx in
*** 1045,1051 ****
/* Mark the return register as used in an unknown fashion. */
rtx reg = XEXP (x, 0);
int regno = REGNO (reg);
! int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (--nregs >= 0)
reg_state[regno + nregs].use_index = -1;
--- 1045,1051 ----
/* Mark the return register as used in an unknown fashion. */
rtx reg = XEXP (x, 0);
int regno = REGNO (reg);
! int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
while (--nregs >= 0)
reg_state[regno + nregs].use_index = -1;
*************** reload_combine_note_use (rtx *xp, rtx in
*** 1081,1087 ****
if (regno >= FIRST_PSEUDO_REGISTER)
abort ();
! nregs = HARD_REGNO_NREGS (regno, GET_MODE (x));
/* We can't substitute into multi-hard-reg uses. */
if (nregs > 1)
--- 1081,1087 ----
if (regno >= FIRST_PSEUDO_REGISTER)
abort ();
! nregs = hard_regno_nregs[regno][GET_MODE (x)];
/* We can't substitute into multi-hard-reg uses. */
if (nregs > 1)
*************** reload_cse_move2add (rtx first)
*** 1391,1397 ****
number of calls to gen_rtx_SET to avoid memory
allocation if possible. */
&& SCALAR_INT_MODE_P (GET_MODE (XEXP (cnd, 0)))
! && HARD_REGNO_NREGS (REGNO (XEXP (cnd, 0)), GET_MODE (XEXP (cnd, 0))) == 1
&& GET_CODE (XEXP (cnd, 1)) == CONST_INT)
{
rtx implicit_set =
--- 1391,1397 ----
number of calls to gen_rtx_SET to avoid memory
allocation if possible. */
&& SCALAR_INT_MODE_P (GET_MODE (XEXP (cnd, 0)))
! && hard_regno_nregs[REGNO (XEXP (cnd, 0))][GET_MODE (XEXP (cnd, 0))] == 1
&& GET_CODE (XEXP (cnd, 1)) == CONST_INT)
{
rtx implicit_set =
*************** move2add_note_store (rtx dst, rtx set, v
*** 1450,1456 ****
regno += REGNO (dst);
if (SCALAR_INT_MODE_P (mode)
! && HARD_REGNO_NREGS (regno, mode) == 1 && GET_CODE (set) == SET
&& GET_CODE (SET_DEST (set)) != ZERO_EXTRACT
&& GET_CODE (SET_DEST (set)) != SIGN_EXTRACT
&& GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
--- 1450,1456 ----
regno += REGNO (dst);
if (SCALAR_INT_MODE_P (mode)
! && hard_regno_nregs[regno][mode] == 1 && GET_CODE (set) == SET
&& GET_CODE (SET_DEST (set)) != ZERO_EXTRACT
&& GET_CODE (SET_DEST (set)) != SIGN_EXTRACT
&& GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
*************** move2add_note_store (rtx dst, rtx set, v
*** 1551,1557 ****
}
else
{
! unsigned int endregno = regno + HARD_REGNO_NREGS (regno, mode);
for (i = regno; i < endregno; i++)
/* Reset the information about this register. */
--- 1551,1557 ----
}
else
{
! unsigned int endregno = regno + hard_regno_nregs[regno][mode];
for (i = regno; i < endregno; i++)
/* Reset the information about this register. */
Index: ra-colorize.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-colorize.c,v
retrieving revision 1.15
diff -c -3 -p -r1.15 ra-colorize.c
*** ra-colorize.c 13 Dec 2003 04:11:23 -0000 1.15
--- ra-colorize.c 1 Feb 2004 23:36:15 -0000
*************** ok (struct web *target, struct web *sour
*** 562,568 ****
return 0;
/* Sanity for funny modes. */
! size = HARD_REGNO_NREGS (color, GET_MODE (target->orig_x));
if (!size)
return 0;
--- 562,568 ----
return 0;
/* Sanity for funny modes. */
! size = hard_regno_nregs[color][GET_MODE (target->orig_x)];
if (!size)
return 0;
*************** combine (struct web *u, struct web *v)
*** 726,732 ****
struct web *web = u;
int nregs = 1 + v->add_hardregs;
if (u->type == PRECOLORED)
! nregs = HARD_REGNO_NREGS (u->color, GET_MODE (v->orig_x));
/* For precolored U's we need to make conflicts between V's
neighbors and as many hardregs from U as V needed if it gets
--- 726,732 ----
struct web *web = u;
int nregs = 1 + v->add_hardregs;
if (u->type == PRECOLORED)
! nregs = hard_regno_nregs[u->color][GET_MODE (v->orig_x)];
/* For precolored U's we need to make conflicts between V's
neighbors and as many hardregs from U as V needed if it gets
*************** color_usable_p (int c, HARD_REG_SET dont
*** 992,998 ****
&& HARD_REGNO_MODE_OK (c, mode))
{
int i, size;
! size = HARD_REGNO_NREGS (c, mode);
for (i = 1; i < size && TEST_HARD_REG_BIT (free_colors, c + i); i++);
if (i == size)
return 1;
--- 992,998 ----
&& HARD_REGNO_MODE_OK (c, mode))
{
int i, size;
! size = hard_regno_nregs[c][mode];
for (i = 1; i < size && TEST_HARD_REG_BIT (free_colors, c + i); i++);
if (i == size)
return 1;
*************** get_free_reg (HARD_REG_SET dont_begin_co
*** 1029,1035 ****
&& HARD_REGNO_MODE_OK (c, mode))
{
int i, size;
! size = HARD_REGNO_NREGS (c, mode);
for (i = 1; i < size && TEST_HARD_REG_BIT (free_colors, c + i); i++);
if (i != size)
{
--- 1029,1035 ----
&& HARD_REGNO_MODE_OK (c, mode))
{
int i, size;
! size = hard_regno_nregs[c][mode];
for (i = 1; i < size && TEST_HARD_REG_BIT (free_colors, c + i); i++);
if (i != size)
{
*************** calculate_dont_begin (struct web *web, H
*** 1172,1182 ****
if (ptarget->type == COLORED || ptarget->type == PRECOLORED)
{
struct web *source = (sl) ? sl->s : web;
! unsigned int tsize = HARD_REGNO_NREGS (ptarget->color,
! GET_MODE (w->orig_x));
/* ssize is only a first guess for the size. */
! unsigned int ssize = HARD_REGNO_NREGS (ptarget->color, GET_MODE
! (source->orig_x));
unsigned int tofs = 0;
unsigned int sofs = 0;
/* C1 and C2 can become negative, so unsigned
--- 1172,1182 ----
if (ptarget->type == COLORED || ptarget->type == PRECOLORED)
{
struct web *source = (sl) ? sl->s : web;
! unsigned int tsize = hard_regno_nregs[ptarget->color]
! [GET_MODE (w->orig_x)];
/* ssize is only a first guess for the size. */
! unsigned int ssize = hard_regno_nregs[ptarget->color][GET_MODE
! (source->orig_x)];
unsigned int tofs = 0;
unsigned int sofs = 0;
/* C1 and C2 can become negative, so unsigned
*************** calculate_dont_begin (struct web *web, H
*** 1202,1212 ****
c1 to a place, where the last of sources hardregs does not
overlap the first of targets colors. */
while (c1 + sofs
! + HARD_REGNO_NREGS (c1, GET_MODE (source->orig_x)) - 1
< ptarget->color + tofs)
c1++;
while (c1 > 0 && c1 + sofs
! + HARD_REGNO_NREGS (c1, GET_MODE (source->orig_x)) - 1
> ptarget->color + tofs)
c1--;
for (; c1 <= c2; c1++)
--- 1202,1212 ----
c1 to a place, where the last of sources hardregs does not
overlap the first of targets colors. */
while (c1 + sofs
! + hard_regno_nregs[c1][GET_MODE (source->orig_x)] - 1
< ptarget->color + tofs)
c1++;
while (c1 > 0 && c1 + sofs
! + hard_regno_nregs[c1][GET_MODE (source->orig_x)] - 1
> ptarget->color + tofs)
c1--;
for (; c1 <= c2; c1++)
*************** colorize_one_web (struct web *web, int h
*** 1588,1594 ****
web->color = c;
if (flag_ra_biased)
{
! int nregs = HARD_REGNO_NREGS (c, GET_MODE (web->orig_x));
for (wl = web->conflict_list; wl; wl = wl->next)
{
struct web *ptarget = alias (wl->t);
--- 1588,1594 ----
web->color = c;
if (flag_ra_biased)
{
! int nregs = hard_regno_nregs[c][GET_MODE (web->orig_x)];
for (wl = web->conflict_list; wl; wl = wl->next)
{
struct web *ptarget = alias (wl->t);
*************** try_recolor_web (struct web *web)
*** 1669,1675 ****
int i, nregs;
if (!HARD_REGNO_MODE_OK (c, GET_MODE (web->orig_x)))
continue;
! nregs = HARD_REGNO_NREGS (c, GET_MODE (web->orig_x));
for (i = 0; i < nregs; i++)
if (!TEST_HARD_REG_BIT (web->usable_regs, c + i))
break;
--- 1669,1675 ----
int i, nregs;
if (!HARD_REGNO_MODE_OK (c, GET_MODE (web->orig_x)))
continue;
! nregs = hard_regno_nregs[c][GET_MODE (web->orig_x)];
for (i = 0; i < nregs; i++)
if (!TEST_HARD_REG_BIT (web->usable_regs, c + i))
break;
*************** try_recolor_web (struct web *web)
*** 1719,1732 ****
/* Note that min_color[] contains 1-based values (zero means
undef). */
c1 = c1 == 0 ? web2->color : (c1 - 1);
! c2 = web2->color + HARD_REGNO_NREGS (web2->color, GET_MODE
! (web2->orig_x)) - 1;
for (; c1 <= c2; c1++)
if (TEST_HARD_REG_BIT (possible_begin, c1))
{
int nregs;
HARD_REG_SET colors;
! nregs = HARD_REGNO_NREGS (c1, GET_MODE (web->orig_x));
COPY_HARD_REG_SET (colors, web2->usable_regs);
for (; nregs--;)
CLEAR_HARD_REG_BIT (colors, c1 + nregs);
--- 1719,1732 ----
/* Note that min_color[] contains 1-based values (zero means
undef). */
c1 = c1 == 0 ? web2->color : (c1 - 1);
! c2 = web2->color + hard_regno_nregs[web2->color][GET_MODE
! (web2->orig_x)] - 1;
for (; c1 <= c2; c1++)
if (TEST_HARD_REG_BIT (possible_begin, c1))
{
int nregs;
HARD_REG_SET colors;
! nregs = hard_regno_nregs[c1][GET_MODE (web->orig_x)];
COPY_HARD_REG_SET (colors, web2->usable_regs);
for (; nregs--;)
CLEAR_HARD_REG_BIT (colors, c1 + nregs);
*************** try_recolor_web (struct web *web)
*** 1752,1758 ****
newcol = c;
if (newcol >= 0 && cost_neighbors[newcol] < web->spill_cost)
{
! int nregs = HARD_REGNO_NREGS (newcol, GET_MODE (web->orig_x));
unsigned HOST_WIDE_INT cost = 0;
int *old_colors;
struct conflict_link *wl_next;
--- 1752,1758 ----
newcol = c;
if (newcol >= 0 && cost_neighbors[newcol] < web->spill_cost)
{
! int nregs = hard_regno_nregs[newcol][GET_MODE (web->orig_x)];
unsigned HOST_WIDE_INT cost = 0;
int *old_colors;
struct conflict_link *wl_next;
*************** try_recolor_web (struct web *web)
*** 1775,1782 ****
wl_next = wl->next;
if (web2->type == COLORED)
{
! int nregs2 = HARD_REGNO_NREGS (web2->color, GET_MODE
! (web2->orig_x));
if (web->color >= web2->color + nregs2
|| web2->color >= web->color + nregs)
continue;
--- 1775,1782 ----
wl_next = wl->next;
if (web2->type == COLORED)
{
! int nregs2 = hard_regno_nregs[web2->color][GET_MODE
! (web2->orig_x)];
if (web->color >= web2->color + nregs2
|| web2->color >= web->color + nregs)
continue;
*************** insert_coalesced_conflicts (void)
*** 1866,1872 ****
int i;
int nregs = 1 + web->add_hardregs;
if (aweb->type == PRECOLORED)
! nregs = HARD_REGNO_NREGS (aweb->color, GET_MODE (web->orig_x));
for (i = 0; i < nregs; i++)
{
if (aweb->type == PRECOLORED)
--- 1866,1872 ----
int i;
int nregs = 1 + web->add_hardregs;
if (aweb->type == PRECOLORED)
! nregs = hard_regno_nregs[aweb->color][GET_MODE (web->orig_x)];
for (i = 0; i < nregs; i++)
{
if (aweb->type == PRECOLORED)
*************** check_colors (void)
*** 1971,1977 ****
if (aweb->type == SPILLED || web->regno >= max_normal_pseudo)
continue;
else if (aweb->type == COLORED)
! nregs = HARD_REGNO_NREGS (aweb->color, GET_MODE (web->orig_x));
else if (aweb->type == PRECOLORED)
nregs = 1;
else
--- 1971,1977 ----
if (aweb->type == SPILLED || web->regno >= max_normal_pseudo)
continue;
else if (aweb->type == COLORED)
! nregs = hard_regno_nregs[aweb->color][GET_MODE (web->orig_x)];
else if (aweb->type == PRECOLORED)
nregs = 1;
else
*************** check_colors (void)
*** 1995,2001 ****
struct web *web2 = alias (wl->t);
int nregs2;
if (web2->type == COLORED)
! nregs2 = HARD_REGNO_NREGS (web2->color, GET_MODE (web2->orig_x));
else if (web2->type == PRECOLORED)
nregs2 = 1;
else
--- 1995,2001 ----
struct web *web2 = alias (wl->t);
int nregs2;
if (web2->type == COLORED)
! nregs2 = hard_regno_nregs[web2->color][GET_MODE (web2->orig_x)];
else if (web2->type == PRECOLORED)
nregs2 = 1;
else
*************** check_colors (void)
*** 2014,2021 ****
continue;
for (sl = wl->sub; sl; sl = sl->next)
{
! int ssize = HARD_REGNO_NREGS (scol, GET_MODE (sl->s->orig_x));
! int tsize = HARD_REGNO_NREGS (tcol, GET_MODE (sl->t->orig_x));
int sofs = 0, tofs = 0;
if (SUBWEB_P (sl->t)
&& GET_MODE_SIZE (GET_MODE (sl->t->orig_x)) >= UNITS_PER_WORD)
--- 2014,2021 ----
continue;
for (sl = wl->sub; sl; sl = sl->next)
{
! int ssize = hard_regno_nregs[scol][GET_MODE (sl->s->orig_x)];
! int tsize = hard_regno_nregs[tcol][GET_MODE (sl->t->orig_x)];
int sofs = 0, tofs = 0;
if (SUBWEB_P (sl->t)
&& GET_MODE_SIZE (GET_MODE (sl->t->orig_x)) >= UNITS_PER_WORD)
*************** break_precolored_alias (struct web *web)
*** 2112,2118 ****
struct web *pre = web->alias;
struct conflict_link *wl;
unsigned int c = pre->color;
! unsigned int nregs = HARD_REGNO_NREGS (c, GET_MODE (web->orig_x));
if (pre->type != PRECOLORED)
abort ();
unalias_web (web);
--- 2112,2118 ----
struct web *pre = web->alias;
struct conflict_link *wl;
unsigned int c = pre->color;
! unsigned int nregs = hard_regno_nregs[c][GET_MODE (web->orig_x)];
if (pre->type != PRECOLORED)
abort ();
unalias_web (web);
Index: ra-debug.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-debug.c,v
retrieving revision 1.14
diff -c -3 -p -r1.14 ra-debug.c
*** ra-debug.c 11 Dec 2003 00:20:46 -0000 1.14
--- ra-debug.c 1 Feb 2004 23:36:15 -0000
***************
*** 32,37 ****
--- 32,38 ----
#include "output.h"
#include "ra.h"
#include "tm_p.h"
+ #include "regs.h"
/* This file contains various dumping and debug functions for
the graph coloring register allocator. */
*************** ra_print_rtx_object (FILE *file, rtx x)
*** 245,251 ****
int regno = REGNO (x);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int i, nregs = HARD_REGNO_NREGS (regno, mode);
if (nregs > 1)
fputs ("[", file);
for (i = 0; i < nregs; i++)
--- 246,252 ----
int regno = REGNO (x);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int i, nregs = hard_regno_nregs[regno][mode];
if (nregs > 1)
fputs ("[", file);
for (i = 0; i < nregs; i++)
*************** ra_print_rtx_object (FILE *file, rtx x)
*** 272,278 ****
&& REGNO (sub) < FIRST_PSEUDO_REGISTER)
{
int regno = REGNO (sub);
! int i, nregs = HARD_REGNO_NREGS (regno, mode);
regno += subreg_regno_offset (regno, GET_MODE (sub),
ofs, mode);
if (nregs > 1)
--- 273,279 ----
&& REGNO (sub) < FIRST_PSEUDO_REGISTER)
{
int regno = REGNO (sub);
! int i, nregs = hard_regno_nregs[regno][mode];
regno += subreg_regno_offset (regno, GET_MODE (sub),
ofs, mode);
if (nregs > 1)
Index: ra-rewrite.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra-rewrite.c,v
retrieving revision 1.16
diff -c -3 -p -r1.16 ra-rewrite.c
*** ra-rewrite.c 11 Dec 2003 00:20:46 -0000 1.16
--- ra-rewrite.c 1 Feb 2004 23:36:15 -0000
*************** choose_spill_colors (void)
*** 352,358 ****
&& HARD_REGNO_MODE_OK (c, PSEUDO_REGNO_MODE (web->regno)))
{
int i, size;
! size = HARD_REGNO_NREGS (c, PSEUDO_REGNO_MODE (web->regno));
for (i = 1; i < size
&& TEST_HARD_REG_BIT (avail, c + i); i++);
if (i == size)
--- 352,358 ----
&& HARD_REGNO_MODE_OK (c, PSEUDO_REGNO_MODE (web->regno)))
{
int i, size;
! size = hard_regno_nregs[c][PSEUDO_REGNO_MODE (web->regno)];
for (i = 1; i < size
&& TEST_HARD_REG_BIT (avail, c + i); i++);
if (i == size)
*************** spill_same_color_p (struct web *web1, st
*** 742,750 ****
return 0;
size1 = web1->type == PRECOLORED
! ? 1 : HARD_REGNO_NREGS (c1, PSEUDO_REGNO_MODE (web1->regno));
size2 = web2->type == PRECOLORED
! ? 1 : HARD_REGNO_NREGS (c2, PSEUDO_REGNO_MODE (web2->regno));
if (c1 >= c2 + size2 || c2 >= c1 + size1)
return 0;
return 1;
--- 742,750 ----
return 0;
size1 = web1->type == PRECOLORED
! ? 1 : hard_regno_nregs[c1][PSEUDO_REGNO_MODE (web1->regno)];
size2 = web2->type == PRECOLORED
! ? 1 : hard_regno_nregs[c2][PSEUDO_REGNO_MODE (web2->regno)];
if (c1 >= c2 + size2 || c2 >= c1 + size1)
return 0;
return 1;
*************** update_spill_colors (HARD_REG_SET *in_us
*** 779,785 ****
if ((c = alias (find_web_for_subweb (web))->color) < 0
|| c == an_unusable_color)
return;
! size = HARD_REGNO_NREGS (c, GET_MODE (web->orig_x));
if (SUBWEB_P (web))
{
c += subreg_regno_offset (c, GET_MODE (SUBREG_REG (web->orig_x)),
--- 779,785 ----
if ((c = alias (find_web_for_subweb (web))->color) < 0
|| c == an_unusable_color)
return;
! size = hard_regno_nregs[c][GET_MODE (web->orig_x)];
if (SUBWEB_P (web))
{
c += subreg_regno_offset (c, GET_MODE (SUBREG_REG (web->orig_x)),
*************** spill_is_free (HARD_REG_SET *in_use, str
*** 810,816 ****
if (c == an_unusable_color)
return 1;
size = web->type == PRECOLORED
! ? 1 : HARD_REGNO_NREGS (c, PSEUDO_REGNO_MODE (web->regno));
for (; size--;)
if (TEST_HARD_REG_BIT (*in_use, c + size))
return 0;
--- 810,816 ----
if (c == an_unusable_color)
return 1;
size = web->type == PRECOLORED
! ? 1 : hard_regno_nregs[c][PSEUDO_REGNO_MODE (web->regno)];
for (; size--;)
if (TEST_HARD_REG_BIT (*in_use, c + size))
return 0;
Index: ra.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/ra.c,v
retrieving revision 1.12
diff -c -3 -p -r1.12 ra.c
*** ra.c 16 Dec 2003 00:06:33 -0000 1.12
--- ra.c 1 Feb 2004 23:36:15 -0000
*************** init_ra (void)
*** 472,497 ****
{
if (! CAN_ELIMINATE (eliminables[j].from, eliminables[j].to)
|| (eliminables[j].to == STACK_POINTER_REGNUM && need_fp))
! for (i = HARD_REGNO_NREGS (eliminables[j].from, Pmode); i--;)
SET_HARD_REG_BIT (never_use_colors, eliminables[j].from + i);
}
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
if (need_fp)
! for (i = HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (never_use_colors, HARD_FRAME_POINTER_REGNUM + i);
#endif
#else
if (need_fp)
! for (i = HARD_REGNO_NREGS (FRAME_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (never_use_colors, FRAME_POINTER_REGNUM + i);
#endif
/* Stack and argument pointer are also rather useless to us. */
! for (i = HARD_REGNO_NREGS (STACK_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (never_use_colors, STACK_POINTER_REGNUM + i);
! for (i = HARD_REGNO_NREGS (ARG_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (never_use_colors, ARG_POINTER_REGNUM + i);
for (i = 0; i < 256; i++)
--- 472,497 ----
{
if (! CAN_ELIMINATE (eliminables[j].from, eliminables[j].to)
|| (eliminables[j].to == STACK_POINTER_REGNUM && need_fp))
! for (i = hard_regno_nregs[eliminables[j].from][Pmode]; i--;)
SET_HARD_REG_BIT (never_use_colors, eliminables[j].from + i);
}
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
if (need_fp)
! for (i = hard_regno_nregs[HARD_FRAME_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (never_use_colors, HARD_FRAME_POINTER_REGNUM + i);
#endif
#else
if (need_fp)
! for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (never_use_colors, FRAME_POINTER_REGNUM + i);
#endif
/* Stack and argument pointer are also rather useless to us. */
! for (i = hard_regno_nregs[STACK_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (never_use_colors, STACK_POINTER_REGNUM + i);
! for (i = hard_regno_nregs[ARG_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (never_use_colors, ARG_POINTER_REGNUM + i);
for (i = 0; i < 256; i++)
*************** init_ra (void)
*** 528,534 ****
for (reg = 0; reg < FIRST_PSEUDO_REGISTER; reg++)
if (HARD_REGNO_MODE_OK (reg, i)
/* Ignore VOIDmode and similar things. */
! && (size = HARD_REGNO_NREGS (reg, i)) != 0
&& (reg + size) <= FIRST_PSEUDO_REGISTER)
{
while (size--)
--- 528,534 ----
for (reg = 0; reg < FIRST_PSEUDO_REGISTER; reg++)
if (HARD_REGNO_MODE_OK (reg, i)
/* Ignore VOIDmode and similar things. */
! && (size = hard_regno_nregs[reg][i]) != 0
&& (reg + size) <= FIRST_PSEUDO_REGISTER)
{
while (size--)
Index: recog.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/recog.c,v
retrieving revision 1.195
diff -c -3 -p -r1.195 recog.c
*** recog.c 23 Jan 2004 23:49:36 -0000 1.195
--- recog.c 1 Feb 2004 23:36:15 -0000
*************** reg_fits_class_p (rtx operand, enum reg_
*** 2666,2672 ****
{
int sr;
regno += offset;
! for (sr = HARD_REGNO_NREGS (regno, mode) - 1;
sr > 0; sr--)
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
regno + sr))
--- 2666,2672 ----
{
int sr;
regno += offset;
! for (sr = hard_regno_nregs[regno][mode] - 1;
sr > 0; sr--)
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
regno + sr))
*************** peep2_reg_dead_p (int ofs, rtx reg)
*** 2910,2916 ****
abort ();
regno = REGNO (reg);
! n = HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (--n >= 0)
if (REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno + n))
return 0;
--- 2910,2916 ----
abort ();
regno = REGNO (reg);
! n = hard_regno_nregs[regno][GET_MODE (reg)];
while (--n >= 0)
if (REGNO_REG_SET_P (peep2_insn_data[ofs].live_before, regno + n))
return 0;
*************** peep2_find_free_register (int from, int
*** 2998,3004 ****
continue;
success = 1;
! for (j = HARD_REGNO_NREGS (regno, mode) - 1; j >= 0; j--)
{
if (TEST_HARD_REG_BIT (*reg_set, regno + j)
|| TEST_HARD_REG_BIT (live, regno + j))
--- 2998,3004 ----
continue;
success = 1;
! for (j = hard_regno_nregs[regno][mode] - 1; j >= 0; j--)
{
if (TEST_HARD_REG_BIT (*reg_set, regno + j)
|| TEST_HARD_REG_BIT (live, regno + j))
*************** peep2_find_free_register (int from, int
*** 3009,3015 ****
}
if (success)
{
! for (j = HARD_REGNO_NREGS (regno, mode) - 1; j >= 0; j--)
SET_HARD_REG_BIT (*reg_set, regno + j);
/* Start the next search with the next register. */
--- 3009,3015 ----
}
if (success)
{
! for (j = hard_regno_nregs[regno][mode] - 1; j >= 0; j--)
SET_HARD_REG_BIT (*reg_set, regno + j);
/* Start the next search with the next register. */
Index: reg-stack.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reg-stack.c,v
retrieving revision 1.141
diff -c -3 -p -r1.141 reg-stack.c
*** reg-stack.c 21 Jan 2004 20:40:03 -0000 1.141
--- reg-stack.c 1 Feb 2004 23:36:15 -0000
*************** subst_stack_regs_pat (rtx insn, stack re
*** 1491,1497 ****
case CALL:
{
int count;
! for (count = HARD_REGNO_NREGS (REGNO (*dest), GET_MODE (*dest));
--count >= 0;)
{
regstack->reg[++regstack->top] = REGNO (*dest) + count;
--- 1491,1497 ----
case CALL:
{
int count;
! for (count = hard_regno_nregs[REGNO (*dest)][GET_MODE (*dest)];
--count >= 0;)
{
regstack->reg[++regstack->top] = REGNO (*dest) + count;
*************** convert_regs_exit (void)
*** 2484,2490 ****
{
value_reg_low = REGNO (retvalue);
value_reg_high = value_reg_low
! + HARD_REGNO_NREGS (value_reg_low, GET_MODE (retvalue)) - 1;
}
output_stack = &BLOCK_INFO (EXIT_BLOCK_PTR)->stack_in;
--- 2484,2490 ----
{
value_reg_low = REGNO (retvalue);
value_reg_high = value_reg_low
! + hard_regno_nregs[value_reg_low][GET_MODE (retvalue)] - 1;
}
output_stack = &BLOCK_INFO (EXIT_BLOCK_PTR)->stack_in;
Index: regclass.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regclass.c,v
retrieving revision 1.183
diff -c -3 -p -r1.183 regclass.c
*** regclass.c 22 Dec 2003 18:23:15 -0000 1.183
--- regclass.c 1 Feb 2004 23:36:16 -0000
*************** static struct reg_info_data *reg_info_he
*** 252,257 ****
--- 252,259 ----
static int no_global_reg_vars = 0;
+ /* Specify number of hard registers given machine mode occupy. */
+ unsigned char hard_regno_nregs[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
/* Function called only once to initialize the above data on reg usage.
Once this is done, various switches may override. */
*************** init_reg_sets_1 (void)
*** 539,545 ****
void
init_reg_modes_once (void)
{
! int i;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
--- 541,551 ----
void
init_reg_modes_once (void)
{
! int i, j;
!
! for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
! for (j = 0; j < MAX_MACHINE_MODE; j++)
! hard_regno_nregs[i][j] = HARD_REGNO_NREGS(i, (enum machine_mode)j);
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
*************** choose_hard_reg_mode (unsigned int regno
*** 658,664 ****
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) HARD_REGNO_NREGS (regno, mode) == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
--- 664,670 ----
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) hard_regno_nregs[regno][mode] == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
*************** choose_hard_reg_mode (unsigned int regno
*** 669,675 ****
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) HARD_REGNO_NREGS (regno, mode) == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
--- 675,681 ----
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) hard_regno_nregs[regno][mode] == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
*************** choose_hard_reg_mode (unsigned int regno
*** 680,686 ****
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) HARD_REGNO_NREGS (regno, mode) == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
--- 686,692 ----
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_FLOAT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) hard_regno_nregs[regno][mode] == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
*************** choose_hard_reg_mode (unsigned int regno
*** 691,697 ****
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) HARD_REGNO_NREGS (regno, mode) == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
--- 697,703 ----
for (mode = GET_CLASS_NARROWEST_MODE (MODE_VECTOR_INT);
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
! if ((unsigned) hard_regno_nregs[regno][mode] == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
found_mode = mode;
*************** choose_hard_reg_mode (unsigned int regno
*** 703,709 ****
for (m = (unsigned int) CCmode; m < (unsigned int) NUM_MACHINE_MODES; ++m)
{
mode = (enum machine_mode) m;
! if ((unsigned) HARD_REGNO_NREGS (regno, mode) == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
return mode;
--- 709,715 ----
for (m = (unsigned int) CCmode; m < (unsigned int) NUM_MACHINE_MODES; ++m)
{
mode = (enum machine_mode) m;
! if ((unsigned) hard_regno_nregs[regno][mode] == nregs
&& HARD_REGNO_MODE_OK (regno, mode)
&& (! call_saved || ! HARD_REGNO_CALL_PART_CLOBBERED (regno, mode)))
return mode;
*************** record_reg_classes (int n_alts, int n_op
*** 1836,1849 ****
op_costs[i].cost[class] = -1;
else
{
! for (nr = 0; nr < (unsigned) HARD_REGNO_NREGS (regno, mode); nr++)
{
if (! TEST_HARD_REG_BIT (reg_class_contents[class],
regno + nr))
break;
}
! if (nr == (unsigned) HARD_REGNO_NREGS (regno,mode))
op_costs[i].cost[class] = -1;
}
}
--- 1842,1855 ----
op_costs[i].cost[class] = -1;
else
{
! for (nr = 0; nr < (unsigned) hard_regno_nregs[regno][mode]; nr++)
{
if (! TEST_HARD_REG_BIT (reg_class_contents[class],
regno + nr))
break;
}
! if (nr == (unsigned) hard_regno_nregs[regno][mode])
op_costs[i].cost[class] = -1;
}
}
Index: regmove.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regmove.c,v
retrieving revision 1.153
diff -c -3 -p -r1.153 regmove.c
*** regmove.c 21 Jan 2004 20:40:03 -0000 1.153
--- regmove.c 1 Feb 2004 23:36:16 -0000
*************** mark_flags_life_zones (rtx flags)
*** 246,252 ****
flags_nregs = 1;
#else
flags_regno = REGNO (flags);
! flags_nregs = HARD_REGNO_NREGS (flags_regno, GET_MODE (flags));
#endif
flags_set_1_rtx = flags;
--- 246,252 ----
flags_nregs = 1;
#else
flags_regno = REGNO (flags);
! flags_nregs = hard_regno_nregs[flags_regno][GET_MODE (flags)];
#endif
flags_set_1_rtx = flags;
Index: regrename.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regrename.c,v
retrieving revision 1.73
diff -c -3 -p -r1.73 regrename.c
*** regrename.c 14 Jan 2004 17:55:20 -0000 1.73
--- regrename.c 1 Feb 2004 23:36:16 -0000
*************** note_sets (rtx x, rtx set ATTRIBUTE_UNUS
*** 104,110 ****
if (GET_CODE (x) != REG)
return;
regno = REGNO (x);
! nregs = HARD_REGNO_NREGS (regno, GET_MODE (x));
/* There must not be pseudos at this point. */
if (regno + nregs > FIRST_PSEUDO_REGISTER)
--- 104,110 ----
if (GET_CODE (x) != REG)
return;
regno = REGNO (x);
! nregs = hard_regno_nregs[regno][GET_MODE (x)];
/* There must not be pseudos at this point. */
if (regno + nregs > FIRST_PSEUDO_REGISTER)
*************** clear_dead_regs (HARD_REG_SET *pset, enu
*** 126,132 ****
{
rtx reg = XEXP (note, 0);
unsigned int regno = REGNO (reg);
! int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
/* There must not be pseudos at this point. */
if (regno + nregs > FIRST_PSEUDO_REGISTER)
--- 126,132 ----
{
rtx reg = XEXP (note, 0);
unsigned int regno = REGNO (reg);
! int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
/* There must not be pseudos at this point. */
if (regno + nregs > FIRST_PSEUDO_REGISTER)
*************** regrename_optimize (void)
*** 218,228 ****
{
int i;
! for (i = HARD_REGNO_NREGS (FRAME_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i);
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
! for (i = HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM, Pmode); i--;)
SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i);
#endif
}
--- 218,228 ----
{
int i;
! for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i);
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
! for (i = hard_regno_nregs[HARD_FRAME_POINTER_REGNUM][Pmode]; i--;)
SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i);
#endif
}
*************** regrename_optimize (void)
*** 287,293 ****
have a closer look at each register still in there. */
for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
{
! int nregs = HARD_REGNO_NREGS (new_reg, GET_MODE (*this->loc));
for (i = nregs - 1; i >= 0; --i)
if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
--- 287,293 ----
have a closer look at each register still in there. */
for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
{
! int nregs = hard_regno_nregs[new_reg][GET_MODE (*this->loc)];
for (i = nregs - 1; i >= 0; --i)
if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
*************** scan_rtx_reg (rtx insn, rtx *loc, enum r
*** 391,397 ****
rtx x = *loc;
enum machine_mode mode = GET_MODE (x);
int this_regno = REGNO (x);
! int this_nregs = HARD_REGNO_NREGS (this_regno, mode);
if (action == mark_write)
{
--- 391,397 ----
rtx x = *loc;
enum machine_mode mode = GET_MODE (x);
int this_regno = REGNO (x);
! int this_nregs = hard_regno_nregs[this_regno][mode];
if (action == mark_write)
{
*************** scan_rtx_reg (rtx insn, rtx *loc, enum r
*** 431,437 ****
else
{
int regno = REGNO (*this->loc);
! int nregs = HARD_REGNO_NREGS (regno, GET_MODE (*this->loc));
int exact_match = (regno == this_regno && nregs == this_nregs);
if (regno + nregs <= this_regno
--- 431,437 ----
else
{
int regno = REGNO (*this->loc);
! int nregs = hard_regno_nregs[regno][GET_MODE (*this->loc)];
int exact_match = (regno == this_regno && nregs == this_nregs);
if (regno + nregs <= this_regno
*************** dump_def_use_chain (struct du_chain *cha
*** 973,979 ****
{
struct du_chain *this = chains;
int r = REGNO (*this->loc);
! int nregs = HARD_REGNO_NREGS (r, GET_MODE (*this->loc));
fprintf (rtl_dump_file, "Register %s (%d):", reg_names[r], nregs);
while (this)
{
--- 973,979 ----
{
struct du_chain *this = chains;
int r = REGNO (*this->loc);
! int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)];
fprintf (rtl_dump_file, "Register %s (%d):", reg_names[r], nregs);
while (this)
{
*************** kill_value (rtx x, struct value_data *vd
*** 1084,1090 ****
if (REG_P (x))
{
unsigned int regno = REGNO (x);
! unsigned int n = HARD_REGNO_NREGS (regno, GET_MODE (x));
unsigned int i, j;
/* Kill the value we're told to kill. */
--- 1084,1090 ----
if (REG_P (x))
{
unsigned int regno = REGNO (x);
! unsigned int n = hard_regno_nregs[regno][GET_MODE (x)];
unsigned int i, j;
/* Kill the value we're told to kill. */
*************** kill_value (rtx x, struct value_data *vd
*** 1100,1106 ****
{
if (vd->e[j].mode == VOIDmode)
continue;
! n = HARD_REGNO_NREGS (j, vd->e[j].mode);
if (j + n > regno)
for (i = 0; i < n; ++i)
kill_value_regno (j + i, vd);
--- 1100,1106 ----
{
if (vd->e[j].mode == VOIDmode)
continue;
! n = hard_regno_nregs[j][vd->e[j].mode];
if (j + n > regno)
for (i = 0; i < n; ++i)
kill_value_regno (j + i, vd);
*************** set_value_regno (unsigned int regno, enu
*** 1118,1124 ****
vd->e[regno].mode = mode;
! nregs = HARD_REGNO_NREGS (regno, mode);
if (nregs > vd->max_value_regs)
vd->max_value_regs = nregs;
}
--- 1118,1124 ----
vd->e[regno].mode = mode;
! nregs = hard_regno_nregs[regno][mode];
if (nregs > vd->max_value_regs)
vd->max_value_regs = nregs;
}
*************** copy_value (rtx dest, rtx src, struct va
*** 1210,1217 ****
return;
/* If SRC and DEST overlap, don't record anything. */
! dn = HARD_REGNO_NREGS (dr, GET_MODE (dest));
! sn = HARD_REGNO_NREGS (sr, GET_MODE (dest));
if ((dr > sr && dr < sr + sn)
|| (sr > dr && sr < dr + dn))
return;
--- 1210,1217 ----
return;
/* If SRC and DEST overlap, don't record anything. */
! dn = hard_regno_nregs[dr][GET_MODE (dest)];
! sn = hard_regno_nregs[sr][GET_MODE (dest)];
if ((dr > sr && dr < sr + sn)
|| (sr > dr && sr < dr + dn))
return;
*************** copy_value (rtx dest, rtx src, struct va
*** 1237,1243 ****
We can't properly represent the latter case in our tables, so don't
record anything then. */
! else if (sn < (unsigned int) HARD_REGNO_NREGS (sr, vd->e[sr].mode)
&& (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
return;
--- 1237,1243 ----
We can't properly represent the latter case in our tables, so don't
record anything then. */
! else if (sn < (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode]
&& (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD
? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
return;
*************** copy_value (rtx dest, rtx src, struct va
*** 1245,1251 ****
/* If SRC had been assigned a mode narrower than the copy, we can't
link DEST into the chain, because not all of the pieces of the
copy came from oldest_regno. */
! else if (sn > (unsigned int) HARD_REGNO_NREGS (sr, vd->e[sr].mode))
return;
/* Link DR at the end of the value chain used by SR. */
--- 1245,1251 ----
/* If SRC had been assigned a mode narrower than the copy, we can't
link DEST into the chain, because not all of the pieces of the
copy came from oldest_regno. */
! else if (sn > (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode])
return;
/* Link DR at the end of the value chain used by SR. */
*************** maybe_mode_change (enum machine_mode ori
*** 1291,1298 ****
return gen_rtx_raw_REG (new_mode, regno);
else if (mode_change_ok (orig_mode, new_mode, regno))
{
! int copy_nregs = HARD_REGNO_NREGS (copy_regno, copy_mode);
! int use_nregs = HARD_REGNO_NREGS (copy_regno, new_mode);
int copy_offset
= GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs);
int offset
--- 1291,1298 ----
return gen_rtx_raw_REG (new_mode, regno);
else if (mode_change_ok (orig_mode, new_mode, regno))
{
! int copy_nregs = hard_regno_nregs[copy_regno][copy_mode];
! int use_nregs = hard_regno_nregs[copy_regno][new_mode];
int copy_offset
= GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs);
int offset
*************** find_oldest_value_reg (enum reg_class cl
*** 1330,1337 ****
Replacing r9 with r11 is invalid. */
if (mode != vd->e[regno].mode)
{
! if (HARD_REGNO_NREGS (regno, mode)
! > HARD_REGNO_NREGS (regno, vd->e[regno].mode))
return NULL_RTX;
}
--- 1330,1337 ----
Replacing r9 with r11 is invalid. */
if (mode != vd->e[regno].mode)
{
! if (hard_regno_nregs[regno][mode]
! > hard_regno_nregs[regno][vd->e[regno].mode])
return NULL_RTX;
}
*************** find_oldest_value_reg (enum reg_class cl
*** 1341,1347 ****
rtx new;
unsigned int last;
! for (last = i; last < i + HARD_REGNO_NREGS (i, mode); last++)
if (!TEST_HARD_REG_BIT (reg_class_contents[class], last))
return NULL_RTX;
--- 1341,1347 ----
rtx new;
unsigned int last;
! for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
if (!TEST_HARD_REG_BIT (reg_class_contents[class], last))
return NULL_RTX;
*************** copyprop_hardreg_forward_1 (basic_block
*** 1600,1607 ****
set it in, make sure that the replacement is valid. */
if (mode != vd->e[regno].mode)
{
! if (HARD_REGNO_NREGS (regno, mode)
! > HARD_REGNO_NREGS (regno, vd->e[regno].mode))
goto no_move_special_case;
}
--- 1600,1607 ----
set it in, make sure that the replacement is valid. */
if (mode != vd->e[regno].mode)
{
! if (hard_regno_nregs[regno][mode]
! > hard_regno_nregs[regno][vd->e[regno].mode])
goto no_move_special_case;
}
Index: regs.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regs.h,v
retrieving revision 1.31
diff -c -3 -p -r1.31 regs.h
*** regs.h 6 Dec 2003 12:22:31 -0000 1.31
--- regs.h 1 Feb 2004 23:36:16 -0000
*************** extern int caller_save_needed;
*** 224,226 ****
--- 224,229 ----
/* Allocate reg_n_info tables */
extern void allocate_reg_info (size_t, int, int);
+
+ /* Specify number of hard registers given machine mode occupy. */
+ extern unsigned char hard_regno_nregs[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
Index: reload.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reload.c,v
retrieving revision 1.233
diff -c -3 -p -r1.233 reload.c
*** reload.c 30 Jan 2004 20:42:24 -0000 1.233
--- reload.c 1 Feb 2004 23:36:16 -0000
*************** reload_inner_reg_of_subreg (rtx x, enum
*** 818,824 ****
&& output
&& GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
&& ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
! != (int) HARD_REGNO_NREGS (REGNO (inner), GET_MODE (inner))));
}
/* Return nonzero if IN can be reloaded into REGNO with mode MODE without
--- 818,824 ----
&& output
&& GET_MODE_SIZE (GET_MODE (inner)) > UNITS_PER_WORD
&& ((GET_MODE_SIZE (GET_MODE (inner)) / UNITS_PER_WORD)
! != (int) hard_regno_nregs[REGNO (inner)][GET_MODE (inner)]));
}
/* Return nonzero if IN can be reloaded into REGNO with mode MODE without
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1038,1045 ****
> UNITS_PER_WORD)
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
/ UNITS_PER_WORD)
! != (int) HARD_REGNO_NREGS (REGNO (SUBREG_REG (in)),
! GET_MODE (SUBREG_REG (in)))))
|| ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
#ifdef SECONDARY_INPUT_RELOAD_CLASS
|| (SECONDARY_INPUT_RELOAD_CLASS (class, inmode, in) != NO_REGS
--- 1038,1045 ----
> UNITS_PER_WORD)
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))
/ UNITS_PER_WORD)
! != (int) hard_regno_nregs[REGNO (SUBREG_REG (in))]
! [GET_MODE (SUBREG_REG (in))]))
|| ! HARD_REGNO_MODE_OK (subreg_regno (in), inmode)))
#ifdef SECONDARY_INPUT_RELOAD_CLASS
|| (SECONDARY_INPUT_RELOAD_CLASS (class, inmode, in) != NO_REGS
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1135,1142 ****
> UNITS_PER_WORD)
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
/ UNITS_PER_WORD)
! != (int) HARD_REGNO_NREGS (REGNO (SUBREG_REG (out)),
! GET_MODE (SUBREG_REG (out)))))
|| ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
#ifdef SECONDARY_OUTPUT_RELOAD_CLASS
|| (SECONDARY_OUTPUT_RELOAD_CLASS (class, outmode, out) != NO_REGS
--- 1135,1142 ----
> UNITS_PER_WORD)
&& ((GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))
/ UNITS_PER_WORD)
! != (int) hard_regno_nregs[REGNO (SUBREG_REG (out))]
! [GET_MODE (SUBREG_REG (out))]))
|| ! HARD_REGNO_MODE_OK (subreg_regno (out), outmode)))
#ifdef SECONDARY_OUTPUT_RELOAD_CLASS
|| (SECONDARY_OUTPUT_RELOAD_CLASS (class, outmode, out) != NO_REGS
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1262,1268 ****
if (HARD_REGNO_MODE_OK (i, mode)
&& TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
{
! int nregs = HARD_REGNO_NREGS (i, mode);
int j;
for (j = 1; j < nregs; j++)
--- 1262,1268 ----
if (HARD_REGNO_MODE_OK (i, mode)
&& TEST_HARD_REG_BIT (reg_class_contents[(int) class], i))
{
! int nregs = hard_regno_nregs[i][mode];
int j;
for (j = 1; j < nregs; j++)
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1520,1527 ****
&& reg_mentioned_p (XEXP (note, 0), in)
&& ! refers_to_regno_for_reload_p (regno,
(regno
! + HARD_REGNO_NREGS (regno,
! rel_mode)),
PATTERN (this_insn), inloc)
/* If this is also an output reload, IN cannot be used as
the reload register if it is set in this insn unless IN
--- 1520,1527 ----
&& reg_mentioned_p (XEXP (note, 0), in)
&& ! refers_to_regno_for_reload_p (regno,
(regno
! + hard_regno_nregs[regno]
! [rel_mode]),
PATTERN (this_insn), inloc)
/* If this is also an output reload, IN cannot be used as
the reload register if it is set in this insn unless IN
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1529,1536 ****
&& (out == 0 || in == out
|| ! hard_reg_set_here_p (regno,
(regno
! + HARD_REGNO_NREGS (regno,
! rel_mode)),
PATTERN (this_insn)))
/* ??? Why is this code so different from the previous?
Is there any simple coherent way to describe the two together?
--- 1529,1536 ----
&& (out == 0 || in == out
|| ! hard_reg_set_here_p (regno,
(regno
! + hard_regno_nregs[regno]
! [rel_mode]),
PATTERN (this_insn)))
/* ??? Why is this code so different from the previous?
Is there any simple coherent way to describe the two together?
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1548,1555 ****
&& HARD_REGNO_MODE_OK (regno, outmode))
{
unsigned int offs;
! unsigned int nregs = MAX (HARD_REGNO_NREGS (regno, inmode),
! HARD_REGNO_NREGS (regno, outmode));
for (offs = 0; offs < nregs; offs++)
if (fixed_regs[regno + offs]
--- 1548,1555 ----
&& HARD_REGNO_MODE_OK (regno, outmode))
{
unsigned int offs;
! unsigned int nregs = MAX (hard_regno_nregs[regno][inmode],
! hard_regno_nregs[regno][outmode]);
for (offs = 0; offs < nregs; offs++)
if (fixed_regs[regno + offs]
*************** push_reload (rtx in, rtx out, rtx *inloc
*** 1559,1565 ****
if (offs == nregs
&& (! (refers_to_regno_for_reload_p
! (regno, (regno + HARD_REGNO_NREGS (regno, inmode)),
in, (rtx *)0))
|| can_reload_into (in, regno, inmode)))
{
--- 1559,1565 ----
if (offs == nregs
&& (! (refers_to_regno_for_reload_p
! (regno, (regno + hard_regno_nregs[regno][inmode]),
in, (rtx *)0))
|| can_reload_into (in, regno, inmode)))
{
*************** combine_reloads (void)
*** 1830,1837 ****
&& HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
&& TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
REGNO (XEXP (note, 0)))
! && (HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
! <= HARD_REGNO_NREGS (REGNO (XEXP (note, 0)), GET_MODE (XEXP (note, 0))))
/* Ensure that a secondary or tertiary reload for this output
won't want this register. */
&& ((secondary_out = rld[output_reload].secondary_out_reload) == -1
--- 1830,1837 ----
&& HARD_REGNO_MODE_OK (REGNO (XEXP (note, 0)), rld[output_reload].outmode)
&& TEST_HARD_REG_BIT (reg_class_contents[(int) rld[output_reload].class],
REGNO (XEXP (note, 0)))
! && (hard_regno_nregs[REGNO (XEXP (note, 0))][rld[output_reload].outmode]
! <= hard_regno_nregs[REGNO (XEXP (note, 0))][GET_MODE (XEXP (note, 0))])
/* Ensure that a secondary or tertiary reload for this output
won't want this register. */
&& ((secondary_out = rld[output_reload].secondary_out_reload) == -1
*************** find_dummy_reload (rtx real_in, rtx real
*** 1923,1929 ****
&& REGNO (out) < FIRST_PSEUDO_REGISTER)
{
unsigned int regno = REGNO (out) + out_offset;
! unsigned int nwords = HARD_REGNO_NREGS (regno, outmode);
rtx saved_rtx;
/* When we consider whether the insn uses OUT,
--- 1923,1929 ----
&& REGNO (out) < FIRST_PSEUDO_REGISTER)
{
unsigned int regno = REGNO (out) + out_offset;
! unsigned int nwords = hard_regno_nregs[regno][outmode];
rtx saved_rtx;
/* When we consider whether the insn uses OUT,
*************** find_dummy_reload (rtx real_in, rtx real
*** 1984,1990 ****
? GET_MODE (out) : outmode)))
{
unsigned int regno = REGNO (in) + in_offset;
! unsigned int nwords = HARD_REGNO_NREGS (regno, inmode);
if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
&& ! hard_reg_set_here_p (regno, regno + nwords,
--- 1984,1990 ----
? GET_MODE (out) : outmode)))
{
unsigned int regno = REGNO (in) + in_offset;
! unsigned int nwords = hard_regno_nregs[regno][inmode];
if (! refers_to_regno_for_reload_p (regno, regno + nwords, out, (rtx*) 0)
&& ! hard_reg_set_here_p (regno, regno + nwords,
*************** hard_reg_set_here_p (unsigned int beg_re
*** 2056,2062 ****
/* See if this reg overlaps range under consideration. */
if (r < end_regno
! && r + HARD_REGNO_NREGS (r, GET_MODE (op0)) > beg_regno)
return 1;
}
}
--- 2056,2062 ----
/* See if this reg overlaps range under consideration. */
if (r < end_regno
! && r + hard_regno_nregs[r][GET_MODE (op0)] > beg_regno)
return 1;
}
}
*************** operands_match_p (rtx x, rtx y)
*** 2148,2157 ****
(reg:SI 1) will be considered the same register. */
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
&& i < FIRST_PSEUDO_REGISTER)
! i += HARD_REGNO_NREGS (i, GET_MODE (x)) - 1;
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
&& j < FIRST_PSEUDO_REGISTER)
! j += HARD_REGNO_NREGS (j, GET_MODE (y)) - 1;
return i == j;
}
--- 2148,2157 ----
(reg:SI 1) will be considered the same register. */
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD
&& i < FIRST_PSEUDO_REGISTER)
! i += hard_regno_nregs[i][GET_MODE (x)] - 1;
if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (y)) > UNITS_PER_WORD
&& j < FIRST_PSEUDO_REGISTER)
! j += hard_regno_nregs[j][GET_MODE (y)] - 1;
return i == j;
}
*************** decompose (rtx x)
*** 2363,2369 ****
}
else
/* A hard reg. */
! val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
}
else if (GET_CODE (x) == SUBREG)
{
--- 2363,2369 ----
}
else
/* A hard reg. */
! val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
}
else if (GET_CODE (x) == SUBREG)
{
*************** decompose (rtx x)
*** 2376,2382 ****
return decompose (SUBREG_REG (x));
else
/* A hard reg. */
! val.end = val.start + HARD_REGNO_NREGS (val.start, GET_MODE (x));
}
else if (CONSTANT_P (x)
/* This hasn't been assigned yet, so it can't conflict yet. */
--- 2376,2382 ----
return decompose (SUBREG_REG (x));
else
/* A hard reg. */
! val.end = val.start + hard_regno_nregs[val.start][GET_MODE (x)];
}
else if (CONSTANT_P (x)
/* This hasn't been assigned yet, so it can't conflict yet. */
*************** find_reloads (rtx insn, int replace, int
*** 4366,4372 ****
&& TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
&& HARD_REGNO_MODE_OK (regno, rld[i].mode))
{
! int nr = HARD_REGNO_NREGS (regno, rld[i].mode);
int ok = 1, nri;
for (nri = 1; nri < nr; nri ++)
--- 4366,4372 ----
&& TEST_HARD_REG_BIT (reg_class_contents[rld[i].class], regno)
&& HARD_REGNO_MODE_OK (regno, rld[i].mode))
{
! int nr = hard_regno_nregs[regno][rld[i].mode];
int ok = 1, nri;
for (nri = 1; nri < nr; nri ++)
*************** refers_to_regno_for_reload_p (unsigned i
*** 6177,6183 ****
return (endregno > r
&& regno < r + (r < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (r, GET_MODE (x))
: 1));
case SUBREG:
--- 6177,6183 ----
return (endregno > r
&& regno < r + (r < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[r][GET_MODE (x)]
: 1));
case SUBREG:
*************** refers_to_regno_for_reload_p (unsigned i
*** 6189,6195 ****
unsigned int inner_regno = subreg_regno (x);
unsigned int inner_endregno
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
return endregno > inner_regno && regno < inner_endregno;
}
--- 6189,6195 ----
unsigned int inner_regno = subreg_regno (x);
unsigned int inner_endregno
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
return endregno > inner_regno && regno < inner_endregno;
}
*************** reg_overlap_mentioned_for_reload_p (rtx
*** 6328,6334 ****
abort ();
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
}
--- 6328,6334 ----
abort ();
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
return refers_to_regno_for_reload_p (regno, endregno, in, (rtx*) 0);
}
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6539,6545 ****
{
int i;
! for (i = HARD_REGNO_NREGS (valueno, mode) - 1; i >= 0; i--)
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
valueno + i))
break;
--- 6539,6545 ----
{
int i;
! for (i = hard_regno_nregs[valueno][mode] - 1; i >= 0; i--)
if (! TEST_HARD_REG_BIT (reg_class_contents[(int) class],
valueno + i))
break;
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6581,6599 ****
if (goal_mem && value == SET_DEST (single_set (where))
&& refers_to_regno_for_reload_p (valueno,
(valueno
! + HARD_REGNO_NREGS (valueno, mode)),
goal, (rtx*) 0))
return 0;
/* Reject registers that overlap GOAL. */
if (!goal_mem && !goal_const
! && regno + (int) HARD_REGNO_NREGS (regno, mode) > valueno
! && regno < valueno + (int) HARD_REGNO_NREGS (valueno, mode))
return 0;
! nregs = HARD_REGNO_NREGS (regno, mode);
! valuenregs = HARD_REGNO_NREGS (valueno, mode);
/* Reject VALUE if it is one of the regs reserved for reloads.
Reload1 knows how to reuse them anyway, and it would get
--- 6581,6602 ----
if (goal_mem && value == SET_DEST (single_set (where))
&& refers_to_regno_for_reload_p (valueno,
(valueno
! + hard_regno_nregs[valueno][mode]),
goal, (rtx*) 0))
return 0;
/* Reject registers that overlap GOAL. */
if (!goal_mem && !goal_const
! && regno + (int) hard_regno_nregs[regno][mode] > valueno
! && regno < valueno + (int) hard_regno_nregs[valueno][mode])
return 0;
! if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER)
! nregs = hard_regno_nregs[regno][mode];
! else
! nregs = 1;
! valuenregs = hard_regno_nregs[valueno][mode];
/* Reject VALUE if it is one of the regs reserved for reloads.
Reload1 knows how to reuse them anyway, and it would get
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6619,6626 ****
if (rld[i].reg_rtx != 0 && rld[i].in)
{
int regno1 = REGNO (rld[i].reg_rtx);
! int nregs1 = HARD_REGNO_NREGS (regno1,
! GET_MODE (rld[i].reg_rtx));
if (regno1 < valueno + valuenregs
&& regno1 + nregs1 > valueno)
return 0;
--- 6622,6629 ----
if (rld[i].reg_rtx != 0 && rld[i].in)
{
int regno1 = REGNO (rld[i].reg_rtx);
! int nregs1 = hard_regno_nregs[regno1]
! [GET_MODE (rld[i].reg_rtx)];
if (regno1 < valueno + valuenregs
&& regno1 + nregs1 > valueno)
return 0;
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6694,6700 ****
int xregno = REGNO (dest);
int xnregs;
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
! xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
else
xnregs = 1;
if (xregno < regno + nregs && xregno + xnregs > regno)
--- 6697,6703 ----
int xregno = REGNO (dest);
int xnregs;
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
! xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
else
xnregs = 1;
if (xregno < regno + nregs && xregno + xnregs > regno)
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6738,6744 ****
int xregno = REGNO (dest);
int xnregs;
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
! xnregs = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
else
xnregs = 1;
if (xregno < regno + nregs
--- 6741,6747 ----
int xregno = REGNO (dest);
int xnregs;
if (REGNO (dest) < FIRST_PSEUDO_REGISTER)
! xnregs = hard_regno_nregs[xregno][GET_MODE (dest)];
else
xnregs = 1;
if (xregno < regno + nregs
*************** find_equiv_reg (rtx goal, rtx insn, enum
*** 6783,6789 ****
{
int xregno = REGNO (dest);
int xnregs
! = HARD_REGNO_NREGS (xregno, GET_MODE (dest));
if (xregno < regno + nregs
&& xregno + xnregs > regno)
--- 6786,6792 ----
{
int xregno = REGNO (dest);
int xnregs
! = hard_regno_nregs[xregno][GET_MODE (dest)];
if (xregno < regno + nregs
&& xregno + xnregs > regno)
*************** int
*** 6898,6904 ****
regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
int sets)
{
! unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
unsigned int endregno = regno + nregs;
if ((GET_CODE (PATTERN (insn)) == CLOBBER
--- 6901,6907 ----
regno_clobbered_p (unsigned int regno, rtx insn, enum machine_mode mode,
int sets)
{
! unsigned int nregs = hard_regno_nregs[regno][mode];
unsigned int endregno = regno + nregs;
if ((GET_CODE (PATTERN (insn)) == CLOBBER
*************** reload_adjust_reg_for_mode (rtx reloadre
*** 6944,6951 ****
regno = REGNO (reloadreg);
if (WORDS_BIG_ENDIAN)
! regno += HARD_REGNO_NREGS (regno, GET_MODE (reloadreg))
! - HARD_REGNO_NREGS (regno, mode);
return gen_rtx_REG (mode, regno);
}
--- 6947,6954 ----
regno = REGNO (reloadreg);
if (WORDS_BIG_ENDIAN)
! regno += (int) hard_regno_nregs[regno][GET_MODE (reloadreg)]
! - (int) hard_regno_nregs[regno][mode];
return gen_rtx_REG (mode, regno);
}
Index: reload1.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reload1.c,v
retrieving revision 1.423
diff -c -3 -p -r1.423 reload1.c
*** reload1.c 31 Jan 2004 17:47:43 -0000 1.423
--- reload1.c 1 Feb 2004 23:36:17 -0000
*************** compute_use_by_pseudos (HARD_REG_SET *to
*** 534,540 ****
}
else
{
! nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (regno));
while (nregs-- > 0)
SET_HARD_REG_BIT (*to, r + nregs);
}
--- 534,540 ----
}
else
{
! nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
while (nregs-- > 0)
SET_HARD_REG_BIT (*to, r + nregs);
}
*************** count_pseudo (int reg)
*** 1572,1578 ****
spill_add_cost[r] += freq;
! nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (reg));
while (nregs-- > 0)
spill_cost[r + nregs] += freq;
}
--- 1572,1578 ----
spill_add_cost[r] += freq;
! nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (reg)];
while (nregs-- > 0)
spill_cost[r + nregs] += freq;
}
*************** static void
*** 1634,1640 ****
count_spilled_pseudo (int spilled, int spilled_nregs, int reg)
{
int r = reg_renumber[reg];
! int nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (reg));
if (REGNO_REG_SET_P (&spilled_pseudos, reg)
|| spilled + spilled_nregs <= r || r + nregs <= spilled)
--- 1634,1640 ----
count_spilled_pseudo (int spilled, int spilled_nregs, int reg)
{
int r = reg_renumber[reg];
! int nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (reg)];
if (REGNO_REG_SET_P (&spilled_pseudos, reg)
|| spilled + spilled_nregs <= r || r + nregs <= spilled)
*************** find_reg (struct insn_chain *chain, int
*** 1685,1691 ****
{
int this_cost = spill_cost[regno];
int ok = 1;
! unsigned int this_nregs = HARD_REGNO_NREGS (regno, rl->mode);
for (j = 1; j < this_nregs; j++)
{
--- 1685,1691 ----
{
int this_cost = spill_cost[regno];
int ok = 1;
! unsigned int this_nregs = hard_regno_nregs[regno][rl->mode];
for (j = 1; j < this_nregs; j++)
{
*************** find_reg (struct insn_chain *chain, int
*** 1724,1730 ****
if (rtl_dump_file)
fprintf (rtl_dump_file, "Using reg %d for reload %d\n", best_reg, rnum);
! rl->nregs = HARD_REGNO_NREGS (best_reg, rl->mode);
rl->regno = best_reg;
EXECUTE_IF_SET_IN_REG_SET
--- 1724,1730 ----
if (rtl_dump_file)
fprintf (rtl_dump_file, "Using reg %d for reload %d\n", best_reg, rnum);
! rl->nregs = hard_regno_nregs[best_reg][rl->mode];
rl->regno = best_reg;
EXECUTE_IF_SET_IN_REG_SET
*************** find_reload_regs (struct insn_chain *cha
*** 1772,1778 ****
int regno = REGNO (chain->rld[i].reg_rtx);
chain->rld[i].regno = regno;
chain->rld[i].nregs
! = HARD_REGNO_NREGS (regno, GET_MODE (chain->rld[i].reg_rtx));
}
else
chain->rld[i].regno = -1;
--- 1772,1778 ----
int regno = REGNO (chain->rld[i].reg_rtx);
chain->rld[i].regno = regno;
chain->rld[i].nregs
! = hard_regno_nregs[regno][GET_MODE (chain->rld[i].reg_rtx)];
}
else
chain->rld[i].regno = -1;
*************** mark_home_live (int regno)
*** 2062,2068 ****
i = reg_renumber[regno];
if (i < 0)
return;
! lim = i + HARD_REGNO_NREGS (i, PSEUDO_REGNO_MODE (regno));
while (i < lim)
regs_ever_live[i++] = 1;
}
--- 2062,2068 ----
i = reg_renumber[regno];
if (i < 0)
return;
! lim = i + hard_regno_nregs[i][PSEUDO_REGNO_MODE (regno)];
while (i < lim)
regs_ever_live[i++] = 1;
}
*************** spill_hard_reg (unsigned int regno, int
*** 3516,3523 ****
if (reg_renumber[i] >= 0
&& (unsigned int) reg_renumber[i] <= regno
&& ((unsigned int) reg_renumber[i]
! + HARD_REGNO_NREGS ((unsigned int) reg_renumber[i],
! PSEUDO_REGNO_MODE (i))
> regno))
SET_REGNO_REG_SET (&spilled_pseudos, i);
}
--- 3516,3523 ----
if (reg_renumber[i] >= 0
&& (unsigned int) reg_renumber[i] <= regno
&& ((unsigned int) reg_renumber[i]
! + hard_regno_nregs[(unsigned int) reg_renumber[i]]
! [PSEUDO_REGNO_MODE (i)]
> regno))
SET_REGNO_REG_SET (&spilled_pseudos, i);
}
*************** forget_old_reloads_1 (rtx x, rtx ignored
*** 4059,4065 ****
{
unsigned int i;
! nr = HARD_REGNO_NREGS (regno, GET_MODE (x));
/* Storing into a spilled-reg invalidates its contents.
This can happen if a block-local pseudo is allocated to that reg
and it wasn't spilled because this block's total need is 0.
--- 4059,4065 ----
{
unsigned int i;
! nr = hard_regno_nregs[regno][GET_MODE (x)];
/* Storing into a spilled-reg invalidates its contents.
This can happen if a block-local pseudo is allocated to that reg
and it wasn't spilled because this block's total need is 0.
*************** static void
*** 4133,4139 ****
mark_reload_reg_in_use (unsigned int regno, int opnum, enum reload_type type,
enum machine_mode mode)
{
! unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
unsigned int i;
for (i = regno; i < nregs + regno; i++)
--- 4133,4139 ----
mark_reload_reg_in_use (unsigned int regno, int opnum, enum reload_type type,
enum machine_mode mode)
{
! unsigned int nregs = hard_regno_nregs[regno][mode];
unsigned int i;
for (i = regno; i < nregs + regno; i++)
*************** static void
*** 4195,4201 ****
clear_reload_reg_in_use (unsigned int regno, int opnum,
enum reload_type type, enum machine_mode mode)
{
! unsigned int nregs = HARD_REGNO_NREGS (regno, mode);
unsigned int start_regno, end_regno, r;
int i;
/* A complication is that for some reload types, inheritance might
--- 4195,4201 ----
clear_reload_reg_in_use (unsigned int regno, int opnum,
enum reload_type type, enum machine_mode mode)
{
! unsigned int nregs = hard_regno_nregs[regno][mode];
unsigned int start_regno, end_regno, r;
int i;
/* A complication is that for some reload types, inheritance might
*************** clear_reload_reg_in_use (unsigned int re
*** 4279,4285 ****
unsigned int conflict_start = true_regnum (rld[i].reg_rtx);
unsigned int conflict_end
= (conflict_start
! + HARD_REGNO_NREGS (conflict_start, rld[i].mode));
/* If there is an overlap with the first to-be-freed register,
adjust the interval start. */
--- 4279,4285 ----
unsigned int conflict_start = true_regnum (rld[i].reg_rtx);
unsigned int conflict_end
= (conflict_start
! + hard_regno_nregs[conflict_start][rld[i].mode]);
/* If there is an overlap with the first to-be-freed register,
adjust the interval start. */
*************** reload_reg_free_for_value_p (int start_r
*** 4774,4780 ****
rtx reg = rld[i].reg_rtx;
if (reg && GET_CODE (reg) == REG
&& ((unsigned) regno - true_regnum (reg)
! <= HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg)) - (unsigned) 1)
&& i != reloadnum)
{
rtx other_input = rld[i].in;
--- 4774,4780 ----
rtx reg = rld[i].reg_rtx;
if (reg && GET_CODE (reg) == REG
&& ((unsigned) regno - true_regnum (reg)
! <= hard_regno_nregs[REGNO (reg)][GET_MODE (reg)] - (unsigned) 1)
&& i != reloadnum)
{
rtx other_input = rld[i].in;
*************** free_for_value_p (int regno, enum machin
*** 4930,4936 ****
enum reload_type type, rtx value, rtx out, int reloadnum,
int ignore_address_reloads)
{
! int nregs = HARD_REGNO_NREGS (regno, mode);
while (nregs-- > 0)
if (! reload_reg_free_for_value_p (regno, regno + nregs, opnum, type,
value, out, reloadnum,
--- 4930,4936 ----
enum reload_type type, rtx value, rtx out, int reloadnum,
int ignore_address_reloads)
{
! int nregs = hard_regno_nregs[regno][mode];
while (nregs-- > 0)
if (! reload_reg_free_for_value_p (regno, regno + nregs, opnum, type,
value, out, reloadnum,
*************** allocate_reload_reg (struct insn_chain *
*** 5103,5109 ****
&& ! TEST_HARD_REG_BIT (reload_reg_used_for_inherit,
regnum))))
{
! int nr = HARD_REGNO_NREGS (regnum, rld[r].mode);
/* Avoid the problem where spilling a GENERAL_OR_FP_REG
(on 68000) got us two FP regs. If NR is 1,
we would reject both of them. */
--- 5103,5109 ----
&& ! TEST_HARD_REG_BIT (reload_reg_used_for_inherit,
regnum))))
{
! int nr = hard_regno_nregs[regnum][rld[r].mode];
/* Avoid the problem where spilling a GENERAL_OR_FP_REG
(on 68000) got us two FP regs. If NR is 1,
we would reject both of them. */
*************** choose_reload_regs (struct insn_chain *c
*** 5436,5442 ****
{
/* If a group is needed, verify that all the subsequent
registers still have their values intact. */
! int nr = HARD_REGNO_NREGS (i, rld[r].mode);
int k;
for (k = 1; k < nr; k++)
--- 5436,5442 ----
{
/* If a group is needed, verify that all the subsequent
registers still have their values intact. */
! int nr = hard_regno_nregs[i][rld[r].mode];
int k;
for (k = 1; k < nr; k++)
*************** choose_reload_regs (struct insn_chain *c
*** 5669,5675 ****
&& (regno != HARD_FRAME_POINTER_REGNUM
|| !frame_pointer_needed))
{
! int nr = HARD_REGNO_NREGS (regno, rld[r].mode);
int k;
rld[r].reg_rtx = equiv;
reload_inherited[r] = 1;
--- 5669,5675 ----
&& (regno != HARD_FRAME_POINTER_REGNUM
|| !frame_pointer_needed))
{
! int nr = hard_regno_nregs[regno][rld[r].mode];
int k;
rld[r].reg_rtx = equiv;
reload_inherited[r] = 1;
*************** choose_reload_regs (struct insn_chain *c
*** 5884,5897 ****
int nr = 1;
if (nregno < FIRST_PSEUDO_REGISTER)
! nr = HARD_REGNO_NREGS (nregno, rld[r].mode);
while (--nr >= 0)
reg_has_output_reload[nregno + nr] = 1;
if (i >= 0)
{
! nr = HARD_REGNO_NREGS (i, rld[r].mode);
while (--nr >= 0)
SET_HARD_REG_BIT (reg_is_output_reload, i + nr);
}
--- 5884,5897 ----
int nr = 1;
if (nregno < FIRST_PSEUDO_REGISTER)
! nr = hard_regno_nregs[nregno][rld[r].mode];
while (--nr >= 0)
reg_has_output_reload[nregno + nr] = 1;
if (i >= 0)
{
! nr = hard_regno_nregs[i][rld[r].mode];
while (--nr >= 0)
SET_HARD_REG_BIT (reg_is_output_reload, i + nr);
}
*************** emit_reload_insns (struct insn_chain *ch
*** 7032,7038 ****
if (i >= 0 && rld[r].reg_rtx != 0)
{
! int nr = HARD_REGNO_NREGS (i, GET_MODE (rld[r].reg_rtx));
int k;
int part_reaches_end = 0;
int all_reaches_end = 1;
--- 7032,7038 ----
if (i >= 0 && rld[r].reg_rtx != 0)
{
! int nr = hard_regno_nregs[i][GET_MODE (rld[r].reg_rtx)];
int k;
int part_reaches_end = 0;
int all_reaches_end = 1;
*************** emit_reload_insns (struct insn_chain *ch
*** 7076,7083 ****
/* AUTO_INC */ : XEXP (rld[r].in_reg, 0));
int nregno = REGNO (out);
int nnr = (nregno >= FIRST_PSEUDO_REGISTER ? 1
! : HARD_REGNO_NREGS (nregno,
! GET_MODE (rld[r].reg_rtx)));
spill_reg_store[i] = new_spill_reg_store[i];
spill_reg_stored_to[i] = out;
--- 7076,7083 ----
/* AUTO_INC */ : XEXP (rld[r].in_reg, 0));
int nregno = REGNO (out);
int nnr = (nregno >= FIRST_PSEUDO_REGISTER ? 1
! : hard_regno_nregs[nregno]
! [GET_MODE (rld[r].reg_rtx)]);
spill_reg_store[i] = new_spill_reg_store[i];
spill_reg_stored_to[i] = out;
*************** emit_reload_insns (struct insn_chain *ch
*** 7137,7144 ****
nregno = REGNO (in);
nnr = (nregno >= FIRST_PSEUDO_REGISTER ? 1
! : HARD_REGNO_NREGS (nregno,
! GET_MODE (rld[r].reg_rtx)));
reg_last_reload_reg[nregno] = rld[r].reg_rtx;
--- 7137,7144 ----
nregno = REGNO (in);
nnr = (nregno >= FIRST_PSEUDO_REGISTER ? 1
! : hard_regno_nregs[nregno]
! [GET_MODE (rld[r].reg_rtx)]);
reg_last_reload_reg[nregno] = rld[r].reg_rtx;
*************** emit_reload_insns (struct insn_chain *ch
*** 7238,7244 ****
&& REGNO (src_reg) < FIRST_PSEUDO_REGISTER)
{
int src_regno = REGNO (src_reg);
! int nr = HARD_REGNO_NREGS (src_regno, rld[r].mode);
/* The place where to find a death note varies with
PRESERVE_DEATH_INFO_REGNO_P . The condition is not
necessarily checked exactly in the code that moves
--- 7238,7244 ----
&& REGNO (src_reg) < FIRST_PSEUDO_REGISTER)
{
int src_regno = REGNO (src_reg);
! int nr = hard_regno_nregs[src_regno][rld[r].mode];
/* The place where to find a death note varies with
PRESERVE_DEATH_INFO_REGNO_P . The condition is not
necessarily checked exactly in the code that moves
*************** emit_reload_insns (struct insn_chain *ch
*** 7269,7275 ****
}
else
{
! int num_regs = HARD_REGNO_NREGS (nregno, GET_MODE (rld[r].out));
while (num_regs-- > 0)
reg_last_reload_reg[nregno + num_regs] = 0;
--- 7269,7275 ----
}
else
{
! int num_regs = hard_regno_nregs[nregno][GET_MODE (rld[r].out)];
while (num_regs-- > 0)
reg_last_reload_reg[nregno + num_regs] = 0;
*************** delete_output_reload (rtx insn, int j, i
*** 7594,7600 ****
}
/* We will be deleting the insn. Remove the spill reg information. */
! for (k = HARD_REGNO_NREGS (last_reload_reg, GET_MODE (reg)); k-- > 0; )
{
spill_reg_store[last_reload_reg + k] = 0;
spill_reg_stored_to[last_reload_reg + k] = 0;
--- 7594,7600 ----
}
/* We will be deleting the insn. Remove the spill reg information. */
! for (k = hard_regno_nregs[last_reload_reg][GET_MODE (reg)]; k-- > 0; )
{
spill_reg_store[last_reload_reg + k] = 0;
spill_reg_stored_to[last_reload_reg + k] = 0;
Index: resource.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/resource.c,v
retrieving revision 1.66
diff -c -3 -p -r1.66 resource.c
*** resource.c 16 Dec 2003 00:06:34 -0000 1.66
--- resource.c 1 Feb 2004 23:36:17 -0000
*************** update_live_status (rtx dest, rtx x, voi
*** 104,110 ****
else
first_regno = REGNO (dest);
! last_regno = first_regno + HARD_REGNO_NREGS (first_regno, GET_MODE (dest));
if (GET_CODE (x) == CLOBBER)
for (i = first_regno; i < last_regno; i++)
--- 104,110 ----
else
first_regno = REGNO (dest);
! last_regno = first_regno + hard_regno_nregs[first_regno][GET_MODE (dest)];
if (GET_CODE (x) == CLOBBER)
for (i = first_regno; i < last_regno; i++)
*************** mark_referenced_resources (rtx x, struct
*** 233,239 ****
{
unsigned int regno = subreg_regno (x);
unsigned int last_regno
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
--- 233,239 ----
{
unsigned int regno = subreg_regno (x);
unsigned int last_regno
! = regno + hard_regno_nregs[regno][GET_MODE (x)];
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
*************** mark_referenced_resources (rtx x, struct
*** 246,252 ****
{
unsigned int regno = REGNO (x);
unsigned int last_regno
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
--- 246,252 ----
{
unsigned int regno = REGNO (x);
unsigned int last_regno
! = regno + hard_regno_nregs[regno][GET_MODE (x)];
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
*************** mark_set_resources (rtx x, struct resour
*** 771,777 ****
{
unsigned int regno = subreg_regno (x);
unsigned int last_regno
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
--- 771,777 ----
{
unsigned int regno = subreg_regno (x);
unsigned int last_regno
! = regno + hard_regno_nregs[regno][GET_MODE (x)];
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
*************** mark_set_resources (rtx x, struct resour
*** 786,792 ****
{
unsigned int regno = REGNO (x);
unsigned int last_regno
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
--- 786,792 ----
{
unsigned int regno = REGNO (x);
unsigned int last_regno
! = regno + hard_regno_nregs[regno][GET_MODE (x)];
if (last_regno > FIRST_PSEUDO_REGISTER)
abort ();
*************** mark_target_live_regs (rtx insns, rtx ta
*** 970,977 ****
{
regno = reg_renumber[i];
for (j = regno;
! j < regno + HARD_REGNO_NREGS (regno,
! PSEUDO_REGNO_MODE (i));
j++)
SET_HARD_REG_BIT (current_live_regs, j);
}
--- 970,977 ----
{
regno = reg_renumber[i];
for (j = regno;
! j < regno + hard_regno_nregs[regno]
! [PSEUDO_REGNO_MODE (i)];
j++)
SET_HARD_REG_BIT (current_live_regs, j);
}
*************** mark_target_live_regs (rtx insns, rtx ta
*** 1044,1051 ****
unsigned int first_regno = REGNO (XEXP (link, 0));
unsigned int last_regno
= (first_regno
! + HARD_REGNO_NREGS (first_regno,
! GET_MODE (XEXP (link, 0))));
for (i = first_regno; i < last_regno; i++)
SET_HARD_REG_BIT (pending_dead_regs, i);
--- 1044,1051 ----
unsigned int first_regno = REGNO (XEXP (link, 0));
unsigned int last_regno
= (first_regno
! + hard_regno_nregs[first_regno]
! [GET_MODE (XEXP (link, 0))]);
for (i = first_regno; i < last_regno; i++)
SET_HARD_REG_BIT (pending_dead_regs, i);
*************** mark_target_live_regs (rtx insns, rtx ta
*** 1063,1070 ****
unsigned int first_regno = REGNO (XEXP (link, 0));
unsigned int last_regno
= (first_regno
! + HARD_REGNO_NREGS (first_regno,
! GET_MODE (XEXP (link, 0))));
for (i = first_regno; i < last_regno; i++)
CLEAR_HARD_REG_BIT (current_live_regs, i);
--- 1063,1070 ----
unsigned int first_regno = REGNO (XEXP (link, 0));
unsigned int last_regno
= (first_regno
! + hard_regno_nregs[first_regno]
! [GET_MODE (XEXP (link, 0))]);
for (i = first_regno; i < last_regno; i++)
CLEAR_HARD_REG_BIT (current_live_regs, i);
Index: rtlanal.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtlanal.c,v
retrieving revision 1.173
diff -c -3 -p -r1.173 rtlanal.c
*** rtlanal.c 22 Jan 2004 12:44:54 -0000 1.173
--- rtlanal.c 1 Feb 2004 23:36:17 -0000
*************** Software Foundation, 59 Temple Place - S
*** 33,38 ****
--- 33,39 ----
#include "flags.h"
#include "basic-block.h"
#include "real.h"
+ #include "regs.h"
/* Forward declarations */
static int global_reg_mentioned_p_1 (rtx *, void *);
*************** refers_to_regno_p (unsigned int regno, u
*** 1437,1443 ****
return (endregno > x_regno
&& regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (x_regno, GET_MODE (x))
: 1));
case SUBREG:
--- 1438,1444 ----
return (endregno > x_regno
&& regno < x_regno + (x_regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[x_regno][GET_MODE (x)]
: 1));
case SUBREG:
*************** refers_to_regno_p (unsigned int regno, u
*** 1449,1455 ****
unsigned int inner_regno = subreg_regno (x);
unsigned int inner_endregno
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
return endregno > inner_regno && regno < inner_endregno;
}
--- 1450,1456 ----
unsigned int inner_regno = subreg_regno (x);
unsigned int inner_endregno
= inner_regno + (inner_regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
return endregno > inner_regno && regno < inner_endregno;
}
*************** reg_overlap_mentioned_p (rtx x, rtx in)
*** 1541,1547 ****
regno = REGNO (x);
do_reg:
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
! ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
return refers_to_regno_p (regno, endregno, in, (rtx*) 0);
case MEM:
--- 1542,1548 ----
regno = REGNO (x);
do_reg:
endregno = regno + (regno < FIRST_PSEUDO_REGISTER
! ? hard_regno_nregs[regno][GET_MODE (x)] : 1);
return refers_to_regno_p (regno, endregno, in, (rtx*) 0);
case MEM:
*************** dead_or_set_p (rtx insn, rtx x)
*** 1794,1800 ****
regno = REGNO (x);
last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
! : regno + HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1);
for (i = regno; i <= last_regno; i++)
if (! dead_or_set_regno_p (insn, i))
--- 1795,1801 ----
regno = REGNO (x);
last_regno = (regno >= FIRST_PSEUDO_REGISTER ? regno
! : regno + hard_regno_nregs[regno][GET_MODE (x)] - 1);
for (i = regno; i <= last_regno; i++)
if (! dead_or_set_regno_p (insn, i))
*************** dead_or_set_regno_p (rtx insn, unsigned
*** 1844,1850 ****
regno = REGNO (dest);
endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
! : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
return (test_regno >= regno && test_regno < endregno);
}
--- 1845,1851 ----
regno = REGNO (dest);
endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
! : regno + hard_regno_nregs[regno][GET_MODE (dest)]);
return (test_regno >= regno && test_regno < endregno);
}
*************** dead_or_set_regno_p (rtx insn, unsigned
*** 1875,1881 ****
regno = REGNO (dest);
endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
! : regno + HARD_REGNO_NREGS (regno, GET_MODE (dest)));
if (test_regno >= regno && test_regno < endregno)
return 1;
--- 1876,1882 ----
regno = REGNO (dest);
endregno = (regno >= FIRST_PSEUDO_REGISTER ? regno + 1
! : regno + hard_regno_nregs[regno][GET_MODE (dest)]);
if (test_regno >= regno && test_regno < endregno)
return 1;
*************** find_regno_note (rtx insn, enum reg_note
*** 1927,1934 ****
&& REGNO (XEXP (link, 0)) <= regno
&& ((REGNO (XEXP (link, 0))
+ (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
! : HARD_REGNO_NREGS (REGNO (XEXP (link, 0)),
! GET_MODE (XEXP (link, 0)))))
> regno))
return link;
return 0;
--- 1928,1935 ----
&& REGNO (XEXP (link, 0)) <= regno
&& ((REGNO (XEXP (link, 0))
+ (REGNO (XEXP (link, 0)) >= FIRST_PSEUDO_REGISTER ? 1
! : hard_regno_nregs[REGNO (XEXP (link, 0))]
! [GET_MODE (XEXP (link, 0))]))
> regno))
return link;
return 0;
*************** find_reg_fusage (rtx insn, enum rtx_code
*** 1990,1996 ****
if (regno < FIRST_PSEUDO_REGISTER)
{
unsigned int end_regno
! = regno + HARD_REGNO_NREGS (regno, GET_MODE (datum));
unsigned int i;
for (i = regno; i < end_regno; i++)
--- 1991,1997 ----
if (regno < FIRST_PSEUDO_REGISTER)
{
unsigned int end_regno
! = regno + hard_regno_nregs[regno][GET_MODE (datum)];
unsigned int i;
for (i = regno; i < end_regno; i++)
*************** find_regno_fusage (rtx insn, enum rtx_co
*** 2025,2031 ****
if (GET_CODE (op = XEXP (link, 0)) == code
&& GET_CODE (reg = XEXP (op, 0)) == REG
&& (regnote = REGNO (reg)) <= regno
! && regnote + HARD_REGNO_NREGS (regnote, GET_MODE (reg)) > regno)
return 1;
}
--- 2026,2032 ----
if (GET_CODE (op = XEXP (link, 0)) == code
&& GET_CODE (reg = XEXP (op, 0)) == REG
&& (regnote = REGNO (reg)) <= regno
! && regnote + hard_regno_nregs[regnote][GET_MODE (reg)] > regno)
return 1;
}
*************** subreg_regno_offset (unsigned int xregno
*** 3257,3264 ****
if (xregno >= FIRST_PSEUDO_REGISTER)
abort ();
! nregs_xmode = HARD_REGNO_NREGS (xregno, xmode);
! nregs_ymode = HARD_REGNO_NREGS (xregno, ymode);
/* If this is a big endian paradoxical subreg, which uses more actual
hard registers than the original register, we must return a negative
--- 3258,3265 ----
if (xregno >= FIRST_PSEUDO_REGISTER)
abort ();
! nregs_xmode = hard_regno_nregs[xregno][xmode];
! nregs_ymode = hard_regno_nregs[xregno][ymode];
/* If this is a big endian paradoxical subreg, which uses more actual
hard registers than the original register, we must return a negative
*************** subreg_offset_representable_p (unsigned
*** 3300,3307 ****
if (xregno >= FIRST_PSEUDO_REGISTER)
abort ();
! nregs_xmode = HARD_REGNO_NREGS (xregno, xmode);
! nregs_ymode = HARD_REGNO_NREGS (xregno, ymode);
/* paradoxical subregs are always valid. */
if (offset == 0
--- 3301,3308 ----
if (xregno >= FIRST_PSEUDO_REGISTER)
abort ();
! nregs_xmode = hard_regno_nregs[xregno][xmode];
! nregs_ymode = hard_regno_nregs[xregno][ymode];
/* paradoxical subregs are always valid. */
if (offset == 0
*************** hoist_test_store (rtx x, rtx val, regset
*** 3513,3519 ****
if (REGNO (x) < FIRST_PSEUDO_REGISTER)
{
int regno = REGNO (x);
! int n = HARD_REGNO_NREGS (regno, GET_MODE (x));
if (!live)
return false;
--- 3514,3520 ----
if (REGNO (x) < FIRST_PSEUDO_REGISTER)
{
int regno = REGNO (x);
! int n = hard_regno_nregs[regno][GET_MODE (x)];
if (!live)
return false;
Index: sched-deps.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-deps.c,v
retrieving revision 1.66
diff -c -3 -p -r1.66 sched-deps.c
*** sched-deps.c 21 Jan 2004 20:40:04 -0000 1.66
--- sched-deps.c 1 Feb 2004 23:36:17 -0000
*************** sched_analyze_1 (struct deps *deps, rtx
*** 492,498 ****
If so, mark all of them just like the first. */
if (regno < FIRST_PSEUDO_REGISTER)
{
! int i = HARD_REGNO_NREGS (regno, GET_MODE (dest));
if (code == SET)
{
while (--i >= 0)
--- 492,498 ----
If so, mark all of them just like the first. */
if (regno < FIRST_PSEUDO_REGISTER)
{
! int i = hard_regno_nregs[regno][GET_MODE (dest)];
if (code == SET)
{
while (--i >= 0)
*************** sched_analyze_2 (struct deps *deps, rtx
*** 639,645 ****
int regno = REGNO (x);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int i = HARD_REGNO_NREGS (regno, GET_MODE (x));
while (--i >= 0)
SET_REGNO_REG_SET (reg_pending_uses, regno + i);
}
--- 639,645 ----
int regno = REGNO (x);
if (regno < FIRST_PSEUDO_REGISTER)
{
! int i = hard_regno_nregs[regno][GET_MODE (x)];
while (--i >= 0)
SET_REGNO_REG_SET (reg_pending_uses, regno + i);
}
Index: sched-rgn.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/sched-rgn.c,v
retrieving revision 1.68
diff -c -3 -p -r1.68 sched-rgn.c
*** sched-rgn.c 30 Dec 2003 10:40:56 -0000 1.68
--- sched-rgn.c 1 Feb 2004 23:36:17 -0000
*************** check_live_1 (int src, rtx x)
*** 1323,1329 ****
if (regno < FIRST_PSEUDO_REGISTER)
{
/* Check for hard registers. */
! int j = HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (--j >= 0)
{
for (i = 0; i < candidate_table[src].split_bbs.nr_members; i++)
--- 1323,1329 ----
if (regno < FIRST_PSEUDO_REGISTER)
{
/* Check for hard registers. */
! int j = hard_regno_nregs[regno][GET_MODE (reg)];
while (--j >= 0)
{
for (i = 0; i < candidate_table[src].split_bbs.nr_members; i++)
*************** update_live_1 (int src, rtx x)
*** 1397,1403 ****
{
if (regno < FIRST_PSEUDO_REGISTER)
{
! int j = HARD_REGNO_NREGS (regno, GET_MODE (reg));
while (--j >= 0)
{
for (i = 0; i < candidate_table[src].update_bbs.nr_members; i++)
--- 1397,1403 ----
{
if (regno < FIRST_PSEUDO_REGISTER)
{
! int j = hard_regno_nregs[regno][GET_MODE (reg)];
while (--j >= 0)
{
for (i = 0; i < candidate_table[src].update_bbs.nr_members; i++)
Index: stmt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/stmt.c,v
retrieving revision 1.344
diff -c -3 -p -r1.344 stmt.c
*** stmt.c 19 Jan 2004 03:08:14 -0000 1.344
--- stmt.c 1 Feb 2004 23:36:18 -0000
*************** Software Foundation, 59 Temple Place - S
*** 58,63 ****
--- 58,64 ----
#include "predict.h"
#include "optabs.h"
#include "target.h"
+ #include "regs.h"
/* Functions and data structures for expanding case statements. */
*************** decl_conflicts_with_clobbers_p (tree dec
*** 1413,1419 ****
for (regno = REGNO (reg);
regno < (REGNO (reg)
! + HARD_REGNO_NREGS (REGNO (reg), GET_MODE (reg)));
regno++)
if (TEST_HARD_REG_BIT (clobbered_regs, regno))
{
--- 1414,1420 ----
for (regno = REGNO (reg);
regno < (REGNO (reg)
! + hard_regno_nregs[REGNO (reg)][GET_MODE (reg)]);
regno++)
if (TEST_HARD_REG_BIT (clobbered_regs, regno))
{
Index: varasm.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/varasm.c,v
retrieving revision 1.408
diff -c -3 -p -r1.408 varasm.c
*** varasm.c 31 Jan 2004 23:13:23 -0000 1.408
--- varasm.c 1 Feb 2004 23:36:18 -0000
*************** make_decl_rtl (tree decl, const char *as
*** 795,801 ****
#ifdef ASM_DECLARE_REGISTER_GLOBAL
ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
#endif
! nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
while (nregs > 0)
globalize_reg (reg_number + --nregs);
}
--- 795,801 ----
#ifdef ASM_DECLARE_REGISTER_GLOBAL
ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
#endif
! nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
while (nregs > 0)
globalize_reg (reg_number + --nregs);
}
Index: Makefile.in
===================================================================
RCS file: /cvs/gcc/gcc/gcc/Makefile.in,v
retrieving revision 1.1239
diff -c -3 -p -r1.1239 Makefile.in
*** Makefile.in 31 Jan 2004 00:49:53 -0000 1.1239
--- Makefile.in 2 Feb 2004 00:12:30 -0000
*************** print-rtl.o : print-rtl.c $(CONFIG_H) $(
*** 1545,1551 ****
$(RTL_H) $(TREE_H) hard-reg-set.h $(BASIC_BLOCK_H) real.h $(TM_P_H)
rtlanal.o : rtlanal.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) toplev.h \
$(RTL_H) hard-reg-set.h $(TM_P_H) insn-config.h $(RECOG_H) real.h flags.h \
! $(BASIC_BLOCK_H)
errors.o : errors.c $(CONFIG_H) $(SYSTEM_H) errors.h
$(CC) -c $(ALL_CFLAGS) -DGENERATOR_FILE $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION)
--- 1545,1551 ----
$(RTL_H) $(TREE_H) hard-reg-set.h $(BASIC_BLOCK_H) real.h $(TM_P_H)
rtlanal.o : rtlanal.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) toplev.h \
$(RTL_H) hard-reg-set.h $(TM_P_H) insn-config.h $(RECOG_H) real.h flags.h \
! $(BASIC_BLOCK_H) $(REGS_H)
errors.o : errors.c $(CONFIG_H) $(SYSTEM_H) errors.h
$(CC) -c $(ALL_CFLAGS) -DGENERATOR_FILE $(ALL_CPPFLAGS) $(INCLUDES) $< $(OUTPUT_OPTION)
*************** cfgbuild.o : cfgbuild.c $(CONFIG_H) $(SY
*** 1702,1708 ****
cfgcleanup.o : cfgcleanup.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
$(RTL_H) $(TIMEVAR_H) $(BASIC_BLOCK_H) hard-reg-set.h output.h flags.h \
$(RECOG_H) toplev.h $(GGC_H) insn-config.h cselib.h $(TARGET_H) $(TM_P_H) \
! $(PARAMS_H)
cfgloop.o : cfgloop.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) coretypes.h $(TM_H) \
$(BASIC_BLOCK_H) hard-reg-set.h cfgloop.h flags.h
cfgloopanal.o : cfgloopanal.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) \
--- 1702,1708 ----
cfgcleanup.o : cfgcleanup.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
$(RTL_H) $(TIMEVAR_H) $(BASIC_BLOCK_H) hard-reg-set.h output.h flags.h \
$(RECOG_H) toplev.h $(GGC_H) insn-config.h cselib.h $(TARGET_H) $(TM_P_H) \
! $(PARAMS_H) $(REGS_H)
cfgloop.o : cfgloop.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) coretypes.h $(TM_H) \
$(BASIC_BLOCK_H) hard-reg-set.h cfgloop.h flags.h
cfgloopanal.o : cfgloopanal.c $(CONFIG_H) $(SYSTEM_H) $(RTL_H) \
*************** ra-colorize.o : ra-colorize.c $(CONFIG_H
*** 1748,1754 ****
$(TM_P_H) function.h $(REGS_H) hard-reg-set.h $(BASIC_BLOCK_H) df.h output.h ra.h
ra-debug.o : ra-debug.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
insn-config.h $(RECOG_H) function.h hard-reg-set.h $(BASIC_BLOCK_H) df.h output.h \
! ra.h $(TM_P_H)
ra-rewrite.o : ra-rewrite.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
$(TM_P_H) function.h $(REGS_H) hard-reg-set.h $(BASIC_BLOCK_H) df.h $(EXPR_H) \
output.h except.h ra.h reload.h insn-config.h
--- 1748,1754 ----
$(TM_P_H) function.h $(REGS_H) hard-reg-set.h $(BASIC_BLOCK_H) df.h output.h ra.h
ra-debug.o : ra-debug.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
insn-config.h $(RECOG_H) function.h hard-reg-set.h $(BASIC_BLOCK_H) df.h output.h \
! ra.h $(TM_P_H) $(REGS_H)
ra-rewrite.o : ra-rewrite.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(RTL_H) \
$(TM_P_H) function.h $(REGS_H) hard-reg-set.h $(BASIC_BLOCK_H) df.h $(EXPR_H) \
output.h except.h ra.h reload.h insn-config.h
More information about the Gcc-patches
mailing list