diff options
Diffstat (limited to 'contrib/gcc/final.c')
| -rw-r--r-- | contrib/gcc/final.c | 1510 |
1 files changed, 1206 insertions, 304 deletions
diff --git a/contrib/gcc/final.c b/contrib/gcc/final.c index 19b2c7c..b49d4f6 100644 --- a/contrib/gcc/final.c +++ b/contrib/gcc/final.c @@ -1,5 +1,5 @@ /* Convert RTL to assembler code and output it, for GNU compiler. - Copyright (C) 1987, 88, 89, 92, 93, 94, 1995 Free Software Foundation, Inc. + Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc. This file is part of GNU CC. @@ -50,8 +50,7 @@ Boston, MA 02111-1307, USA. */ #else #include <varargs.h> #endif -#include <stdio.h> -#include <ctype.h> +#include "system.h" #include "tree.h" #include "rtl.h" @@ -67,20 +66,37 @@ Boston, MA 02111-1307, USA. */ #include "hard-reg-set.h" #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 <stab.h> /* On BSD, use the system's stab.h. */ -#endif /* not USG */ +#include <stab.h> +#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 @@ -95,6 +111,10 @@ Boston, MA 02111-1307, USA. */ #define INT_TYPE_SIZE BITS_PER_WORD #endif +#ifndef LONG_TYPE_SIZE +#define LONG_TYPE_SIZE BITS_PER_WORD +#endif + /* If we aren't using cc0, CC_STATUS_INIT shouldn't exist. So define a null default for it to save conditionalization later. */ #ifndef CC_STATUS_INIT @@ -111,6 +131,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. */ @@ -135,13 +159,18 @@ static char *last_filename; used if profile_block_flag is set. */ 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. */ @@ -269,17 +298,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 (); @@ -309,14 +344,21 @@ end_final (filename) { int i; - if (profile_block_flag) + if (profile_block_flag || profile_arc_flag) { char name[20]; int align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT); - int size = (POINTER_SIZE / BITS_PER_UNIT) * count_basic_blocks; - int rounded = size; + int size, rounded; struct bb_list *ptr; struct bb_str *sptr; + int long_bytes = LONG_TYPE_SIZE / BITS_PER_UNIT; + int pointer_bytes = POINTER_SIZE / BITS_PER_UNIT; + + if (profile_block_flag) + size = long_bytes * count_basic_blocks; + else + size = long_bytes * count_instrumented_arcs; + rounded = size; rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1; rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT) @@ -324,8 +366,8 @@ end_final (filename) data_section (); - /* Output the main header, of 10 words: - 0: 1 if this file's initialized, else 0. + /* Output the main header, of 11 words: + 0: 1 if this file is initialized, else 0. 1: address of file name (LPBX1). 2: address of table of counts (LPBX2). 3: number of counts in the table. @@ -337,53 +379,73 @@ end_final (filename) 6: Number of bytes in this header. 7: address of table of function names (LPBX4). 8: address of table of line numbers (LPBX5) or 0. - 9: address of table of file names (LPBX6) or 0. */ + 9: address of table of file names (LPBX6) or 0. + 10: space reserved for basic block profiling. */ ASM_OUTPUT_ALIGN (asm_out_file, align); ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 0); /* zero word */ - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + assemble_integer (const0_rtx, long_bytes, 1); /* address of filename */ ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 1); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 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), UNITS_PER_WORD, 1); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); - /* count of the # of basic blocks */ - assemble_integer (GEN_INT (count_basic_blocks), UNITS_PER_WORD, 1); + /* count of the # of basic blocks or # of instrumented arcs */ + if (profile_block_flag) + assemble_integer (GEN_INT (count_basic_blocks), long_bytes, 1); + else + assemble_integer (GEN_INT (count_instrumented_arcs), long_bytes, + 1); /* zero word (link field) */ - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + assemble_integer (const0_rtx, pointer_bytes, 1); /* address of basic block start address table */ - ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1); + if (profile_block_flag) + { + ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, + 1); + } + else + assemble_integer (const0_rtx, pointer_bytes, 1); /* byte count for extended structure. */ - assemble_integer (GEN_INT (10 * UNITS_PER_WORD), UNITS_PER_WORD, 1); + assemble_integer (GEN_INT (10 * UNITS_PER_WORD), long_bytes, 1); /* address of function name table */ - ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1); + if (profile_block_flag) + { + ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, + 1); + } + else + assemble_integer (const0_rtx, pointer_bytes, 1); /* address of line number and filename tables if debugging. */ - if (write_symbols != NO_DEBUG) + if (write_symbols != NO_DEBUG && profile_block_flag) { ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 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), UNITS_PER_WORD, 1); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1); } else { - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + assemble_integer (const0_rtx, pointer_bytes, 1); + assemble_integer (const0_rtx, pointer_bytes, 1); } + /* space for extension ptr (link field) */ + assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + /* Output the file name changing the suffix to .d for Sun tcov compatibility. */ ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 1); @@ -396,12 +458,15 @@ end_final (filename) strcat (data_file, "/"); strcat (data_file, filename); strip_off_ending (data_file, len); - strcat (data_file, ".d"); + if (profile_block_flag) + strcat (data_file, ".d"); + else + strcat (data_file, ".da"); assemble_string (data_file, strlen (data_file) + 1); } /* Make space for the table of counts. */ - if (flag_no_common || size == 0) + if (size == 0) { /* Realign data section. */ ASM_OUTPUT_ALIGN (asm_out_file, align); @@ -417,63 +482,79 @@ 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 */ - readonly_data_section (); - if (sbb_head) + if (profile_block_flag) { - ASM_OUTPUT_ALIGN (asm_out_file, align); - for (sptr = sbb_head; sptr != 0; sptr = sptr->next) + readonly_data_section (); + if (sbb_head) { - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBC", sptr->label_num); - assemble_string (sptr->string, sptr->length); + ASM_OUTPUT_ALIGN (asm_out_file, align); + for (sptr = sbb_head; sptr != 0; sptr = sptr->next) + { + ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBC", + sptr->label_num); + assemble_string (sptr->string, sptr->length); + } } } /* Output the table of addresses. */ - /* Realign in new section */ - ASM_OUTPUT_ALIGN (asm_out_file, align); - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 3); - for (i = 0; i < count_basic_blocks; i++) + if (profile_block_flag) { - ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), - UNITS_PER_WORD, 1); + /* Realign in new section */ + ASM_OUTPUT_ALIGN (asm_out_file, align); + ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 3); + for (i = 0; i < count_basic_blocks; i++) + { + ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), + pointer_bytes, 1); + } } /* Output the table of function names. */ - ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 4); - for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++) + if (profile_block_flag) { - if (ptr->func_label_num >= 0) + ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 4); + for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++) { - ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->func_label_num); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), - UNITS_PER_WORD, 1); + if (ptr->func_label_num >= 0) + { + ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", + ptr->func_label_num); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), + pointer_bytes, 1); + } + else + assemble_integer (const0_rtx, pointer_bytes, 1); } - else - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); - } - for ( ; i < count_basic_blocks; i++) - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + for ( ; i < count_basic_blocks; i++) + assemble_integer (const0_rtx, pointer_bytes, 1); + } - if (write_symbols != NO_DEBUG) + if (write_symbols != NO_DEBUG && profile_block_flag) { /* Output the table of line numbers. */ ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 5); for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++) - assemble_integer (GEN_INT (ptr->line_num), UNITS_PER_WORD, 1); + assemble_integer (GEN_INT (ptr->line_num), long_bytes, 1); for ( ; i < count_basic_blocks; i++) - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + assemble_integer (const0_rtx, long_bytes, 1); /* Output the table of file names. */ ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 6); @@ -481,22 +562,27 @@ end_final (filename) { if (ptr->file_label_num >= 0) { - ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->file_label_num); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), - UNITS_PER_WORD, 1); + ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", + ptr->file_label_num); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), + pointer_bytes, 1); } else - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + assemble_integer (const0_rtx, pointer_bytes, 1); } for ( ; i < count_basic_blocks; i++) - assemble_integer (const0_rtx, UNITS_PER_WORD, 1); + assemble_integer (const0_rtx, pointer_bytes, 1); } /* End with the address of the table of addresses, so we can find it easily, as the last word in the file's text. */ - ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); - assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1); + if (profile_block_flag) + { + ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3); + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, + 1); + } } } @@ -508,7 +594,7 @@ app_enable () { if (! app_on) { - fprintf (asm_out_file, ASM_APP_ON); + fputs (ASM_APP_ON, asm_out_file); app_on = 1; } } @@ -521,7 +607,7 @@ app_disable () { if (app_on) { - fprintf (asm_out_file, ASM_APP_OFF); + fputs (ASM_APP_OFF, asm_out_file); app_on = 0; } } @@ -553,12 +639,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, @@ -591,16 +725,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); @@ -618,6 +744,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 @@ -629,6 +759,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. */ @@ -638,27 +971,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]; - /* 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); + /* 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') + { + 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 + + /* 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; @@ -666,31 +1235,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); @@ -705,7 +1286,7 @@ shorten_branches (first) #endif /* Inside a delay slot sequence, we do not do any branch shortening if the shortening could change the number of delay slots - of the branch. */ + of the branch. */ for (i = 0; i < XVECLEN (body, 0); i++) { rtx inner_insn = XVECEXP (body, 0, i); @@ -751,16 +1332,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; @@ -801,14 +1520,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]) { @@ -820,6 +1537,9 @@ shorten_branches (first) if (!optimize) break; } + + free (varying_length); + #endif /* HAVE_ATTR_length */ } @@ -890,10 +1610,16 @@ final_start_function (first, file, optimize) last_linenum = high_block_linenum = high_function_linenum = NOTE_LINE_NUMBER (first); +#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) + /* Output DWARF definition of the function. */ + if (dwarf2out_do_frame ()) + dwarf2out_begin_prologue (); +#endif + /* For SDB and XCOFF, the function beginning must be marked between the function label and the prologue. We always need this, even when -g1 was used. Defer on MIPS systems so that parameter descriptions - follow function entry. */ + follow function entry. */ #if defined(SDB_DEBUGGING_INFO) && !defined(MIPS_DEBUGGING_INFO) if (write_symbols == SDB_DEBUG) sdbout_begin_function (last_linenum); @@ -924,6 +1650,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 ()); @@ -947,9 +1678,8 @@ final_start_function (first, file, optimize) of the function name. */ if (profile_block_flag) { - char *junk = "function"; - bb_func_label_num = - add_bb_string ((*decl_printable_name) (current_function_decl, &junk), FALSE); + bb_func_label_num + = add_bb_string ((*decl_printable_name) (current_function_decl, 2), FALSE); } } @@ -960,7 +1690,7 @@ profile_after_prologue (file) #ifdef FUNCTION_BLOCK_PROFILER if (profile_block_flag) { - FUNCTION_BLOCK_PROFILER (file, profile_label_no); + FUNCTION_BLOCK_PROFILER (file, count_basic_blocks); } #endif /* FUNCTION_BLOCK_PROFILER */ @@ -975,63 +1705,73 @@ profile_function (file) FILE *file; { #ifndef NO_PROFILE_DATA - int align = MIN (BIGGEST_ALIGNMENT, POINTER_SIZE); + int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE); #endif /* not NO_PROFILE_DATA */ +#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 */ #ifndef NO_PROFILE_DATA data_section (); ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT)); ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no); - assemble_integer (const0_rtx, POINTER_SIZE / BITS_PER_UNIT, 1); + assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, 1); #endif /* not NO_PROFILE_DATA */ - text_section (); + function_section (current_function_decl); -#ifdef STRUCT_VALUE_INCOMING_REGNUM +#if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (sval) ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM); #else -#ifdef STRUCT_VALUE_REGNUM +#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 -#if 0 -#ifdef STATIC_CHAIN_INCOMING_REGNUM +#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (cxt) ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM); #else -#ifdef STATIC_CHAIN_REGNUM +#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 -#endif /* 0 */ FUNCTION_PROFILER (file, profile_label_no); -#if 0 -#ifdef STATIC_CHAIN_INCOMING_REGNUM +#if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (cxt) ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM); #else -#ifdef STATIC_CHAIN_REGNUM +#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 -#endif /* 0 */ -#ifdef STRUCT_VALUE_INCOMING_REGNUM +#if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH) if (sval) ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM); #else -#ifdef STRUCT_VALUE_REGNUM +#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 } @@ -1048,7 +1788,7 @@ final_end_function (first, file, optimize) { if (app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } @@ -1086,6 +1826,11 @@ final_end_function (first, file, optimize) dwarfout_end_epilogue (); #endif +#if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO) + if (dwarf2out_do_frame ()) + dwarf2out_end_epilogue (); +#endif + #ifdef XCOFF_DEBUGGING_INFO if (write_symbols == XCOFF_DEBUG) xcoffout_end_epilogue (file); @@ -1123,6 +1868,8 @@ add_bb (file) count of times it was entered. */ #ifdef BLOCK_PROFILER BLOCK_PROFILER (file, count_basic_blocks); +#endif +#ifdef HAVE_cc0 CC_STATUS_INIT; #endif @@ -1158,7 +1905,7 @@ add_bb_string (string, perm_p) string = p; } else - for (ptr = sbb_head; ptr != (struct bb_str *)0; ptr = ptr->next) + for (ptr = sbb_head; ptr != (struct bb_str *) 0; ptr = ptr->next) if (ptr->string == string) break; @@ -1198,10 +1945,13 @@ final (first, file, optimize, prescan) { register rtx insn; int max_line = 0; + int max_uid = 0; last_ignored_compare = 0; new_block = 1; + check_exception_handler_labels (); + /* Make a map indicating which line numbers appear in this function. When producing SDB debugging info, delete troublesome line number notes from inlined functions in other files as well as duplicate @@ -1240,8 +1990,16 @@ 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; + } + + /* Initialize insn_eh_region table if eh is being used. */ + + init_insn_eh_region (first, max_uid); init_recog (); @@ -1249,12 +2007,19 @@ final (first, file, optimize, prescan) /* Output the insns. */ for (insn = NEXT_INSN (first); insn;) - insn = final_scan_insn (insn, file, optimize, prescan, 0); + { +#ifdef HAVE_ATTR_length + insn_current_address = insn_addresses[INSN_UID (insn)]; +#endif + insn = final_scan_insn (insn, file, optimize, prescan, 0); + } /* Do basic-block profiling here 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. @@ -1274,6 +2039,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 @@ -1290,19 +2059,34 @@ 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) + 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 + && ! exceptions_via_longjmp) { -#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); - } + ASM_OUTPUT_INTERNAL_LABEL (file, "LEHB", 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 + && ! 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 break; } - if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END) - break; if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END) { @@ -1327,7 +2111,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) { #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. */ + function entry point rather than before. */ if (write_symbols == SDB_DEBUG) sdbout_begin_function (last_linenum); else @@ -1344,17 +2128,14 @@ 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 && (debug_info_level == DINFO_LEVEL_NORMAL || debug_info_level == DINFO_LEVEL_VERBOSE -#ifdef DWARF_DEBUGGING_INFO || write_symbols == DWARF_DEBUG -#endif - ) - ) + || write_symbols == DWARF2_DEBUG)) { /* Beginning of a symbol-block. Assign it a sequence number and push the number onto the stack PENDING_BLOCKS. */ @@ -1386,20 +2167,21 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index); #endif #ifdef DWARF_DEBUGGING_INFO - if (write_symbols == DWARF_DEBUG && block_depth > 1) + if (write_symbols == DWARF_DEBUG) dwarfout_begin_block (next_block_index); #endif +#ifdef DWARF2_DEBUGGING_INFO + if (write_symbols == DWARF2_DEBUG) + dwarf2out_begin_block (next_block_index); +#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 -#ifdef DWARF_DEBUGGING_INFO || write_symbols == DWARF_DEBUG -#endif - ) - ) + || write_symbols == DWARF2_DEBUG)) { /* End of a symbol-block. Pop its sequence number off PENDING_BLOCKS and output debugging info based on that. */ @@ -1422,9 +2204,13 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) pending_blocks[block_depth]); #endif #ifdef DWARF_DEBUGGING_INFO - if (write_symbols == DWARF_DEBUG && block_depth >= 1) + if (write_symbols == DWARF_DEBUG && block_depth >= 0) dwarfout_end_block (pending_blocks[block_depth]); #endif +#ifdef DWARF2_DEBUGGING_INFO + if (write_symbols == DWARF2_DEBUG && block_depth >= 0) + dwarf2out_end_block (pending_blocks[block_depth]); +#endif } else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL && (debug_info_level == DINFO_LEVEL_NORMAL @@ -1434,6 +2220,10 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) if (write_symbols == DWARF_DEBUG) dwarfout_label (insn); #endif +#ifdef DWARF2_DEBUGGING_INFO + if (write_symbols == DWARF2_DEBUG) + dwarf2out_label (insn); +#endif } else if (NOTE_LINE_NUMBER (insn) > 0) /* This note is a line-number. */ @@ -1483,20 +2273,40 @@ 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 + } CC_STATUS_INIT; if (prescan > 0) break; new_block = 1; + +#ifdef FINAL_PRESCAN_LABEL + FINAL_PRESCAN_INSN (insn, NULL_PTR, 0); +#endif + #ifdef SDB_DEBUGGING_INFO if (write_symbols == SDB_DEBUG && LABEL_NAME (insn)) sdbout_label (insn); @@ -1505,9 +2315,13 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) if (write_symbols == DWARF_DEBUG && LABEL_NAME (insn)) dwarfout_label (insn); #endif +#ifdef DWARF2_DEBUGGING_INFO + if (write_symbols == DWARF2_DEBUG && LABEL_NAME (insn)) + dwarf2out_label (insn); +#endif if (app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } if (NEXT_INSN (insn) != 0 @@ -1522,16 +2336,18 @@ 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 (! 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)); @@ -1550,7 +2366,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. */ @@ -1585,7 +2403,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) if (app_on) { - fprintf (file, ASM_APP_OFF); + fputs (ASM_APP_OFF, file); app_on = 0; } @@ -1606,6 +2424,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 @@ -1637,7 +2456,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)); @@ -1647,7 +2466,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; @@ -1658,7 +2477,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; } @@ -1677,7 +2496,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; } @@ -1724,7 +2543,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. */ @@ -1749,6 +2570,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, @@ -1757,35 +2580,41 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) and the next statement should reexamine the variable to compute the condition codes. */ - if (optimize - && GET_CODE (body) == SET - && GET_CODE (SET_DEST (body)) == CC0 - && insn != last_ignored_compare) + if (optimize) { - if (GET_CODE (SET_SRC (body)) == SUBREG) - SET_SRC (body) = alter_subreg (SET_SRC (body)); - else if (GET_CODE (SET_SRC (body)) == COMPARE) - { - if (GET_CODE (XEXP (SET_SRC (body), 0)) == SUBREG) - XEXP (SET_SRC (body), 0) - = alter_subreg (XEXP (SET_SRC (body), 0)); - if (GET_CODE (XEXP (SET_SRC (body), 1)) == SUBREG) - XEXP (SET_SRC (body), 1) - = alter_subreg (XEXP (SET_SRC (body), 1)); - } - if ((cc_status.value1 != 0 - && rtx_equal_p (SET_SRC (body), cc_status.value1)) - || (cc_status.value2 != 0 - && rtx_equal_p (SET_SRC (body), cc_status.value2))) +#if 0 + rtx set = single_set(insn); +#endif + + if (set + && GET_CODE (SET_DEST (set)) == CC0 + && insn != last_ignored_compare) { - /* Don't delete insn if it has an addressing side-effect. */ - if (! FIND_REG_INC_NOTE (insn, 0) - /* or if anything in it is volatile. */ - && ! volatile_refs_p (PATTERN (insn))) + if (GET_CODE (SET_SRC (set)) == SUBREG) + SET_SRC (set) = alter_subreg (SET_SRC (set)); + else if (GET_CODE (SET_SRC (set)) == COMPARE) { - /* We don't really delete the insn; just ignore it. */ - last_ignored_compare = insn; - break; + if (GET_CODE (XEXP (SET_SRC (set), 0)) == SUBREG) + XEXP (SET_SRC (set), 0) + = alter_subreg (XEXP (SET_SRC (set), 0)); + if (GET_CODE (XEXP (SET_SRC (set), 1)) == SUBREG) + XEXP (SET_SRC (set), 1) + = alter_subreg (XEXP (SET_SRC (set), 1)); + } + if ((cc_status.value1 != 0 + && rtx_equal_p (SET_SRC (set), cc_status.value1)) + || (cc_status.value2 != 0 + && rtx_equal_p (SET_SRC (set), cc_status.value2))) + { + /* Don't delete insn if it has an addressing side-effect. */ + if (! FIND_REG_INC_NOTE (insn, 0) + /* or if anything in it is volatile. */ + && ! volatile_refs_p (PATTERN (insn))) + { + /* We don't really delete the insn; just ignore it. */ + last_ignored_compare = insn; + break; + } } } } @@ -1866,12 +2695,29 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) } /* Make same adjustments to instructions that examine the - condition codes without jumping (if this machine has them). */ + condition codes without jumping and instructions that + handle conditional moves (if this machine has either one). */ if (cc_status.flags != 0 - && GET_CODE (body) == SET) + && set != 0) { - switch (GET_CODE (SET_SRC (body))) + rtx cond_rtx, then_rtx, else_rtx; + + if (GET_CODE (insn) != JUMP_INSN + && GET_CODE (SET_SRC (set)) == IF_THEN_ELSE) + { + 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 (set); + then_rtx = const_true_rtx; + else_rtx = const0_rtx; + } + + switch (GET_CODE (cond_rtx)) { case GTU: case GT: @@ -1885,18 +2731,29 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) case NE: { register int result; - if (XEXP (SET_SRC (body), 0) != cc0_rtx) + if (XEXP (cond_rtx, 0) != cc0_rtx) break; - result = alter_cond (SET_SRC (body)); + result = alter_cond (cond_rtx); if (result == 1) - validate_change (insn, &SET_SRC (body), const_true_rtx, 0); + validate_change (insn, &SET_SRC (set), then_rtx, 0); else if (result == -1) - validate_change (insn, &SET_SRC (body), const0_rtx, 0); + validate_change (insn, &SET_SRC (set), else_rtx, 0); else if (result == 2) INSN_CODE (insn) = -1; + if (SET_DEST (set) == SET_SRC (set)) + { + PUT_CODE (insn, NOTE); + NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; + NOTE_SOURCE_FILE (insn) = 0; + } } + break; + + default: + break; } } + #endif /* Do machine-specific peephole optimizations if desired. */ @@ -1981,6 +2838,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. */ @@ -2009,8 +2872,15 @@ 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, + to ensure that we would have valid length info for the + splitees. */ + abort (); +#endif + new_block = 0; return new; } @@ -2022,6 +2892,22 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes) output_asm_insn (template, recog_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 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 +#endif +#endif + #if 0 /* It's not at all clear why we did this and doing so interferes with tests we'd like to do to use REG_WAS_0 notes, so let's try @@ -2095,6 +2981,11 @@ output_source_line (file, insn) if (write_symbols == DWARF_DEBUG) dwarfout_line (filename, NOTE_LINE_NUMBER (insn)); #endif + +#ifdef DWARF2_DEBUGGING_INFO + if (write_symbols == DWARF2_DEBUG) + dwarf2out_line (filename, NOTE_LINE_NUMBER (insn)); +#endif } } @@ -2106,14 +2997,31 @@ 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 } else if (GET_CODE (y) == MEM) { @@ -2123,6 +3031,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); } @@ -2149,6 +3059,9 @@ walk_alter_subreg (x) case SUBREG: return alter_subreg (x); + + default: + break; } return x; @@ -2207,6 +3120,9 @@ alter_cond (cond) PUT_CODE (cond, NE); value = 2; break; + + default: + break; } if (cc_status.flags & CC_NOT_NEGATIVE) @@ -2233,6 +3149,9 @@ alter_cond (cond) PUT_CODE (cond, NE); value = 2; break; + + default: + break; } if (cc_status.flags & CC_NO_OVERFLOW) @@ -2255,19 +3174,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: @@ -2305,6 +3220,9 @@ alter_cond (cond) PUT_CODE (cond, GEU); value = 2; break; + + default: + break; } return value; @@ -2321,7 +3239,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. */ @@ -2370,7 +3288,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. */ @@ -2384,7 +3302,7 @@ output_asm_insn (template, operands) ASM_OUTPUT_OPCODE (asm_out_file, p); #endif - while (c = *p++) + while ((c = *p++)) switch (c) { case '\n': @@ -2402,16 +3320,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 '|': @@ -2452,7 +3374,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]); @@ -2468,12 +3390,7 @@ output_asm_insn (template, operands) else if (letter == 'n') { if (GET_CODE (operands[c]) == CONST_INT) - fprintf (asm_out_file, -#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT - "%d", -#else - "%ld", -#endif + fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, - INTVAL (operands[c])); else { @@ -2490,7 +3407,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); @@ -2609,13 +3526,7 @@ output_addr_const (file, x) break; case CONST_INT: - fprintf (file, -#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT - "%d", -#else - "%ld", -#endif - INTVAL (x)); + fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x)); break; case CONST: @@ -2629,37 +3540,12 @@ output_addr_const (file, x) { /* We can use %d if the number is one word and positive. */ if (CONST_DOUBLE_HIGH (x)) - fprintf (file, -#if HOST_BITS_PER_WIDE_INT == 64 -#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT - "0x%lx%016lx", -#else - "0x%x%016x", -#endif -#else -#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT - "0x%lx%08lx", -#else - "0x%x%08x", -#endif -#endif + fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX, CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x)); else if (CONST_DOUBLE_LOW (x) < 0) - fprintf (file, -#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT - "0x%x", -#else - "0x%lx", -#endif - CONST_DOUBLE_LOW (x)); + fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x)); else - fprintf (file, -#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT - "%d", -#else - "%ld", -#endif - CONST_DOUBLE_LOW (x)); + fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x)); } else /* We can't handle floating point constants; @@ -2735,32 +3621,35 @@ asm_fprintf VPROTO((FILE *file, char *p, ...)) va_list argptr; char buf[10]; char *q, c; - int i; VA_START (argptr, p); #ifndef __STDC__ - file = va_arg (argptr, FILE*); - p = va_arg (argptr, char*); + 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 '|': @@ -2800,9 +3689,15 @@ asm_fprintf VPROTO((FILE *file, char *p, ...)) but we do not check for those cases. It means that the value is a HOST_WIDE_INT, which may be either `int' or `long'. */ -#if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT +#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT +#else +#if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG + *q++ = 'l'; +#else + *q++ = 'l'; *q++ = 'l'; #endif +#endif *q++ = *p++; *q = 0; @@ -2885,16 +3780,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; @@ -2963,7 +3860,7 @@ split_double (value, first, second) /* Note, this converts the REAL_VALUE_TYPE to the target's format, splits up the floating point double and outputs exactly 32 bits of it into each of l[0] and l[1] -- - not necessarily BITS_PER_WORD bits. */ + not necessarily BITS_PER_WORD bits. */ REAL_VALUE_TO_TARGET_DOUBLE (r, l); *first = GEN_INT ((HOST_WIDE_INT) l[0]); @@ -3002,7 +3899,7 @@ leaf_function_p () { rtx insn; - if (profile_flag || profile_block_flag) + if (profile_flag || profile_block_flag || profile_arc_flag) return 0; for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) @@ -3049,11 +3946,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; } |
