/* Convert RTL to assembler code and output it, for GNU compiler.
- Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
+ 1998, 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "tree.h"
#include "rtl.h"
+#include "tm_p.h"
#include "regs.h"
#include "insn-config.h"
#include "insn-flags.h"
#include "defaults.h"
#include "output.h"
#include "except.h"
+#include "function.h"
#include "toplev.h"
#include "reload.h"
+#include "intl.h"
+#include "basic-block.h"
/* Get N_SLINE and N_SOL from stab.h if we can expect the file to exist. */
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
+#ifndef ACCUMULATE_OUTGOING_ARGS
+#define ACCUMULATE_OUTGOING_ARGS 0
+#endif
+
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h"
#endif
#define JUMP_TABLES_IN_TEXT_SECTION 0
#endif
-/* Nonzero means this function is a leaf function, with no function calls.
- This variable exists to be examined in FUNCTION_PROLOGUE
- and FUNCTION_EPILOGUE. Always zero, unless set by some action. */
-int leaf_function;
-
/* Last insn processed by final_scan_insn. */
static rtx debug_insn = 0;
static int high_function_linenum;
/* Filename of last NOTE. */
-static char *last_filename;
+static const char *last_filename;
/* Number of basic blocks seen so far;
used if profile_block_flag is set. */
static int new_block = 1;
-/* All the symbol-blocks (levels of scoping) in the compilation
- are assigned sequence numbers in order of appearance of the
- beginnings of the symbol-blocks. Both final and dbxout do this,
- and assume that they will both give the same number to each block.
- Final uses these sequence numbers to generate assembler label names
- LBBnnn and LBEnnn for the beginning and end of the symbol-block.
- Dbxout uses the sequence numbers to generate references to the same labels
- from the dbx debugging information.
-
- Sdb records this level at the beginning of each function,
- in order to find the current level when recursing down declarations.
- It outputs the block beginning and endings
- at the point in the asm file where the blocks would begin and end. */
-
-int next_block_index;
-
/* Assign a unique number to each insn that is output.
This can be used to generate unique local labels. */
int profile_label_no;
-/* Length so far allocated in PENDING_BLOCKS. */
-
-static int max_block_depth;
-
-/* Stack of sequence numbers of symbol-blocks of which we have seen the
- beginning but not yet the end. Sequence numbers are assigned at
- the beginning; this stack allows us to find the sequence number
- of a block that is ending. */
-
-static int *pending_blocks;
-
-/* Number of elements currently in use in PENDING_BLOCKS. */
+/* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen. */
static int block_depth;
static char *line_note_exists;
+#ifdef HAVE_conditional_execution
+/* Nonnull if the insn currently being emitted was a COND_EXEC pattern. */
+rtx current_insn_predicate;
+#endif
+
/* Linked list to hold line numbers for each basic block. */
struct bb_list {
struct bb_str {
struct bb_str *next; /* pointer to next string */
- char *string; /* string */
+ const char *string; /* string */
int label_num; /* label number */
int length; /* string length */
};
-extern rtx peephole PROTO((rtx));
-
static struct bb_str *sbb_head = 0; /* Head of string list. */
static struct bb_str **sbb_tail = &sbb_head; /* Ptr to store next bb str */
static int sbb_label_num = 0; /* Last label used */
#ifdef HAVE_ATTR_length
-static int asm_insn_count PROTO((rtx));
-#endif
-static void profile_function PROTO((FILE *));
-static void profile_after_prologue PROTO((FILE *));
-static void add_bb PROTO((FILE *));
-static int add_bb_string PROTO((char *, int));
-static void output_source_line PROTO((FILE *, rtx));
-static rtx walk_alter_subreg PROTO((rtx));
-static void output_asm_name PROTO((void));
-static void output_operand PROTO((rtx, int));
+static int asm_insn_count PARAMS ((rtx));
+#endif
+static void profile_function PARAMS ((FILE *));
+static void profile_after_prologue PARAMS ((FILE *));
+static void add_bb PARAMS ((FILE *));
+static int add_bb_string PARAMS ((const char *, int));
+static void output_source_line PARAMS ((FILE *, rtx));
+static rtx walk_alter_subreg PARAMS ((rtx));
+static void output_asm_name PARAMS ((void));
+static void output_operand PARAMS ((rtx, int));
#ifdef LEAF_REGISTERS
-static void leaf_renumber_regs PROTO((rtx));
+static void leaf_renumber_regs PARAMS ((rtx));
#endif
#ifdef HAVE_cc0
-static int alter_cond PROTO((rtx));
+static int alter_cond PARAMS ((rtx));
+#endif
+#ifndef ADDR_VEC_ALIGN
+static int final_addr_vec_align PARAMS ((rtx));
+#endif
+#ifdef HAVE_ATTR_length
+static int align_fuzz PARAMS ((rtx, rtx, int, unsigned));
#endif
-
-extern char *getpwd ();
\f
/* Initialize data in final at the beginning of a compilation. */
void
init_final (filename)
- char *filename;
+ const char *filename ATTRIBUTE_UNUSED;
{
- next_block_index = 2;
app_on = 0;
- max_block_depth = 20;
- pending_blocks = (int *) xmalloc (20 * sizeof *pending_blocks);
final_sequence = 0;
#ifdef ASSEMBLER_DIALECT
void
end_final (filename)
- char *filename;
+ const char *filename;
{
int i;
assemble_integer (const0_rtx, pointer_bytes, 1);
/* byte count for extended structure. */
- assemble_integer (GEN_INT (10 * UNITS_PER_WORD), long_bytes, 1);
+ assemble_integer (GEN_INT (11 * UNITS_PER_WORD), long_bytes, 1);
/* address of function name table */
if (profile_block_flag)
if (write_symbols != NO_DEBUG && profile_block_flag)
{
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
+ pointer_bytes, 1);
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 6);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
+ pointer_bytes, 1);
}
else
{
static short *insn_lengths;
int *insn_addresses;
+/* Max uid for which the above arrays are valid. */
+static int insn_lengths_max_uid;
+
/* Address of insn being processed. Used by `insn_current_length'. */
int insn_current_address;
{
free (insn_lengths);
insn_lengths = 0;
+ insn_lengths_max_uid = 0;
}
if (insn_addresses)
{
int
get_attr_length (insn)
- rtx insn;
+ rtx insn ATTRIBUTE_UNUSED;
{
#ifdef HAVE_ATTR_length
rtx body;
int i;
int length = 0;
- if (insn_lengths)
+ if (insn_lengths_max_uid > INSN_UID (insn))
return insn_lengths[INSN_UID (insn)];
else
switch (GET_CODE (insn))
address mod X to one mod Y, which is Y - X. */
#ifndef LABEL_ALIGN
-#define LABEL_ALIGN(LABEL) 0
+#define LABEL_ALIGN(LABEL) align_labels_log
#endif
#ifndef LABEL_ALIGN_MAX_SKIP
-#define LABEL_ALIGN_MAX_SKIP 0
+#define LABEL_ALIGN_MAX_SKIP (align_labels-1)
#endif
#ifndef LOOP_ALIGN
-#define LOOP_ALIGN(LABEL) 0
+#define LOOP_ALIGN(LABEL) align_loops_log
#endif
#ifndef LOOP_ALIGN_MAX_SKIP
-#define LOOP_ALIGN_MAX_SKIP 0
+#define LOOP_ALIGN_MAX_SKIP (align_loops-1)
#endif
#ifndef LABEL_ALIGN_AFTER_BARRIER
-#define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0
+#define LABEL_ALIGN_AFTER_BARRIER(LABEL) align_jumps_log
#endif
#ifndef LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP
-#define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP 0
+#define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP (align_jumps-1)
#endif
#ifndef ADDR_VEC_ALIGN
-int
+static int
final_addr_vec_align (addr_vec)
rtx addr_vec;
{
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. */
-int
+static int
align_fuzz (start, end, known_align_log, growth)
rtx start, end;
int known_align_log;
void
shorten_branches (first)
- rtx first;
+ rtx first ATTRIBUTE_UNUSED;
{
rtx insn;
int max_uid;
if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
{
rtx old = insn;
- insn = try_split (PATTERN (old), old, 1);
+ /* Don't split the insn if it has been deleted. */
+ if (! INSN_DELETED_P (old))
+ insn = try_split (PATTERN (old), old, 1);
/* When not optimizing, the old insn will be still left around
with only the 'deleted' bit set. Transform it into a note
to avoid confusion of subsequent processing. */
max_labelno = max_label_num ();
min_labelno = get_first_label_num ();
- label_align = (struct label_alignment *) xmalloc (
- (max_labelno - min_labelno + 1) * sizeof (struct label_alignment));
- bzero ((char *) label_align,
- (max_labelno - min_labelno + 1) * sizeof (struct label_alignment));
+ label_align = (struct label_alignment *)
+ xcalloc ((max_labelno - min_labelno + 1), sizeof (struct label_alignment));
uid_shuid = (int *) xmalloc (max_uid * sizeof *uid_shuid);
&& NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
{
rtx label;
+ int nest = 0;
+ /* Search for the label that starts the loop.
+ Don't skip past the end of the loop, since that could
+ lead to putting an alignment where it does not belong.
+ However, a label after a nested (non-)loop would be OK. */
for (label = insn; label; label = NEXT_INSN (label))
- if (GET_CODE (label) == CODE_LABEL)
- {
- log = LOOP_ALIGN (insn);
- if (max_log < log)
- {
- max_log = log;
- max_skip = LOOP_ALIGN_MAX_SKIP;
- }
+ {
+ if (GET_CODE (label) == NOTE
+ && NOTE_LINE_NUMBER (label) == NOTE_INSN_LOOP_BEG)
+ nest++;
+ else if (GET_CODE (label) == NOTE
+ && NOTE_LINE_NUMBER (label) == NOTE_INSN_LOOP_END
+ && --nest == 0)
break;
- }
+ else if (GET_CODE (label) == CODE_LABEL)
+ {
+ log = LOOP_ALIGN (label);
+ if (max_log < log)
+ {
+ max_log = log;
+ max_skip = LOOP_ALIGN_MAX_SKIP;
+ }
+ break;
+ }
+ }
}
else
continue;
/* Allocate the rest of the arrays. */
insn_lengths = (short *) xmalloc (max_uid * sizeof (short));
- insn_addresses = (int *) xmalloc (max_uid * sizeof (int));
+ insn_lengths_max_uid = max_uid;
/* Syntax errors can lead to labels being outside of the main insn stream.
Initialize insn_addresses, so that we get reproducible results. */
- bzero ((char *)insn_addresses, max_uid * sizeof *insn_addresses);
- uid_align = (rtx *) xmalloc (max_uid * sizeof *uid_align);
-
- varying_length = (char *) xmalloc (max_uid * sizeof (char));
+ insn_addresses = (int *) xcalloc (max_uid, sizeof (int));
- bzero (varying_length, max_uid);
+ varying_length = (char *) xcalloc (max_uid, sizeof (char));
/* Initialize uid_align. We scan instructions
from end to start, and keep in align_tab[n] the last seen insn
that does an alignment of at least n+1, i.e. the successor
in the alignment chain for an insn that does / has a known
alignment of n. */
-
- bzero ((char *) uid_align, max_uid * sizeof *uid_align);
+ uid_align = (rtx *) xcalloc (max_uid, sizeof *uid_align);
for (i = MAX_CODE_ALIGN; --i >= 0; )
align_tab[i] = NULL_RTX;
* GET_MODE_SIZE (GET_MODE (body)));
/* Alignment is handled by ADDR_VEC_ALIGN. */
}
- else if (asm_noperands (body) >= 0)
+ else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
else if (GET_CODE (body) == SEQUENCE)
{
int inner_uid = INSN_UID (inner_insn);
int inner_length;
- if (asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0)
+ if (GET_CODE (body) == ASM_INPUT
+ || asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0)
inner_length = (asm_insn_count (PATTERN (inner_insn))
* insn_default_length (inner_insn));
else
/* If needed, do any adjustment. */
#ifdef ADJUST_INSN_LENGTH
ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
+ if (insn_lengths[uid] < 0)
+ fatal_insn ("Negative insn length", insn);
#endif
}
asm_insn_count (body)
rtx body;
{
- char *template;
+ const char *template;
int count = 1;
if (GET_CODE (body) == ASM_INPUT)
final_start_function (first, file, optimize)
rtx first;
FILE *file;
- int optimize;
+ int optimize ATTRIBUTE_UNUSED;
{
block_depth = 0;
/* Output DWARF definition of the function. */
if (dwarf2out_do_frame ())
dwarf2out_begin_prologue ();
+ else
+ current_function_func_begin_label = 0;
#endif
/* For SDB and XCOFF, the function beginning must be marked between
output_source_line (file, first);
#ifdef LEAF_REG_REMAP
- if (leaf_function)
+ if (current_function_uses_only_leaf_regs)
leaf_renumber_regs (first);
#endif
dwarf2out_frame_debug (NULL_RTX);
#endif
+ /* If debugging, assign block numbers to all of the blocks in this
+ function. */
+ if (write_symbols)
+ {
+ number_blocks (current_function_decl);
+ remove_unnecessary_notes ();
+ /* We never actually put out begin/end notes for the top-level
+ block in the function. But, conceptually, that block is
+ always needed. */
+ TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1;
+ }
+
#ifdef FUNCTION_PROLOGUE
/* First output the function prologue: code to set up the stack frame. */
FUNCTION_PROLOGUE (file, get_frame_size ());
#endif
-#if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
- if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
- next_block_index = 1;
-#endif
-
/* If the machine represents the prologue as RTL, the profiling code must
be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
#ifdef HAVE_prologue
static void
profile_after_prologue (file)
- FILE *file;
+ FILE *file ATTRIBUTE_UNUSED;
{
#ifdef FUNCTION_BLOCK_PROFILER
if (profile_block_flag)
void
final_end_function (first, file, optimize)
- rtx first;
+ rtx first ATTRIBUTE_UNUSED;
FILE *file;
- int optimize;
+ int optimize ATTRIBUTE_UNUSED;
{
- if (app_on)
- {
- fputs (ASM_APP_OFF, file);
- app_on = 0;
- }
+ app_disable ();
#ifdef SDB_DEBUGGING_INFO
if (write_symbols == SDB_DEBUG)
static int
add_bb_string (string, perm_p)
- char *string;
+ const char *string;
int perm_p;
{
int len;
max_line = NOTE_LINE_NUMBER (insn);
}
- line_note_exists = (char *) oballoc (max_line + 1);
- bzero (line_note_exists, max_line + 1);
+ line_note_exists = (char *) xcalloc (max_line + 1, sizeof (char));
for (insn = first; insn; insn = NEXT_INSN (insn))
{
#ifdef HAVE_cc0
/* If CC tracking across branches is enabled, record the insn which
jumps to each branch only reached from one place. */
- if (GET_CODE (insn) == JUMP_INSN)
+ if (optimize && GET_CODE (insn) == JUMP_INSN)
{
rtx lab = JUMP_LABEL (insn);
if (lab && LABEL_NUSES (lab) == 1)
add_bb (file);
free_insn_eh_region ();
+ free (line_note_exists);
+ line_note_exists = NULL;
}
\f
+const char *
+get_insn_template (code, insn)
+ int code;
+ rtx insn;
+{
+ const void *output = insn_data[code].output;
+ switch (insn_data[code].output_format)
+ {
+ case INSN_OUTPUT_FORMAT_SINGLE:
+ return (const char *) output;
+ case INSN_OUTPUT_FORMAT_MULTI:
+ 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);
+
+ default:
+ abort ();
+ }
+}
/* The final scan for one insn, INSN.
Args are same as in `final', except that INSN
is the insn being scanned.
final_scan_insn (insn, file, optimize, prescan, nopeepholes)
rtx insn;
FILE *file;
- int optimize;
+ int optimize ATTRIBUTE_UNUSED;
int prescan;
- int nopeepholes;
+ int nopeepholes ATTRIBUTE_UNUSED;
{
- register int i;
#ifdef HAVE_cc0
rtx set;
#endif
if (prescan > 0)
break;
- /* Align the beginning of a loop, for higher speed
- on certain machines. */
+ switch (NOTE_LINE_NUMBER (insn))
+ {
+ case NOTE_INSN_DELETED:
+ case NOTE_INSN_LOOP_BEG:
+ case NOTE_INSN_LOOP_END:
+ case NOTE_INSN_LOOP_CONT:
+ case NOTE_INSN_LOOP_VTOP:
+ case NOTE_INSN_FUNCTION_END:
+ case NOTE_INSN_SETJMP:
+ case NOTE_INSN_REPEATED_LINE_NUMBER:
+ case NOTE_INSN_RANGE_BEG:
+ case NOTE_INSN_RANGE_END:
+ case NOTE_INSN_LIVE:
+ case NOTE_INSN_EXPECTED_VALUE:
+ break;
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
- break; /* This used to depend on optimize, but that was bogus. */
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
- break;
+ case NOTE_INSN_BASIC_BLOCK:
+ if (flag_debug_asm)
+ fprintf (asm_out_file, "\t%s basic block %d\n",
+ ASM_COMMENT_START, NOTE_BASIC_BLOCK (insn)->index);
+ break;
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
- && ! exceptions_via_longjmp)
- {
- ASM_OUTPUT_INTERNAL_LABEL (file, "LEHB", NOTE_BLOCK_NUMBER (insn));
- if (! flag_new_exceptions)
- add_eh_table_entry (NOTE_BLOCK_NUMBER (insn));
+ case NOTE_INSN_EH_REGION_BEG:
+ if (! exceptions_via_longjmp)
+ {
+ ASM_OUTPUT_INTERNAL_LABEL (file, "LEHB", NOTE_EH_HANDLER (insn));
+ if (! flag_new_exceptions)
+ add_eh_table_entry (NOTE_EH_HANDLER (insn));
#ifdef ASM_OUTPUT_EH_REGION_BEG
- ASM_OUTPUT_EH_REGION_BEG (file, NOTE_BLOCK_NUMBER (insn));
+ ASM_OUTPUT_EH_REGION_BEG (file, NOTE_EH_HANDLER (insn));
#endif
+ }
break;
- }
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END
- && ! exceptions_via_longjmp)
- {
- ASM_OUTPUT_INTERNAL_LABEL (file, "LEHE", NOTE_BLOCK_NUMBER (insn));
- if (flag_new_exceptions)
- add_eh_table_entry (NOTE_BLOCK_NUMBER (insn));
+ case NOTE_INSN_EH_REGION_END:
+ if (! exceptions_via_longjmp)
+ {
+ ASM_OUTPUT_INTERNAL_LABEL (file, "LEHE", NOTE_EH_HANDLER (insn));
+ if (flag_new_exceptions)
+ add_eh_table_entry (NOTE_EH_HANDLER (insn));
#ifdef ASM_OUTPUT_EH_REGION_END
- ASM_OUTPUT_EH_REGION_END (file, NOTE_BLOCK_NUMBER (insn));
+ ASM_OUTPUT_EH_REGION_END (file, NOTE_EH_HANDLER (insn));
#endif
+ }
break;
- }
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
- {
+ case NOTE_INSN_PROLOGUE_END:
#ifdef FUNCTION_END_PROLOGUE
FUNCTION_END_PROLOGUE (file);
#endif
profile_after_prologue (file);
break;
- }
+ case NOTE_INSN_EPILOGUE_BEG:
#ifdef FUNCTION_BEGIN_EPILOGUE
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
- {
FUNCTION_BEGIN_EPILOGUE (file);
- break;
- }
#endif
+ break;
- if (write_symbols == NO_DEBUG)
- break;
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
- {
+ case NOTE_INSN_FUNCTION_BEG:
+ if (write_symbols == NO_DEBUG)
+ break;
#if defined(SDB_DEBUGGING_INFO) && defined(MIPS_DEBUGGING_INFO)
/* MIPS stabs require the parameter descriptions to be after the
function entry point rather than before. */
if (write_symbols == SDB_DEBUG)
- sdbout_begin_function (last_linenum);
+ {
+ app_disable ();
+ sdbout_begin_function (last_linenum);
+ }
else
#endif
#ifdef DWARF_DEBUGGING_INFO
/* This outputs a marker where the function body starts, so it
must be after the prologue. */
if (write_symbols == DWARF_DEBUG)
- dwarfout_begin_function ();
+ {
+ app_disable ();
+ dwarfout_begin_function ();
+ }
#endif
break;
- }
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
- break; /* An insn that was "deleted" */
- if (app_on)
- {
- fputs (ASM_APP_OFF, file);
- app_on = 0;
- }
- if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
- && (debug_info_level == DINFO_LEVEL_NORMAL
+
+ case NOTE_INSN_BLOCK_BEG:
+ if (debug_info_level == DINFO_LEVEL_NORMAL
|| debug_info_level == DINFO_LEVEL_VERBOSE
|| write_symbols == DWARF_DEBUG
- || write_symbols == DWARF2_DEBUG))
- {
- /* Beginning of a symbol-block. Assign it a sequence number
- and push the number onto the stack PENDING_BLOCKS. */
-
- if (block_depth == max_block_depth)
+ || write_symbols == DWARF2_DEBUG)
{
- /* PENDING_BLOCKS is full; make it longer. */
- max_block_depth *= 2;
- pending_blocks
- = (int *) xrealloc (pending_blocks,
- max_block_depth * sizeof (int));
- }
- pending_blocks[block_depth++] = next_block_index;
-
- high_block_linenum = last_linenum;
+ int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
- /* Output debugging info about the symbol-block beginning. */
+ app_disable ();
+ ++block_depth;
+ high_block_linenum = last_linenum;
+ /* Output debugging info about the symbol-block beginning. */
#ifdef SDB_DEBUGGING_INFO
- if (write_symbols == SDB_DEBUG)
- sdbout_begin_block (file, last_linenum, next_block_index);
+ if (write_symbols == SDB_DEBUG)
+ sdbout_begin_block (file, last_linenum, n);
#endif
#ifdef XCOFF_DEBUGGING_INFO
- if (write_symbols == XCOFF_DEBUG)
- xcoffout_begin_block (file, last_linenum, next_block_index);
+ if (write_symbols == XCOFF_DEBUG)
+ xcoffout_begin_block (file, last_linenum, n);
#endif
#ifdef DBX_DEBUGGING_INFO
- if (write_symbols == DBX_DEBUG)
- ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index);
+ if (write_symbols == DBX_DEBUG)
+ ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", n);
#endif
#ifdef DWARF_DEBUGGING_INFO
- if (write_symbols == DWARF_DEBUG)
- dwarfout_begin_block (next_block_index);
+ if (write_symbols == DWARF_DEBUG)
+ dwarfout_begin_block (n);
#endif
#ifdef DWARF2_DEBUGGING_INFO
- if (write_symbols == DWARF2_DEBUG)
- dwarf2out_begin_block (next_block_index);
+ if (write_symbols == DWARF2_DEBUG)
+ dwarf2out_begin_block (n);
#endif
- next_block_index++;
- }
- else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
- && (debug_info_level == DINFO_LEVEL_NORMAL
- || debug_info_level == DINFO_LEVEL_VERBOSE
- || write_symbols == DWARF_DEBUG
- || write_symbols == DWARF2_DEBUG))
- {
- /* End of a symbol-block. Pop its sequence number off
- PENDING_BLOCKS and output debugging info based on that. */
+ /* Mark this block as output. */
+ TREE_ASM_WRITTEN (NOTE_BLOCK (insn)) = 1;
+ }
+ break;
+
+ case NOTE_INSN_BLOCK_END:
+ if (debug_info_level == DINFO_LEVEL_NORMAL
+ || debug_info_level == DINFO_LEVEL_VERBOSE
+ || write_symbols == DWARF_DEBUG
+ || write_symbols == DWARF2_DEBUG)
+ {
+ int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
+
+ app_disable ();
- --block_depth;
+ /* End of a symbol-block. */
+ --block_depth;
+ if (block_depth < 0)
+ abort ();
#ifdef XCOFF_DEBUGGING_INFO
- if (write_symbols == XCOFF_DEBUG && block_depth >= 0)
- xcoffout_end_block (file, high_block_linenum,
- pending_blocks[block_depth]);
+ if (write_symbols == XCOFF_DEBUG)
+ xcoffout_end_block (file, high_block_linenum, n);
#endif
#ifdef DBX_DEBUGGING_INFO
- if (write_symbols == DBX_DEBUG && block_depth >= 0)
- ASM_OUTPUT_INTERNAL_LABEL (file, "LBE",
- pending_blocks[block_depth]);
+ if (write_symbols == DBX_DEBUG)
+ ASM_OUTPUT_INTERNAL_LABEL (file, "LBE", n);
#endif
#ifdef SDB_DEBUGGING_INFO
- if (write_symbols == SDB_DEBUG && block_depth >= 0)
- sdbout_end_block (file, high_block_linenum,
- pending_blocks[block_depth]);
+ if (write_symbols == SDB_DEBUG)
+ sdbout_end_block (file, high_block_linenum, n);
#endif
#ifdef DWARF_DEBUGGING_INFO
- if (write_symbols == DWARF_DEBUG && block_depth >= 0)
- dwarfout_end_block (pending_blocks[block_depth]);
+ if (write_symbols == DWARF_DEBUG)
+ dwarfout_end_block (n);
#endif
#ifdef DWARF2_DEBUGGING_INFO
- if (write_symbols == DWARF2_DEBUG && block_depth >= 0)
- dwarf2out_end_block (pending_blocks[block_depth]);
+ if (write_symbols == DWARF2_DEBUG)
+ dwarf2out_end_block (n);
#endif
- }
- else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL
- && (debug_info_level == DINFO_LEVEL_NORMAL
- || debug_info_level == DINFO_LEVEL_VERBOSE))
- {
+ }
+ break;
+
+ case NOTE_INSN_DELETED_LABEL:
+ /* 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);
+ if (write_symbols == DWARF_DEBUG)
+ dwarfout_label (insn);
#endif
#ifdef DWARF2_DEBUGGING_INFO
- if (write_symbols == DWARF2_DEBUG)
- dwarf2out_label (insn);
+ if (write_symbols == DWARF2_DEBUG)
+ dwarf2out_label (insn);
#endif
- }
- else if (NOTE_LINE_NUMBER (insn) > 0)
- /* This note is a line-number. */
- {
- register rtx note;
+ }
+ break;
-#if 0 /* This is what we used to do. */
- output_source_line (file, insn);
-#endif
- int note_after = 0;
+ default:
+ if (NOTE_LINE_NUMBER (insn) <= 0)
+ abort ();
- /* 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 (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL)
- break;
- /* These types of notes can be significant
- so make sure the preceding line number stays. */
- else if (GET_CODE (note) == NOTE
- && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG
- || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END
- || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG))
- break;
- else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0)
- {
- /* Another line note follows; we can delete this note
- if no intervening line numbers have notes elsewhere. */
- int num;
- for (num = NOTE_LINE_NUMBER (insn) + 1;
- num < NOTE_LINE_NUMBER (note);
- num++)
- if (line_note_exists[num])
- break;
-
- if (num >= NOTE_LINE_NUMBER (note))
- note_after = 1;
+ /* This note is a line-number. */
+ {
+ register rtx note;
+ int note_after = 0;
+
+ /* 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 (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL)
break;
- }
- }
- /* Output this line note
- if it is the first or the last line note in a row. */
- if (!note_after)
- output_source_line (file, insn);
+ /* These types of notes can be significant
+ so make sure the preceding line number stays. */
+ else if (GET_CODE (note) == NOTE
+ && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG
+ || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END
+ || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG))
+ break;
+ else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0)
+ {
+ /* Another line note follows; we can delete this note
+ if no intervening line numbers have notes elsewhere. */
+ int num;
+ for (num = NOTE_LINE_NUMBER (insn) + 1;
+ num < NOTE_LINE_NUMBER (note);
+ num++)
+ if (line_note_exists[num])
+ break;
+
+ if (num >= NOTE_LINE_NUMBER (note))
+ note_after = 1;
+ break;
+ }
+ }
+
+ /* Output this line note if it is the first or the last line
+ note in a row. */
+ if (!note_after)
+ output_source_line (file, insn);
+ }
+ break;
}
break;
case BARRIER:
-#if defined (DWARF2_UNWIND_INFO) && !defined (ACCUMULATE_OUTGOING_ARGS)
- /* If we push arguments, we need to check all insns for stack
- adjustments. */
- if (dwarf2out_do_frame ())
- dwarf2out_frame_debug (insn);
+#if defined (DWARF2_UNWIND_INFO)
+ /* If we push arguments, we need to check all insns for stack
+ adjustments. */
+ if (!ACCUMULATE_OUTGOING_ARGS && dwarf2out_do_frame ())
+ dwarf2out_frame_debug (insn);
#endif
break;
CC_STATUS_INIT;
/* If this label is reached from only one place, set the condition
codes from the instruction just before the branch. */
- if (LABEL_NUSES (insn) == 1)
+
+ /* Disabled because some insns set cc_status in the C output code
+ and NOTICE_UPDATE_CC alone can set incorrect status. */
+ if (0 /* optimize && LABEL_NUSES (insn) == 1*/)
{
rtx jump = LABEL_REFS (insn);
rtx barrier = prev_nonnote_insn (insn);
ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
NEXT_INSN (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;
}
}
-
- 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));
break;
default:
{
register rtx body = PATTERN (insn);
int insn_code_number;
- char *template;
+ const char *template;
#ifdef HAVE_cc0
rtx note;
#endif
if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
{
+#if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
register int vlen, idx;
+#endif
if (prescan > 0)
break;
{
unsigned int noperands = asm_noperands (body);
rtx *ops = (rtx *) alloca (noperands * sizeof (rtx));
- char *string;
+ const char *string;
/* There's no telling what that did to the condition codes. */
CC_STATUS_INIT;
#endif
+#ifdef HAVE_peephole
/* Do machine-specific peephole optimizations if desired. */
if (optimize && !flag_no_peephole && !nopeepholes)
/* PEEPHOLE might have changed this. */
body = PATTERN (insn);
}
+#endif
/* Try to recognize the instruction.
If successful, verify that the operands satisfy the
since `reload' should have changed them so that they do. */
insn_code_number = recog_memoized (insn);
- insn_extract (insn);
- for (i = 0; i < insn_n_operands[insn_code_number]; i++)
- {
- if (GET_CODE (recog_operand[i]) == SUBREG)
- recog_operand[i] = alter_subreg (recog_operand[i]);
- else if (GET_CODE (recog_operand[i]) == PLUS
- || GET_CODE (recog_operand[i]) == MULT)
- recog_operand[i] = walk_alter_subreg (recog_operand[i]);
- }
-
- for (i = 0; i < insn_n_dups[insn_code_number]; i++)
- {
- if (GET_CODE (*recog_dup_loc[i]) == SUBREG)
- *recog_dup_loc[i] = alter_subreg (*recog_dup_loc[i]);
- else if (GET_CODE (*recog_dup_loc[i]) == PLUS
- || GET_CODE (*recog_dup_loc[i]) == MULT)
- *recog_dup_loc[i] = walk_alter_subreg (*recog_dup_loc[i]);
- }
+ extract_insn (insn);
+ cleanup_subreg_operands (insn);
-#ifdef REGISTER_CONSTRAINTS
- if (! constrain_operands (insn_code_number, 1))
+ if (! constrain_operands (1))
fatal_insn_not_found (insn);
-#endif
/* Some target machines need to prescan each insn before
it is output. */
#ifdef FINAL_PRESCAN_INSN
- FINAL_PRESCAN_INSN (insn, recog_operand,
- insn_n_operands[insn_code_number]);
+ FINAL_PRESCAN_INSN (insn, recog_data.operand, recog_data.n_operands);
+#endif
+
+#ifdef HAVE_conditional_execution
+ if (GET_CODE (PATTERN (insn)) == COND_EXEC)
+ current_insn_predicate = COND_EXEC_TEST (PATTERN (insn));
+ else
+ current_insn_predicate = NULL_RTX;
#endif
#ifdef HAVE_cc0
debug_insn = insn;
-#if defined (DWARF2_UNWIND_INFO) && !defined (ACCUMULATE_OUTGOING_ARGS)
+#if defined (DWARF2_UNWIND_INFO)
/* If we push arguments, we want to know where the calls are. */
- if (GET_CODE (insn) == CALL_INSN && dwarf2out_do_frame ())
+ if (!ACCUMULATE_OUTGOING_ARGS && GET_CODE (insn) == CALL_INSN
+ && dwarf2out_do_frame ())
dwarf2out_frame_debug (insn);
#endif
- /* If the proper template needs to be chosen by some C code,
- run that code and get the real template. */
+ /* Find the proper template for this insn. */
+ template = get_insn_template (insn_code_number, insn);
- template = insn_template[insn_code_number];
+ /* If the C code returns 0, it means that it is a jump insn
+ which follows a deleted test insn, and that test insn
+ needs to be reinserted. */
if (template == 0)
{
- template = (*insn_outfun[insn_code_number]) (recog_operand, insn);
-
- /* If the C code returns 0, it means that it is a jump insn
- which follows a deleted test insn, and that test insn
- needs to be reinserted. */
- if (template == 0)
- {
- if (prev_nonnote_insn (insn) != last_ignored_compare)
- abort ();
- new_block = 0;
- return prev_nonnote_insn (insn);
- }
+ if (prev_nonnote_insn (insn) != last_ignored_compare)
+ abort ();
+ new_block = 0;
+ return prev_nonnote_insn (insn);
}
/* If the template is the string "#", it means that this insn must
/* Output assembler code from the template. */
- output_asm_insn (template, recog_operand);
+ output_asm_insn (template, recog_data.operand);
#if defined (DWARF2_UNWIND_INFO)
-#if !defined (ACCUMULATE_OUTGOING_ARGS)
/* If we push arguments, we need to check all insns for stack
adjustments. */
- if (GET_CODE (insn) == INSN && dwarf2out_do_frame ())
- dwarf2out_frame_debug (insn);
-#else
+ if (!ACCUMULATE_OUTGOING_ARGS)
+ {
+ if (GET_CODE (insn) == INSN && dwarf2out_do_frame ())
+ dwarf2out_frame_debug (insn);
+ }
+ else
+ {
#if defined (HAVE_prologue)
- /* If this insn is part of the prologue, emit DWARF v2
- call frame info. */
- if (RTX_FRAME_RELATED_P (insn) && dwarf2out_do_frame ())
- dwarf2out_frame_debug (insn);
-#endif
+ /* If this insn is part of the prologue, emit DWARF v2
+ call frame info. */
+ if (RTX_FRAME_RELATED_P (insn) && dwarf2out_do_frame ())
+ dwarf2out_frame_debug (insn);
#endif
+ }
#endif
#if 0
static void
output_source_line (file, insn)
- FILE *file;
+ FILE *file ATTRIBUTE_UNUSED;
rtx insn;
{
- register char *filename = NOTE_SOURCE_FILE (insn);
+ register const char *filename = NOTE_SOURCE_FILE (insn);
/* Remember filename for basic block profiling.
Filenames are allocated on the permanent obstack
}
}
\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);
+ 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]);
+ 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]);
+ }
+
+ 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]);
+ 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]);
+ }
+}
+
/* If X is a SUBREG, replace it with a REG or a MEM,
based on the thing it is a subreg of. */
if (GET_CODE (y) == REG)
{
+ int regno;
/* If the word size is larger than the size of this register,
adjust the register number to compensate. */
/* ??? Note that this just catches stragglers created by/for
earlier, or kept _all_ subregs until now and eliminate
gen_lowpart and friends. */
- PUT_CODE (x, REG);
#ifdef ALTER_HARD_SUBREG
- REGNO (x) = 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 (x) = REGNO (y) + SUBREG_WORD (x);
+ regno = REGNO (y) + SUBREG_WORD (x);
#endif
+ PUT_CODE (x, REG);
+ REGNO (x) = regno;
+ /* This field has a different meaning for REGs and SUBREGs. Make sure
+ to clear it! */
+ x->used = 0;
}
else if (GET_CODE (y) == MEM)
{
register int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
+
if (BYTES_BIG_ENDIAN)
offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))
- MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y))));
PUT_CODE (x, MEM);
- MEM_VOLATILE_P (x) = MEM_VOLATILE_P (y);
- MEM_IN_STRUCT_P (x) = MEM_IN_STRUCT_P (y);
- MEM_ALIAS_SET (x) = MEM_ALIAS_SET (y);
+ MEM_COPY_ATTRIBUTES (x, y);
XEXP (x, 0) = plus_constant (XEXP (y, 0), offset);
}
In an `asm', it's the user's fault; otherwise, the compiler's fault. */
void
-output_operand_lossage (str)
- char *str;
+output_operand_lossage (msgid)
+ const char *msgid;
{
if (this_is_asm_operands)
- error_for_asm (this_is_asm_operands, "invalid `asm': %s", str);
+ error_for_asm (this_is_asm_operands, "invalid `asm': %s", _(msgid));
else
- fatal ("Internal compiler error, output_operand_lossage `%s'", str);
+ {
+ error ("output_operand: %s", _(msgid));
+ abort ();
+ }
}
\f
/* Output of assembler code from a template, and its subroutines. */
if (debug_insn)
{
register int num = INSN_CODE (debug_insn);
- fprintf (asm_out_file, " %s %d %s",
- ASM_COMMENT_START, INSN_UID (debug_insn), insn_name[num]);
- if (insn_n_alternatives[num] > 1)
+ 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)
fprintf (asm_out_file, "/%d", which_alternative + 1);
-
+#ifdef HAVE_ATTR_length
+ fprintf (asm_out_file, "\t[length = %d]",
+ get_attr_length (debug_insn));
+#endif
/* Clear this so only the first assembler insn
of any rtl insn will get the special comment for -dp. */
debug_insn = 0;
void
output_asm_insn (template, operands)
- char *template;
+ const char *template;
rtx *operands;
{
- register char *p;
+ register const char *p;
register int c;
/* An insn may return a null string template
DIALECT_NUMBER of strings ending with '|'. */
for (i = 0; i < dialect_number; i++)
{
- while (*p && *p++ != '|')
+ while (*p && *p != '}' && *p++ != '|')
;
-
+ if (*p == '}')
+ break;
if (*p == '|')
p++;
}
Letters `acln' are implemented directly.
Other letters are passed to `output_operand' so that
the PRINT_OPERAND macro can define them. */
- else if ((*p >= 'a' && *p <= 'z')
- || (*p >= 'A' && *p <= 'Z'))
+ else if (ISLOWER(*p) || ISUPPER(*p))
{
int letter = *p++;
c = atoi (p);
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 (*p))
+ else if (PRINT_OPERAND_PUNCT_VALID_P ((unsigned char)*p))
output_operand (NULL_RTX, *p++);
#endif
else
char buf[256];
if (GET_CODE (x) == LABEL_REF)
- ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
- else if (GET_CODE (x) == CODE_LABEL)
+ x = XEXP (x, 0);
+ if (GET_CODE (x) == CODE_LABEL
+ || (GET_CODE (x) == NOTE
+ && NOTE_LINE_NUMBER (x) == NOTE_INSN_DELETED_LABEL))
ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
else
output_operand_lossage ("`%l' operand isn't a label");
static void
output_operand (x, code)
rtx x;
- int code;
+ int code ATTRIBUTE_UNUSED;
{
if (x && GET_CODE (x) == SUBREG)
x = alter_subreg (x);
if (GET_CODE (XEXP (x, 1)) == CONST_INT
&& INTVAL (XEXP (x, 1)) < 0)
{
- fprintf (file, ASM_OPEN_PAREN);
+ fprintf (file, "%s", ASM_OPEN_PAREN);
output_addr_const (file, XEXP (x, 1));
- fprintf (file, ASM_CLOSE_PAREN);
+ fprintf (file, "%s", ASM_CLOSE_PAREN);
}
else
output_addr_const (file, XEXP (x, 1));
We handle alternate assembler dialects here, just like output_asm_insn. */
void
-asm_fprintf VPROTO((FILE *file, char *p, ...))
+asm_fprintf VPARAMS ((FILE *file, const char *p, ...))
{
-#ifndef __STDC__
+#ifndef ANSI_PROTOTYPES
FILE *file;
- char *p;
+ const char *p;
#endif
va_list argptr;
char buf[10];
VA_START (argptr, p);
-#ifndef __STDC__
+#ifndef ANSI_PROTOTYPES
file = va_arg (argptr, FILE *);
- p = va_arg (argptr, char *);
+ p = va_arg (argptr, const char *);
#endif
buf[0] = '%';
break;
case 'U':
-#ifdef USER_LABEL_PREFIX
- fprintf (file, "%s", USER_LABEL_PREFIX);
-#endif
+ fputs (user_label_prefix, file);
break;
+#ifdef ASM_FPRINTF_EXTENSIONS
+ /* Upper case letters are reserved for general use by asm_fprintf
+ and so are not available to target specific code. In order to
+ prevent the ASM_FPRINTF_EXTENSIONS macro from using them then,
+ they are defined here. As they get turned into real extensions
+ to asm_fprintf they should be removed from this list. */
+ case 'A': case 'B': case 'C': case 'D': case 'E':
+ case 'F': case 'G': case 'H': case 'J': case 'K':
+ 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:
abort ();
}
default:
fputc (c, file);
}
+ va_end (argptr);
}
\f
/* Split up a CONST_DOUBLE or integer constant rtx
not necessarily BITS_PER_WORD bits. */
REAL_VALUE_TO_TARGET_DOUBLE (r, l);
+ /* If 32 bits is an entire word for the target, but not for the host,
+ then sign-extend on the host so that the number will look the same
+ way on the host that it would on the target. See for instance
+ simplify_unary_operation. The #if is needed to avoid compiler
+ warnings. */
+
+#if HOST_BITS_PER_LONG > 32
+ if (BITS_PER_WORD < HOST_BITS_PER_LONG && BITS_PER_WORD == 32)
+ {
+ if (l[0] & ((long) 1 << 31))
+ l[0] |= ((long) (-1) << 32);
+ if (l[1] & ((long) 1 << 31))
+ l[1] |= ((long) (-1) << 32);
+ }
+#endif
+
*first = GEN_INT ((HOST_WIDE_INT) l[0]);
*second = GEN_INT ((HOST_WIDE_INT) l[1]);
#else
for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
{
- if (GET_CODE (insn) == CALL_INSN)
+ if (GET_CODE (insn) == CALL_INSN
+ && ! SIBLING_CALL_P (insn))
return 0;
if (GET_CODE (insn) == INSN
&& GET_CODE (PATTERN (insn)) == SEQUENCE
- && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN)
+ && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN
+ && ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
return 0;
}
for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
{
- if (GET_CODE (XEXP (insn, 0)) == CALL_INSN)
+ if (GET_CODE (XEXP (insn, 0)) == CALL_INSN
+ && ! SIBLING_CALL_P (insn))
return 0;
if (GET_CODE (XEXP (insn, 0)) == INSN
&& GET_CODE (PATTERN (XEXP (insn, 0))) == SEQUENCE
- && GET_CODE (XVECEXP (PATTERN (XEXP (insn, 0)), 0, 0)) == CALL_INSN)
+ && GET_CODE (XVECEXP (PATTERN (XEXP (insn, 0)), 0, 0)) == CALL_INSN
+ && ! SIBLING_CALL_P (XVECEXP (PATTERN (XEXP (insn, 0)), 0, 0)))
return 0;
}
#ifdef LEAF_REGISTERS
-static char permitted_reg_in_leaf_functions[] = LEAF_REGISTERS;
-
/* Return 1 if this function uses only the registers that can be
safely renumbered. */
only_leaf_regs_used ()
{
int i;
+ char *permitted_reg_in_leaf_functions = LEAF_REGISTERS;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if ((regs_ever_live[i] || global_regs[i])
register rtx in_rtx;
{
register int i, j;
- register char *format_ptr;
+ register const char *format_ptr;
if (in_rtx == 0)
return;
OSDN Git Service
