X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ffinal.c;h=066b621e9a823ddf5b636645cfda970705fe2646;hb=e965e3405db23b8c3293cbad110961a42291a53f;hp=be46e06c13803ee60c3e73ebd099794695b7993d;hpb=9f88a3cd43affcbba11d810167b16b77a60e8050;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/final.c b/gcc/final.c index be46e06c138..066b621e9a8 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -1,5 +1,5 @@ /* Convert RTL to assembler code and output it, for GNU compiler. - Copyright (C) 1987, 88, 89, 92-6, 1997 Free Software Foundation, Inc. + Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc. This file is part of GNU CC. @@ -45,13 +45,7 @@ Boston, MA 02111-1307, USA. */ FUNCTION_EPILOGUE. Those instructions never exist as rtl. */ #include "config.h" -#ifdef __STDC__ -#include -#else -#include -#endif -#include -#include +#include "system.h" #include "tree.h" #include "rtl.h" @@ -68,20 +62,36 @@ Boston, MA 02111-1307, USA. */ #include "defaults.h" #include "output.h" #include "except.h" +#include "toplev.h" +#include "reload.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) -#if defined (USG) || defined (NO_STAB_H) +#include "dbxout.h" +#if defined (USG) || !defined (HAVE_STAB_H) #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */ #else -#include /* On BSD, use the system's stab.h. */ -#endif /* not USG */ +#include +#endif + #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */ #ifdef XCOFF_DEBUGGING_INFO #include "xcoffout.h" #endif +#ifdef DWARF_DEBUGGING_INFO +#include "dwarfout.h" +#endif + +#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) +#include "dwarf2out.h" +#endif + +#ifdef SDB_DEBUGGING_INFO +#include "sdbout.h" +#endif + /* .stabd code for line number. */ #ifndef N_SLINE #define N_SLINE 0x44 @@ -116,6 +126,10 @@ Boston, MA 02111-1307, USA. */ #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == ';') #endif +#ifndef JUMP_TABLES_IN_TEXT_SECTION +#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. */ @@ -143,13 +157,15 @@ static int count_basic_blocks; /* Number of instrumented arcs when profile_arc_flag is set. */ extern int count_instrumented_arcs; +extern int length_unit_log; /* This is defined in insn-attrtab.c. */ + /* Nonzero while outputting an `asm' with operands. This means that inconsistencies are the user's fault, so don't abort. The precise value is the insn being output, to pass to error_for_asm. */ static rtx this_is_asm_operands; /* Number of operands of this insn, for an `asm' with operands. */ -static int insn_noperands; +static unsigned int insn_noperands; /* Compare optimization flag. */ @@ -277,17 +293,23 @@ 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 int alter_cond PROTO((rtx)); static void output_asm_name PROTO((void)); static void output_operand PROTO((rtx, int)); +#ifdef LEAF_REGISTERS static void leaf_renumber_regs PROTO((rtx)); +#endif +#ifdef HAVE_cc0 +static int alter_cond PROTO((rtx)); +#endif extern char *getpwd (); @@ -363,11 +385,11 @@ end_final (filename) /* address of filename */ ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 1); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), pointer_bytes, 1); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); /* address of count table */ ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), pointer_bytes, 1); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); /* count of the # of basic blocks or # of instrumented arcs */ if (profile_block_flag) @@ -383,7 +405,7 @@ end_final (filename) if (profile_block_flag) { ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), pointer_bytes, + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); } else @@ -396,7 +418,7 @@ end_final (filename) if (profile_block_flag) { ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), pointer_bytes, + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); } else @@ -406,9 +428,9 @@ end_final (filename) 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 { @@ -455,12 +477,17 @@ end_final (filename) ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded); else #endif +#ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL + 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, BIGGEST_ALIGNMENT); #else ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded); #endif +#endif } /* Output any basic block strings */ @@ -488,7 +515,7 @@ end_final (filename) for (i = 0; i < count_basic_blocks; i++) { ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); } } @@ -503,7 +530,7 @@ end_final (filename) { ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->func_label_num); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); } else @@ -532,7 +559,7 @@ end_final (filename) { ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->file_label_num); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); } else @@ -548,7 +575,7 @@ end_final (filename) if (profile_block_flag) { ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), pointer_bytes, + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); } } @@ -562,7 +589,7 @@ app_enable () { if (! app_on) { - fprintf (asm_out_file, ASM_APP_ON); + fputs (ASM_APP_ON, asm_out_file); app_on = 1; } } @@ -575,7 +602,7 @@ app_disable () { if (app_on) { - fprintf (asm_out_file, ASM_APP_OFF); + fputs (ASM_APP_OFF, asm_out_file); app_on = 0; } } @@ -607,12 +634,60 @@ int *insn_addresses; /* Address of insn being processed. Used by `insn_current_length'. */ int insn_current_address; +/* Address of insn being processed in previous iteration. */ +int insn_last_address; + +/* konwn invariant alignment of insn being processed. */ +int insn_current_align; + +/* After shorten_branches, for any insn, uid_align[INSN_UID (insn)] + gives the next following alignment insn that increases the known + alignment, or NULL_RTX if there is no such insn. + For any alignment obtained this way, we can again index uid_align with + its uid to obtain the next following align that in turn increases the + alignment, till we reach NULL_RTX; the sequence obtained this way + for each insn we'll call the alignment chain of this insn in the following + comments. */ + +struct label_alignment { + short alignment; + short max_skip; +}; + +static rtx *uid_align; +static int *uid_shuid; +static struct label_alignment *label_align; + /* Indicate that branch shortening hasn't yet been done. */ void init_insn_lengths () { - insn_lengths = 0; + if (label_align) + { + free (label_align); + label_align = 0; + } + if (uid_shuid) + { + free (uid_shuid); + uid_shuid = 0; + } + if (insn_lengths) + { + free (insn_lengths); + insn_lengths = 0; + } + if (insn_addresses) + { + free (insn_addresses); + insn_addresses = 0; + } + if (uid_align) + { + free (uid_align); + uid_align = 0; + } } /* Obtain the current length of an insn. If branch shortening has been done, @@ -645,16 +720,8 @@ get_attr_length (insn) body = PATTERN (insn); if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC) { - /* This only takes room if jump tables go into the text section. */ -#if !defined(READONLY_DATA_SECTION) || defined(JUMP_TABLES_IN_TEXT_SECTION) - length = (XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC) - * GET_MODE_SIZE (GET_MODE (body))); - - /* Be pessimistic and assume worst-case alignment. */ - length += (GET_MODE_SIZE (GET_MODE (body)) - 1); -#else - return 0; -#endif + /* Alignment is machine-dependent and should be handled by + ADDR_VEC_ALIGN. */ } else length = insn_default_length (insn); @@ -672,6 +739,10 @@ get_attr_length (insn) length += get_attr_length (XVECEXP (body, 0, i)); else length = insn_default_length (insn); + break; + + default: + break; } #ifdef ADJUST_INSN_LENGTH @@ -683,6 +754,209 @@ get_attr_length (insn) #endif /* not HAVE_ATTR_length */ } +/* Code to handle alignment inside shorten_branches. */ + +/* Here is an explanation how the algorithm in align_fuzz can give + proper results: + + 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 + 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, + `middle bits', so we have to assume the worst when aligning up from an + address mod X to one mod Y, which is Y - X. */ + +#ifndef LABEL_ALIGN +#define LABEL_ALIGN(LABEL) 0 +#endif + +#ifndef LABEL_ALIGN_MAX_SKIP +#define LABEL_ALIGN_MAX_SKIP 0 +#endif + +#ifndef LOOP_ALIGN +#define LOOP_ALIGN(LABEL) 0 +#endif + +#ifndef LOOP_ALIGN_MAX_SKIP +#define LOOP_ALIGN_MAX_SKIP 0 +#endif + +#ifndef LABEL_ALIGN_AFTER_BARRIER +#define LABEL_ALIGN_AFTER_BARRIER(LABEL) 0 +#endif + +#ifndef LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP +#define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP 0 +#endif + +#ifndef ADDR_VEC_ALIGN +int +final_addr_vec_align (addr_vec) + rtx addr_vec; +{ + int align = exact_log2 (GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec)))); + + if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT) + align = BIGGEST_ALIGNMENT / BITS_PER_UNIT; + return align; + +} +#define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC) +#endif + +#ifndef INSN_LENGTH_ALIGNMENT +#define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log +#endif + +#define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)]) + +static int min_labelno, max_labelno; + +#define LABEL_TO_ALIGNMENT(LABEL) \ + (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment) + +#define LABEL_TO_MAX_SKIP(LABEL) \ + (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; +{ + return LABEL_TO_ALIGNMENT (label); +} + +#ifdef HAVE_ATTR_length +/* The differences in addresses + between a branch and its target might grow or shrink depending on + the alignment the start insn of the range (the branch for a forward + branch or the label for a backward branch) starts out on; if these + differences are used naively, they can even oscillate infinitely. + We therefore want to compute a 'worst case' address difference that + is independent of the alignment the start insn of the range end + up on, and that is at least as large as the actual difference. + The function align_fuzz calculates the amount we have to add to the + naively computed difference, by traversing the part of the alignment + chain of the start insn of the range that is in front of the end insn + of the range, and considering for each alignment the maximum amount + that it might contribute to a size increase. + + For casesi tables, we also want to know worst case minimum amounts of + address difference, in case a machine description wants to introduce + some common offset that is added to all offsets in a table. + 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. + KNOWN_ALIGN_LOG is the alignment known for START. + 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 +align_fuzz (start, end, known_align_log, growth) + rtx start, end; + int known_align_log; + unsigned growth; +{ + int uid = INSN_UID (start); + rtx align_label; + int known_align = 1 << known_align_log; + int end_shuid = INSN_SHUID (end); + int fuzz = 0; + + for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid]) + { + int align_addr, new_align; + + uid = INSN_UID (align_label); + align_addr = insn_addresses[uid] - insn_lengths[uid]; + if (uid_shuid[uid] > end_shuid) + break; + known_align_log = LABEL_TO_ALIGNMENT (align_label); + new_align = 1 << known_align_log; + if (new_align < known_align) + continue; + fuzz += (-align_addr ^ growth) & (new_align - known_align); + known_align = new_align; + } + return fuzz; +} + +/* Compute a worst-case reference address of a branch so that it + can be safely used in the presence of aligned labels. Since the + size of the branch itself is unknown, the size of the branch is + not included in the range. I.e. for a forward branch, the reference + address is the end address of the branch as known from the previous + branch shortening pass, minus a value to account for possible size + increase due to alignment. For a backward branch, it is the start + address of the branch as known from the current pass, plus a value + 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; +{ + rtx dest; + rtx seq = NEXT_INSN (PREV_INSN (branch)); + int seq_uid = INSN_UID (seq); + if (GET_CODE (branch) != JUMP_INSN) + /* This can happen for example on the PA; the objective is to know the + offset to address something in front of the start of the function. + Thus, we can treat it like a backward branch. + We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than + any alignment we'd encounter, so we skip the call to align_fuzz. */ + 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)) + { + /* Forward branch. */ + return (insn_last_address + insn_lengths[seq_uid] + - align_fuzz (seq, dest, length_unit_log, ~0)); + } + else + { + /* Backward branch. */ + return (insn_current_address + + align_fuzz (dest, seq, length_unit_log, ~0)); + } +} +#endif /* HAVE_ATTR_length */ + /* Make a pass over all insns and compute their actual lengths by shortening any branches of variable length if possible. */ @@ -692,34 +966,263 @@ get_attr_length (insn) #define FIRST_INSN_ADDRESS 0 #endif +/* shorten_branches might be called multiple times: for example, the SH + port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG. + In order to do this, it needs proper length information, which it obtains + by calling shorten_branches. This cannot be collapsed with + shorten_branches itself into a single pass unless we also want to intergate + reorg.c, since the branch splitting exposes new instructions with delay + slots. */ + void shorten_branches (first) rtx first; { -#ifdef HAVE_ATTR_length rtx insn; + int max_uid; + int i; + int max_log; + int max_skip; +#ifdef HAVE_ATTR_length +#define MAX_CODE_ALIGN 16 + rtx seq; int something_changed = 1; - int max_uid = 0; char *varying_length; rtx body; int uid; + rtx align_tab[MAX_CODE_ALIGN]; /* In order to make sure that all instructions have valid length info, we must split them before we compute the address/length info. */ for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn)) if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') - insn = try_split (PATTERN (insn), insn, 1); + { + rtx old = insn; + 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. */ + if (INSN_DELETED_P (old)) + { + PUT_CODE (old , NOTE); + NOTE_LINE_NUMBER (old) = NOTE_INSN_DELETED; + NOTE_SOURCE_FILE (old) = 0; + } + } +#endif - /* Compute maximum UID and allocate arrays. */ - for (insn = first; insn; insn = NEXT_INSN (insn)) - if (INSN_UID (insn) > max_uid) - max_uid = INSN_UID (insn); + /* We must do some computations even when not actually shortening, in + order to get the alignment information for the labels. */ + + init_insn_lengths (); + + /* Compute maximum UID and allocate label_align / uid_shuid. */ + max_uid = get_max_uid (); + + 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)); + + uid_shuid = (int *) xmalloc (max_uid * sizeof *uid_shuid); + + /* Initialize label_align and set up uid_shuid to be strictly + monotonically rising with insn order. */ + /* 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; + + for (insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn)) + { + int log; + + INSN_SHUID (insn) = i++; + if (GET_RTX_CLASS (GET_CODE (insn)) == 'i') + { + /* reorg might make the first insn of a loop being run once only, + and delete the label in front of it. Then we want to apply + the loop alignment to the new label created by reorg, which + is separated by the former loop start insn from the + NOTE_INSN_LOOP_BEG. */ + } + else if (GET_CODE (insn) == CODE_LABEL) + { + rtx next; + + log = LABEL_ALIGN (insn); + if (max_log < log) + { + max_log = log; + max_skip = LABEL_ALIGN_MAX_SKIP; + } + next = NEXT_INSN (insn); + /* ADDR_VECs only take room if read-only data goes into the text + section. */ + if (JUMP_TABLES_IN_TEXT_SECTION +#if !defined(READONLY_DATA_SECTION) + || 1 +#endif + ) + if (next && GET_CODE (next) == JUMP_INSN) + { + rtx nextbody = PATTERN (next); + if (GET_CODE (nextbody) == ADDR_VEC + || GET_CODE (nextbody) == ADDR_DIFF_VEC) + { + log = ADDR_VEC_ALIGN (next); + if (max_log < log) + { + max_log = log; + max_skip = LABEL_ALIGN_MAX_SKIP; + } + } + } + LABEL_TO_ALIGNMENT (insn) = max_log; + LABEL_TO_MAX_SKIP (insn) = max_skip; + max_log = 0; + max_skip = 0; + } + else if (GET_CODE (insn) == BARRIER) + { + rtx label; + + for (label = insn; label && GET_RTX_CLASS (GET_CODE (label)) != 'i'; + label = NEXT_INSN (label)) + if (GET_CODE (label) == CODE_LABEL) + { + log = LABEL_ALIGN_AFTER_BARRIER (insn); + if (max_log < log) + { + max_log = log; + max_skip = LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP; + } + break; + } + } + /* Again, we allow NOTE_INSN_LOOP_BEG - INSN - CODE_LABEL + sequences in order to handle reorg output efficiently. */ + else if (GET_CODE (insn) == NOTE + && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG) + { + rtx label; + + 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; + } + break; + } + } + else + continue; + } +#ifdef HAVE_ATTR_length + + /* Allocate the rest of the arrays. */ + insn_lengths = (short *) xmalloc (max_uid * sizeof (short)); + insn_addresses = (int *) xmalloc (max_uid * sizeof (int)); + /* 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)); + + bzero (varying_length, max_uid); + + /* 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); + + for (i = MAX_CODE_ALIGN; --i >= 0; ) + align_tab[i] = NULL_RTX; + seq = get_last_insn (); + for (; seq; seq = PREV_INSN (seq)) + { + int uid = INSN_UID (seq); + int log; + log = (GET_CODE (seq) == CODE_LABEL ? LABEL_TO_ALIGNMENT (seq) : 0); + uid_align[uid] = align_tab[0]; + if (log) + { + /* Found an alignment label. */ + uid_align[uid] = align_tab[log]; + for (i = log - 1; i >= 0; i--) + align_tab[i] = seq; + } + } +#ifdef CASE_VECTOR_SHORTEN_MODE + if (optimize) + { + /* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum + label fields. */ + + int min_shuid = INSN_SHUID (get_insns ()) - 1; + int max_shuid = INSN_SHUID (get_last_insn ()) + 1; + int rel; + + for (insn = first; insn != 0; insn = NEXT_INSN (insn)) + { + rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat; + int len, i, min, max, insn_shuid; + int min_align; + addr_diff_vec_flags flags; + + if (GET_CODE (insn) != JUMP_INSN + || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC) + continue; + pat = PATTERN (insn); + len = XVECLEN (pat, 1); + if (len <= 0) + abort (); + min_align = MAX_CODE_ALIGN; + for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--) + { + rtx lab = XEXP (XVECEXP (pat, 1, i), 0); + int shuid = INSN_SHUID (lab); + if (shuid < min) + { + min = shuid; + min_lab = lab; + } + if (shuid > max) + { + max = shuid; + max_lab = lab; + } + if (min_align > LABEL_TO_ALIGNMENT (lab)) + min_align = LABEL_TO_ALIGNMENT (lab); + } + XEXP (pat, 2) = gen_rtx_LABEL_REF (VOIDmode, min_lab); + XEXP (pat, 3) = gen_rtx_LABEL_REF (VOIDmode, max_lab); + insn_shuid = INSN_SHUID (insn); + rel = INSN_SHUID (XEXP (XEXP (pat, 0), 0)); + flags.min_align = min_align; + flags.base_after_vec = rel > insn_shuid; + flags.min_after_vec = min > insn_shuid; + flags.max_after_vec = max > insn_shuid; + flags.min_after_base = min > rel; + flags.max_after_base = max > rel; + ADDR_DIFF_VEC_FLAGS (pat) = flags; + } + } +#endif /* CASE_VECTOR_SHORTEN_MODE */ - max_uid++; - insn_lengths = (short *) oballoc (max_uid * sizeof (short)); - insn_addresses = (int *) oballoc (max_uid * sizeof (int)); - varying_length = (char *) oballoc (max_uid * sizeof (char)); /* Compute initial lengths, addresses, and varying flags for each insn. */ for (insn_current_address = FIRST_INSN_ADDRESS, insn = first; @@ -727,31 +1230,43 @@ shorten_branches (first) insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn)) { uid = INSN_UID (insn); - insn_addresses[uid] = insn_current_address; + insn_lengths[uid] = 0; - varying_length[uid] = 0; + + if (GET_CODE (insn) == CODE_LABEL) + { + int log = LABEL_TO_ALIGNMENT (insn); + if (log) + { + 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; + if (INSN_DELETED_P (insn)) + continue; body = PATTERN (insn); if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC) { /* This only takes room if read-only data goes into the text section. */ -#if !defined(READONLY_DATA_SECTION) || defined(JUMP_TABLES_IN_TEXT_SECTION) - int unitsize = GET_MODE_SIZE (GET_MODE (body)); - - insn_lengths[uid] = (XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC) - * GET_MODE_SIZE (GET_MODE (body))); - - /* Account for possible alignment. */ - insn_lengths[uid] - += unitsize - (insn_current_address & (unitsize - 1)); -#else - ; + if (JUMP_TABLES_IN_TEXT_SECTION +#if !defined(READONLY_DATA_SECTION) + || 1 #endif + ) + insn_lengths[uid] = (XVECLEN (body, + GET_CODE (body) == ADDR_DIFF_VEC) + * GET_MODE_SIZE (GET_MODE (body))); + /* Alignment is handled by ADDR_VEC_ALIGN. */ } else if (asm_noperands (body) >= 0) insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn); @@ -812,16 +1327,154 @@ shorten_branches (first) while (something_changed) { something_changed = 0; + insn_current_align = MAX_CODE_ALIGN - 1; for (insn_current_address = FIRST_INSN_ADDRESS, insn = first; insn != 0; insn = NEXT_INSN (insn)) { int new_length; +#ifdef ADJUST_INSN_LENGTH int tmp_length; +#endif + int length_align; uid = INSN_UID (insn); + + if (GET_CODE (insn) == CODE_LABEL) + { + int log = LABEL_TO_ALIGNMENT (insn); + if (log > insn_current_align) + { + int align = 1 << log; + int new_address= (insn_current_address + align - 1) & -align; + insn_lengths[uid] = new_address - insn_current_address; + insn_current_align = log; + insn_current_address = new_address; + } + else + insn_lengths[uid] = 0; + insn_addresses[uid] = insn_current_address; + continue; + } + + length_align = INSN_LENGTH_ALIGNMENT (insn); + if (length_align < insn_current_align) + insn_current_align = length_align; + + insn_last_address = insn_addresses[uid]; insn_addresses[uid] = insn_current_address; - if (! varying_length[uid]) + +#ifdef CASE_VECTOR_SHORTEN_MODE + if (optimize && GET_CODE (insn) == JUMP_INSN + && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC) + { + rtx body = PATTERN (insn); + int old_length = insn_lengths[uid]; + rtx rel_lab = XEXP (XEXP (body, 0), 0); + rtx min_lab = XEXP (XEXP (body, 2), 0); + rtx max_lab = XEXP (XEXP (body, 3), 0); + addr_diff_vec_flags flags = ADDR_DIFF_VEC_FLAGS (body); + int rel_addr = insn_addresses[INSN_UID (rel_lab)]; + int min_addr = insn_addresses[INSN_UID (min_lab)]; + int max_addr = insn_addresses[INSN_UID (max_lab)]; + rtx prev; + int rel_align = 0; + + /* Try to find a known alignment for rel_lab. */ + for (prev = rel_lab; + prev + && ! insn_lengths[INSN_UID (prev)] + && ! (varying_length[INSN_UID (prev)] & 1); + prev = PREV_INSN (prev)) + if (varying_length[INSN_UID (prev)] & 2) + { + rel_align = LABEL_TO_ALIGNMENT (prev); + break; + } + + /* See the comment on addr_diff_vec_flags in rtl.h for the + meaning of the flags values. base: REL_LAB vec: INSN */ + /* Anything after INSN has still addresses from the last + pass; adjust these so that they reflect our current + estimate for this pass. */ + if (flags.base_after_vec) + rel_addr += insn_current_address - insn_last_address; + if (flags.min_after_vec) + min_addr += insn_current_address - insn_last_address; + if (flags.max_after_vec) + max_addr += insn_current_address - insn_last_address; + /* We want to know the worst case, i.e. lowest possible value + for the offset of MIN_LAB. If MIN_LAB is after REL_LAB, + its offset is positive, and we have to be wary of code shrink; + otherwise, it is negative, and we have to be vary of code + size increase. */ + if (flags.min_after_base) + { + /* If INSN is between REL_LAB and MIN_LAB, the size + changes we are about to make can change the alignment + within the observed offset, therefore we have to break + it up into two parts that are independent. */ + if (! flags.base_after_vec && flags.min_after_vec) + { + min_addr -= align_fuzz (rel_lab, insn, rel_align, 0); + min_addr -= align_fuzz (insn, min_lab, 0, 0); + } + else + min_addr -= align_fuzz (rel_lab, min_lab, rel_align, 0); + } + else + { + if (flags.base_after_vec && ! flags.min_after_vec) + { + min_addr -= align_fuzz (min_lab, insn, 0, ~0); + min_addr -= align_fuzz (insn, rel_lab, 0, ~0); + } + else + min_addr -= align_fuzz (min_lab, rel_lab, 0, ~0); + } + /* Likewise, determine the highest lowest possible value + for the offset of MAX_LAB. */ + if (flags.max_after_base) + { + if (! flags.base_after_vec && flags.max_after_vec) + { + max_addr += align_fuzz (rel_lab, insn, rel_align, ~0); + max_addr += align_fuzz (insn, max_lab, 0, ~0); + } + else + max_addr += align_fuzz (rel_lab, max_lab, rel_align, ~0); + } + else + { + if (flags.base_after_vec && ! flags.max_after_vec) + { + max_addr += align_fuzz (max_lab, insn, 0, 0); + max_addr += align_fuzz (insn, rel_lab, 0, 0); + } + else + max_addr += align_fuzz (max_lab, rel_lab, 0, 0); + } + PUT_MODE (body, CASE_VECTOR_SHORTEN_MODE (min_addr - rel_addr, + max_addr - rel_addr, + body)); + if (JUMP_TABLES_IN_TEXT_SECTION +#if !defined(READONLY_DATA_SECTION) + || 1 +#endif + ) + { + insn_lengths[uid] + = (XVECLEN (body, 1) * GET_MODE_SIZE (GET_MODE (body))); + insn_current_address += insn_lengths[uid]; + if (insn_lengths[uid] != old_length) + something_changed = 1; + } + + continue; + } +#endif /* CASE_VECTOR_SHORTEN_MODE */ + + if (! (varying_length[uid])) { insn_current_address += insn_lengths[uid]; continue; @@ -862,14 +1515,12 @@ shorten_branches (first) insn_current_address += new_length; } -#ifdef SHORTEN_WITH_ADJUST_INSN_LENGTH #ifdef ADJUST_INSN_LENGTH /* If needed, do any adjustment. */ tmp_length = new_length; ADJUST_INSN_LENGTH (insn, new_length); insn_current_address += (new_length - tmp_length); #endif -#endif if (new_length != insn_lengths[uid]) { @@ -881,6 +1532,9 @@ shorten_branches (first) if (!optimize) break; } + + free (varying_length); + #endif /* HAVE_ATTR_length */ } @@ -938,7 +1592,7 @@ final_start_function (first, file, optimize) int i; for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - if (!call_used_regs[i] && !call_fixed_regs[i]) + if (!call_used_regs[i]) regs_ever_live[i] = 1; } #endif @@ -951,9 +1605,9 @@ final_start_function (first, file, optimize) last_linenum = high_block_linenum = high_function_linenum = NOTE_LINE_NUMBER (first); -#ifdef DWARF2_DEBUGGING_INFO +#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) /* Output DWARF definition of the function. */ - if (write_symbols == DWARF2_DEBUG) + if (dwarf2out_do_frame ()) dwarf2out_begin_prologue (); #endif @@ -988,6 +1642,11 @@ final_start_function (first, file, optimize) profile_function (file); #endif /* PROFILE_BEFORE_PROLOGUE */ +#if defined (DWARF2_UNWIND_INFO) && defined (HAVE_prologue) + if (dwarf2out_do_frame ()) + dwarf2out_frame_debug (NULL_RTX); +#endif + #ifdef FUNCTION_PROLOGUE /* First output the function prologue: code to set up the stack frame. */ FUNCTION_PROLOGUE (file, get_frame_size ()); @@ -1038,8 +1697,14 @@ profile_function (file) FILE *file; { int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE); +#if defined(ASM_OUTPUT_REG_PUSH) +#if defined(STRUCT_VALUE_INCOMING_REGNUM) || defined(STRUCT_VALUE_REGNUM) int sval = current_function_returns_struct; +#endif +#if defined(STATIC_CHAIN_INCOMING_REGNUM) || defined(STATIC_CHAIN_REGNUM) int cxt = current_function_needs_context; +#endif +#endif /* ASM_OUTPUT_REG_PUSH */ data_section (); ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT)); @@ -1054,7 +1719,9 @@ profile_function (file) #else #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (sval) - ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM); + { + ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM); + } #endif #endif @@ -1064,7 +1731,9 @@ profile_function (file) #else #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (cxt) - ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM); + { + ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM); + } #endif #endif @@ -1076,7 +1745,9 @@ profile_function (file) #else #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (cxt) - ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM); + { + ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM); + } #endif #endif @@ -1086,7 +1757,9 @@ profile_function (file) #else #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (sval) - ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM); + { + ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM); + } #endif #endif } @@ -1103,7 +1776,7 @@ final_end_function (first, file, optimize) { if (app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } @@ -1138,8 +1811,8 @@ final_end_function (first, file, optimize) dwarfout_end_epilogue (); #endif -#ifdef DWARF2_DEBUGGING_INFO - if (write_symbols == DWARF2_DEBUG) +#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) + if (dwarf2out_do_frame ()) dwarf2out_end_epilogue (); #endif @@ -1257,14 +1930,11 @@ final (first, file, optimize, prescan) { register rtx insn; int max_line = 0; + int max_uid = 0; last_ignored_compare = 0; new_block = 1; -#if defined (DWARF2_DEBUGGING_INFO) && defined (HAVE_prologue) - dwarf2out_frame_debug (NULL_RTX); -#endif - check_exception_handler_labels (); /* Make a map indicating which line numbers appear in this function. @@ -1305,8 +1975,28 @@ final (first, file, optimize, prescan) bzero (line_note_exists, max_line + 1); for (insn = first; insn; insn = NEXT_INSN (insn)) - if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) - line_note_exists[NOTE_LINE_NUMBER (insn)] = 1; + { + if (INSN_UID (insn) > max_uid) /* find largest UID */ + max_uid = INSN_UID (insn); + if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0) + 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. */ + if (optimize && GET_CODE (insn) == JUMP_INSN) + { + rtx lab = JUMP_LABEL (insn); + if (lab && LABEL_NUSES (lab) == 1) + { + LABEL_REFS (lab) = insn; + } + } +#endif + } + + /* Initialize insn_eh_region table if eh is being used. */ + + init_insn_eh_region (first, max_uid); init_recog (); @@ -1325,6 +2015,8 @@ final (first, file, optimize, prescan) if the last insn was a conditional branch. */ if (profile_block_flag && new_block) add_bb (file); + + free_insn_eh_region (); } /* The final scan for one insn, INSN. @@ -1344,6 +2036,10 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) int nopeepholes; { register int i; +#ifdef HAVE_cc0 + rtx set; +#endif + insn_counter++; /* Ignore deleted insns. These can occur when we split insns (due to a @@ -1360,33 +2056,29 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) /* Align the beginning of a loop, for higher speed on certain machines. */ - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG && optimize > 0) - { -#ifdef ASM_OUTPUT_LOOP_ALIGN - rtx next = next_nonnote_insn (insn); - if (next && GET_CODE (next) == CODE_LABEL) - { - ASM_OUTPUT_LOOP_ALIGN (asm_out_file); - } -#endif - 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; - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG) + if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG + && ! exceptions_via_longjmp) { ASM_OUTPUT_INTERNAL_LABEL (file, "LEHB", NOTE_BLOCK_NUMBER (insn)); - add_eh_table_entry (NOTE_BLOCK_NUMBER (insn)); + if (! flag_new_exceptions) + add_eh_table_entry (NOTE_BLOCK_NUMBER (insn)); #ifdef ASM_OUTPUT_EH_REGION_BEG ASM_OUTPUT_EH_REGION_BEG (file, NOTE_BLOCK_NUMBER (insn)); #endif break; } - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END) + 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)); #ifdef ASM_OUTPUT_EH_REGION_END ASM_OUTPUT_EH_REGION_END (file, NOTE_BLOCK_NUMBER (insn)); #endif @@ -1433,7 +2125,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) break; /* An insn that was "deleted" */ if (app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG @@ -1492,28 +2184,30 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) PENDING_BLOCKS and output debugging info based on that. */ --block_depth; + if (block_depth < 0) + abort (); #ifdef XCOFF_DEBUGGING_INFO - if (write_symbols == XCOFF_DEBUG && block_depth >= 0) + if (write_symbols == XCOFF_DEBUG) xcoffout_end_block (file, high_block_linenum, pending_blocks[block_depth]); #endif #ifdef DBX_DEBUGGING_INFO - if (write_symbols == DBX_DEBUG && block_depth >= 0) + if (write_symbols == DBX_DEBUG) ASM_OUTPUT_INTERNAL_LABEL (file, "LBE", pending_blocks[block_depth]); #endif #ifdef SDB_DEBUGGING_INFO - if (write_symbols == SDB_DEBUG && block_depth >= 0) + if (write_symbols == SDB_DEBUG) sdbout_end_block (file, high_block_linenum, pending_blocks[block_depth]); #endif #ifdef DWARF_DEBUGGING_INFO - if (write_symbols == DWARF_DEBUG && block_depth >= 0) + if (write_symbols == DWARF_DEBUG) dwarfout_end_block (pending_blocks[block_depth]); #endif #ifdef DWARF2_DEBUGGING_INFO - if (write_symbols == DWARF2_DEBUG && block_depth >= 0) + if (write_symbols == DWARF2_DEBUG) dwarf2out_end_block (pending_blocks[block_depth]); #endif } @@ -1578,17 +2272,58 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) break; case BARRIER: -#ifdef ASM_OUTPUT_ALIGN_CODE - /* Don't litter the assembler output with needless alignments. A - BARRIER will be placed at the end of every function if HAVE_epilogue - is true. */ - if (NEXT_INSN (insn)) - ASM_OUTPUT_ALIGN_CODE (file); +#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); #endif break; case CODE_LABEL: + /* The target port might emit labels in the output function for + some insn, e.g. sh.c output_branchy_insn. */ + if (CODE_LABEL_NUMBER (insn) <= max_labelno) + { + int align = LABEL_TO_ALIGNMENT (insn); +#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN + int max_skip = LABEL_TO_MAX_SKIP (insn); +#endif + + if (align && NEXT_INSN (insn)) +#ifdef ASM_OUTPUT_MAX_SKIP_ALIGN + ASM_OUTPUT_MAX_SKIP_ALIGN (file, align, max_skip); +#else + ASM_OUTPUT_ALIGN (file, align); +#endif + } +#ifdef HAVE_cc0 CC_STATUS_INIT; + /* If this label is reached from only one place, set the condition + codes from the instruction just before the branch. */ + + /* 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); + rtx prev; + /* If the LABEL_REFS field of this label has been set to point + at a branch, the predecessor of the branch is a regular + insn, and that branch is the only way to reach this label, + set the condition codes based on the branch and its + predecessor. */ + if (barrier && GET_CODE (barrier) == BARRIER + && jump && GET_CODE (jump) == JUMP_INSN + && (prev = prev_nonnote_insn (jump)) + && GET_CODE (prev) == INSN) + { + NOTICE_UPDATE_CC (PATTERN (prev), prev); + NOTICE_UPDATE_CC (PATTERN (jump), jump); + } + } +#endif if (prescan > 0) break; new_block = 1; @@ -1611,7 +2346,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) #endif if (app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } if (NEXT_INSN (insn) != 0 @@ -1626,22 +2361,30 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) if (GET_CODE (nextbody) == ADDR_VEC || GET_CODE (nextbody) == ADDR_DIFF_VEC) { -#ifndef JUMP_TABLES_IN_TEXT_SECTION - readonly_data_section (); +#if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC) + /* In this case, the case vector is being moved by the + target, so don't output the label at all. Leave that + to the back end macros. */ +#else + if (! JUMP_TABLES_IN_TEXT_SECTION) + { + readonly_data_section (); #ifdef READONLY_DATA_SECTION - ASM_OUTPUT_ALIGN (file, - exact_log2 (BIGGEST_ALIGNMENT - / BITS_PER_UNIT)); + ASM_OUTPUT_ALIGN (file, + exact_log2 (BIGGEST_ALIGNMENT + / BITS_PER_UNIT)); #endif /* READONLY_DATA_SECTION */ -#else /* JUMP_TABLES_IN_TEXT_SECTION */ - function_section (current_function_decl); -#endif /* JUMP_TABLES_IN_TEXT_SECTION */ + } + else + function_section (current_function_decl); + #ifdef ASM_OUTPUT_CASE_LABEL ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn), NEXT_INSN (insn)); #else ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn)); #endif +#endif break; } } @@ -1654,7 +2397,9 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) register rtx body = PATTERN (insn); int insn_code_number; char *template; +#ifdef HAVE_cc0 rtx note; +#endif /* An INSN, JUMP_INSN or CALL_INSN. First check for special kinds that recog doesn't recognize. */ @@ -1682,17 +2427,37 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) 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; if (app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } +#if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC) + if (GET_CODE (body) == ADDR_VEC) + { +#ifdef ASM_OUTPUT_ADDR_VEC + ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body); +#else + abort(); +#endif + } + else + { +#ifdef ASM_OUTPUT_ADDR_DIFF_VEC + ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body); +#else + abort(); +#endif + } +#else vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC); for (idx = 0; idx < vlen; idx++) { @@ -1710,6 +2475,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) #ifdef ASM_OUTPUT_ADDR_DIFF_ELT ASM_OUTPUT_ADDR_DIFF_ELT (file, + body, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)), CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0))); #else @@ -1722,6 +2488,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) CODE_LABEL_NUMBER (PREV_INSN (insn)), insn); #endif +#endif function_section (current_function_decl); @@ -1741,7 +2508,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) break; if (! app_on) { - fprintf (file, ASM_APP_ON); + fputs (ASM_APP_ON, file); app_on = 1; } fprintf (asm_out_file, "\t%s\n", XSTR (body, 0)); @@ -1751,7 +2518,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) /* Detect `asm' construct with operands. */ if (asm_noperands (body) >= 0) { - int noperands = asm_noperands (body); + unsigned int noperands = asm_noperands (body); rtx *ops = (rtx *) alloca (noperands * sizeof (rtx)); char *string; @@ -1762,7 +2529,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) if (! app_on) { - fprintf (file, ASM_APP_ON); + fputs (ASM_APP_ON, file); app_on = 1; } @@ -1781,7 +2548,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) if (prescan <= 0 && app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } @@ -1828,7 +2595,9 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) actions in these insns and the CC must be marked as being clobbered by the function. */ if (GET_CODE (XVECEXP (body, 0, 0)) == CALL_INSN) - CC_STATUS_INIT; + { + CC_STATUS_INIT; + } /* Following a conditional branch sequence, we have a new basic block. */ @@ -1853,6 +2622,8 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) body = PATTERN (insn); #ifdef HAVE_cc0 + set = single_set(insn); + /* Check for redundant test and compare instructions (when the condition codes are already set up as desired). This is done only when optimizing; if not optimizing, @@ -1863,7 +2634,9 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) if (optimize) { +#if 0 rtx set = single_set(insn); +#endif if (set && GET_CODE (SET_DEST (set)) == CC0 @@ -1978,20 +2751,20 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) handle conditional moves (if this machine has either one). */ if (cc_status.flags != 0 - && GET_CODE (body) == SET) + && set != 0) { rtx cond_rtx, then_rtx, else_rtx; if (GET_CODE (insn) != JUMP_INSN - && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE) + && GET_CODE (SET_SRC (set)) == IF_THEN_ELSE) { - cond_rtx = XEXP (SET_SRC (body), 0); - then_rtx = XEXP (SET_SRC (body), 1); - else_rtx = XEXP (SET_SRC (body), 2); + cond_rtx = XEXP (SET_SRC (set), 0); + then_rtx = XEXP (SET_SRC (set), 1); + else_rtx = XEXP (SET_SRC (set), 2); } else { - cond_rtx = SET_SRC (body); + cond_rtx = SET_SRC (set); then_rtx = const_true_rtx; else_rtx = const0_rtx; } @@ -2014,19 +2787,22 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) break; result = alter_cond (cond_rtx); if (result == 1) - validate_change (insn, &SET_SRC (body), then_rtx, 0); + validate_change (insn, &SET_SRC (set), then_rtx, 0); else if (result == -1) - validate_change (insn, &SET_SRC (body), else_rtx, 0); + validate_change (insn, &SET_SRC (set), else_rtx, 0); else if (result == 2) INSN_CODE (insn) = -1; - if (SET_DEST (body) == SET_SRC (body)) + if (SET_DEST (set) == SET_SRC (set)) { PUT_CODE (insn, NOTE); NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; NOTE_SOURCE_FILE (insn) = 0; - break; } } + break; + + default: + break; } } @@ -2069,27 +2845,11 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) 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 @@ -2097,8 +2857,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) it is output. */ #ifdef FINAL_PRESCAN_INSN - FINAL_PRESCAN_INSN (insn, recog_operand, - insn_n_operands[insn_code_number]); + FINAL_PRESCAN_INSN (insn, recog_operand, recog_n_operands); #endif #ifdef HAVE_cc0 @@ -2114,6 +2873,12 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) debug_insn = insn; +#if defined (DWARF2_UNWIND_INFO) && !defined (ACCUMULATE_OUTGOING_ARGS) + /* If we push arguments, we want to know where the calls are. */ + if (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. */ @@ -2142,7 +2907,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) /* If we didn't split the insn, go away. */ if (new == insn && PATTERN (new) == body) - abort (); + fatal_insn ("Could not split insn", insn); #ifdef HAVE_ATTR_length /* This instruction should have been split in shorten_branches, @@ -2162,12 +2927,21 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) output_asm_insn (template, recog_operand); -#if defined (DWARF2_DEBUGGING_INFO) && defined (HAVE_prologue) +#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 defined (HAVE_prologue) /* If this insn is part of the prologue, emit DWARF v2 call frame info. */ - if (write_symbols == DWARF2_DEBUG && RTX_FRAME_RELATED_P (insn)) + if (RTX_FRAME_RELATED_P (insn) && dwarf2out_do_frame ()) dwarf2out_frame_debug (insn); #endif +#endif +#endif #if 0 /* It's not at all clear why we did this and doing so interferes @@ -2250,6 +3024,35 @@ output_source_line (file, insn) } } + +/* 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_n_operands; 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 < recog_n_dups; 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]); + } +} + /* If X is a SUBREG, replace it with a REG or a MEM, based on the thing it is a subreg of. */ @@ -2258,14 +3061,34 @@ alter_subreg (x) register rtx x; { register rtx y = SUBREG_REG (x); + if (GET_CODE (y) == SUBREG) y = alter_subreg (y); + /* If reload is operating, we may be replacing inside this SUBREG. + Check for that and make a new one if so. */ + if (reload_in_progress && find_replacement (&SUBREG_REG (x)) != 0) + x = copy_rtx (x); + if (GET_CODE (y) == REG) { - /* If the containing reg really gets a hard reg, so do we. */ + /* 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 + integrate. It would be better if we either caught these + 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)); +#else REGNO (x) = REGNO (y) + SUBREG_WORD (x); +#endif + /* This field has a different meaning for REGs and SUBREGs. Make sure + to clear it! */ + x->used = 0; } else if (GET_CODE (y) == MEM) { @@ -2275,6 +3098,8 @@ alter_subreg (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); XEXP (x, 0) = plus_constant (XEXP (y, 0), offset); } @@ -2301,6 +3126,9 @@ walk_alter_subreg (x) case SUBREG: return alter_subreg (x); + + default: + break; } return x; @@ -2359,6 +3187,9 @@ alter_cond (cond) PUT_CODE (cond, NE); value = 2; break; + + default: + break; } if (cc_status.flags & CC_NOT_NEGATIVE) @@ -2385,6 +3216,9 @@ alter_cond (cond) PUT_CODE (cond, NE); value = 2; break; + + default: + break; } if (cc_status.flags & CC_NO_OVERFLOW) @@ -2407,19 +3241,15 @@ alter_cond (cond) case LTU: /* Jump becomes no-op. */ return -1; + + default: + break; } if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N)) switch (GET_CODE (cond)) { - case LE: - case LEU: - case GE: - case GEU: - case LT: - case LTU: - case GT: - case GTU: + default: abort (); case NE: @@ -2457,6 +3287,9 @@ alter_cond (cond) PUT_CODE (cond, GEU); value = 2; break; + + default: + break; } return value; @@ -2473,7 +3306,7 @@ output_operand_lossage (str) if (this_is_asm_operands) error_for_asm (this_is_asm_operands, "invalid `asm': %s", str); else - abort (); + fatal ("Internal compiler error, output_operand_lossage `%s'", str); } /* Output of assembler code from a template, and its subroutines. */ @@ -2504,11 +3337,13 @@ output_asm_name () if (debug_insn) { register int num = INSN_CODE (debug_insn); - fprintf (asm_out_file, " %s %d %s", + fprintf (asm_out_file, "\t%s %d\t%s", ASM_COMMENT_START, INSN_UID (debug_insn), insn_name[num]); if (insn_n_alternatives[num] > 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; @@ -2522,7 +3357,7 @@ output_asm_insn (template, operands) rtx *operands; { register char *p; - register int c, i; + register int c; /* An insn may return a null string template in a case where no assembler code is needed. */ @@ -2536,7 +3371,7 @@ output_asm_insn (template, operands) ASM_OUTPUT_OPCODE (asm_out_file, p); #endif - while (c = *p++) + while ((c = *p++)) switch (c) { case '\n': @@ -2554,16 +3389,20 @@ output_asm_insn (template, operands) #ifdef ASSEMBLER_DIALECT case '{': - /* If we want the first dialect, do nothing. Otherwise, skip - DIALECT_NUMBER of strings ending with '|'. */ - for (i = 0; i < dialect_number; i++) - { - while (*p && *p++ != '|') - ; + { + 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++) + { + while (*p && *p++ != '|') + ; - if (*p == '|') - p++; - } + if (*p == '|') + p++; + } + } break; case '|': @@ -2604,7 +3443,7 @@ output_asm_insn (template, operands) if (! (*p >= '0' && *p <= '9')) output_operand_lossage ("operand number missing after %-letter"); - else if (this_is_asm_operands && c >= (unsigned) insn_noperands) + else if (this_is_asm_operands && (c < 0 || (unsigned int) c >= insn_noperands)) output_operand_lossage ("operand number out of range"); else if (letter == 'l') output_asm_label (operands[c]); @@ -2637,7 +3476,7 @@ output_asm_insn (template, operands) else if (*p >= '0' && *p <= '9') { c = atoi (p); - if (this_is_asm_operands && c >= (unsigned) 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); @@ -2844,39 +3683,42 @@ output_addr_const (file, x) void asm_fprintf VPROTO((FILE *file, char *p, ...)) { -#ifndef __STDC__ +#ifndef ANSI_PROTOTYPES FILE *file; char *p; #endif va_list argptr; char buf[10]; char *q, c; - int i; VA_START (argptr, p); -#ifndef __STDC__ +#ifndef ANSI_PROTOTYPES file = va_arg (argptr, FILE *); p = va_arg (argptr, char *); #endif buf[0] = '%'; - while (c = *p++) + while ((c = *p++)) switch (c) { #ifdef ASSEMBLER_DIALECT case '{': - /* If we want the first dialect, do nothing. Otherwise, skip - DIALECT_NUMBER of strings ending with '|'. */ - for (i = 0; i < dialect_number; i++) - { - while (*p && *p++ != '|') - ; + { + int i; - if (*p == '|') - p++; + /* If we want the first dialect, do nothing. Otherwise, skip + DIALECT_NUMBER of strings ending with '|'. */ + for (i = 0; i < dialect_number; i++) + { + while (*p && *p++ != '|') + ; + + if (*p == '|') + p++; } + } break; case '|': @@ -2977,9 +3819,7 @@ asm_fprintf VPROTO((FILE *file, char *p, ...)) break; case 'U': -#ifdef USER_LABEL_PREFIX - fprintf (file, "%s", USER_LABEL_PREFIX); -#endif + fputs (user_label_prefix, file); break; default: @@ -3007,16 +3847,18 @@ split_double (value, first, second) if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD)) { /* In this case the CONST_INT holds both target words. - Extract the bits from it into two word-sized pieces. */ + Extract the bits from it into two word-sized pieces. + Sign extend each half to HOST_WIDE_INT. */ rtx low, high; - HOST_WIDE_INT word_mask; - /* Avoid warnings for shift count >= BITS_PER_WORD. */ - int shift_count = BITS_PER_WORD - 1; - - word_mask = (HOST_WIDE_INT) 1 << shift_count; - word_mask |= word_mask - 1; - low = GEN_INT (INTVAL (value) & word_mask); - high = GEN_INT ((INTVAL (value) >> (shift_count + 1)) & word_mask); + /* On machines where HOST_BITS_PER_WIDE_INT == BITS_PER_WORD + the shift below will cause a compiler warning, even though + this code won't be executed. So put the shift amounts in + variables to avoid the warning. */ + int rshift = HOST_BITS_PER_WIDE_INT - BITS_PER_WORD; + int lshift = HOST_BITS_PER_WIDE_INT - 2 * BITS_PER_WORD; + + low = GEN_INT ((INTVAL (value) << rshift) >> rshift); + high = GEN_INT ((INTVAL (value) << lshift) >> rshift); if (WORDS_BIG_ENDIAN) { *first = high; @@ -3171,11 +4013,16 @@ only_leaf_regs_used () int i; for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) - { - if ((regs_ever_live[i] || global_regs[i]) - && ! permitted_reg_in_leaf_functions[i]) - return 0; - } + if ((regs_ever_live[i] || global_regs[i]) + && ! permitted_reg_in_leaf_functions[i]) + return 0; + + if (current_function_uses_pic_offset_table + && pic_offset_table_rtx != 0 + && GET_CODE (pic_offset_table_rtx) == REG + && ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)]) + return 0; + return 1; }