the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
/* This is the final pass of the compiler.
It looks at the rtl code for a function and outputs assembler code.
/* Linked list to hold line numbers for each basic block. */
-struct bb_list {
+struct bb_list
+{
struct bb_list *next; /* pointer to next basic block */
int line_num; /* line number */
int file_label_num; /* LPBC<n> label # for stored filename */
/* Linked list to hold the strings for each file and function name output. */
-struct bb_str {
+struct bb_str
+{
struct bb_str *next; /* pointer to next string */
const char *string; /* string */
int label_num; /* label number */
void
end_final (filename)
- const char *filename;
+ const char *filename;
{
int i;
else
#endif
#ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
- ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
- BIGGEST_ALIGNMENT);
+ ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name,
+ size, BIGGEST_ALIGNMENT);
#else
#ifdef ASM_OUTPUT_ALIGNED_LOCAL
ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
assemble_integer (const0_rtx, pointer_bytes, 1);
}
- for ( ; i < count_basic_blocks; i++)
+ for (; i < count_basic_blocks; i++)
assemble_integer (const0_rtx, pointer_bytes, 1);
}
for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
assemble_integer (GEN_INT (ptr->line_num), long_bytes, 1);
- for ( ; i < count_basic_blocks; i++)
+ for (; i < count_basic_blocks; i++)
assemble_integer (const0_rtx, long_bytes, 1);
/* Output the table of file names. */
assemble_integer (const0_rtx, pointer_bytes, 1);
}
- for ( ; i < count_basic_blocks; i++)
+ for (; i < count_basic_blocks; i++)
assemble_integer (const0_rtx, pointer_bytes, 1);
}
}
}
\f
-/* Return the number of slots filled in the current
+/* Return the number of slots filled in the current
delayed branch sequence (we don't count the insn needing the
delay slot). Zero if not in a delayed branch sequence. */
for each insn we'll call the alignment chain of this insn in the following
comments. */
-struct label_alignment {
+struct label_alignment
+{
short alignment;
short max_skip;
};
Call a sequence of instructions beginning with alignment point X
and continuing until the next alignment point `block X'. When `X'
- is used in an expression, it means the alignment value of the
+ is used in an expression, it means the alignment value of the
alignment point.
-
+
Call the distance between the start of the first insn of block X, and
the end of the last insn of block X `IX', for the `inner size of X'.
This is clearly the sum of the instruction lengths.
-
+
Likewise with the next alignment-delimited block following X, which we
shall call block Y.
-
+
Call the distance between the start of the first insn of block X, and
the start of the first insn of block Y `OX', for the `outer size of X'.
-
+
The estimated padding is then OX - IX.
-
+
OX can be safely estimated as
-
+
if (X >= Y)
OX = round_up(IX, Y)
else
OX = round_up(IX, X) + Y - X
-
+
Clearly est(IX) >= real(IX), because that only depends on the
instruction lengths, and those being overestimated is a given.
-
+
Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so
we needn't worry about that when thinking about OX.
-
+
When X >= Y, the alignment provided by Y adds no uncertainty factor
for branch ranges starting before X, so we can just round what we have.
But when X < Y, we don't know anything about the, so to speak,
return align;
}
+
#define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC)
#endif
(label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip)
/* For the benefit of port specific code do this also as a function. */
+
int
label_to_alignment (label)
rtx label;
For this purpose, align_fuzz with a growth argument of 0 comuptes the
appropriate adjustment. */
-
/* Compute the maximum delta by which the difference of the addresses of
START and END might grow / shrink due to a different address for start
which changes the size of alignment insns between START and END.
GROWTH should be ~0 if the objective is to compute potential code size
increase, and 0 if the objective is to compute potential shrink.
The return value is undefined for any other value of GROWTH. */
+
static int
align_fuzz (start, end, known_align_log, growth)
rtx start, end;
to account for possible size increase due to alignment.
NB.: Therefore, the maximum offset allowed for backward branches needs
to exclude the branch size. */
+
int
insn_current_reference_address (branch)
rtx branch;
return insn_current_address;
dest = JUMP_LABEL (branch);
- /* BRANCH has no proper alignment chain set, so use SEQ. */
- if (INSN_SHUID (branch) < INSN_SHUID (dest))
+ /* BRANCH has no proper alignment chain set, so use SEQ.
+ BRANCH also has no INSN_SHUID. */
+ if (INSN_SHUID (seq) < INSN_SHUID (dest))
{
- /* Forward branch. */
+ /* Forward branch. */
return (insn_last_address + insn_lengths[seq_uid]
- align_fuzz (seq, dest, length_unit_log, ~0));
}
else
{
- /* Backward branch. */
+ /* Backward branch. */
return (insn_current_address
+ align_fuzz (dest, seq, length_unit_log, ~0));
}
with only the 'deleted' bit set. Transform it into a note
to avoid confusion of subsequent processing. */
if (INSN_DELETED_P (old))
- {
- PUT_CODE (old , NOTE);
- NOTE_LINE_NUMBER (old) = NOTE_INSN_DELETED;
- NOTE_SOURCE_FILE (old) = 0;
- }
+ {
+ PUT_CODE (old, NOTE);
+ NOTE_LINE_NUMBER (old) = NOTE_INSN_DELETED;
+ NOTE_SOURCE_FILE (old) = 0;
+ }
}
#endif
/* We use max_log here to keep track of the maximum alignment we want to
impose on the next CODE_LABEL (or the current one if we are processing
the CODE_LABEL itself). */
-
+
max_log = 0;
max_skip = 0;
alignment of n. */
uid_align = (rtx *) xcalloc (max_uid, sizeof *uid_align);
- for (i = MAX_CODE_ALIGN; --i >= 0; )
+ for (i = MAX_CODE_ALIGN; --i >= 0;)
align_tab[i] = NULL_RTX;
seq = get_last_insn ();
for (; seq; seq = PREV_INSN (seq))
}
#endif /* CASE_VECTOR_SHORTEN_MODE */
-
/* Compute initial lengths, addresses, and varying flags for each insn. */
for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
insn != 0;
int align = 1 << log;
int new_address = (insn_current_address + align - 1) & -align;
insn_lengths[uid] = new_address - insn_current_address;
- insn_current_address = new_address;
}
}
INSN_ADDRESSES (uid) = insn_current_address;
-
+
if (GET_CODE (insn) == NOTE || GET_CODE (insn) == BARRIER
|| GET_CODE (insn) == CODE_LABEL)
continue;
* insn_default_length (inner_insn));
else
inner_length = insn_default_length (inner_insn);
-
+
insn_lengths[inner_uid] = inner_length;
if (const_delay_slots)
{
if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
{
int i;
-
+
body = PATTERN (insn);
new_length = 0;
for (i = 0; i < XVECLEN (body, 0); i++)
template = decode_asm_operands (body, NULL_PTR, NULL_PTR,
NULL_PTR, NULL_PTR);
- for ( ; *template; template++)
- if (IS_ASM_LOGICAL_LINE_SEPARATOR(*template) || *template == '\n')
+ for (; *template; template++)
+ if (IS_ASM_LOGICAL_LINE_SEPARATOR (*template) || *template == '\n')
count++;
return count;
regs_ever_live[i] = 1;
}
#endif
-
+
/* Initial line number is supposed to be output
before the function's prologue and label
so that the function's address will not appear to be
if (write_symbols == XCOFF_DEBUG)
xcoffout_begin_function (file, last_linenum);
else
-#endif
+#endif
/* But only output line number for other debug info types if -g2
or better. */
if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
of the function name. */
if (profile_block_flag)
{
- bb_func_label_num
- = add_bb_string ((*decl_printable_name) (current_function_decl, 2), FALSE);
+ bb_func_label_num =
+ add_bb_string ((*decl_printable_name) (current_function_decl, 2),
+ FALSE);
}
}
add_bb (file)
FILE *file;
{
- struct bb_list *ptr = (struct bb_list *) permalloc (sizeof (struct bb_list));
+ struct bb_list *ptr =
+ (struct bb_list *) permalloc (sizeof (struct bb_list));
/* Add basic block to linked list. */
ptr->next = 0;
if (!perm_p)
{
char *p = (char *) permalloc (len);
- bcopy (string, p, len);
+ memcpy (p, string, len);
string = p;
}
else
return ptr->label_num;
}
-
\f
/* Output assembler code for some insns: all or part of a function.
For description of args, see `final_start_function', above.
for (insn = first; insn; insn = NEXT_INSN (insn))
{
if (INSN_UID (insn) > max_uid) /* find largest UID */
- max_uid = INSN_UID (insn);
+ max_uid = INSN_UID (insn);
if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
- line_note_exists[NOTE_LINE_NUMBER (insn)] = 1;
+ line_note_exists[NOTE_LINE_NUMBER (insn)] = 1;
#ifdef HAVE_cc0
/* If CC tracking across branches is enabled, record the insn which
jumps to each branch only reached from one place. */
#endif
}
- /* Initialize insn_eh_region table if eh is being used. */
-
+ /* Initialize insn_eh_region table if eh is being used. */
+
init_insn_eh_region (first, max_uid);
init_recog ();
case INSN_OUTPUT_FORMAT_SINGLE:
return (const char *) output;
case INSN_OUTPUT_FORMAT_MULTI:
- return ((const char * const *) output)[which_alternative];
+ return ((const char *const *) output)[which_alternative];
case INSN_OUTPUT_FORMAT_FUNCTION:
if (insn == NULL)
abort ();
- return (* (insn_output_fn) output) (recog_data.operand, insn);
+ return (*(insn_output_fn) output) (recog_data.operand, insn);
default:
abort ();
}
}
+
/* The final scan for one insn, INSN.
Args are same as in `final', except that INSN
is the insn being scanned.
/* Emit the label. We may have deleted the CODE_LABEL because
the label could be proved to be unreachable, though still
referenced (in the form of having its address taken. */
- /* ??? Figure out how not to do this unconditionally. This
- interferes with bundling on LIW targets. */
- ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
-
- if (debug_info_level == DINFO_LEVEL_NORMAL
- || debug_info_level == DINFO_LEVEL_VERBOSE)
- {
-#ifdef DWARF_DEBUGGING_INFO
- if (write_symbols == DWARF_DEBUG)
- dwarfout_label (insn);
-#endif
-#ifdef DWARF2_DEBUGGING_INFO
- if (write_symbols == DWARF2_DEBUG)
- dwarf2out_label (insn);
-#endif
- }
+ ASM_OUTPUT_DEBUG_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
break;
case 0:
register rtx note;
int note_after = 0;
- /* If there is anything real after this note, output it.
+ /* If there is anything real after this note, output it.
If another line note follows, omit this one. */
for (note = NEXT_INSN (insn); note; note = NEXT_INSN (note))
{
if (!note_after)
output_source_line (file, insn);
}
- break;
+ break;
}
break;
if (write_symbols == SDB_DEBUG && LABEL_NAME (insn))
sdbout_label (insn);
#endif
-#ifdef DWARF_DEBUGGING_INFO
- if (write_symbols == DWARF_DEBUG && LABEL_NAME (insn))
- dwarfout_label (insn);
-#endif
-#ifdef DWARF2_DEBUGGING_INFO
- if (write_symbols == DWARF2_DEBUG && LABEL_NAME (insn))
- dwarf2out_label (insn);
-#endif
if (app_on)
{
fputs (ASM_APP_OFF, file);
ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
NEXT_INSN (insn));
#else
- if (LABEL_ALTERNATE_NAME (insn))
- ASM_OUTPUT_ALTERNATE_LABEL_NAME (file, insn);
- else
- ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
+ if (LABEL_ALTERNATE_NAME (insn))
+ ASM_OUTPUT_ALTERNATE_LABEL_NAME (file, insn);
+ else
+ ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
#endif
#endif
break;
}
}
if (LABEL_ALTERNATE_NAME (insn))
- ASM_OUTPUT_ALTERNATE_LABEL_NAME (file, insn);
+ ASM_OUTPUT_ALTERNATE_LABEL_NAME (file, insn);
else
- ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
+ ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
break;
default:
#ifdef ASM_OUTPUT_ADDR_VEC
ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body);
#else
- abort();
+ abort ();
#endif
}
else
#ifdef ASM_OUTPUT_ADDR_DIFF_VEC
ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body);
#else
- abort();
+ abort ();
#endif
}
#else
body = PATTERN (insn);
#ifdef HAVE_cc0
- set = single_set(insn);
+ set = single_set (insn);
/* Check for redundant test and compare instructions
(when the condition codes are already set up as desired).
if (optimize)
{
#if 0
- rtx set = single_set(insn);
+ rtx set = single_set (insn);
#endif
if (set
&& set != 0)
{
rtx cond_rtx, then_rtx, else_rtx;
-
+
if (GET_CODE (insn) != JUMP_INSN
&& GET_CODE (SET_SRC (set)) == IF_THEN_ELSE)
{
then_rtx = const_true_rtx;
else_rtx = const0_rtx;
}
-
+
switch (GET_CODE (cond_rtx))
{
case GTU:
since `reload' should have changed them so that they do. */
insn_code_number = recog_memoized (insn);
- extract_insn (insn);
cleanup_subreg_operands (insn);
- if (! constrain_operands (1))
+ /* Dump the insn in the assembly for debugging. */
+ if (flag_dump_rtl_in_asm)
+ {
+ print_rtx_head = ASM_COMMENT_START;
+ print_rtl_single (asm_out_file, insn);
+ print_rtx_head = "";
+ }
+
+ if (! constrain_operands_cached (1))
fatal_insn_not_found (insn);
/* Some target machines need to prescan each insn before
/* If we didn't split the insn, go away. */
if (new == insn && PATTERN (new) == body)
fatal_insn ("Could not split insn", insn);
-
+
#ifdef HAVE_ATTR_length
/* This instruction should have been split in shorten_branches,
to ensure that we would have valid length info for the
new_block = 0;
return new;
}
-
+
if (prescan > 0)
break;
}
}
\f
-
/* For each operand in INSN, simplify (subreg (reg)) so that it refers
directly to the desired hard register. */
+
void
cleanup_subreg_operands (insn)
rtx insn;
{
int i;
-
- extract_insn (insn);
+ extract_insn_cached (insn);
for (i = 0; i < recog_data.n_operands; i++)
{
if (GET_CODE (recog_data.operand[i]) == SUBREG)
- recog_data.operand[i] = alter_subreg (recog_data.operand[i]);
+ recog_data.operand[i] = alter_subreg (recog_data.operand[i]);
else if (GET_CODE (recog_data.operand[i]) == PLUS
- || GET_CODE (recog_data.operand[i]) == MULT)
- recog_data.operand[i] = walk_alter_subreg (recog_data.operand[i]);
+ || GET_CODE (recog_data.operand[i]) == MULT)
+ recog_data.operand[i] = walk_alter_subreg (recog_data.operand[i]);
}
for (i = 0; i < recog_data.n_dups; i++)
{
if (GET_CODE (*recog_data.dup_loc[i]) == SUBREG)
- *recog_data.dup_loc[i] = alter_subreg (*recog_data.dup_loc[i]);
+ *recog_data.dup_loc[i] = alter_subreg (*recog_data.dup_loc[i]);
else if (GET_CODE (*recog_data.dup_loc[i]) == PLUS
- || GET_CODE (*recog_data.dup_loc[i]) == MULT)
- *recog_data.dup_loc[i] = walk_alter_subreg (*recog_data.dup_loc[i]);
+ || GET_CODE (*recog_data.dup_loc[i]) == MULT)
+ *recog_data.dup_loc[i] = walk_alter_subreg (*recog_data.dup_loc[i]);
}
}
gen_lowpart and friends. */
#ifdef ALTER_HARD_SUBREG
- regno = ALTER_HARD_SUBREG(GET_MODE (x), SUBREG_WORD (x),
- GET_MODE (y), REGNO (y));
+ regno = ALTER_HARD_SUBREG (GET_MODE (x), SUBREG_WORD (x),
+ GET_MODE (y), REGNO (y));
#else
regno = REGNO (y) + SUBREG_WORD (x);
#endif
case SUBREG:
return alter_subreg (x);
-
+
default:
break;
}
PUT_CODE (cond, NE);
value = 2;
break;
-
+
default:
break;
}
PUT_CODE (cond, NE);
value = 2;
break;
-
+
default:
break;
}
case LTU:
/* Jump becomes no-op. */
return -1;
-
+
default:
break;
}
if (debug_insn)
{
register int num = INSN_CODE (debug_insn);
- fprintf (asm_out_file, "\t%s %d\t%s",
+ fprintf (asm_out_file, "\t%s %d\t%s",
ASM_COMMENT_START, INSN_UID (debug_insn),
insn_data[num].name);
if (insn_data[num].n_alternatives > 1)
case '{':
{
register int i;
-
+
/* If we want the first dialect, do nothing. Otherwise, skip
DIALECT_NUMBER of strings ending with '|'. */
for (i = 0; i < dialect_number; i++)
Letters `acln' are implemented directly.
Other letters are passed to `output_operand' so that
the PRINT_OPERAND macro can define them. */
- else if (ISLOWER(*p) || ISUPPER(*p))
+ else if (ISLOWER (*p) || ISUPPER (*p))
{
int letter = *p++;
c = atoi (p);
}
else
output_operand (operands[c], letter);
-
- while ((c = *p) >= '0' && c <= '9') p++;
+
+ while ((c = *p) >= '0' && c <= '9')
+ p++;
}
/* % followed by a digit outputs an operand the default way. */
else if (*p >= '0' && *p <= '9')
{
c = atoi (p);
- if (this_is_asm_operands && (c < 0 || (unsigned int) c >= insn_noperands))
+ if (this_is_asm_operands
+ && (c < 0 || (unsigned int) c >= insn_noperands))
output_operand_lossage ("operand number out of range");
else
output_operand (operands[c], 0);
- while ((c = *p) >= '0' && c <= '9') p++;
+ while ((c = *p) >= '0' && c <= '9')
+ p++;
}
/* % followed by punctuation: output something for that
punctuation character alone, with no operand.
The PRINT_OPERAND macro decides what is actually done. */
#ifdef PRINT_OPERAND_PUNCT_VALID_P
- else if (PRINT_OPERAND_PUNCT_VALID_P ((unsigned char)*p))
+ else if (PRINT_OPERAND_PUNCT_VALID_P ((unsigned char) *p))
output_operand (NULL_RTX, *p++);
#endif
else
if (CONST_DOUBLE_HIGH (x))
fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
- else if (CONST_DOUBLE_LOW (x) < 0)
+ else if (CONST_DOUBLE_LOW (x) < 0)
fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
else
fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
if (*p == '|')
p++;
- }
+ }
}
break;
case 'M': case 'N': case 'P': case 'Q': case 'S':
case 'T': case 'V': case 'W': case 'Y': case 'Z':
break;
-
+
ASM_FPRINTF_EXTENSIONS (file, argptr, p)
#endif
default:
/* Set sign_extend as any remaining bits. */
sign_extend = ~mask;
-
+
/* Pick the lower word and sign-extend it. */
low = INTVAL (value);
low &= mask;
else
{
#ifdef REAL_ARITHMETIC
- REAL_VALUE_TYPE r; long l[2];
+ REAL_VALUE_TYPE r;
+ long l[2];
REAL_VALUE_FROM_CONST_DOUBLE (r, value);
/* Note, this converts the REAL_VALUE_TYPE to the target's
&& ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
return 0;
}
- for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
+ for (insn = current_function_epilogue_delay_list;
+ insn;
+ insn = XEXP (insn, 1))
{
if (GET_CODE (XEXP (insn, 0)) == CALL_INSN
&& ! SIBLING_CALL_P (insn))
for (insn = first; insn; insn = NEXT_INSN (insn))
if (INSN_P (insn))
leaf_renumber_regs_insn (PATTERN (insn));
- for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
+ for (insn = current_function_epilogue_delay_list;
+ insn;
+ insn = XEXP (insn, 1))
if (INSN_P (XEXP (insn, 0)))
leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0)));
}
OSDN Git Service
