When to use frame_pointer_rtx and hard_frame_pointer_rtx is a little
tricky: until register elimination has taken place hard_frame_pointer_rtx
- should be used if it is being set, and frame_pointer_rtx otherwise. After
+ should be used if it is being set, and frame_pointer_rtx otherwise. After
register elimination hard_frame_pointer_rtx should always be used.
On machines where the two registers are same (most) then these are the
same.
**
** ...would be generated by the following C code:
**
-** gen_rtx (PLUS, QImode,
+** gen_rtx (PLUS, QImode,
** gen_rtx (MEM, QImode,
** gen_rtx (REG, SImode, 1)),
** gen_rtx (MEM, QImode,
/* Return a value representing some low-order bits of X, where the number
of low-order bits is given by MODE. Note that no conversion is done
- between floating-point and fixed-point values, rather, the bit
+ between floating-point and fixed-point values, rather, the bit
representation is returned.
This function handles the cases in common between gen_lowpart, below,
/* If X is an integral constant but we want it in floating-point, it
must be the case that we have a union of an integer and a floating-point
value. If the machine-parameters allow it, simulate that union here
- and return the result. The two-word and single-word cases are
+ and return the result. The two-word and single-word cases are
different. */
else if (((HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT
}
else
{
- low = CONST_DOUBLE_LOW (x);
+ low = CONST_DOUBLE_LOW (x);
high = CONST_DOUBLE_HIGH (x);
}
abort ();
}
-/* Like `gen_lowpart', but refer to the most significant part.
+/* Like `gen_lowpart', but refer to the most significant part.
This is used to access the imaginary part of a complex number. */
rtx
return GEN_INT (u.i);
}
#endif /* no REAL_ARITHMETIC */
-
+
/* The only remaining cases that we can handle are integers.
Convert to proper endianness now since these cases need it.
- At this point, offset == 0 means the low-order word.
+ At this point, offset == 0 means the low-order word.
We do not want to handle the case when BITS_PER_WORD <= HOST_BITS_PER_INT
in general. However, if OP is (const_int 0), we can just return
int validate_address;
enum machine_mode mode;
{
- rtx new;
if (mode == VOIDmode)
mode = GET_MODE (op);
/* Similar to `operand_subword', but never return 0. If we can't extract
the required subword, put OP into a register and try again. If that fails,
- abort. We always validate the address in this case.
+ abort. We always validate the address in this case.
MODE is the mode of OP, in case it is CONST_INT. */
}
else
addr = memory_address (mode, addr);
-
+
if (rtx_equal_p (addr, XEXP (memref, 0)) && mode == GET_MODE (memref))
return memref;
f->emit = NULL;
}
\f
-/* Go through all the RTL insn bodies and copy any invalid shared
+/* Go through all the RTL insn bodies and copy any invalid shared
structure. This routine should only be called once. */
void
/* Unshare just about everything else. */
unshare_all_rtl_1 (insn);
-
+
/* Make sure the addresses of stack slots found outside the insn chain
(such as, in DECL_RTL of a variable) are not shared
with the insn chain.
stack_slot_list = copy_rtx_if_shared (stack_slot_list);
}
-/* Go through all the RTL insn bodies and copy any invalid shared
+/* Go through all the RTL insn bodies and copy any invalid shared
structure, again. This is a fairly expensive thing to do so it
should be done sparingly. */
case MEM:
/* A MEM is allowed to be shared if its address is constant.
- We used to allow sharing of MEMs which referenced
+ We used to allow sharing of MEMs which referenced
virtual_stack_vars_rtx or virtual_incoming_args_rtx, but
that can lose. instantiate_virtual_regs will not unshare
the MEMs, and combine may change the structure of the address
case BARRIER:
/* The chain of insns is not being copied. */
return;
-
+
default:
break;
}
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
{
if (stream)
- fprintf (stream, "Renumbering insn %d to %d\n",
+ fprintf (stream, "Renumbering insn %d to %d\n",
INSN_UID (insn), cur_insn_uid);
INSN_UID (insn) = cur_insn_uid++;
}
{
int i;
rtx eh_note;
-
- /* Avoid infinite loop if any insn of the result matches
+
+ /* Avoid infinite loop if any insn of the result matches
the original pattern. */
for (i = 0; i < XVECLEN (seq, 0); i++)
- if (GET_CODE (XVECEXP (seq, 0, i)) == INSN
+ if (GET_CODE (XVECEXP (seq, 0, i)) == INSN
&& rtx_equal_p (PATTERN (XVECEXP (seq, 0, i)), pat))
- return trial;
+ return trial;
/* Mark labels. */
for (i = XVECLEN (seq, 0) - 1; i >= 0; i--)
{
rtx insn = XVECEXP (seq, 0, i);
if (GET_CODE (insn) == CALL_INSN
- || (flag_non_call_exceptions
+ || (flag_non_call_exceptions
&& may_trap_p (PATTERN (insn))))
- REG_NOTES (insn)
+ REG_NOTES (insn)
= gen_rtx_EXPR_LIST (REG_EH_REGION, XEXP (eh_note, 0),
REG_NOTES (insn));
}
/* Return either the first or the last insn, depending on which was
requested. */
- return last
- ? (after ? prev_active_insn (after) : last_insn)
+ return last
+ ? (after ? prev_active_insn (after) : last_insn)
: next_active_insn (before);
}
debug_rtx (insn);
}
#endif
-
+
return insn;
}
/* Place a note of KIND on insn INSN with DATUM as the datum. If a
note of this type already exists, remove it first. */
-void
+void
set_unique_reg_note (insn, kind, datum)
rtx insn;
enum reg_note kind;
rtx note = find_reg_note (insn, kind, NULL_RTX);
/* First remove the note if there already is one. */
- if (note)
+ if (note)
remove_note (insn, note);
REG_NOTES (insn) = gen_rtx_EXPR_LIST (kind, datum, REG_NOTES (insn));
/* After emitting to a sequence, restore previous saved state.
To get the contents of the sequence just made, you must call
- `gen_sequence' *before* calling here.
+ `gen_sequence' *before* calling here.
If the compiler might have deferred popping arguments while
generating this sequence, and this sequence will not be immediately
/* If only one insn, return it rather than a SEQUENCE.
(Now that we cache SEQUENCE expressions, it isn't worth special-casing
- the case of an empty list.)
+ the case of an empty list.)
We only return the pattern of an insn if its code is INSN and it
has no notes. This ensures that no information gets lost. */
if (len == 1
&& GET_CODE (XEXP (XEXP (orig, 0), 1)) == CONST_INT)
return orig;
break;
-
+
/* A MEM with a constant address is not sharable. The problem is that
the constant address may need to be reloaded. If the mem is shared,
then reloading one copy of this mem will cause all copies to appear
copy->call = 0;
copy->frame_related = 0;
}
-
+
format_ptr = GET_RTX_FORMAT (GET_CODE (copy));
for (i = 0; i < GET_RTX_LENGTH (GET_CODE (copy)); i++)
= (unsigned char *) xcalloc (f->emit->regno_pointer_align_length,
sizeof (unsigned char));
- regno_reg_rtx
+ regno_reg_rtx
= (rtx *) xcalloc (f->emit->regno_pointer_align_length * sizeof (rtx),
sizeof (rtx));
enum machine_mode double_mode;
/* Initialize the CONST_INT hash table. */
- const_int_htab = htab_create (37, const_int_htab_hash,
+ const_int_htab = htab_create (37, const_int_htab_hash,
const_int_htab_eq, NULL);
- ggc_add_root (&const_int_htab, 1, sizeof (const_int_htab),
+ ggc_add_root (&const_int_htab, 1, sizeof (const_int_htab),
rtx_htab_mark);
no_line_numbers = ! line_numbers;
stack_pointer_rtx = gen_raw_REG (Pmode, STACK_POINTER_REGNUM);
frame_pointer_rtx = gen_raw_REG (Pmode, FRAME_POINTER_REGNUM);
if (hard_frame_pointer_rtx == 0)
- hard_frame_pointer_rtx = gen_raw_REG (Pmode,
+ hard_frame_pointer_rtx = gen_raw_REG (Pmode,
HARD_FRAME_POINTER_REGNUM);
if (arg_pointer_rtx == 0)
arg_pointer_rtx = gen_raw_REG (Pmode, ARG_POINTER_REGNUM);
- virtual_incoming_args_rtx =
+ virtual_incoming_args_rtx =
gen_raw_REG (Pmode, VIRTUAL_INCOMING_ARGS_REGNUM);
- virtual_stack_vars_rtx =
+ virtual_stack_vars_rtx =
gen_raw_REG (Pmode, VIRTUAL_STACK_VARS_REGNUM);
- virtual_stack_dynamic_rtx =
+ virtual_stack_dynamic_rtx =
gen_raw_REG (Pmode, VIRTUAL_STACK_DYNAMIC_REGNUM);
- virtual_outgoing_args_rtx =
- gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
+ virtual_outgoing_args_rtx =
+ gen_raw_REG (Pmode, VIRTUAL_OUTGOING_ARGS_REGNUM);
virtual_cfa_rtx = gen_raw_REG (Pmode, VIRTUAL_CFA_REGNUM);
/* These rtx must be roots if GC is enabled. */
/* Don't use gen_rtx here since gen_rtx in this case
tries to use these variables. */
for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
- const_int_rtx[i + MAX_SAVED_CONST_INT] =
+ const_int_rtx[i + MAX_SAVED_CONST_INT] =
gen_rtx_raw_CONST_INT (VOIDmode, i);
ggc_add_rtx_root (const_int_rtx, 2 * MAX_SAVED_CONST_INT + 1);
OSDN Git Service
