From a8fdc208b866c06f7266adeda8cc9ba63dd4cacc Mon Sep 17 00:00:00 2001 From: Richard Stallman Date: Wed, 29 Jan 1992 04:37:22 +0000 Subject: [PATCH] *** empty log message *** From-SVN: r248 --- gcc/reload1.c | 76 +++++++++++++++++++++++++-------------------------- 1 file changed, 38 insertions(+), 38 deletions(-) diff --git a/gcc/reload1.c b/gcc/reload1.c index b4f6fa3ac75..566b18fbb23 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -366,7 +366,7 @@ init_reload () /* See if reg+reg is a valid (and offsettable) address. */ - tem = gen_rtx (PLUS, Pmode, + tem = gen_rtx (PLUS, Pmode, gen_rtx (REG, Pmode, FRAME_POINTER_REGNUM), gen_rtx (REG, Pmode, FRAME_POINTER_REGNUM)); /* This way, we make sure that reg+reg is an offsettable address. */ @@ -521,7 +521,7 @@ reload (first, global, dumpfile) /* Initialize the save area information for caller-save, in case some are needed. */ init_save_areas (); - + /* Compute which hard registers are now in use as homes for pseudo registers. This is done here rather than (eg) in global_alloc @@ -570,7 +570,7 @@ reload (first, global, dumpfile) rtx note = find_reg_note (insn, REG_EQUIV, 0); if (note #ifdef LEGITIMATE_PIC_OPERAND_P - && (! CONSTANT_P (XEXP (note, 0)) || ! flag_pic + && (! CONSTANT_P (XEXP (note, 0)) || ! flag_pic || LEGITIMATE_PIC_OPERAND_P (XEXP (note, 0))) #endif ) @@ -647,7 +647,7 @@ reload (first, global, dumpfile) #endif /* Count the number of eliminable registers and build the FROM and TO - REG rtx's. Note that code in gen_rtx will cause, e.g., + REG rtx's. Note that code in gen_rtx will cause, e.g., gen_rtx (REG, Pmode, STACK_POINTER_REGNUM) to equal stack_pointer_rtx. We depend on this. */ for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++) @@ -839,7 +839,7 @@ reload (first, global, dumpfile) and constant, it is probably not addressable because the constant is out of range, in that case record the address; we will generate hairy code to compute the address in a register each time it is - needed. + needed. If the location is not addressable, but does not have one of the above forms, assign a stack slot. We have to do this to avoid the @@ -868,7 +868,7 @@ reload (first, global, dumpfile) else { /* Make a new stack slot. Then indicate that something - changed so we go back and recompute offsets for + changed so we go back and recompute offsets for eliminable registers because the allocation of memory below might change some offset. reg_equiv_{mem,address} will be set up for this pseudo on the next pass around @@ -879,7 +879,7 @@ reload (first, global, dumpfile) something_changed = 1; } } - + /* If we allocated another psuedo to the stack, redo elimination bookkeeping. */ if (something_changed) @@ -1024,7 +1024,7 @@ reload (first, global, dumpfile) } /* If this insn has no reloads, we need not do anything except - in the case of a CALL_INSN when we have caller-saves and + in the case of a CALL_INSN when we have caller-saves and caller-save needs reloads. */ if (n_reloads == 0 @@ -1179,7 +1179,7 @@ reload (first, global, dumpfile) needed for this insn. However, the spill register can be used by any reload of this insn, so we only need do something if no need for that class has - been recorded. + been recorded. The assumption that every CALL_INSN will trigger a caller-save is highly conservative, however, the number @@ -1279,7 +1279,7 @@ reload (first, global, dumpfile) supports the sum of two registers for an address; see find_address_reloads for details. */ - caller_save_spill_class + caller_save_spill_class = double_reg_address_ok ? INDEX_REG_CLASS : BASE_REG_CLASS; caller_save_group_size = CLASS_MAX_NREGS (caller_save_spill_class, Pmode); @@ -1331,7 +1331,7 @@ reload (first, global, dumpfile) count_possible_groups (group_size, group_mode, max_groups); /* Now count all spill regs against the individual need, - This includes those counted above for groups, + This includes those counted above for groups, but not those previously counted for nongroups. Those that weren't counted_for_groups can also count against @@ -1373,7 +1373,7 @@ reload (first, global, dumpfile) no longer replace register C with register B and we need to disable such an elimination, if it exists. This occurs often with A == ap, B == sp, and C == fp. */ - + for (ep = reg_eliminate; ep < ®_eliminate[NUM_ELIMINABLE_REGS]; ep++) { struct elim_table *op; @@ -1839,7 +1839,7 @@ count_possible_groups (group_size, group_mode, max_groups) p = reg_class_superclasses[i]; while (*p != LIM_REG_CLASSES) max_groups[(int) *p++]--; - /* Don't count these registers again. */ + /* Don't count these registers again. */ for (k = 0; k < group_size[i]; k++) SET_HARD_REG_BIT (counted_for_groups, j + k); } @@ -2171,7 +2171,7 @@ set_label_offsets (x, insn, initial_p) /* If neither of the above cases is true, compare each offset with those previously recorded and suppress any eliminations where the offsets disagree. */ - + for (i = 0; i < NUM_ELIMINABLE_REGS; i++) if (offsets_at[CODE_LABEL_NUMBER (x)][i] != (initial_p ? reg_eliminate[i].initial_offset @@ -2259,7 +2259,7 @@ set_label_offsets (x, insn, initial_p) static struct rtvec_def *old_asm_operands_vec, *new_asm_operands_vec; -/* Scan X and replace any eliminable registers (such as fp) with a +/* Scan X and replace any eliminable registers (such as fp) with a replacement (such as sp), plus an offset. MEM_MODE is the mode of an enclosing MEM. We need this to know how @@ -2401,7 +2401,7 @@ eliminate_regs (x, mem_mode, insn) if (new0 != XEXP (x, 0) || new1 != XEXP (x, 1)) { /* If one side is a PLUS and the other side is a pseudo that - didn't get a hard register but has a reg_equiv_constant, + didn't get a hard register but has a reg_equiv_constant, we must replace the constant here since it may no longer be in the position of any operand. */ if (GET_CODE (new0) == PLUS && GET_CODE (new1) == REG @@ -2609,7 +2609,7 @@ eliminate_regs (x, mem_mode, insn) if (GET_CODE (SET_DEST (x)) == REG) { /* See if this is setting the replacement register for an - elimination. + elimination. If DEST is the frame pointer, we do nothing because we assume that all assignments to the frame pointer are for non-local gotos and @@ -2819,7 +2819,7 @@ eliminate_regs_in_insn (insn, replace) REG_NOTES (insn) = eliminate_regs (REG_NOTES (insn), 0, 0); val = 1; } - + /* Loop through all elimination pairs. See if any have changed and recalculate the number not at initial offset. @@ -2937,7 +2937,7 @@ spill_hard_reg (regno, global, dumpfile, cant_eliminate) for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++) if (reg_renumber[i] >= 0 && reg_renumber[i] <= regno - && (reg_renumber[i] + && (reg_renumber[i] + HARD_REGNO_NREGS (reg_renumber[i], PSEUDO_REGNO_MODE (i)) > regno)) @@ -2960,7 +2960,7 @@ spill_hard_reg (regno, global, dumpfile, cant_eliminate) *p != LIM_REG_CLASSES; p++) if (basic_block_needs[(int) *p][reg_basic_block[i]] > 0) break; - + if (*p == LIM_REG_CLASSES) continue; } @@ -3278,7 +3278,7 @@ reload_as_needed (first, live_known) int class; /* If this block has not had spilling done for a - particular class, deactivate any optional reloads + particular class, deactivate any optional reloads of that class lest they try to use a spill-reg which isn't available here. If we have any non-optionals that need a spill reg, abort. */ @@ -3448,7 +3448,7 @@ reload_reg_class_lower (p1, p2) { register int r1 = *p1, r2 = *p2; register int t; - + /* Consider required reloads before optional ones. */ t = reload_optional[r1] - reload_optional[r2]; if (t != 0) @@ -3703,7 +3703,7 @@ allocate_reload_reg (r, insn, last_reload, noerror) /* If we put this reload ahead, thinking it is a group, then insist on finding a group. Otherwise we can grab a - reg that some other reload needs. + reg that some other reload needs. (That can happen when we have a 68000 DATA_OR_FP_REG which is a group of data regs or one fp reg.) We need not be so restrictive if there are no more reloads @@ -3948,7 +3948,7 @@ choose_reload_regs (insn, avoid_return_reg) #if 0 /* Not needed, now that we can always retry without inheritance. */ /* See if we have more mandatory reloads than spill regs. If so, then we cannot risk optimizations that could prevent - reloads from sharing one spill register. + reloads from sharing one spill register. Since we will try finding a better register than reload_reg_rtx unless it is equal to reload_in or reload_out, count such reloads. */ @@ -3957,7 +3957,7 @@ choose_reload_regs (insn, avoid_return_reg) int tem = 0; #ifdef SMALL_REGISTER_CLASSES int tem = (avoid_return_reg != 0); -#endif +#endif for (j = 0; j < n_reloads; j++) if (! reload_optional[j] && (reload_in[j] != 0 || reload_out[j] != 0 || reload_secondary_p[j]) @@ -3989,7 +3989,7 @@ choose_reload_regs (insn, avoid_return_reg) /* In order to be certain of getting the registers we need, we must sort the reloads into order of increasing register class. Then our grabbing of reload registers will parallel the process - that provided the reload registers. + that provided the reload registers. Also note whether any of the reloads wants a consecutive group of regs. If so, record the maximum size of the group desired and what @@ -4544,7 +4544,7 @@ emit_reload_insns (insn) /* If OLDEQUIV is a spill register, don't use it for this if any other reload needs it at an earlier stage of this insn - or at this stage. */ + or at this stage. */ if (spill_reg_order[regno] >= 0 && (! reload_reg_free_p (regno, reload_when_needed[j]) || ! reload_reg_free_before_p (regno, @@ -4719,10 +4719,10 @@ emit_reload_insns (insn) new_icode = reload_in_optab[(int) mode]; if (new_icode != CODE_FOR_nothing && ((insn_operand_predicate[(int) new_icode][0] - && ! (insn_operand_predicate[(int) new_icode][0] + && ! ((*insn_operand_predicate[(int) new_icode][0]) (reloadreg, mode))) - || (insn_operand_predicate[(int) new_icode] - && ! (insn_operand_predicate[(int) new_icode][1] + || (insn_operand_predicate[(int) new_icode][1] + && ! ((*insn_operand_predicate[(int) new_icode][1]) (oldequiv, mode))))) new_icode = CODE_FOR_nothing; @@ -4860,7 +4860,7 @@ emit_reload_insns (insn) { register rtx reloadreg = reload_reg_rtx[j]; -#if 0 +#if 0 /* We can't abort here because we need to support this for sched.c. It's not terrible to miss a REG_DEAD note, but we should try to figure out how to do this correctly. */ @@ -4900,7 +4900,7 @@ emit_reload_insns (insn) && GET_CODE (reload_in[j]) == REG && spill_reg_store[reload_spill_index[j]] == 0 && reload_inheritance_insn[j] != 0 - && find_regno_note (reload_inheritance_insn[j], REG_DEAD, + && find_regno_note (reload_inheritance_insn[j], REG_DEAD, REGNO (reload_reg_rtx[j]))) remove_death (REGNO (reload_reg_rtx[j]), reload_inheritance_insn[j]); @@ -5258,7 +5258,7 @@ emit_reload_insns (insn) /* If there are two separate reloads (one in and one out) for the same (hard or pseudo) reg, - leave reg_last_reload_reg set + leave reg_last_reload_reg set based on the output reload. Otherwise, set it from this input reload. */ if (!reg_has_output_reload[nregno] @@ -5312,7 +5312,7 @@ gen_input_reload (reloadreg, in, before_insn) { register rtx prev_insn = PREV_INSN (before_insn); - /* How to do this reload can get quite tricky. Normally, we are being + /* How to do this reload can get quite tricky. Normally, we are being asked to reload a simple operand, such as a MEM, a constant, or a pseudo register that didn't get a hard register. In that case we can just call emit_move_insn. @@ -5356,17 +5356,17 @@ gen_input_reload (reloadreg, in, before_insn) but we need to pass the insn as an operand to `recog' and it is simpler to emit and then delete the insn if not valid than to dummy things up. */ - + rtx move_operand, other_operand, insn; int code; - + /* Since constraint checking is strict, commutativity won't be checked, so we need to do that here to avoid spurious failure if the add instruction is two-address and the second operand of the add is the same as the reload reg, which is frequently the case. If the insn would be A = B + A, rearrange it so it will be A = A + B as constrain_operands expects. */ - + if (GET_CODE (XEXP (in, 1)) == REG && REGNO (reloadreg) == REGNO (XEXP (in, 1))) in = gen_rtx (PLUS, GET_MODE (in), XEXP (in, 1), XEXP (in, 0)); @@ -5526,7 +5526,7 @@ delete_output_reload (insn, j, output_reload_insn) } -/* Output reload-insns to reload VALUE into RELOADREG. +/* Output reload-insns to reload VALUE into RELOADREG. VALUE is a autoincrement or autodecrement RTX whose operand is a register or memory location; so reloading involves incrementing that location. -- 2.30.2