gcc/final.c

   1 /* Convert RTL to assembler code and output it, for GNU compiler.
   2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
   3    1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /* This is the final pass of the compiler.
  23    It looks at the rtl code for a function and outputs assembler code.
  24
  25    Call `final_start_function' to output the assembler code for function entry,
  26    `final' to output assembler code for some RTL code,
  27    `final_end_function' to output assembler code for function exit.
  28    If a function is compiled in several pieces, each piece is
  29    output separately with `final'.
  30
  31    Some optimizations are also done at this level.
  32    Move instructions that were made unnecessary by good register allocation
  33    are detected and omitted from the output.  (Though most of these
  34    are removed by the last jump pass.)
  35
  36    Instructions to set the condition codes are omitted when it can be
  37    seen that the condition codes already had the desired values.
  38
  39    In some cases it is sufficient if the inherited condition codes
  40    have related values, but this may require the following insn
  41    (the one that tests the condition codes) to be modified.
  42
  43    The code for the function prologue and epilogue are generated
  44    directly as assembler code by the macros FUNCTION_PROLOGUE and
  45    FUNCTION_EPILOGUE.  Those instructions never exist as rtl.  */
  46
  47 #include "config.h"
  48 #include "system.h"
  49
  50 #include "tree.h"
  51 #include "rtl.h"
  52 #include "tm_p.h"
  53 #include "regs.h"
  54 #include "insn-config.h"
  55 #include "insn-flags.h"
  56 #include "insn-attr.h"
  57 #include "insn-codes.h"
  58 #include "recog.h"
  59 #include "conditions.h"
  60 #include "flags.h"
  61 #include "real.h"
  62 #include "hard-reg-set.h"
  63 #include "output.h"
  64 #include "except.h"
  65 #include "function.h"
  66 #include "toplev.h"
  67 #include "reload.h"
  68 #include "intl.h"
  69 #include "basic-block.h"
  70
  71 /* Get N_SLINE and N_SOL from stab.h if we can expect the file to exist.  */
  72 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
  73 #include "dbxout.h"
  74 #if defined (USG) || !defined (HAVE_STAB_H)
  75 #include "gstab.h"  /* If doing DBX on sysV, use our own stab.h.  */
  76 #else
  77 #include <stab.h>
  78 #endif
  79
  80 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
  81
  82 #ifndef ACCUMULATE_OUTGOING_ARGS
  83 #define ACCUMULATE_OUTGOING_ARGS 0
  84 #endif
  85
  86 #ifdef XCOFF_DEBUGGING_INFO
  87 #include "xcoffout.h"
  88 #endif
  89
  90 #ifdef DWARF_DEBUGGING_INFO
  91 #include "dwarfout.h"
  92 #endif
  93
  94 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
  95 #include "dwarf2out.h"
  96 #endif
  97
  98 #ifdef SDB_DEBUGGING_INFO
  99 #include "sdbout.h"
 100 #endif
 101
 102 /* .stabd code for line number.  */
 103 #ifndef N_SLINE
 104 #define N_SLINE 0x44
 105 #endif
 106
 107 /* .stabs code for included file name.  */
 108 #ifndef N_SOL
 109 #define N_SOL 0x84
 110 #endif
 111
 112 /* If we aren't using cc0, CC_STATUS_INIT shouldn't exist.  So define a
 113    null default for it to save conditionalization later.  */
 114 #ifndef CC_STATUS_INIT
 115 #define CC_STATUS_INIT
 116 #endif
 117
 118 /* How to start an assembler comment.  */
 119 #ifndef ASM_COMMENT_START
 120 #define ASM_COMMENT_START ";#"
 121 #endif
 122
 123 /* Is the given character a logical line separator for the assembler?  */
 124 #ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
 125 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C) ((C) == ';')
 126 #endif
 127
 128 #ifndef JUMP_TABLES_IN_TEXT_SECTION
 129 #define JUMP_TABLES_IN_TEXT_SECTION 0
 130 #endif
 131
 132 /* Last insn processed by final_scan_insn.  */
 133 static rtx debug_insn;
 134 rtx current_output_insn;
 135
 136 /* Line number of last NOTE.  */
 137 static int last_linenum;
 138
 139 /* Highest line number in current block.  */
 140 static int high_block_linenum;
 141
 142 /* Likewise for function.  */
 143 static int high_function_linenum;
 144
 145 /* Filename of last NOTE.  */
 146 static const char *last_filename;
 147
 148 /* Number of basic blocks seen so far;
 149    used if profile_block_flag is set.  */
 150 static int count_basic_blocks;
 151
 152 /* Number of instrumented arcs when profile_arc_flag is set.  */
 153 extern int count_instrumented_edges;
 154
 155 extern int length_unit_log; /* This is defined in insn-attrtab.c.  */
 156
 157 /* Nonzero while outputting an `asm' with operands.
 158    This means that inconsistencies are the user's fault, so don't abort.
 159    The precise value is the insn being output, to pass to error_for_asm.  */
 160 static rtx this_is_asm_operands;
 161
 162 /* Number of operands of this insn, for an `asm' with operands.  */
 163 static unsigned int insn_noperands;
 164
 165 /* Compare optimization flag.  */
 166
 167 static rtx last_ignored_compare = 0;
 168
 169 /* Flag indicating this insn is the start of a new basic block.  */
 170
 171 static int new_block = 1;
 172
 173 /* Assign a unique number to each insn that is output.
 174    This can be used to generate unique local labels.  */
 175
 176 static int insn_counter = 0;
 177
 178 #ifdef HAVE_cc0
 179 /* This variable contains machine-dependent flags (defined in tm.h)
 180    set and examined by output routines
 181    that describe how to interpret the condition codes properly.  */
 182
 183 CC_STATUS cc_status;
 184
 185 /* During output of an insn, this contains a copy of cc_status
 186    from before the insn.  */
 187
 188 CC_STATUS cc_prev_status;
 189 #endif
 190
 191 /* Indexed by hardware reg number, is 1 if that register is ever
 192    used in the current function.
 193
 194    In life_analysis, or in stupid_life_analysis, this is set
 195    up to record the hard regs used explicitly.  Reload adds
 196    in the hard regs used for holding pseudo regs.  Final uses
 197    it to generate the code in the function prologue and epilogue
 198    to save and restore registers as needed.  */
 199
 200 char regs_ever_live[FIRST_PSEUDO_REGISTER];
 201
 202 /* Nonzero means current function must be given a frame pointer.
 203    Set in stmt.c if anything is allocated on the stack there.
 204    Set in reload1.c if anything is allocated on the stack there.  */
 205
 206 int frame_pointer_needed;
 207
 208 /* Number of unmatched NOTE_INSN_BLOCK_BEG notes we have seen.  */
 209
 210 static int block_depth;
 211
 212 /* Nonzero if have enabled APP processing of our assembler output.  */
 213
 214 static int app_on;
 215
 216 /* If we are outputting an insn sequence, this contains the sequence rtx.
 217    Zero otherwise.  */
 218
 219 rtx final_sequence;
 220
 221 #ifdef ASSEMBLER_DIALECT
 222
 223 /* Number of the assembler dialect to use, starting at 0.  */
 224 static int dialect_number;
 225 #endif
 226
 227 /* Indexed by line number, nonzero if there is a note for that line.  */
 228
 229 static char *line_note_exists;
 230
 231 #ifdef HAVE_conditional_execution
 232 /* Nonnull if the insn currently being emitted was a COND_EXEC pattern.  */
 233 rtx current_insn_predicate;
 234 #endif
 235
 236 /* Linked list to hold line numbers for each basic block.  */
 237
 238 struct bb_list
 239 {
 240   struct bb_list *next;         /* pointer to next basic block */
 241   int line_num;                 /* line number */
 242   int file_label_num;           /* LPBC<n> label # for stored filename */
 243   int func_label_num;           /* LPBC<n> label # for stored function name */
 244 };
 245
 246 static struct bb_list *bb_head  = 0;            /* Head of basic block list */
 247 static struct bb_list **bb_tail = &bb_head;     /* Ptr to store next bb ptr */
 248 static int bb_file_label_num    = -1;           /* Current label # for file */
 249 static int bb_func_label_num    = -1;           /* Current label # for func */
 250
 251 /* Linked list to hold the strings for each file and function name output.  */
 252
 253 struct bb_str
 254 {
 255   struct bb_str *next;          /* pointer to next string */
 256   const char *string;           /* string */
 257   int label_num;                /* label number */
 258   int length;                   /* string length */
 259 };
 260
 261 static struct bb_str *sbb_head  = 0;            /* Head of string list.  */
 262 static struct bb_str **sbb_tail = &sbb_head;    /* Ptr to store next bb str */
 263 static int sbb_label_num        = 0;            /* Last label used */
 264
 265 #ifdef HAVE_ATTR_length
 266 static int asm_insn_count       PARAMS ((rtx));
 267 #endif
 268 static void profile_function    PARAMS ((FILE *));
 269 static void profile_after_prologue PARAMS ((FILE *));
 270 static void add_bb              PARAMS ((FILE *));
 271 static int add_bb_string        PARAMS ((const char *, int));
 272 static void output_source_line  PARAMS ((FILE *, rtx));
 273 static rtx walk_alter_subreg    PARAMS ((rtx));
 274 static void output_asm_name     PARAMS ((void));
 275 static void output_operand      PARAMS ((rtx, int));
 276 #ifdef LEAF_REGISTERS
 277 static void leaf_renumber_regs  PARAMS ((rtx));
 278 #endif
 279 #ifdef HAVE_cc0
 280 static int alter_cond           PARAMS ((rtx));
 281 #endif
 282 #ifndef ADDR_VEC_ALIGN
 283 static int final_addr_vec_align PARAMS ((rtx));
 284 #endif
 285 #ifdef HAVE_ATTR_length
 286 static int align_fuzz           PARAMS ((rtx, rtx, int, unsigned));
 287 #endif
 288 \f
 289 /* Initialize data in final at the beginning of a compilation.  */
 290
 291 void
 292 init_final (filename)
 293      const char *filename ATTRIBUTE_UNUSED;
 294 {
 295   app_on = 0;
 296   final_sequence = 0;
 297
 298 #ifdef ASSEMBLER_DIALECT
 299   dialect_number = ASSEMBLER_DIALECT;
 300 #endif
 301 }
 302
 303 /* Called at end of source file,
 304    to output the block-profiling table for this entire compilation.  */
 305
 306 void
 307 end_final (filename)
 308      const char *filename;
 309 {
 310   int i;
 311
 312   if (profile_block_flag || profile_arc_flag)
 313     {
 314       char name[20];
 315       int align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT);
 316       int size, rounded;
 317       struct bb_list *ptr;
 318       struct bb_str *sptr;
 319       int long_bytes = LONG_TYPE_SIZE / BITS_PER_UNIT;
 320       int pointer_bytes = POINTER_SIZE / BITS_PER_UNIT;
 321
 322       if (profile_block_flag)
 323         size = long_bytes * count_basic_blocks;
 324       else
 325         size = long_bytes * count_instrumented_edges;
 326       rounded = size;
 327
 328       rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
 329       rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
 330                  * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
 331
 332       data_section ();
 333
 334       /* Output the main header, of 11 words:
 335          0:  1 if this file is initialized, else 0.
 336          1:  address of file name (LPBX1).
 337          2:  address of table of counts (LPBX2).
 338          3:  number of counts in the table.
 339          4:  always 0, for compatibility with Sun.
 340
 341          The following are GNU extensions:
 342
 343          5:  address of table of start addrs of basic blocks (LPBX3).
 344          6:  Number of bytes in this header.
 345          7:  address of table of function names (LPBX4).
 346          8:  address of table of line numbers (LPBX5) or 0.
 347          9:  address of table of file names (LPBX6) or 0.
 348         10:  space reserved for basic block profiling.  */
 349
 350       ASM_OUTPUT_ALIGN (asm_out_file, align);
 351
 352       ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 0);
 353       /* zero word */
 354       assemble_integer (const0_rtx, long_bytes, 1);
 355
 356       /* address of filename */
 357       ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 1);
 358       assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
 359
 360       /* address of count table */
 361       ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
 362       assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
 363
 364       /* count of the # of basic blocks or # of instrumented arcs */
 365       if (profile_block_flag)
 366         assemble_integer (GEN_INT (count_basic_blocks), long_bytes, 1);
 367       else
 368         assemble_integer (GEN_INT (count_instrumented_edges), long_bytes, 1);
 369
 370       /* zero word (link field) */
 371       assemble_integer (const0_rtx, pointer_bytes, 1);
 372
 373       /* address of basic block start address table */
 374       if (profile_block_flag)
 375         {
 376           ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
 377           assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
 378                             1);
 379         }
 380       else
 381         assemble_integer (const0_rtx, pointer_bytes, 1);
 382
 383       /* byte count for extended structure.  */
 384       assemble_integer (GEN_INT (11 * UNITS_PER_WORD), long_bytes, 1);
 385
 386       /* address of function name table */
 387       if (profile_block_flag)
 388         {
 389           ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4);
 390           assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
 391                             1);
 392         }
 393       else
 394         assemble_integer (const0_rtx, pointer_bytes, 1);
 395
 396       /* address of line number and filename tables if debugging.  */
 397       if (write_symbols != NO_DEBUG && profile_block_flag)
 398         {
 399           ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5);
 400           assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
 401                             pointer_bytes, 1);
 402           ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 6);
 403           assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
 404                             pointer_bytes, 1);
 405         }
 406       else
 407         {
 408           assemble_integer (const0_rtx, pointer_bytes, 1);
 409           assemble_integer (const0_rtx, pointer_bytes, 1);
 410         }
 411
 412       /* space for extension ptr (link field) */
 413       assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
 414
 415       /* Output the file name changing the suffix to .d for Sun tcov
 416          compatibility.  */
 417       ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 1);
 418       {
 419         char *cwd = getpwd ();
 420         int len = strlen (filename) + strlen (cwd) + 1;
 421         char *data_file = (char *) alloca (len + 4);
 422
 423         strcpy (data_file, cwd);
 424         strcat (data_file, "/");
 425         strcat (data_file, filename);
 426         strip_off_ending (data_file, len);
 427         if (profile_block_flag)
 428           strcat (data_file, ".d");
 429         else
 430           strcat (data_file, ".da");
 431         assemble_string (data_file, strlen (data_file) + 1);
 432       }
 433
 434       /* Make space for the table of counts.  */
 435       if (size == 0)
 436         {
 437           /* Realign data section.  */
 438           ASM_OUTPUT_ALIGN (asm_out_file, align);
 439           ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 2);
 440           if (size != 0)
 441             assemble_zeros (size);
 442         }
 443       else
 444         {
 445           ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
 446 #ifdef ASM_OUTPUT_SHARED_LOCAL
 447           if (flag_shared_data)
 448             ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
 449           else
 450 #endif
 451 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
 452             ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name,
 453                                            size, BIGGEST_ALIGNMENT);
 454 #else
 455 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
 456             ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
 457                                       BIGGEST_ALIGNMENT);
 458 #else
 459             ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
 460 #endif
 461 #endif
 462         }
 463
 464       /* Output any basic block strings */
 465       if (profile_block_flag)
 466         {
 467           readonly_data_section ();
 468           if (sbb_head)
 469             {
 470               ASM_OUTPUT_ALIGN (asm_out_file, align);
 471               for (sptr = sbb_head; sptr != 0; sptr = sptr->next)
 472                 {
 473                   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBC",
 474                                              sptr->label_num);
 475                   assemble_string (sptr->string, sptr->length);
 476                 }
 477             }
 478         }
 479
 480       /* Output the table of addresses.  */
 481       if (profile_block_flag)
 482         {
 483           /* Realign in new section */
 484           ASM_OUTPUT_ALIGN (asm_out_file, align);
 485           ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 3);
 486           for (i = 0; i < count_basic_blocks; i++)
 487             {
 488               ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i);
 489               assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
 490                                 pointer_bytes, 1);
 491             }
 492         }
 493
 494       /* Output the table of function names.  */
 495       if (profile_block_flag)
 496         {
 497           ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 4);
 498           for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
 499             {
 500               if (ptr->func_label_num >= 0)
 501                 {
 502                   ASM_GENERATE_INTERNAL_LABEL (name, "LPBC",
 503                                                ptr->func_label_num);
 504                   assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
 505                                     pointer_bytes, 1);
 506                 }
 507               else
 508                 assemble_integer (const0_rtx, pointer_bytes, 1);
 509             }
 510
 511           for (; i < count_basic_blocks; i++)
 512             assemble_integer (const0_rtx, pointer_bytes, 1);
 513         }
 514
 515       if (write_symbols != NO_DEBUG && profile_block_flag)
 516         {
 517           /* Output the table of line numbers.  */
 518           ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 5);
 519           for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
 520             assemble_integer (GEN_INT (ptr->line_num), long_bytes, 1);
 521
 522           for (; i < count_basic_blocks; i++)
 523             assemble_integer (const0_rtx, long_bytes, 1);
 524
 525           /* Output the table of file names.  */
 526           ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 6);
 527           for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
 528             {
 529               if (ptr->file_label_num >= 0)
 530                 {
 531                   ASM_GENERATE_INTERNAL_LABEL (name, "LPBC",
 532                                                ptr->file_label_num);
 533                   assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
 534                                     pointer_bytes, 1);
 535                 }
 536               else
 537                 assemble_integer (const0_rtx, pointer_bytes, 1);
 538             }
 539
 540           for (; i < count_basic_blocks; i++)
 541             assemble_integer (const0_rtx, pointer_bytes, 1);
 542         }
 543
 544       /* End with the address of the table of addresses,
 545          so we can find it easily, as the last word in the file's text.  */
 546       if (profile_block_flag)
 547         {
 548           ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
 549           assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes,
 550                             1);
 551         }
 552     }
 553 }
 554
 555 /* Enable APP processing of subsequent output.
 556    Used before the output from an `asm' statement.  */
 557
 558 void
 559 app_enable ()
 560 {
 561   if (! app_on)
 562     {
 563       fputs (ASM_APP_ON, asm_out_file);
 564       app_on = 1;
 565     }
 566 }
 567
 568 /* Disable APP processing of subsequent output.
 569    Called from varasm.c before most kinds of output.  */
 570
 571 void
 572 app_disable ()
 573 {
 574   if (app_on)
 575     {
 576       fputs (ASM_APP_OFF, asm_out_file);
 577       app_on = 0;
 578     }
 579 }
 580 \f
 581 /* Return the number of slots filled in the current
 582    delayed branch sequence (we don't count the insn needing the
 583    delay slot).   Zero if not in a delayed branch sequence.  */
 584
 585 #ifdef DELAY_SLOTS
 586 int
 587 dbr_sequence_length ()
 588 {
 589   if (final_sequence != 0)
 590     return XVECLEN (final_sequence, 0) - 1;
 591   else
 592     return 0;
 593 }
 594 #endif
 595 \f
 596 /* The next two pages contain routines used to compute the length of an insn
 597    and to shorten branches.  */
 598
 599 /* Arrays for insn lengths, and addresses.  The latter is referenced by
 600    `insn_current_length'.  */
 601
 602 static short *insn_lengths;
 603
 604 #ifdef HAVE_ATTR_length
 605 varray_type insn_addresses_;
 606 #endif
 607
 608 /* Max uid for which the above arrays are valid.  */
 609 static int insn_lengths_max_uid;
 610
 611 /* Address of insn being processed.  Used by `insn_current_length'.  */
 612 int insn_current_address;
 613
 614 /* Address of insn being processed in previous iteration.  */
 615 int insn_last_address;
 616
 617 /* konwn invariant alignment of insn being processed.  */
 618 int insn_current_align;
 619
 620 /* After shorten_branches, for any insn, uid_align[INSN_UID (insn)]
 621    gives the next following alignment insn that increases the known
 622    alignment, or NULL_RTX if there is no such insn.
 623    For any alignment obtained this way, we can again index uid_align with
 624    its uid to obtain the next following align that in turn increases the
 625    alignment, till we reach NULL_RTX; the sequence obtained this way
 626    for each insn we'll call the alignment chain of this insn in the following
 627    comments.  */
 628
 629 struct label_alignment
 630 {
 631   short alignment;
 632   short max_skip;
 633 };
 634
 635 static rtx *uid_align;
 636 static int *uid_shuid;
 637 static struct label_alignment *label_align;
 638
 639 /* Indicate that branch shortening hasn't yet been done.  */
 640
 641 void
 642 init_insn_lengths ()
 643 {
 644   if (label_align)
 645     {
 646       free (label_align);
 647       label_align = 0;
 648     }
 649   if (uid_shuid)
 650     {
 651       free (uid_shuid);
 652       uid_shuid = 0;
 653     }
 654   if (insn_lengths)
 655     {
 656       free (insn_lengths);
 657       insn_lengths = 0;
 658       insn_lengths_max_uid = 0;
 659     }
 660 #ifdef HAVE_ATTR_length
 661   INSN_ADDRESSES_FREE ();
 662 #endif
 663   if (uid_align)
 664     {
 665       free (uid_align);
 666       uid_align = 0;
 667     }
 668 }
 669
 670 /* Obtain the current length of an insn.  If branch shortening has been done,
 671    get its actual length.  Otherwise, get its maximum length.  */
 672
 673 int
 674 get_attr_length (insn)
 675      rtx insn ATTRIBUTE_UNUSED;
 676 {
 677 #ifdef HAVE_ATTR_length
 678   rtx body;
 679   int i;
 680   int length = 0;
 681
 682   if (insn_lengths_max_uid > INSN_UID (insn))
 683     return insn_lengths[INSN_UID (insn)];
 684   else
 685     switch (GET_CODE (insn))
 686       {
 687       case NOTE:
 688       case BARRIER:
 689       case CODE_LABEL:
 690         return 0;
 691
 692       case CALL_INSN:
 693         length = insn_default_length (insn);
 694         break;
 695
 696       case JUMP_INSN:
 697         body = PATTERN (insn);
 698         if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
 699           {
 700             /* Alignment is machine-dependent and should be handled by
 701                ADDR_VEC_ALIGN.  */
 702           }
 703         else
 704           length = insn_default_length (insn);
 705         break;
 706
 707       case INSN:
 708         body = PATTERN (insn);
 709         if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
 710           return 0;
 711
 712         else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
 713           length = asm_insn_count (body) * insn_default_length (insn);
 714         else if (GET_CODE (body) == SEQUENCE)
 715           for (i = 0; i < XVECLEN (body, 0); i++)
 716             length += get_attr_length (XVECEXP (body, 0, i));
 717         else
 718           length = insn_default_length (insn);
 719         break;
 720
 721       default:
 722         break;
 723       }
 724
 725 #ifdef ADJUST_INSN_LENGTH
 726   ADJUST_INSN_LENGTH (insn, length);
 727 #endif
 728   return length;
 729 #else /* not HAVE_ATTR_length */
 730   return 0;
 731 #endif /* not HAVE_ATTR_length */
 732 }
 733 \f
 734 /* Code to handle alignment inside shorten_branches.  */
 735
 736 /* Here is an explanation how the algorithm in align_fuzz can give
 737    proper results:
 738
 739    Call a sequence of instructions beginning with alignment point X
 740    and continuing until the next alignment point `block X'.  When `X'
 741    is used in an expression, it means the alignment value of the
 742    alignment point.
 743
 744    Call the distance between the start of the first insn of block X, and
 745    the end of the last insn of block X `IX', for the `inner size of X'.
 746    This is clearly the sum of the instruction lengths.
 747
 748    Likewise with the next alignment-delimited block following X, which we
 749    shall call block Y.
 750
 751    Call the distance between the start of the first insn of block X, and
 752    the start of the first insn of block Y `OX', for the `outer size of X'.
 753
 754    The estimated padding is then OX - IX.
 755
 756    OX can be safely estimated as
 757
 758            if (X >= Y)
 759                    OX = round_up(IX, Y)
 760            else
 761                    OX = round_up(IX, X) + Y - X
 762
 763    Clearly est(IX) >= real(IX), because that only depends on the
 764    instruction lengths, and those being overestimated is a given.
 765
 766    Clearly round_up(foo, Z) >= round_up(bar, Z) if foo >= bar, so
 767    we needn't worry about that when thinking about OX.
 768
 769    When X >= Y, the alignment provided by Y adds no uncertainty factor
 770    for branch ranges starting before X, so we can just round what we have.
 771    But when X < Y, we don't know anything about the, so to speak,
 772    `middle bits', so we have to assume the worst when aligning up from an
 773    address mod X to one mod Y, which is Y - X.  */
 774
 775 #ifndef LABEL_ALIGN
 776 #define LABEL_ALIGN(LABEL) align_labels_log
 777 #endif
 778
 779 #ifndef LABEL_ALIGN_MAX_SKIP
 780 #define LABEL_ALIGN_MAX_SKIP (align_labels-1)
 781 #endif
 782
 783 #ifndef LOOP_ALIGN
 784 #define LOOP_ALIGN(LABEL) align_loops_log
 785 #endif
 786
 787 #ifndef LOOP_ALIGN_MAX_SKIP
 788 #define LOOP_ALIGN_MAX_SKIP (align_loops-1)
 789 #endif
 790
 791 #ifndef LABEL_ALIGN_AFTER_BARRIER
 792 #define LABEL_ALIGN_AFTER_BARRIER(LABEL) align_jumps_log
 793 #endif
 794
 795 #ifndef LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP
 796 #define LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP (align_jumps-1)
 797 #endif
 798
 799 #ifndef ADDR_VEC_ALIGN
 800 static int
 801 final_addr_vec_align (addr_vec)
 802      rtx addr_vec;
 803 {
 804   int align = GET_MODE_SIZE (GET_MODE (PATTERN (addr_vec)));
 805
 806   if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
 807     align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
 808   return exact_log2 (align);
 809
 810 }
 811
 812 #define ADDR_VEC_ALIGN(ADDR_VEC) final_addr_vec_align (ADDR_VEC)
 813 #endif
 814
 815 #ifndef INSN_LENGTH_ALIGNMENT
 816 #define INSN_LENGTH_ALIGNMENT(INSN) length_unit_log
 817 #endif
 818
 819 #define INSN_SHUID(INSN) (uid_shuid[INSN_UID (INSN)])
 820
 821 static int min_labelno, max_labelno;
 822
 823 #define LABEL_TO_ALIGNMENT(LABEL) \
 824   (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].alignment)
 825
 826 #define LABEL_TO_MAX_SKIP(LABEL) \
 827   (label_align[CODE_LABEL_NUMBER (LABEL) - min_labelno].max_skip)
 828
 829 /* For the benefit of port specific code do this also as a function.  */
 830
 831 int
 832 label_to_alignment (label)
 833      rtx label;
 834 {
 835   return LABEL_TO_ALIGNMENT (label);
 836 }
 837
 838 #ifdef HAVE_ATTR_length
 839 /* The differences in addresses
 840    between a branch and its target might grow or shrink depending on
 841    the alignment the start insn of the range (the branch for a forward
 842    branch or the label for a backward branch) starts out on; if these
 843    differences are used naively, they can even oscillate infinitely.
 844    We therefore want to compute a 'worst case' address difference that
 845    is independent of the alignment the start insn of the range end
 846    up on, and that is at least as large as the actual difference.
 847    The function align_fuzz calculates the amount we have to add to the
 848    naively computed difference, by traversing the part of the alignment
 849    chain of the start insn of the range that is in front of the end insn
 850    of the range, and considering for each alignment the maximum amount
 851    that it might contribute to a size increase.
 852
 853    For casesi tables, we also want to know worst case minimum amounts of
 854    address difference, in case a machine description wants to introduce
 855    some common offset that is added to all offsets in a table.
 856    For this purpose, align_fuzz with a growth argument of 0 comuptes the
 857    appropriate adjustment.  */
 858
 859 /* Compute the maximum delta by which the difference of the addresses of
 860    START and END might grow / shrink due to a different address for start
 861    which changes the size of alignment insns between START and END.
 862    KNOWN_ALIGN_LOG is the alignment known for START.
 863    GROWTH should be ~0 if the objective is to compute potential code size
 864    increase, and 0 if the objective is to compute potential shrink.
 865    The return value is undefined for any other value of GROWTH.  */
 866
 867 static int
 868 align_fuzz (start, end, known_align_log, growth)
 869      rtx start, end;
 870      int known_align_log;
 871      unsigned growth;
 872 {
 873   int uid = INSN_UID (start);
 874   rtx align_label;
 875   int known_align = 1 << known_align_log;
 876   int end_shuid = INSN_SHUID (end);
 877   int fuzz = 0;
 878
 879   for (align_label = uid_align[uid]; align_label; align_label = uid_align[uid])
 880     {
 881       int align_addr, new_align;
 882
 883       uid = INSN_UID (align_label);
 884       align_addr = INSN_ADDRESSES (uid) - insn_lengths[uid];
 885       if (uid_shuid[uid] > end_shuid)
 886         break;
 887       known_align_log = LABEL_TO_ALIGNMENT (align_label);
 888       new_align = 1 << known_align_log;
 889       if (new_align < known_align)
 890         continue;
 891       fuzz += (-align_addr ^ growth) & (new_align - known_align);
 892       known_align = new_align;
 893     }
 894   return fuzz;
 895 }
 896
 897 /* Compute a worst-case reference address of a branch so that it
 898    can be safely used in the presence of aligned labels.  Since the
 899    size of the branch itself is unknown, the size of the branch is
 900    not included in the range.  I.e. for a forward branch, the reference
 901    address is the end address of the branch as known from the previous
 902    branch shortening pass, minus a value to account for possible size
 903    increase due to alignment.  For a backward branch, it is the start
 904    address of the branch as known from the current pass, plus a value
 905    to account for possible size increase due to alignment.
 906    NB.: Therefore, the maximum offset allowed for backward branches needs
 907    to exclude the branch size.  */
 908
 909 int
 910 insn_current_reference_address (branch)
 911      rtx branch;
 912 {
 913   rtx dest, seq;
 914   int seq_uid;
 915
 916   if (! INSN_ADDRESSES_SET_P ())
 917     return 0;
 918
 919   seq = NEXT_INSN (PREV_INSN (branch));
 920   seq_uid = INSN_UID (seq);
 921   if (GET_CODE (branch) != JUMP_INSN)
 922     /* This can happen for example on the PA; the objective is to know the
 923        offset to address something in front of the start of the function.
 924        Thus, we can treat it like a backward branch.
 925        We assume here that FUNCTION_BOUNDARY / BITS_PER_UNIT is larger than
 926        any alignment we'd encounter, so we skip the call to align_fuzz.  */
 927     return insn_current_address;
 928   dest = JUMP_LABEL (branch);
 929
 930   /* BRANCH has no proper alignment chain set, so use SEQ.
 931      BRANCH also has no INSN_SHUID.  */
 932   if (INSN_SHUID (seq) < INSN_SHUID (dest))
 933     {
 934       /* Forward branch.  */
 935       return (insn_last_address + insn_lengths[seq_uid]
 936               - align_fuzz (seq, dest, length_unit_log, ~0));
 937     }
 938   else
 939     {
 940       /* Backward branch.  */
 941       return (insn_current_address
 942               + align_fuzz (dest, seq, length_unit_log, ~0));
 943     }
 944 }
 945 #endif /* HAVE_ATTR_length */
 946 \f
 947 /* Make a pass over all insns and compute their actual lengths by shortening
 948    any branches of variable length if possible.  */
 949
 950 /* Give a default value for the lowest address in a function.  */
 951
 952 #ifndef FIRST_INSN_ADDRESS
 953 #define FIRST_INSN_ADDRESS 0
 954 #endif
 955
 956 /* shorten_branches might be called multiple times:  for example, the SH
 957    port splits out-of-range conditional branches in MACHINE_DEPENDENT_REORG.
 958    In order to do this, it needs proper length information, which it obtains
 959    by calling shorten_branches.  This cannot be collapsed with
 960    shorten_branches itself into a single pass unless we also want to intergate
 961    reorg.c, since the branch splitting exposes new instructions with delay
 962    slots.  */
 963
 964 void
 965 shorten_branches (first)
 966      rtx first ATTRIBUTE_UNUSED;
 967 {
 968   rtx insn;
 969   int max_uid;
 970   int i;
 971   int max_log;
 972   int max_skip;
 973 #ifdef HAVE_ATTR_length
 974 #define MAX_CODE_ALIGN 16
 975   rtx seq;
 976   int something_changed = 1;
 977   char *varying_length;
 978   rtx body;
 979   int uid;
 980   rtx align_tab[MAX_CODE_ALIGN];
 981
 982   /* In order to make sure that all instructions have valid length info,
 983      we must split them before we compute the address/length info.  */
 984
 985   for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn))
 986     if (INSN_P (insn))
 987       {
 988         rtx old = insn;
 989         /* Don't split the insn if it has been deleted.  */
 990         if (! INSN_DELETED_P (old))
 991           insn = try_split (PATTERN (old), old, 1);
 992         /* When not optimizing, the old insn will be still left around
 993            with only the 'deleted' bit set.  Transform it into a note
 994            to avoid confusion of subsequent processing.  */
 995         if (INSN_DELETED_P (old))
 996           {
 997             PUT_CODE (old, NOTE);
 998             NOTE_LINE_NUMBER (old) = NOTE_INSN_DELETED;
 999             NOTE_SOURCE_FILE (old) = 0;
1000           }
1001       }
1002 #endif
1003
1004   /* We must do some computations even when not actually shortening, in
1005      order to get the alignment information for the labels.  */
1006
1007   init_insn_lengths ();
1008
1009   /* Compute maximum UID and allocate label_align / uid_shuid.  */
1010   max_uid = get_max_uid ();
1011
1012   max_labelno = max_label_num ();
1013   min_labelno = get_first_label_num ();
1014   label_align = (struct label_alignment *)
1015     xcalloc ((max_labelno - min_labelno + 1), sizeof (struct label_alignment));
1016
1017   uid_shuid = (int *) xmalloc (max_uid * sizeof *uid_shuid);
1018
1019   /* Initialize label_align and set up uid_shuid to be strictly
1020      monotonically rising with insn order.  */
1021   /* We use max_log here to keep track of the maximum alignment we want to
1022      impose on the next CODE_LABEL (or the current one if we are processing
1023      the CODE_LABEL itself).  */
1024
1025   max_log = 0;
1026   max_skip = 0;
1027
1028   for (insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn))
1029     {
1030       int log;
1031
1032       INSN_SHUID (insn) = i++;
1033       if (INSN_P (insn))
1034         {
1035           /* reorg might make the first insn of a loop being run once only,
1036              and delete the label in front of it.  Then we want to apply
1037              the loop alignment to the new label created by reorg, which
1038              is separated by the former loop start insn from the
1039              NOTE_INSN_LOOP_BEG.  */
1040         }
1041       else if (GET_CODE (insn) == CODE_LABEL)
1042         {
1043           rtx next;
1044
1045           log = LABEL_ALIGN (insn);
1046           if (max_log < log)
1047             {
1048               max_log = log;
1049               max_skip = LABEL_ALIGN_MAX_SKIP;
1050             }
1051           next = NEXT_INSN (insn);
1052           /* ADDR_VECs only take room if read-only data goes into the text
1053              section.  */
1054           if (JUMP_TABLES_IN_TEXT_SECTION
1055 #if !defined(READONLY_DATA_SECTION)
1056               || 1
1057 #endif
1058               )
1059             if (next && GET_CODE (next) == JUMP_INSN)
1060               {
1061                 rtx nextbody = PATTERN (next);
1062                 if (GET_CODE (nextbody) == ADDR_VEC
1063                     || GET_CODE (nextbody) == ADDR_DIFF_VEC)
1064                   {
1065                     log = ADDR_VEC_ALIGN (next);
1066                     if (max_log < log)
1067                       {
1068                         max_log = log;
1069                         max_skip = LABEL_ALIGN_MAX_SKIP;
1070                       }
1071                   }
1072               }
1073           LABEL_TO_ALIGNMENT (insn) = max_log;
1074           LABEL_TO_MAX_SKIP (insn) = max_skip;
1075           max_log = 0;
1076           max_skip = 0;
1077         }
1078       else if (GET_CODE (insn) == BARRIER)
1079         {
1080           rtx label;
1081
1082           for (label = insn; label && ! INSN_P (label);
1083                label = NEXT_INSN (label))
1084             if (GET_CODE (label) == CODE_LABEL)
1085               {
1086                 log = LABEL_ALIGN_AFTER_BARRIER (insn);
1087                 if (max_log < log)
1088                   {
1089                     max_log = log;
1090                     max_skip = LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP;
1091                   }
1092                 break;
1093               }
1094         }
1095       /* Again, we allow NOTE_INSN_LOOP_BEG - INSN - CODE_LABEL
1096          sequences in order to handle reorg output efficiently.  */
1097       else if (GET_CODE (insn) == NOTE
1098                && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
1099         {
1100           rtx label;
1101           int nest = 0;
1102
1103           /* Search for the label that starts the loop.
1104              Don't skip past the end of the loop, since that could
1105              lead to putting an alignment where it does not belong.
1106              However, a label after a nested (non-)loop would be OK.  */
1107           for (label = insn; label; label = NEXT_INSN (label))
1108             {
1109               if (GET_CODE (label) == NOTE
1110                   && NOTE_LINE_NUMBER (label) == NOTE_INSN_LOOP_BEG)
1111                 nest++;
1112               else if (GET_CODE (label) == NOTE
1113                        && NOTE_LINE_NUMBER (label) == NOTE_INSN_LOOP_END
1114                        && --nest == 0)
1115                 break;
1116               else if (GET_CODE (label) == CODE_LABEL)
1117                 {
1118                   log = LOOP_ALIGN (label);
1119                   if (max_log < log)
1120                     {
1121                       max_log = log;
1122                       max_skip = LOOP_ALIGN_MAX_SKIP;
1123                     }
1124                   break;
1125                 }
1126             }
1127         }
1128       else
1129         continue;
1130     }
1131 #ifdef HAVE_ATTR_length
1132
1133   /* Allocate the rest of the arrays.  */
1134   insn_lengths = (short *) xmalloc (max_uid * sizeof (short));
1135   insn_lengths_max_uid = max_uid;
1136   /* Syntax errors can lead to labels being outside of the main insn stream.
1137      Initialize insn_addresses, so that we get reproducible results.  */
1138   INSN_ADDRESSES_ALLOC (max_uid);
1139
1140   varying_length = (char *) xcalloc (max_uid, sizeof (char));
1141
1142   /* Initialize uid_align.  We scan instructions
1143      from end to start, and keep in align_tab[n] the last seen insn
1144      that does an alignment of at least n+1, i.e. the successor
1145      in the alignment chain for an insn that does / has a known
1146      alignment of n.  */
1147   uid_align = (rtx *) xcalloc (max_uid, sizeof *uid_align);
1148
1149   for (i = MAX_CODE_ALIGN; --i >= 0;)
1150     align_tab[i] = NULL_RTX;
1151   seq = get_last_insn ();
1152   for (; seq; seq = PREV_INSN (seq))
1153     {
1154       int uid = INSN_UID (seq);
1155       int log;
1156       log = (GET_CODE (seq) == CODE_LABEL ? LABEL_TO_ALIGNMENT (seq) : 0);
1157       uid_align[uid] = align_tab[0];
1158       if (log)
1159         {
1160           /* Found an alignment label.  */
1161           uid_align[uid] = align_tab[log];
1162           for (i = log - 1; i >= 0; i--)
1163             align_tab[i] = seq;
1164         }
1165     }
1166 #ifdef CASE_VECTOR_SHORTEN_MODE
1167   if (optimize)
1168     {
1169       /* Look for ADDR_DIFF_VECs, and initialize their minimum and maximum
1170          label fields.  */
1171
1172       int min_shuid = INSN_SHUID (get_insns ()) - 1;
1173       int max_shuid = INSN_SHUID (get_last_insn ()) + 1;
1174       int rel;
1175
1176       for (insn = first; insn != 0; insn = NEXT_INSN (insn))
1177         {
1178           rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat;
1179           int len, i, min, max, insn_shuid;
1180           int min_align;
1181           addr_diff_vec_flags flags;
1182
1183           if (GET_CODE (insn) != JUMP_INSN
1184               || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
1185             continue;
1186           pat = PATTERN (insn);
1187           len = XVECLEN (pat, 1);
1188           if (len <= 0)
1189             abort ();
1190           min_align = MAX_CODE_ALIGN;
1191           for (min = max_shuid, max = min_shuid, i = len - 1; i >= 0; i--)
1192             {
1193               rtx lab = XEXP (XVECEXP (pat, 1, i), 0);
1194               int shuid = INSN_SHUID (lab);
1195               if (shuid < min)
1196                 {
1197                   min = shuid;
1198                   min_lab = lab;
1199                 }
1200               if (shuid > max)
1201                 {
1202                   max = shuid;
1203                   max_lab = lab;
1204                 }
1205               if (min_align > LABEL_TO_ALIGNMENT (lab))
1206                 min_align = LABEL_TO_ALIGNMENT (lab);
1207             }
1208           XEXP (pat, 2) = gen_rtx_LABEL_REF (VOIDmode, min_lab);
1209           XEXP (pat, 3) = gen_rtx_LABEL_REF (VOIDmode, max_lab);
1210           insn_shuid = INSN_SHUID (insn);
1211           rel = INSN_SHUID (XEXP (XEXP (pat, 0), 0));
1212           flags.min_align = min_align;
1213           flags.base_after_vec = rel > insn_shuid;
1214           flags.min_after_vec  = min > insn_shuid;
1215           flags.max_after_vec  = max > insn_shuid;
1216           flags.min_after_base = min > rel;
1217           flags.max_after_base = max > rel;
1218           ADDR_DIFF_VEC_FLAGS (pat) = flags;
1219         }
1220     }
1221 #endif /* CASE_VECTOR_SHORTEN_MODE */
1222
1223   /* Compute initial lengths, addresses, and varying flags for each insn.  */
1224   for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
1225        insn != 0;
1226        insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
1227     {
1228       uid = INSN_UID (insn);
1229
1230       insn_lengths[uid] = 0;
1231
1232       if (GET_CODE (insn) == CODE_LABEL)
1233         {
1234           int log = LABEL_TO_ALIGNMENT (insn);
1235           if (log)
1236             {
1237               int align = 1 << log;
1238               int new_address = (insn_current_address + align - 1) & -align;
1239               insn_lengths[uid] = new_address - insn_current_address;
1240             }
1241         }
1242
1243       INSN_ADDRESSES (uid) = insn_current_address;
1244
1245       if (GET_CODE (insn) == NOTE || GET_CODE (insn) == BARRIER
1246           || GET_CODE (insn) == CODE_LABEL)
1247         continue;
1248       if (INSN_DELETED_P (insn))
1249         continue;
1250
1251       body = PATTERN (insn);
1252       if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
1253         {
1254           /* This only takes room if read-only data goes into the text
1255              section.  */
1256           if (JUMP_TABLES_IN_TEXT_SECTION
1257 #if !defined(READONLY_DATA_SECTION)
1258               || 1
1259 #endif
1260               )
1261             insn_lengths[uid] = (XVECLEN (body,
1262                                           GET_CODE (body) == ADDR_DIFF_VEC)
1263                                  * GET_MODE_SIZE (GET_MODE (body)));
1264           /* Alignment is handled by ADDR_VEC_ALIGN.  */
1265         }
1266       else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
1267         insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
1268       else if (GET_CODE (body) == SEQUENCE)
1269         {
1270           int i;
1271           int const_delay_slots;
1272 #ifdef DELAY_SLOTS
1273           const_delay_slots = const_num_delay_slots (XVECEXP (body, 0, 0));
1274 #else
1275           const_delay_slots = 0;
1276 #endif
1277           /* Inside a delay slot sequence, we do not do any branch shortening
1278              if the shortening could change the number of delay slots
1279              of the branch.  */
1280           for (i = 0; i < XVECLEN (body, 0); i++)
1281             {
1282               rtx inner_insn = XVECEXP (body, 0, i);
1283               int inner_uid = INSN_UID (inner_insn);
1284               int inner_length;
1285
1286               if (GET_CODE (body) == ASM_INPUT
1287                   || asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0)
1288                 inner_length = (asm_insn_count (PATTERN (inner_insn))
1289                                 * insn_default_length (inner_insn));
1290               else
1291                 inner_length = insn_default_length (inner_insn);
1292
1293               insn_lengths[inner_uid] = inner_length;
1294               if (const_delay_slots)
1295                 {
1296                   if ((varying_length[inner_uid]
1297                        = insn_variable_length_p (inner_insn)) != 0)
1298                     varying_length[uid] = 1;
1299                   INSN_ADDRESSES (inner_uid) = (insn_current_address
1300                                                 + insn_lengths[uid]);
1301                 }
1302               else
1303                 varying_length[inner_uid] = 0;
1304               insn_lengths[uid] += inner_length;
1305             }
1306         }
1307       else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
1308         {
1309           insn_lengths[uid] = insn_default_length (insn);
1310           varying_length[uid] = insn_variable_length_p (insn);
1311         }
1312
1313       /* If needed, do any adjustment.  */
1314 #ifdef ADJUST_INSN_LENGTH
1315       ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
1316       if (insn_lengths[uid] < 0)
1317         fatal_insn ("Negative insn length", insn);
1318 #endif
1319     }
1320
1321   /* Now loop over all the insns finding varying length insns.  For each,
1322      get the current insn length.  If it has changed, reflect the change.
1323      When nothing changes for a full pass, we are done.  */
1324
1325   while (something_changed)
1326     {
1327       something_changed = 0;
1328       insn_current_align = MAX_CODE_ALIGN - 1;
1329       for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
1330            insn != 0;
1331            insn = NEXT_INSN (insn))
1332         {
1333           int new_length;
1334 #ifdef ADJUST_INSN_LENGTH
1335           int tmp_length;
1336 #endif
1337           int length_align;
1338
1339           uid = INSN_UID (insn);
1340
1341           if (GET_CODE (insn) == CODE_LABEL)
1342             {
1343               int log = LABEL_TO_ALIGNMENT (insn);
1344               if (log > insn_current_align)
1345                 {
1346                   int align = 1 << log;
1347                   int new_address= (insn_current_address + align - 1) & -align;
1348                   insn_lengths[uid] = new_address - insn_current_address;
1349                   insn_current_align = log;
1350                   insn_current_address = new_address;
1351                 }
1352               else
1353                 insn_lengths[uid] = 0;
1354               INSN_ADDRESSES (uid) = insn_current_address;
1355               continue;
1356             }
1357
1358           length_align = INSN_LENGTH_ALIGNMENT (insn);
1359           if (length_align < insn_current_align)
1360             insn_current_align = length_align;
1361
1362           insn_last_address = INSN_ADDRESSES (uid);
1363           INSN_ADDRESSES (uid) = insn_current_address;
1364
1365 #ifdef CASE_VECTOR_SHORTEN_MODE
1366           if (optimize && GET_CODE (insn) == JUMP_INSN
1367               && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
1368             {
1369               rtx body = PATTERN (insn);
1370               int old_length = insn_lengths[uid];
1371               rtx rel_lab = XEXP (XEXP (body, 0), 0);
1372               rtx min_lab = XEXP (XEXP (body, 2), 0);
1373               rtx max_lab = XEXP (XEXP (body, 3), 0);
1374               addr_diff_vec_flags flags = ADDR_DIFF_VEC_FLAGS (body);
1375               int rel_addr = INSN_ADDRESSES (INSN_UID (rel_lab));
1376               int min_addr = INSN_ADDRESSES (INSN_UID (min_lab));
1377               int max_addr = INSN_ADDRESSES (INSN_UID (max_lab));
1378               rtx prev;
1379               int rel_align = 0;
1380
1381               /* Try to find a known alignment for rel_lab.  */
1382               for (prev = rel_lab;
1383                    prev
1384                    && ! insn_lengths[INSN_UID (prev)]
1385                    && ! (varying_length[INSN_UID (prev)] & 1);
1386                    prev = PREV_INSN (prev))
1387                 if (varying_length[INSN_UID (prev)] & 2)
1388                   {
1389                     rel_align = LABEL_TO_ALIGNMENT (prev);
1390                     break;
1391                   }
1392
1393               /* See the comment on addr_diff_vec_flags in rtl.h for the
1394                  meaning of the flags values.  base: REL_LAB   vec: INSN  */
1395               /* Anything after INSN has still addresses from the last
1396                  pass; adjust these so that they reflect our current
1397                  estimate for this pass.  */
1398               if (flags.base_after_vec)
1399                 rel_addr += insn_current_address - insn_last_address;
1400               if (flags.min_after_vec)
1401                 min_addr += insn_current_address - insn_last_address;
1402               if (flags.max_after_vec)
1403                 max_addr += insn_current_address - insn_last_address;
1404               /* We want to know the worst case, i.e. lowest possible value
1405                  for the offset of MIN_LAB.  If MIN_LAB is after REL_LAB,
1406                  its offset is positive, and we have to be wary of code shrink;
1407                  otherwise, it is negative, and we have to be vary of code
1408                  size increase.  */
1409               if (flags.min_after_base)
1410                 {
1411                   /* If INSN is between REL_LAB and MIN_LAB, the size
1412                      changes we are about to make can change the alignment
1413                      within the observed offset, therefore we have to break
1414                      it up into two parts that are independent.  */
1415                   if (! flags.base_after_vec && flags.min_after_vec)
1416                     {
1417                       min_addr -= align_fuzz (rel_lab, insn, rel_align, 0);
1418                       min_addr -= align_fuzz (insn, min_lab, 0, 0);
1419                     }
1420                   else
1421                     min_addr -= align_fuzz (rel_lab, min_lab, rel_align, 0);
1422                 }
1423               else
1424                 {
1425                   if (flags.base_after_vec && ! flags.min_after_vec)
1426                     {
1427                       min_addr -= align_fuzz (min_lab, insn, 0, ~0);
1428                       min_addr -= align_fuzz (insn, rel_lab, 0, ~0);
1429                     }
1430                   else
1431                     min_addr -= align_fuzz (min_lab, rel_lab, 0, ~0);
1432                 }
1433               /* Likewise, determine the highest lowest possible value
1434                  for the offset of MAX_LAB.  */
1435               if (flags.max_after_base)
1436                 {
1437                   if (! flags.base_after_vec && flags.max_after_vec)
1438                     {
1439                       max_addr += align_fuzz (rel_lab, insn, rel_align, ~0);
1440                       max_addr += align_fuzz (insn, max_lab, 0, ~0);
1441                     }
1442                   else
1443                     max_addr += align_fuzz (rel_lab, max_lab, rel_align, ~0);
1444                 }
1445               else
1446                 {
1447                   if (flags.base_after_vec && ! flags.max_after_vec)
1448                     {
1449                       max_addr += align_fuzz (max_lab, insn, 0, 0);
1450                       max_addr += align_fuzz (insn, rel_lab, 0, 0);
1451                     }
1452                   else
1453                     max_addr += align_fuzz (max_lab, rel_lab, 0, 0);
1454                 }
1455               PUT_MODE (body, CASE_VECTOR_SHORTEN_MODE (min_addr - rel_addr,
1456                                                         max_addr - rel_addr,
1457                                                         body));
1458               if (JUMP_TABLES_IN_TEXT_SECTION
1459 #if !defined(READONLY_DATA_SECTION)
1460                   || 1
1461 #endif
1462                   )
1463                 {
1464                   insn_lengths[uid]
1465                     = (XVECLEN (body, 1) * GET_MODE_SIZE (GET_MODE (body)));
1466                   insn_current_address += insn_lengths[uid];
1467                   if (insn_lengths[uid] != old_length)
1468                     something_changed = 1;
1469                 }
1470
1471               continue;
1472             }
1473 #endif /* CASE_VECTOR_SHORTEN_MODE */
1474
1475           if (! (varying_length[uid]))
1476             {
1477               insn_current_address += insn_lengths[uid];
1478               continue;
1479             }
1480           if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
1481             {
1482               int i;
1483
1484               body = PATTERN (insn);
1485               new_length = 0;
1486               for (i = 0; i < XVECLEN (body, 0); i++)
1487                 {
1488                   rtx inner_insn = XVECEXP (body, 0, i);
1489                   int inner_uid = INSN_UID (inner_insn);
1490                   int inner_length;
1491
1492                   INSN_ADDRESSES (inner_uid) = insn_current_address;
1493
1494                   /* insn_current_length returns 0 for insns with a
1495                      non-varying length.  */
1496                   if (! varying_length[inner_uid])
1497                     inner_length = insn_lengths[inner_uid];
1498                   else
1499                     inner_length = insn_current_length (inner_insn);
1500
1501                   if (inner_length != insn_lengths[inner_uid])
1502                     {
1503                       insn_lengths[inner_uid] = inner_length;
1504                       something_changed = 1;
1505                     }
1506                   insn_current_address += insn_lengths[inner_uid];
1507                   new_length += inner_length;
1508                 }
1509             }
1510           else
1511             {
1512               new_length = insn_current_length (insn);
1513               insn_current_address += new_length;
1514             }
1515
1516 #ifdef ADJUST_INSN_LENGTH
1517           /* If needed, do any adjustment.  */
1518           tmp_length = new_length;
1519           ADJUST_INSN_LENGTH (insn, new_length);
1520           insn_current_address += (new_length - tmp_length);
1521 #endif
1522
1523           if (new_length != insn_lengths[uid])
1524             {
1525               insn_lengths[uid] = new_length;
1526               something_changed = 1;
1527             }
1528         }
1529       /* For a non-optimizing compile, do only a single pass.  */
1530       if (!optimize)
1531         break;
1532     }
1533
1534   free (varying_length);
1535
1536 #endif /* HAVE_ATTR_length */
1537 }
1538
1539 #ifdef HAVE_ATTR_length
1540 /* Given the body of an INSN known to be generated by an ASM statement, return
1541    the number of machine instructions likely to be generated for this insn.
1542    This is used to compute its length.  */
1543
1544 static int
1545 asm_insn_count (body)
1546      rtx body;
1547 {
1548   const char *template;
1549   int count = 1;
1550
1551   if (GET_CODE (body) == ASM_INPUT)
1552     template = XSTR (body, 0);
1553   else
1554     template = decode_asm_operands (body, NULL_PTR, NULL_PTR,
1555                                     NULL_PTR, NULL_PTR);
1556
1557   for (; *template; template++)
1558     if (IS_ASM_LOGICAL_LINE_SEPARATOR (*template) || *template == '\n')
1559       count++;
1560
1561   return count;
1562 }
1563 #endif
1564 \f
1565 /* Output assembler code for the start of a function,
1566    and initialize some of the variables in this file
1567    for the new function.  The label for the function and associated
1568    assembler pseudo-ops have already been output in `assemble_start_function'.
1569
1570    FIRST is the first insn of the rtl for the function being compiled.
1571    FILE is the file to write assembler code to.
1572    OPTIMIZE is nonzero if we should eliminate redundant
1573      test and compare insns.  */
1574
1575 void
1576 final_start_function (first, file, optimize)
1577      rtx first;
1578      FILE *file;
1579      int optimize ATTRIBUTE_UNUSED;
1580 {
1581   block_depth = 0;
1582
1583   this_is_asm_operands = 0;
1584
1585 #ifdef NON_SAVING_SETJMP
1586   /* A function that calls setjmp should save and restore all the
1587      call-saved registers on a system where longjmp clobbers them.  */
1588   if (NON_SAVING_SETJMP && current_function_calls_setjmp)
1589     {
1590       int i;
1591
1592       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1593         if (!call_used_regs[i])
1594           regs_ever_live[i] = 1;
1595     }
1596 #endif
1597
1598   /* Initial line number is supposed to be output
1599      before the function's prologue and label
1600      so that the function's address will not appear to be
1601      in the last statement of the preceding function.  */
1602   if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
1603     last_linenum = high_block_linenum = high_function_linenum
1604       = NOTE_LINE_NUMBER (first);
1605
1606 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
1607   /* Output DWARF definition of the function.  */
1608   if (dwarf2out_do_frame ())
1609     dwarf2out_begin_prologue ();
1610   else
1611     current_function_func_begin_label = 0;
1612 #endif
1613
1614   /* For SDB and XCOFF, the function beginning must be marked between
1615      the function label and the prologue.  We always need this, even when
1616      -g1 was used.  Defer on MIPS systems so that parameter descriptions
1617      follow function entry.  */
1618 #if defined(SDB_DEBUGGING_INFO) && !defined(MIPS_DEBUGGING_INFO)
1619   if (write_symbols == SDB_DEBUG)
1620     sdbout_begin_function (last_linenum);
1621   else
1622 #endif
1623 #ifdef XCOFF_DEBUGGING_INFO
1624     if (write_symbols == XCOFF_DEBUG)
1625       xcoffout_begin_function (file, last_linenum);
1626     else
1627 #endif
1628       /* But only output line number for other debug info types if -g2
1629          or better.  */
1630       if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
1631         output_source_line (file, first);
1632
1633 #ifdef LEAF_REG_REMAP
1634   if (current_function_uses_only_leaf_regs)
1635     leaf_renumber_regs (first);
1636 #endif
1637
1638   /* The Sun386i and perhaps other machines don't work right
1639      if the profiling code comes after the prologue.  */
1640 #ifdef PROFILE_BEFORE_PROLOGUE
1641   if (profile_flag)
1642     profile_function (file);
1643 #endif /* PROFILE_BEFORE_PROLOGUE */
1644
1645 #if defined (DWARF2_UNWIND_INFO) && defined (HAVE_prologue)
1646   if (dwarf2out_do_frame ())
1647     dwarf2out_frame_debug (NULL_RTX);
1648 #endif
1649
1650   /* If debugging, assign block numbers to all of the blocks in this
1651      function.  */
1652   if (write_symbols)
1653     {
1654       number_blocks (current_function_decl);
1655       remove_unnecessary_notes ();
1656       /* We never actually put out begin/end notes for the top-level
1657          block in the function.  But, conceptually, that block is
1658          always needed.  */
1659       TREE_ASM_WRITTEN (DECL_INITIAL (current_function_decl)) = 1;
1660     }
1661
1662 #ifdef FUNCTION_PROLOGUE
1663   /* First output the function prologue: code to set up the stack frame.  */
1664   FUNCTION_PROLOGUE (file, get_frame_size ());
1665 #endif
1666
1667   /* If the machine represents the prologue as RTL, the profiling code must
1668      be emitted when NOTE_INSN_PROLOGUE_END is scanned.  */
1669 #ifdef HAVE_prologue
1670   if (! HAVE_prologue)
1671 #endif
1672     profile_after_prologue (file);
1673
1674   profile_label_no++;
1675
1676   /* If we are doing basic block profiling, remember a printable version
1677      of the function name.  */
1678   if (profile_block_flag)
1679     {
1680       bb_func_label_num =
1681         add_bb_string ((*decl_printable_name) (current_function_decl, 2),
1682                        FALSE);
1683     }
1684 }
1685
1686 static void
1687 profile_after_prologue (file)
1688      FILE *file ATTRIBUTE_UNUSED;
1689 {
1690 #ifdef FUNCTION_BLOCK_PROFILER
1691   if (profile_block_flag)
1692     {
1693       FUNCTION_BLOCK_PROFILER (file, count_basic_blocks);
1694     }
1695 #endif /* FUNCTION_BLOCK_PROFILER */
1696
1697 #ifndef PROFILE_BEFORE_PROLOGUE
1698   if (profile_flag)
1699     profile_function (file);
1700 #endif /* not PROFILE_BEFORE_PROLOGUE */
1701 }
1702
1703 static void
1704 profile_function (file)
1705      FILE *file;
1706 {
1707 #ifndef NO_PROFILE_COUNTERS
1708   int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE);
1709 #endif
1710 #if defined(ASM_OUTPUT_REG_PUSH)
1711 #if defined(STRUCT_VALUE_INCOMING_REGNUM) || defined(STRUCT_VALUE_REGNUM)
1712   int sval = current_function_returns_struct;
1713 #endif
1714 #if defined(STATIC_CHAIN_INCOMING_REGNUM) || defined(STATIC_CHAIN_REGNUM)
1715   int cxt = current_function_needs_context;
1716 #endif
1717 #endif /* ASM_OUTPUT_REG_PUSH */
1718
1719 #ifndef NO_PROFILE_COUNTERS
1720   data_section ();
1721   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
1722   ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no);
1723   assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, 1);
1724 #endif
1725
1726   function_section (current_function_decl);
1727
1728 #if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1729   if (sval)
1730     ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM);
1731 #else
1732 #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1733   if (sval)
1734     {
1735       ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM);
1736     }
1737 #endif
1738 #endif
1739
1740 #if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1741   if (cxt)
1742     ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM);
1743 #else
1744 #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1745   if (cxt)
1746     {
1747       ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM);
1748     }
1749 #endif
1750 #endif
1751
1752   FUNCTION_PROFILER (file, profile_label_no);
1753
1754 #if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1755   if (cxt)
1756     ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM);
1757 #else
1758 #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1759   if (cxt)
1760     {
1761       ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM);
1762     }
1763 #endif
1764 #endif
1765
1766 #if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1767   if (sval)
1768     ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM);
1769 #else
1770 #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1771   if (sval)
1772     {
1773       ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM);
1774     }
1775 #endif
1776 #endif
1777 }
1778
1779 /* Output assembler code for the end of a function.
1780    For clarity, args are same as those of `final_start_function'
1781    even though not all of them are needed.  */
1782
1783 void
1784 final_end_function (first, file, optimize)
1785      rtx first ATTRIBUTE_UNUSED;
1786      FILE *file ATTRIBUTE_UNUSED;
1787      int optimize ATTRIBUTE_UNUSED;
1788 {
1789   app_disable ();
1790
1791 #ifdef SDB_DEBUGGING_INFO
1792   if (write_symbols == SDB_DEBUG)
1793     sdbout_end_function (high_function_linenum);
1794 #endif
1795
1796 #ifdef DWARF_DEBUGGING_INFO
1797   if (write_symbols == DWARF_DEBUG)
1798     dwarfout_end_function ();
1799 #endif
1800
1801 #ifdef XCOFF_DEBUGGING_INFO
1802   if (write_symbols == XCOFF_DEBUG)
1803     xcoffout_end_function (file, high_function_linenum);
1804 #endif
1805
1806 #ifdef FUNCTION_EPILOGUE
1807   /* Finally, output the function epilogue:
1808      code to restore the stack frame and return to the caller.  */
1809   FUNCTION_EPILOGUE (file, get_frame_size ());
1810 #endif
1811
1812 #ifdef SDB_DEBUGGING_INFO
1813   if (write_symbols == SDB_DEBUG)
1814     sdbout_end_epilogue ();
1815 #endif
1816
1817 #ifdef DWARF_DEBUGGING_INFO
1818   if (write_symbols == DWARF_DEBUG)
1819     dwarfout_end_epilogue ();
1820 #endif
1821
1822 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
1823   if (dwarf2out_do_frame ())
1824     dwarf2out_end_epilogue ();
1825 #endif
1826
1827 #ifdef XCOFF_DEBUGGING_INFO
1828   if (write_symbols == XCOFF_DEBUG)
1829     xcoffout_end_epilogue (file);
1830 #endif
1831
1832   bb_func_label_num = -1;       /* not in function, nuke label # */
1833
1834 #ifdef IA64_UNWIND_INFO
1835   output_function_exception_table ();
1836 #endif
1837
1838   /* If FUNCTION_EPILOGUE is not defined, then the function body
1839      itself contains return instructions wherever needed.  */
1840 }
1841 \f
1842 /* Add a block to the linked list that remembers the current line/file/function
1843    for basic block profiling.  Emit the label in front of the basic block and
1844    the instructions that increment the count field.  */
1845
1846 static void
1847 add_bb (file)
1848      FILE *file;
1849 {
1850   struct bb_list *ptr =
1851     (struct bb_list *) permalloc (sizeof (struct bb_list));
1852
1853   /* Add basic block to linked list.  */
1854   ptr->next = 0;
1855   ptr->line_num = last_linenum;
1856   ptr->file_label_num = bb_file_label_num;
1857   ptr->func_label_num = bb_func_label_num;
1858   *bb_tail = ptr;
1859   bb_tail = &ptr->next;
1860
1861   /* Enable the table of basic-block use counts
1862      to point at the code it applies to.  */
1863   ASM_OUTPUT_INTERNAL_LABEL (file, "LPB", count_basic_blocks);
1864
1865   /* Before first insn of this basic block, increment the
1866      count of times it was entered.  */
1867 #ifdef BLOCK_PROFILER
1868   BLOCK_PROFILER (file, count_basic_blocks);
1869 #endif
1870 #ifdef HAVE_cc0
1871   CC_STATUS_INIT;
1872 #endif
1873
1874   new_block = 0;
1875   count_basic_blocks++;
1876 }
1877
1878 /* Add a string to be used for basic block profiling.  */
1879
1880 static int
1881 add_bb_string (string, perm_p)
1882      const char *string;
1883      int perm_p;
1884 {
1885   int len;
1886   struct bb_str *ptr = 0;
1887
1888   if (!string)
1889     {
1890       string = "<unknown>";
1891       perm_p = TRUE;
1892     }
1893
1894   /* Allocate a new string if the current string isn't permanent.  If
1895      the string is permanent search for the same string in other
1896      allocations.  */
1897
1898   len = strlen (string) + 1;
1899   if (!perm_p)
1900     {
1901       char *p = (char *) permalloc (len);
1902       memcpy (p, string, len);
1903       string = p;
1904     }
1905   else
1906     for (ptr = sbb_head; ptr != (struct bb_str *) 0; ptr = ptr->next)
1907       if (ptr->string == string)
1908         break;
1909
1910   /* Allocate a new string block if we need to.  */
1911   if (!ptr)
1912     {
1913       ptr = (struct bb_str *) permalloc (sizeof (*ptr));
1914       ptr->next = 0;
1915       ptr->length = len;
1916       ptr->label_num = sbb_label_num++;
1917       ptr->string = string;
1918       *sbb_tail = ptr;
1919       sbb_tail = &ptr->next;
1920     }
1921
1922   return ptr->label_num;
1923 }
1924 \f
1925 /* Output assembler code for some insns: all or part of a function.
1926    For description of args, see `final_start_function', above.
1927
1928    PRESCAN is 1 if we are not really outputting,
1929      just scanning as if we were outputting.
1930    Prescanning deletes and rearranges insns just like ordinary output.
1931    PRESCAN is -2 if we are outputting after having prescanned.
1932    In this case, don't try to delete or rearrange insns
1933    because that has already been done.
1934    Prescanning is done only on certain machines.  */
1935
1936 void
1937 final (first, file, optimize, prescan)
1938      rtx first;
1939      FILE *file;
1940      int optimize;
1941      int prescan;
1942 {
1943   register rtx insn;
1944   int max_line = 0;
1945   int max_uid = 0;
1946
1947   last_ignored_compare = 0;
1948   new_block = 1;
1949
1950   check_exception_handler_labels ();
1951
1952   /* Make a map indicating which line numbers appear in this function.
1953      When producing SDB debugging info, delete troublesome line number
1954      notes from inlined functions in other files as well as duplicate
1955      line number notes.  */
1956 #ifdef SDB_DEBUGGING_INFO
1957   if (write_symbols == SDB_DEBUG)
1958     {
1959       rtx last = 0;
1960       for (insn = first; insn; insn = NEXT_INSN (insn))
1961         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1962           {
1963             if ((RTX_INTEGRATED_P (insn)
1964                  && strcmp (NOTE_SOURCE_FILE (insn), main_input_filename) != 0)
1965                  || (last != 0
1966                      && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last)
1967                      && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last)))
1968               {
1969                 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1970                 NOTE_SOURCE_FILE (insn) = 0;
1971                 continue;
1972               }
1973             last = insn;
1974             if (NOTE_LINE_NUMBER (insn) > max_line)
1975               max_line = NOTE_LINE_NUMBER (insn);
1976           }
1977     }
1978   else
1979 #endif
1980     {
1981       for (insn = first; insn; insn = NEXT_INSN (insn))
1982         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > max_line)
1983           max_line = NOTE_LINE_NUMBER (insn);
1984     }
1985
1986   line_note_exists = (char *) xcalloc (max_line + 1, sizeof (char));
1987
1988   for (insn = first; insn; insn = NEXT_INSN (insn))
1989     {
1990       if (INSN_UID (insn) > max_uid)       /* find largest UID */
1991         max_uid = INSN_UID (insn);
1992       if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1993         line_note_exists[NOTE_LINE_NUMBER (insn)] = 1;
1994 #ifdef HAVE_cc0
1995       /* If CC tracking across branches is enabled, record the insn which
1996          jumps to each branch only reached from one place.  */
1997       if (optimize && GET_CODE (insn) == JUMP_INSN)
1998         {
1999           rtx lab = JUMP_LABEL (insn);
2000           if (lab && LABEL_NUSES (lab) == 1)
2001             {
2002               LABEL_REFS (lab) = insn;
2003             }
2004         }
2005 #endif
2006     }
2007
2008   /* Initialize insn_eh_region table if eh is being used.  */
2009
2010   init_insn_eh_region (first, max_uid);
2011
2012   init_recog ();
2013
2014   CC_STATUS_INIT;
2015
2016   /* Output the insns.  */
2017   for (insn = NEXT_INSN (first); insn;)
2018     {
2019 #ifdef HAVE_ATTR_length
2020       if (INSN_UID (insn) >= INSN_ADDRESSES_SIZE ())
2021         {
2022 #ifdef STACK_REGS
2023           /* Irritatingly, the reg-stack pass is creating new instructions
2024              and because of REG_DEAD note abuse it has to run after
2025              shorten_branches.  Fake address of -1 then.  */
2026           insn_current_address = -1;
2027 #else
2028           /* This can be triggered by bugs elsewhere in the compiler if
2029              new insns are created after init_insn_lengths is called.  */
2030           abort ();
2031 #endif
2032         }
2033       else
2034         insn_current_address = INSN_ADDRESSES (INSN_UID (insn));
2035 #endif /* HAVE_ATTR_length */
2036
2037       insn = final_scan_insn (insn, file, optimize, prescan, 0);
2038     }
2039
2040   /* Do basic-block profiling here
2041      if the last insn was a conditional branch.  */
2042   if (profile_block_flag && new_block)
2043     add_bb (file);
2044
2045   free_insn_eh_region ();
2046   free (line_note_exists);
2047   line_note_exists = NULL;
2048 }
2049 \f
2050 const char *
2051 get_insn_template (code, insn)
2052      int code;
2053      rtx insn;
2054 {
2055   const void *output = insn_data[code].output;
2056   switch (insn_data[code].output_format)
2057     {
2058     case INSN_OUTPUT_FORMAT_SINGLE:
2059       return (const char *) output;
2060     case INSN_OUTPUT_FORMAT_MULTI:
2061       return ((const char *const *) output)[which_alternative];
2062     case INSN_OUTPUT_FORMAT_FUNCTION:
2063       if (insn == NULL)
2064         abort ();
2065       return (*(insn_output_fn) output) (recog_data.operand, insn);
2066
2067     default:
2068       abort ();
2069     }
2070 }
2071
2072 /* The final scan for one insn, INSN.
2073    Args are same as in `final', except that INSN
2074    is the insn being scanned.
2075    Value returned is the next insn to be scanned.
2076
2077    NOPEEPHOLES is the flag to disallow peephole processing (currently
2078    used for within delayed branch sequence output).  */
2079
2080 rtx
2081 final_scan_insn (insn, file, optimize, prescan, nopeepholes)
2082      rtx insn;
2083      FILE *file;
2084      int optimize ATTRIBUTE_UNUSED;
2085      int prescan;
2086      int nopeepholes ATTRIBUTE_UNUSED;
2087 {
2088 #ifdef HAVE_cc0
2089   rtx set;
2090 #endif
2091
2092   insn_counter++;
2093
2094   /* Ignore deleted insns.  These can occur when we split insns (due to a
2095      template of "#") while not optimizing.  */
2096   if (INSN_DELETED_P (insn))
2097     return NEXT_INSN (insn);
2098
2099   switch (GET_CODE (insn))
2100     {
2101     case NOTE:
2102       if (prescan > 0)
2103         break;
2104
2105       switch (NOTE_LINE_NUMBER (insn))
2106         {
2107         case NOTE_INSN_DELETED:
2108         case NOTE_INSN_LOOP_BEG:
2109         case NOTE_INSN_LOOP_END:
2110         case NOTE_INSN_LOOP_CONT:
2111         case NOTE_INSN_LOOP_VTOP:
2112         case NOTE_INSN_FUNCTION_END:
2113         case NOTE_INSN_SETJMP:
2114         case NOTE_INSN_REPEATED_LINE_NUMBER:
2115         case NOTE_INSN_RANGE_BEG:
2116         case NOTE_INSN_RANGE_END:
2117         case NOTE_INSN_LIVE:
2118         case NOTE_INSN_EXPECTED_VALUE:
2119           break;
2120
2121         case NOTE_INSN_BASIC_BLOCK:
2122           if (flag_debug_asm)
2123             fprintf (asm_out_file, "\t%s basic block %d\n",
2124                      ASM_COMMENT_START, NOTE_BASIC_BLOCK (insn)->index);
2125           break;
2126
2127         case NOTE_INSN_EH_REGION_BEG:
2128           if (! exceptions_via_longjmp)
2129             {
2130               ASM_OUTPUT_INTERNAL_LABEL (file, "LEHB", NOTE_EH_HANDLER (insn));
2131               if (! flag_new_exceptions)
2132                 add_eh_table_entry (NOTE_EH_HANDLER (insn));
2133 #ifdef ASM_OUTPUT_EH_REGION_BEG
2134               ASM_OUTPUT_EH_REGION_BEG (file, NOTE_EH_HANDLER (insn));
2135 #endif
2136             }
2137           break;
2138
2139         case NOTE_INSN_EH_REGION_END:
2140           if (! exceptions_via_longjmp)
2141             {
2142               ASM_OUTPUT_INTERNAL_LABEL (file, "LEHE", NOTE_EH_HANDLER (insn));
2143               if (flag_new_exceptions)
2144                 add_eh_table_entry (NOTE_EH_HANDLER (insn));
2145 #ifdef ASM_OUTPUT_EH_REGION_END
2146               ASM_OUTPUT_EH_REGION_END (file, NOTE_EH_HANDLER (insn));
2147 #endif
2148             }
2149           break;
2150
2151         case NOTE_INSN_PROLOGUE_END:
2152 #ifdef FUNCTION_END_PROLOGUE
2153           FUNCTION_END_PROLOGUE (file);
2154 #endif
2155           profile_after_prologue (file);
2156           break;
2157
2158         case NOTE_INSN_EPILOGUE_BEG:
2159 #ifdef FUNCTION_BEGIN_EPILOGUE
2160           FUNCTION_BEGIN_EPILOGUE (file);
2161 #endif
2162           break;
2163
2164         case NOTE_INSN_FUNCTION_BEG:
2165 #if defined(SDB_DEBUGGING_INFO) && defined(MIPS_DEBUGGING_INFO)
2166           /* MIPS stabs require the parameter descriptions to be after the
2167              function entry point rather than before.  */
2168           if (write_symbols == SDB_DEBUG)
2169             {
2170               app_disable ();
2171               sdbout_begin_function (last_linenum);
2172             }
2173 #endif
2174 #ifdef DWARF_DEBUGGING_INFO
2175           /* This outputs a marker where the function body starts, so it
2176              must be after the prologue.  */
2177           if (write_symbols == DWARF_DEBUG)
2178             {
2179               app_disable ();
2180               dwarfout_begin_function ();
2181             }
2182 #endif
2183           break;
2184
2185         case NOTE_INSN_BLOCK_BEG:
2186           if (debug_info_level == DINFO_LEVEL_NORMAL
2187               || debug_info_level == DINFO_LEVEL_VERBOSE
2188               || write_symbols == DWARF_DEBUG
2189               || write_symbols == DWARF2_DEBUG)
2190             {
2191               int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2192
2193               app_disable ();
2194               ++block_depth;
2195               high_block_linenum = last_linenum;
2196
2197             /* Output debugging info about the symbol-block beginning.  */
2198 #ifdef SDB_DEBUGGING_INFO
2199               if (write_symbols == SDB_DEBUG)
2200                 sdbout_begin_block (file, last_linenum, n);
2201 #endif
2202 #ifdef XCOFF_DEBUGGING_INFO
2203               if (write_symbols == XCOFF_DEBUG)
2204                 xcoffout_begin_block (file, last_linenum, n);
2205 #endif
2206 #ifdef DBX_DEBUGGING_INFO
2207               if (write_symbols == DBX_DEBUG)
2208                 ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", n);
2209 #endif
2210 #ifdef DWARF_DEBUGGING_INFO
2211               if (write_symbols == DWARF_DEBUG)
2212                 dwarfout_begin_block (n);
2213 #endif
2214 #ifdef DWARF2_DEBUGGING_INFO
2215               if (write_symbols == DWARF2_DEBUG)
2216                 dwarf2out_begin_block (n);
2217 #endif
2218
2219               /* Mark this block as output.  */
2220               TREE_ASM_WRITTEN (NOTE_BLOCK (insn)) = 1;
2221             }
2222           break;
2223
2224         case NOTE_INSN_BLOCK_END:
2225           if (debug_info_level == DINFO_LEVEL_NORMAL
2226               || debug_info_level == DINFO_LEVEL_VERBOSE
2227               || write_symbols == DWARF_DEBUG
2228               || write_symbols == DWARF2_DEBUG)
2229             {
2230               int n = BLOCK_NUMBER (NOTE_BLOCK (insn));
2231
2232               app_disable ();
2233
2234               /* End of a symbol-block.  */
2235               --block_depth;
2236               if (block_depth < 0)
2237                 abort ();
2238
2239 #ifdef XCOFF_DEBUGGING_INFO
2240               if (write_symbols == XCOFF_DEBUG)
2241                 xcoffout_end_block (file, high_block_linenum, n);
2242 #endif
2243 #ifdef DBX_DEBUGGING_INFO
2244               if (write_symbols == DBX_DEBUG)
2245                 ASM_OUTPUT_INTERNAL_LABEL (file, "LBE", n);
2246 #endif
2247 #ifdef SDB_DEBUGGING_INFO
2248               if (write_symbols == SDB_DEBUG)
2249                 sdbout_end_block (file, high_block_linenum, n);
2250 #endif
2251 #ifdef DWARF_DEBUGGING_INFO
2252               if (write_symbols == DWARF_DEBUG)
2253                 dwarfout_end_block (n);
2254 #endif
2255 #ifdef DWARF2_DEBUGGING_INFO
2256               if (write_symbols == DWARF2_DEBUG)
2257                 dwarf2out_end_block (n);
2258 #endif
2259             }
2260           break;
2261
2262         case NOTE_INSN_DELETED_LABEL:
2263           /* Emit the label.  We may have deleted the CODE_LABEL because
2264              the label could be proved to be unreachable, though still
2265              referenced (in the form of having its address taken.  */
2266           ASM_OUTPUT_DEBUG_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2267           break;
2268
2269         case 0:
2270           break;
2271
2272         default:
2273           if (NOTE_LINE_NUMBER (insn) <= 0)
2274             abort ();
2275
2276           /* This note is a line-number.  */
2277           {
2278             register rtx note;
2279             int note_after = 0;
2280
2281             /* If there is anything real after this note, output it.
2282                If another line note follows, omit this one.  */
2283             for (note = NEXT_INSN (insn); note; note = NEXT_INSN (note))
2284               {
2285                 if (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL)
2286                   break;
2287
2288                 /* These types of notes can be significant
2289                    so make sure the preceding line number stays.  */
2290                 else if (GET_CODE (note) == NOTE
2291                          && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG
2292                              || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END
2293                              || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG))
2294                   break;
2295                 else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0)
2296                   {
2297                     /* Another line note follows; we can delete this note
2298                        if no intervening line numbers have notes elsewhere.  */
2299                     int num;
2300                     for (num = NOTE_LINE_NUMBER (insn) + 1;
2301                          num < NOTE_LINE_NUMBER (note);
2302                          num++)
2303                       if (line_note_exists[num])
2304                         break;
2305
2306                     if (num >= NOTE_LINE_NUMBER (note))
2307                       note_after = 1;
2308                     break;
2309                   }
2310               }
2311
2312             /* Output this line note if it is the first or the last line
2313                note in a row.  */
2314             if (!note_after)
2315               output_source_line (file, insn);
2316           }
2317           break;
2318         }
2319       break;
2320
2321     case BARRIER:
2322 #if defined (DWARF2_UNWIND_INFO)
2323       /* If we push arguments, we need to check all insns for stack
2324          adjustments.  */
2325       if (!ACCUMULATE_OUTGOING_ARGS && dwarf2out_do_frame ())
2326         dwarf2out_frame_debug (insn);
2327 #endif
2328       break;
2329
2330     case CODE_LABEL:
2331       /* The target port might emit labels in the output function for
2332          some insn, e.g. sh.c output_branchy_insn.  */
2333       if (CODE_LABEL_NUMBER (insn) <= max_labelno)
2334         {
2335           int align = LABEL_TO_ALIGNMENT (insn);
2336 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2337           int max_skip = LABEL_TO_MAX_SKIP (insn);
2338 #endif
2339
2340           if (align && NEXT_INSN (insn))
2341 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
2342             ASM_OUTPUT_MAX_SKIP_ALIGN (file, align, max_skip);
2343 #else
2344             ASM_OUTPUT_ALIGN (file, align);
2345 #endif
2346         }
2347 #ifdef HAVE_cc0
2348       CC_STATUS_INIT;
2349       /* If this label is reached from only one place, set the condition
2350          codes from the instruction just before the branch.  */
2351
2352       /* Disabled because some insns set cc_status in the C output code
2353          and NOTICE_UPDATE_CC alone can set incorrect status.  */
2354       if (0 /* optimize && LABEL_NUSES (insn) == 1*/)
2355         {
2356           rtx jump = LABEL_REFS (insn);
2357           rtx barrier = prev_nonnote_insn (insn);
2358           rtx prev;
2359           /* If the LABEL_REFS field of this label has been set to point
2360              at a branch, the predecessor of the branch is a regular
2361              insn, and that branch is the only way to reach this label,
2362              set the condition codes based on the branch and its
2363              predecessor.  */
2364           if (barrier && GET_CODE (barrier) == BARRIER
2365               && jump && GET_CODE (jump) == JUMP_INSN
2366               && (prev = prev_nonnote_insn (jump))
2367               && GET_CODE (prev) == INSN)
2368             {
2369               NOTICE_UPDATE_CC (PATTERN (prev), prev);
2370               NOTICE_UPDATE_CC (PATTERN (jump), jump);
2371             }
2372         }
2373 #endif
2374       if (prescan > 0)
2375         break;
2376       new_block = 1;
2377
2378 #ifdef FINAL_PRESCAN_LABEL
2379       FINAL_PRESCAN_INSN (insn, NULL_PTR, 0);
2380 #endif
2381
2382 #ifdef SDB_DEBUGGING_INFO
2383       if (write_symbols == SDB_DEBUG && LABEL_NAME (insn))
2384         sdbout_label (insn);
2385 #endif
2386       if (app_on)
2387         {
2388           fputs (ASM_APP_OFF, file);
2389           app_on = 0;
2390         }
2391       if (NEXT_INSN (insn) != 0
2392           && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN)
2393         {
2394           rtx nextbody = PATTERN (NEXT_INSN (insn));
2395
2396           /* If this label is followed by a jump-table,
2397              make sure we put the label in the read-only section.  Also
2398              possibly write the label and jump table together.  */
2399
2400           if (GET_CODE (nextbody) == ADDR_VEC
2401               || GET_CODE (nextbody) == ADDR_DIFF_VEC)
2402             {
2403 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2404               /* In this case, the case vector is being moved by the
2405                  target, so don't output the label at all.  Leave that
2406                  to the back end macros.  */
2407 #else
2408               if (! JUMP_TABLES_IN_TEXT_SECTION)
2409                 {
2410                   readonly_data_section ();
2411 #ifdef READONLY_DATA_SECTION
2412                   ASM_OUTPUT_ALIGN (file,
2413                                     exact_log2 (BIGGEST_ALIGNMENT
2414                                                 / BITS_PER_UNIT));
2415 #endif /* READONLY_DATA_SECTION */
2416                 }
2417               else
2418                 function_section (current_function_decl);
2419
2420 #ifdef ASM_OUTPUT_CASE_LABEL
2421               ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
2422                                      NEXT_INSN (insn));
2423 #else
2424               if (LABEL_ALTERNATE_NAME (insn))
2425                 ASM_OUTPUT_ALTERNATE_LABEL_NAME (file, insn);
2426               else
2427                 ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2428 #endif
2429 #endif
2430               break;
2431             }
2432         }
2433       if (LABEL_ALTERNATE_NAME (insn))
2434         ASM_OUTPUT_ALTERNATE_LABEL_NAME (file, insn);
2435       else
2436         ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2437       break;
2438
2439     default:
2440       {
2441         register rtx body = PATTERN (insn);
2442         int insn_code_number;
2443         const char *template;
2444 #ifdef HAVE_cc0
2445         rtx note;
2446 #endif
2447
2448         /* An INSN, JUMP_INSN or CALL_INSN.
2449            First check for special kinds that recog doesn't recognize.  */
2450
2451         if (GET_CODE (body) == USE /* These are just declarations */
2452             || GET_CODE (body) == CLOBBER)
2453           break;
2454
2455 #ifdef HAVE_cc0
2456         /* If there is a REG_CC_SETTER note on this insn, it means that
2457            the setting of the condition code was done in the delay slot
2458            of the insn that branched here.  So recover the cc status
2459            from the insn that set it.  */
2460
2461         note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2462         if (note)
2463           {
2464             NOTICE_UPDATE_CC (PATTERN (XEXP (note, 0)), XEXP (note, 0));
2465             cc_prev_status = cc_status;
2466           }
2467 #endif
2468
2469         /* Detect insns that are really jump-tables
2470            and output them as such.  */
2471
2472         if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
2473           {
2474 #if !(defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC))
2475             register int vlen, idx;
2476 #endif
2477
2478             if (prescan > 0)
2479               break;
2480
2481             if (app_on)
2482               {
2483                 fputs (ASM_APP_OFF, file);
2484                 app_on = 0;
2485               }
2486
2487 #if defined(ASM_OUTPUT_ADDR_VEC) || defined(ASM_OUTPUT_ADDR_DIFF_VEC)
2488             if (GET_CODE (body) == ADDR_VEC)
2489               {
2490 #ifdef ASM_OUTPUT_ADDR_VEC
2491                 ASM_OUTPUT_ADDR_VEC (PREV_INSN (insn), body);
2492 #else
2493                 abort ();
2494 #endif
2495               }
2496             else
2497               {
2498 #ifdef ASM_OUTPUT_ADDR_DIFF_VEC
2499                 ASM_OUTPUT_ADDR_DIFF_VEC (PREV_INSN (insn), body);
2500 #else
2501                 abort ();
2502 #endif
2503               }
2504 #else
2505             vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
2506             for (idx = 0; idx < vlen; idx++)
2507               {
2508                 if (GET_CODE (body) == ADDR_VEC)
2509                   {
2510 #ifdef ASM_OUTPUT_ADDR_VEC_ELT
2511                     ASM_OUTPUT_ADDR_VEC_ELT
2512                       (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
2513 #else
2514                     abort ();
2515 #endif
2516                   }
2517                 else
2518                   {
2519 #ifdef ASM_OUTPUT_ADDR_DIFF_ELT
2520                     ASM_OUTPUT_ADDR_DIFF_ELT
2521                       (file,
2522                        body,
2523                        CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
2524                        CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
2525 #else
2526                     abort ();
2527 #endif
2528                   }
2529               }
2530 #ifdef ASM_OUTPUT_CASE_END
2531             ASM_OUTPUT_CASE_END (file,
2532                                  CODE_LABEL_NUMBER (PREV_INSN (insn)),
2533                                  insn);
2534 #endif
2535 #endif
2536
2537             function_section (current_function_decl);
2538
2539             break;
2540           }
2541
2542         /* Do basic-block profiling when we reach a new block.
2543            Done here to avoid jump tables.  */
2544         if (profile_block_flag && new_block)
2545           add_bb (file);
2546
2547         if (GET_CODE (body) == ASM_INPUT)
2548           {
2549             /* There's no telling what that did to the condition codes.  */
2550             CC_STATUS_INIT;
2551             if (prescan > 0)
2552               break;
2553             if (! app_on)
2554               {
2555                 fputs (ASM_APP_ON, file);
2556                 app_on = 1;
2557               }
2558             fprintf (asm_out_file, "\t%s\n", XSTR (body, 0));
2559             break;
2560           }
2561
2562         /* Detect `asm' construct with operands.  */
2563         if (asm_noperands (body) >= 0)
2564           {
2565             unsigned int noperands = asm_noperands (body);
2566             rtx *ops = (rtx *) alloca (noperands * sizeof (rtx));
2567             const char *string;
2568
2569             /* There's no telling what that did to the condition codes.  */
2570             CC_STATUS_INIT;
2571             if (prescan > 0)
2572               break;
2573
2574             if (! app_on)
2575               {
2576                 fputs (ASM_APP_ON, file);
2577                 app_on = 1;
2578               }
2579
2580             /* Get out the operand values.  */
2581             string = decode_asm_operands (body, ops, NULL_PTR,
2582                                           NULL_PTR, NULL_PTR);
2583             /* Inhibit aborts on what would otherwise be compiler bugs.  */
2584             insn_noperands = noperands;
2585             this_is_asm_operands = insn;
2586
2587             /* Output the insn using them.  */
2588             output_asm_insn (string, ops);
2589             this_is_asm_operands = 0;
2590             break;
2591           }
2592
2593         if (prescan <= 0 && app_on)
2594           {
2595             fputs (ASM_APP_OFF, file);
2596             app_on = 0;
2597           }
2598
2599         if (GET_CODE (body) == SEQUENCE)
2600           {
2601             /* A delayed-branch sequence */
2602             register int i;
2603             rtx next;
2604
2605             if (prescan > 0)
2606               break;
2607             final_sequence = body;
2608
2609             /* The first insn in this SEQUENCE might be a JUMP_INSN that will
2610                force the restoration of a comparison that was previously
2611                thought unnecessary.  If that happens, cancel this sequence
2612                and cause that insn to be restored.  */
2613
2614             next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, prescan, 1);
2615             if (next != XVECEXP (body, 0, 1))
2616               {
2617                 final_sequence = 0;
2618                 return next;
2619               }
2620
2621             for (i = 1; i < XVECLEN (body, 0); i++)
2622               {
2623                 rtx insn = XVECEXP (body, 0, i);
2624                 rtx next = NEXT_INSN (insn);
2625                 /* We loop in case any instruction in a delay slot gets
2626                    split.  */
2627                 do
2628                   insn = final_scan_insn (insn, file, 0, prescan, 1);
2629                 while (insn != next);
2630               }
2631 #ifdef DBR_OUTPUT_SEQEND
2632             DBR_OUTPUT_SEQEND (file);
2633 #endif
2634             final_sequence = 0;
2635
2636             /* If the insn requiring the delay slot was a CALL_INSN, the
2637                insns in the delay slot are actually executed before the
2638                called function.  Hence we don't preserve any CC-setting
2639                actions in these insns and the CC must be marked as being
2640                clobbered by the function.  */
2641             if (GET_CODE (XVECEXP (body, 0, 0)) == CALL_INSN)
2642               {
2643                 CC_STATUS_INIT;
2644               }
2645
2646             /* Following a conditional branch sequence, we have a new basic
2647                block.  */
2648             if (profile_block_flag)
2649               {
2650                 rtx insn = XVECEXP (body, 0, 0);
2651                 rtx body = PATTERN (insn);
2652
2653                 if ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
2654                      && GET_CODE (SET_SRC (body)) != LABEL_REF)
2655                     || (GET_CODE (insn) == JUMP_INSN
2656                         && GET_CODE (body) == PARALLEL
2657                         && GET_CODE (XVECEXP (body, 0, 0)) == SET
2658                         && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF))
2659                   new_block = 1;
2660               }
2661             break;
2662           }
2663
2664         /* We have a real machine instruction as rtl.  */
2665
2666         body = PATTERN (insn);
2667
2668 #ifdef HAVE_cc0
2669         set = single_set (insn);
2670
2671         /* Check for redundant test and compare instructions
2672            (when the condition codes are already set up as desired).
2673            This is done only when optimizing; if not optimizing,
2674            it should be possible for the user to alter a variable
2675            with the debugger in between statements
2676            and the next statement should reexamine the variable
2677            to compute the condition codes.  */
2678
2679         if (optimize)
2680           {
2681 #if 0
2682             rtx set = single_set (insn);
2683 #endif
2684
2685             if (set
2686                 && GET_CODE (SET_DEST (set)) == CC0
2687                 && insn != last_ignored_compare)
2688               {
2689                 if (GET_CODE (SET_SRC (set)) == SUBREG)
2690                   SET_SRC (set) = alter_subreg (SET_SRC (set));
2691                 else if (GET_CODE (SET_SRC (set)) == COMPARE)
2692                   {
2693                     if (GET_CODE (XEXP (SET_SRC (set), 0)) == SUBREG)
2694                       XEXP (SET_SRC (set), 0)
2695                         = alter_subreg (XEXP (SET_SRC (set), 0));
2696                     if (GET_CODE (XEXP (SET_SRC (set), 1)) == SUBREG)
2697                       XEXP (SET_SRC (set), 1)
2698                         = alter_subreg (XEXP (SET_SRC (set), 1));
2699                   }
2700                 if ((cc_status.value1 != 0
2701                      && rtx_equal_p (SET_SRC (set), cc_status.value1))
2702                     || (cc_status.value2 != 0
2703                         && rtx_equal_p (SET_SRC (set), cc_status.value2)))
2704                   {
2705                     /* Don't delete insn if it has an addressing side-effect.  */
2706                     if (! FIND_REG_INC_NOTE (insn, 0)
2707                         /* or if anything in it is volatile.  */
2708                         && ! volatile_refs_p (PATTERN (insn)))
2709                       {
2710                         /* We don't really delete the insn; just ignore it.  */
2711                         last_ignored_compare = insn;
2712                         break;
2713                       }
2714                   }
2715               }
2716           }
2717 #endif
2718
2719         /* Following a conditional branch, we have a new basic block.
2720            But if we are inside a sequence, the new block starts after the
2721            last insn of the sequence.  */
2722         if (profile_block_flag && final_sequence == 0
2723             && ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
2724                  && GET_CODE (SET_SRC (body)) != LABEL_REF)
2725                 || (GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == PARALLEL
2726                     && GET_CODE (XVECEXP (body, 0, 0)) == SET
2727                     && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF)))
2728           new_block = 1;
2729
2730 #ifndef STACK_REGS
2731         /* Don't bother outputting obvious no-ops, even without -O.
2732            This optimization is fast and doesn't interfere with debugging.
2733            Don't do this if the insn is in a delay slot, since this
2734            will cause an improper number of delay insns to be written.  */
2735         if (final_sequence == 0
2736             && prescan >= 0
2737             && GET_CODE (insn) == INSN && GET_CODE (body) == SET
2738             && GET_CODE (SET_SRC (body)) == REG
2739             && GET_CODE (SET_DEST (body)) == REG
2740             && REGNO (SET_SRC (body)) == REGNO (SET_DEST (body)))
2741           break;
2742 #endif
2743
2744 #ifdef HAVE_cc0
2745         /* If this is a conditional branch, maybe modify it
2746            if the cc's are in a nonstandard state
2747            so that it accomplishes the same thing that it would
2748            do straightforwardly if the cc's were set up normally.  */
2749
2750         if (cc_status.flags != 0
2751             && GET_CODE (insn) == JUMP_INSN
2752             && GET_CODE (body) == SET
2753             && SET_DEST (body) == pc_rtx
2754             && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE
2755             && GET_RTX_CLASS (GET_CODE (XEXP (SET_SRC (body), 0))) == '<'
2756             && XEXP (XEXP (SET_SRC (body), 0), 0) == cc0_rtx
2757             /* This is done during prescan; it is not done again
2758                in final scan when prescan has been done.  */
2759             && prescan >= 0)
2760           {
2761             /* This function may alter the contents of its argument
2762                and clear some of the cc_status.flags bits.
2763                It may also return 1 meaning condition now always true
2764                or -1 meaning condition now always false
2765                or 2 meaning condition nontrivial but altered.  */
2766             register int result = alter_cond (XEXP (SET_SRC (body), 0));
2767             /* If condition now has fixed value, replace the IF_THEN_ELSE
2768                with its then-operand or its else-operand.  */
2769             if (result == 1)
2770               SET_SRC (body) = XEXP (SET_SRC (body), 1);
2771             if (result == -1)
2772               SET_SRC (body) = XEXP (SET_SRC (body), 2);
2773
2774             /* The jump is now either unconditional or a no-op.
2775                If it has become a no-op, don't try to output it.
2776                (It would not be recognized.)  */
2777             if (SET_SRC (body) == pc_rtx)
2778               {
2779                 PUT_CODE (insn, NOTE);
2780                 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2781                 NOTE_SOURCE_FILE (insn) = 0;
2782                 break;
2783               }
2784             else if (GET_CODE (SET_SRC (body)) == RETURN)
2785               /* Replace (set (pc) (return)) with (return).  */
2786               PATTERN (insn) = body = SET_SRC (body);
2787
2788             /* Rerecognize the instruction if it has changed.  */
2789             if (result != 0)
2790               INSN_CODE (insn) = -1;
2791           }
2792
2793         /* Make same adjustments to instructions that examine the
2794            condition codes without jumping and instructions that
2795            handle conditional moves (if this machine has either one).  */
2796
2797         if (cc_status.flags != 0
2798             && set != 0)
2799           {
2800             rtx cond_rtx, then_rtx, else_rtx;
2801
2802             if (GET_CODE (insn) != JUMP_INSN
2803                 && GET_CODE (SET_SRC (set)) == IF_THEN_ELSE)
2804               {
2805                 cond_rtx = XEXP (SET_SRC (set), 0);
2806                 then_rtx = XEXP (SET_SRC (set), 1);
2807                 else_rtx = XEXP (SET_SRC (set), 2);
2808               }
2809             else
2810               {
2811                 cond_rtx = SET_SRC (set);
2812                 then_rtx = const_true_rtx;
2813                 else_rtx = const0_rtx;
2814               }
2815
2816             switch (GET_CODE (cond_rtx))
2817               {
2818               case GTU:
2819               case GT:
2820               case LTU:
2821               case LT:
2822               case GEU:
2823               case GE:
2824               case LEU:
2825               case LE:
2826               case EQ:
2827               case NE:
2828                 {
2829                   register int result;
2830                   if (XEXP (cond_rtx, 0) != cc0_rtx)
2831                     break;
2832                   result = alter_cond (cond_rtx);
2833                   if (result == 1)
2834                     validate_change (insn, &SET_SRC (set), then_rtx, 0);
2835                   else if (result == -1)
2836                     validate_change (insn, &SET_SRC (set), else_rtx, 0);
2837                   else if (result == 2)
2838                     INSN_CODE (insn) = -1;
2839                   if (SET_DEST (set) == SET_SRC (set))
2840                     {
2841                       PUT_CODE (insn, NOTE);
2842                       NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2843                       NOTE_SOURCE_FILE (insn) = 0;
2844                     }
2845                 }
2846                 break;
2847
2848               default:
2849                 break;
2850               }
2851           }
2852
2853 #endif
2854
2855 #ifdef HAVE_peephole
2856         /* Do machine-specific peephole optimizations if desired.  */
2857
2858         if (optimize && !flag_no_peephole && !nopeepholes)
2859           {
2860             rtx next = peephole (insn);
2861             /* When peepholing, if there were notes within the peephole,
2862                emit them before the peephole.  */
2863             if (next != 0 && next != NEXT_INSN (insn))
2864               {
2865                 rtx prev = PREV_INSN (insn);
2866                 rtx note;
2867
2868                 for (note = NEXT_INSN (insn); note != next;
2869                      note = NEXT_INSN (note))
2870                   final_scan_insn (note, file, optimize, prescan, nopeepholes);
2871
2872                 /* In case this is prescan, put the notes
2873                    in proper position for later rescan.  */
2874                 note = NEXT_INSN (insn);
2875                 PREV_INSN (note) = prev;
2876                 NEXT_INSN (prev) = note;
2877                 NEXT_INSN (PREV_INSN (next)) = insn;
2878                 PREV_INSN (insn) = PREV_INSN (next);
2879                 NEXT_INSN (insn) = next;
2880                 PREV_INSN (next) = insn;
2881               }
2882
2883             /* PEEPHOLE might have changed this.  */
2884             body = PATTERN (insn);
2885           }
2886 #endif
2887
2888         /* Try to recognize the instruction.
2889            If successful, verify that the operands satisfy the
2890            constraints for the instruction.  Crash if they don't,
2891            since `reload' should have changed them so that they do.  */
2892
2893         insn_code_number = recog_memoized (insn);
2894         cleanup_subreg_operands (insn);
2895
2896        /* Dump the insn in the assembly for debugging.  */
2897        if (flag_dump_rtl_in_asm)
2898          {
2899            print_rtx_head = ASM_COMMENT_START;
2900            print_rtl_single (asm_out_file, insn);
2901            print_rtx_head = "";
2902          }
2903
2904         if (! constrain_operands_cached (1))
2905           fatal_insn_not_found (insn);
2906
2907         /* Some target machines need to prescan each insn before
2908            it is output.  */
2909
2910 #ifdef FINAL_PRESCAN_INSN
2911         FINAL_PRESCAN_INSN (insn, recog_data.operand, recog_data.n_operands);
2912 #endif
2913
2914 #ifdef HAVE_conditional_execution
2915         if (GET_CODE (PATTERN (insn)) == COND_EXEC)
2916           current_insn_predicate = COND_EXEC_TEST (PATTERN (insn));
2917         else
2918           current_insn_predicate = NULL_RTX;
2919 #endif
2920
2921 #ifdef HAVE_cc0
2922         cc_prev_status = cc_status;
2923
2924         /* Update `cc_status' for this instruction.
2925            The instruction's output routine may change it further.
2926            If the output routine for a jump insn needs to depend
2927            on the cc status, it should look at cc_prev_status.  */
2928
2929         NOTICE_UPDATE_CC (body, insn);
2930 #endif
2931
2932         current_output_insn = debug_insn = insn;
2933
2934 #if defined (DWARF2_UNWIND_INFO)
2935         /* If we push arguments, we want to know where the calls are.  */
2936         if (!ACCUMULATE_OUTGOING_ARGS && GET_CODE (insn) == CALL_INSN
2937             && dwarf2out_do_frame ())
2938           dwarf2out_frame_debug (insn);
2939 #endif
2940
2941         /* Find the proper template for this insn.  */
2942         template = get_insn_template (insn_code_number, insn);
2943
2944         /* If the C code returns 0, it means that it is a jump insn
2945            which follows a deleted test insn, and that test insn
2946            needs to be reinserted.  */
2947         if (template == 0)
2948           {
2949             rtx prev;
2950
2951             if (prev_nonnote_insn (insn) != last_ignored_compare)
2952               abort ();
2953             new_block = 0;
2954
2955             /* We have already processed the notes between the setter and
2956                the user.  Make sure we don't process them again, this is
2957                particularly important if one of the notes is a block
2958                scope note or an EH note.  */
2959             for (prev = insn;
2960                  prev != last_ignored_compare;
2961                  prev = PREV_INSN (prev))
2962               {
2963                 if (GET_CODE (prev) == NOTE)
2964                   {
2965                     NOTE_LINE_NUMBER (prev) = NOTE_INSN_DELETED;
2966                     NOTE_SOURCE_FILE (prev) = 0;
2967                   }
2968               }
2969
2970             return prev;
2971           }
2972
2973         /* If the template is the string "#", it means that this insn must
2974            be split.  */
2975         if (template[0] == '#' && template[1] == '\0')
2976           {
2977             rtx new = try_split (body, insn, 0);
2978
2979             /* If we didn't split the insn, go away.  */
2980             if (new == insn && PATTERN (new) == body)
2981               fatal_insn ("Could not split insn", insn);
2982
2983 #ifdef HAVE_ATTR_length
2984             /* This instruction should have been split in shorten_branches,
2985                to ensure that we would have valid length info for the
2986                splitees.  */
2987             abort ();
2988 #endif
2989
2990             new_block = 0;
2991             return new;
2992           }
2993
2994         if (prescan > 0)
2995           break;
2996
2997 #ifdef IA64_UNWIND_INFO
2998         IA64_UNWIND_EMIT (asm_out_file, insn);
2999 #endif
3000         /* Output assembler code from the template.  */
3001
3002         output_asm_insn (template, recog_data.operand);
3003
3004 #if defined (DWARF2_UNWIND_INFO)
3005         /* If we push arguments, we need to check all insns for stack
3006            adjustments.  */
3007         if (!ACCUMULATE_OUTGOING_ARGS)
3008           {
3009             if (GET_CODE (insn) == INSN && dwarf2out_do_frame ())
3010               dwarf2out_frame_debug (insn);
3011           }
3012         else
3013           {
3014 #if defined (HAVE_prologue)
3015             /* If this insn is part of the prologue, emit DWARF v2
3016                call frame info.  */
3017             if (RTX_FRAME_RELATED_P (insn) && dwarf2out_do_frame ())
3018               dwarf2out_frame_debug (insn);
3019 #endif
3020           }
3021 #endif
3022
3023 #if 0
3024         /* It's not at all clear why we did this and doing so interferes
3025            with tests we'd like to do to use REG_WAS_0 notes, so let's try
3026            with this out.  */
3027
3028         /* Mark this insn as having been output.  */
3029         INSN_DELETED_P (insn) = 1;
3030 #endif
3031
3032         current_output_insn = debug_insn = 0;
3033       }
3034     }
3035   return NEXT_INSN (insn);
3036 }
3037 \f
3038 /* Output debugging info to the assembler file FILE
3039    based on the NOTE-insn INSN, assumed to be a line number.  */
3040
3041 static void
3042 output_source_line (file, insn)
3043      FILE *file ATTRIBUTE_UNUSED;
3044      rtx insn;
3045 {
3046   register const char *filename = NOTE_SOURCE_FILE (insn);
3047
3048   /* Remember filename for basic block profiling.
3049      Filenames are allocated on the permanent obstack
3050      or are passed in ARGV, so we don't have to save
3051      the string.  */
3052
3053   if (profile_block_flag && last_filename != filename)
3054     bb_file_label_num = add_bb_string (filename, TRUE);
3055
3056   last_filename = filename;
3057   last_linenum = NOTE_LINE_NUMBER (insn);
3058   high_block_linenum = MAX (last_linenum, high_block_linenum);
3059   high_function_linenum = MAX (last_linenum, high_function_linenum);
3060
3061   if (write_symbols != NO_DEBUG)
3062     {
3063 #ifdef SDB_DEBUGGING_INFO
3064       if (write_symbols == SDB_DEBUG
3065 #if 0 /* People like having line numbers even in wrong file!  */
3066           /* COFF can't handle multiple source files--lose, lose.  */
3067           && !strcmp (filename, main_input_filename)
3068 #endif
3069           /* COFF relative line numbers must be positive.  */
3070           && last_linenum > sdb_begin_function_line)
3071         {
3072 #ifdef ASM_OUTPUT_SOURCE_LINE
3073           ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
3074 #else
3075           fprintf (file, "\t.ln\t%d\n",
3076                    ((sdb_begin_function_line > -1)
3077                     ? last_linenum - sdb_begin_function_line : 1));
3078 #endif
3079         }
3080 #endif
3081
3082 #if defined (DBX_DEBUGGING_INFO)
3083       if (write_symbols == DBX_DEBUG)
3084         dbxout_source_line (file, filename, NOTE_LINE_NUMBER (insn));
3085 #endif
3086
3087 #if defined (XCOFF_DEBUGGING_INFO)
3088       if (write_symbols == XCOFF_DEBUG)
3089         xcoffout_source_line (file, filename, insn);
3090 #endif
3091
3092 #ifdef DWARF_DEBUGGING_INFO
3093       if (write_symbols == DWARF_DEBUG)
3094         dwarfout_line (filename, NOTE_LINE_NUMBER (insn));
3095 #endif
3096
3097 #ifdef DWARF2_DEBUGGING_INFO
3098       if (write_symbols == DWARF2_DEBUG)
3099         dwarf2out_line (filename, NOTE_LINE_NUMBER (insn));
3100 #endif
3101     }
3102 }
3103 \f
3104 /* For each operand in INSN, simplify (subreg (reg)) so that it refers
3105    directly to the desired hard register.  */
3106
3107 void
3108 cleanup_subreg_operands (insn)
3109      rtx insn;
3110 {
3111   int i;
3112   extract_insn_cached (insn);
3113   for (i = 0; i < recog_data.n_operands; i++)
3114     {
3115       if (GET_CODE (recog_data.operand[i]) == SUBREG)
3116         recog_data.operand[i] = alter_subreg (recog_data.operand[i]);
3117       else if (GET_CODE (recog_data.operand[i]) == PLUS
3118                || GET_CODE (recog_data.operand[i]) == MULT)
3119         recog_data.operand[i] = walk_alter_subreg (recog_data.operand[i]);
3120     }
3121
3122   for (i = 0; i < recog_data.n_dups; i++)
3123     {
3124       if (GET_CODE (*recog_data.dup_loc[i]) == SUBREG)
3125         *recog_data.dup_loc[i] = alter_subreg (*recog_data.dup_loc[i]);
3126       else if (GET_CODE (*recog_data.dup_loc[i]) == PLUS
3127                || GET_CODE (*recog_data.dup_loc[i]) == MULT)
3128         *recog_data.dup_loc[i] = walk_alter_subreg (*recog_data.dup_loc[i]);
3129     }
3130 }
3131
3132 /* If X is a SUBREG, replace it with a REG or a MEM,
3133    based on the thing it is a subreg of.  */
3134
3135 rtx
3136 alter_subreg (x)
3137      register rtx x;
3138 {
3139   register rtx y = SUBREG_REG (x);
3140
3141   if (GET_CODE (y) == SUBREG)
3142     y = alter_subreg (y);
3143
3144   /* If reload is operating, we may be replacing inside this SUBREG.
3145      Check for that and make a new one if so.  */
3146   if (reload_in_progress && find_replacement (&SUBREG_REG (x)) != 0)
3147     x = copy_rtx (x);
3148
3149   if (GET_CODE (y) == REG)
3150     {
3151       int regno;
3152       /* If the word size is larger than the size of this register,
3153          adjust the register number to compensate.  */
3154       /* ??? Note that this just catches stragglers created by/for
3155          integrate.  It would be better if we either caught these
3156          earlier, or kept _all_ subregs until now and eliminate
3157          gen_lowpart and friends.  */
3158
3159 #ifdef ALTER_HARD_SUBREG
3160       regno = ALTER_HARD_SUBREG (GET_MODE (x), SUBREG_WORD (x),
3161                                  GET_MODE (y), REGNO (y));
3162 #else
3163       regno = REGNO (y) + SUBREG_WORD (x);
3164 #endif
3165       PUT_CODE (x, REG);
3166       REGNO (x) = regno;
3167       ORIGINAL_REGNO (x) = ORIGINAL_REGNO (y);
3168       /* This field has a different meaning for REGs and SUBREGs.  Make sure
3169          to clear it!  */
3170       x->used = 0;
3171     }
3172   else if (GET_CODE (y) == MEM)
3173     {
3174       register int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
3175
3176       if (BYTES_BIG_ENDIAN)
3177         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))
3178                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y))));
3179       PUT_CODE (x, MEM);
3180       MEM_COPY_ATTRIBUTES (x, y);
3181       XEXP (x, 0) = plus_constant (XEXP (y, 0), offset);
3182     }
3183
3184   return x;
3185 }
3186
3187 /* Do alter_subreg on all the SUBREGs contained in X.  */
3188
3189 static rtx
3190 walk_alter_subreg (x)
3191      rtx x;
3192 {
3193   switch (GET_CODE (x))
3194     {
3195     case PLUS:
3196     case MULT:
3197       XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
3198       XEXP (x, 1) = walk_alter_subreg (XEXP (x, 1));
3199       break;
3200
3201     case MEM:
3202       XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
3203       break;
3204
3205     case SUBREG:
3206       return alter_subreg (x);
3207
3208     default:
3209       break;
3210     }
3211
3212   return x;
3213 }
3214 \f
3215 #ifdef HAVE_cc0
3216
3217 /* Given BODY, the body of a jump instruction, alter the jump condition
3218    as required by the bits that are set in cc_status.flags.
3219    Not all of the bits there can be handled at this level in all cases.
3220
3221    The value is normally 0.
3222    1 means that the condition has become always true.
3223    -1 means that the condition has become always false.
3224    2 means that COND has been altered.  */
3225
3226 static int
3227 alter_cond (cond)
3228      register rtx cond;
3229 {
3230   int value = 0;
3231
3232   if (cc_status.flags & CC_REVERSED)
3233     {
3234       value = 2;
3235       PUT_CODE (cond, swap_condition (GET_CODE (cond)));
3236     }
3237
3238   if (cc_status.flags & CC_INVERTED)
3239     {
3240       value = 2;
3241       PUT_CODE (cond, reverse_condition (GET_CODE (cond)));
3242     }
3243
3244   if (cc_status.flags & CC_NOT_POSITIVE)
3245     switch (GET_CODE (cond))
3246       {
3247       case LE:
3248       case LEU:
3249       case GEU:
3250         /* Jump becomes unconditional.  */
3251         return 1;
3252
3253       case GT:
3254       case GTU:
3255       case LTU:
3256         /* Jump becomes no-op.  */
3257         return -1;
3258
3259       case GE:
3260         PUT_CODE (cond, EQ);
3261         value = 2;
3262         break;
3263
3264       case LT:
3265         PUT_CODE (cond, NE);
3266         value = 2;
3267         break;
3268
3269       default:
3270         break;
3271       }
3272
3273   if (cc_status.flags & CC_NOT_NEGATIVE)
3274     switch (GET_CODE (cond))
3275       {
3276       case GE:
3277       case GEU:
3278         /* Jump becomes unconditional.  */
3279         return 1;
3280
3281       case LT:
3282       case LTU:
3283         /* Jump becomes no-op.  */
3284         return -1;
3285
3286       case LE:
3287       case LEU:
3288         PUT_CODE (cond, EQ);
3289         value = 2;
3290         break;
3291
3292       case GT:
3293       case GTU:
3294         PUT_CODE (cond, NE);
3295         value = 2;
3296         break;
3297
3298       default:
3299         break;
3300       }
3301
3302   if (cc_status.flags & CC_NO_OVERFLOW)
3303     switch (GET_CODE (cond))
3304       {
3305       case GEU:
3306         /* Jump becomes unconditional.  */
3307         return 1;
3308
3309       case LEU:
3310         PUT_CODE (cond, EQ);
3311         value = 2;
3312         break;
3313
3314       case GTU:
3315         PUT_CODE (cond, NE);
3316         value = 2;
3317         break;
3318
3319       case LTU:
3320         /* Jump becomes no-op.  */
3321         return -1;
3322
3323       default:
3324         break;
3325       }
3326
3327   if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N))
3328     switch (GET_CODE (cond))
3329       {
3330       default:
3331         abort ();
3332
3333       case NE:
3334         PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
3335         value = 2;
3336         break;
3337
3338       case EQ:
3339         PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE);
3340         value = 2;
3341         break;
3342       }
3343
3344   if (cc_status.flags & CC_NOT_SIGNED)
3345     /* The flags are valid if signed condition operators are converted
3346        to unsigned.  */
3347     switch (GET_CODE (cond))
3348       {
3349       case LE:
3350         PUT_CODE (cond, LEU);
3351         value = 2;
3352         break;
3353
3354       case LT:
3355         PUT_CODE (cond, LTU);
3356         value = 2;
3357         break;
3358
3359       case GT:
3360         PUT_CODE (cond, GTU);
3361         value = 2;
3362         break;
3363
3364       case GE:
3365         PUT_CODE (cond, GEU);
3366         value = 2;
3367         break;
3368
3369       default:
3370         break;
3371       }
3372
3373   return value;
3374 }
3375 #endif
3376 \f
3377 /* Report inconsistency between the assembler template and the operands.
3378    In an `asm', it's the user's fault; otherwise, the compiler's fault.  */
3379
3380 void
3381 output_operand_lossage (msgid)
3382      const char *msgid;
3383 {
3384   if (this_is_asm_operands)
3385     error_for_asm (this_is_asm_operands, "invalid `asm': %s", _(msgid));
3386   else
3387     {
3388       error ("output_operand: %s", _(msgid));
3389       abort ();
3390     }
3391 }
3392 \f
3393 /* Output of assembler code from a template, and its subroutines.  */
3394
3395 /* Output text from TEMPLATE to the assembler output file,
3396    obeying %-directions to substitute operands taken from
3397    the vector OPERANDS.
3398
3399    %N (for N a digit) means print operand N in usual manner.
3400    %lN means require operand N to be a CODE_LABEL or LABEL_REF
3401       and print the label name with no punctuation.
3402    %cN means require operand N to be a constant
3403       and print the constant expression with no punctuation.
3404    %aN means expect operand N to be a memory address
3405       (not a memory reference!) and print a reference
3406       to that address.
3407    %nN means expect operand N to be a constant
3408       and print a constant expression for minus the value
3409       of the operand, with no other punctuation.  */
3410
3411 static void
3412 output_asm_name ()
3413 {
3414   if (flag_print_asm_name)
3415     {
3416       /* Annotate the assembly with a comment describing the pattern and
3417          alternative used.  */
3418       if (debug_insn)
3419         {
3420           register int num = INSN_CODE (debug_insn);
3421           fprintf (asm_out_file, "\t%s %d\t%s",
3422                    ASM_COMMENT_START, INSN_UID (debug_insn),
3423                    insn_data[num].name);
3424           if (insn_data[num].n_alternatives > 1)
3425             fprintf (asm_out_file, "/%d", which_alternative + 1);
3426 #ifdef HAVE_ATTR_length
3427           fprintf (asm_out_file, "\t[length = %d]",
3428                    get_attr_length (debug_insn));
3429 #endif
3430           /* Clear this so only the first assembler insn
3431              of any rtl insn will get the special comment for -dp.  */
3432           debug_insn = 0;
3433         }
3434     }
3435 }
3436
3437 void
3438 output_asm_insn (template, operands)
3439      const char *template;
3440      rtx *operands;
3441 {
3442   register const char *p;
3443   register int c;
3444
3445   /* An insn may return a null string template
3446      in a case where no assembler code is needed.  */
3447   if (*template == 0)
3448     return;
3449
3450   p = template;
3451   putc ('\t', asm_out_file);
3452
3453 #ifdef ASM_OUTPUT_OPCODE
3454   ASM_OUTPUT_OPCODE (asm_out_file, p);
3455 #endif
3456
3457   while ((c = *p++))
3458     switch (c)
3459       {
3460       case '\n':
3461         output_asm_name ();
3462         putc (c, asm_out_file);
3463 #ifdef ASM_OUTPUT_OPCODE
3464         while ((c = *p) == '\t')
3465           {
3466             putc (c, asm_out_file);
3467             p++;
3468           }
3469         ASM_OUTPUT_OPCODE (asm_out_file, p);
3470 #endif
3471         break;
3472
3473 #ifdef ASSEMBLER_DIALECT
3474       case '{':
3475         {
3476           register int i;
3477
3478           /* If we want the first dialect, do nothing.  Otherwise, skip
3479              DIALECT_NUMBER of strings ending with '|'.  */
3480           for (i = 0; i < dialect_number; i++)
3481             {
3482               while (*p && *p != '}' && *p++ != '|')
3483                 ;
3484               if (*p == '}')
3485                 break;
3486               if (*p == '|')
3487                 p++;
3488             }
3489         }
3490         break;
3491
3492       case '|':
3493         /* Skip to close brace.  */
3494         while (*p && *p++ != '}')
3495           ;
3496         break;
3497
3498       case '}':
3499         break;
3500 #endif
3501
3502       case '%':
3503         /* %% outputs a single %.  */
3504         if (*p == '%')
3505           {
3506             p++;
3507             putc (c, asm_out_file);
3508           }
3509         /* %= outputs a number which is unique to each insn in the entire
3510            compilation.  This is useful for making local labels that are
3511            referred to more than once in a given insn.  */
3512         else if (*p == '=')
3513           {
3514             p++;
3515             fprintf (asm_out_file, "%d", insn_counter);
3516           }
3517         /* % followed by a letter and some digits
3518            outputs an operand in a special way depending on the letter.
3519            Letters `acln' are implemented directly.
3520            Other letters are passed to `output_operand' so that
3521            the PRINT_OPERAND macro can define them.  */
3522         else if (ISLOWER (*p) || ISUPPER (*p))
3523           {
3524             int letter = *p++;
3525             c = atoi (p);
3526
3527             if (! (*p >= '0' && *p <= '9'))
3528               output_operand_lossage ("operand number missing after %-letter");
3529             else if (this_is_asm_operands && (c < 0 || (unsigned int) c >= insn_noperands))
3530               output_operand_lossage ("operand number out of range");
3531             else if (letter == 'l')
3532               output_asm_label (operands[c]);
3533             else if (letter == 'a')
3534               output_address (operands[c]);
3535             else if (letter == 'c')
3536               {
3537                 if (CONSTANT_ADDRESS_P (operands[c]))
3538                   output_addr_const (asm_out_file, operands[c]);
3539                 else
3540                   output_operand (operands[c], 'c');
3541               }
3542             else if (letter == 'n')
3543               {
3544                 if (GET_CODE (operands[c]) == CONST_INT)
3545                   fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC,
3546                            - INTVAL (operands[c]));
3547                 else
3548                   {
3549                     putc ('-', asm_out_file);
3550                     output_addr_const (asm_out_file, operands[c]);
3551                   }
3552               }
3553             else
3554               output_operand (operands[c], letter);
3555
3556             while ((c = *p) >= '0' && c <= '9')
3557               p++;
3558           }
3559         /* % followed by a digit outputs an operand the default way.  */
3560         else if (*p >= '0' && *p <= '9')
3561           {
3562             c = atoi (p);
3563             if (this_is_asm_operands
3564                 && (c < 0 || (unsigned int) c >= insn_noperands))
3565               output_operand_lossage ("operand number out of range");
3566             else
3567               output_operand (operands[c], 0);
3568             while ((c = *p) >= '0' && c <= '9')
3569               p++;
3570           }
3571         /* % followed by punctuation: output something for that
3572            punctuation character alone, with no operand.
3573            The PRINT_OPERAND macro decides what is actually done.  */
3574 #ifdef PRINT_OPERAND_PUNCT_VALID_P
3575         else if (PRINT_OPERAND_PUNCT_VALID_P ((unsigned char) *p))
3576           output_operand (NULL_RTX, *p++);
3577 #endif
3578         else
3579           output_operand_lossage ("invalid %%-code");
3580         break;
3581
3582       default:
3583         putc (c, asm_out_file);
3584       }
3585
3586   output_asm_name ();
3587
3588   putc ('\n', asm_out_file);
3589 }
3590 \f
3591 /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol.  */
3592
3593 void
3594 output_asm_label (x)
3595      rtx x;
3596 {
3597   char buf[256];
3598
3599   if (GET_CODE (x) == LABEL_REF)
3600     x = XEXP (x, 0);
3601   if (GET_CODE (x) == CODE_LABEL
3602       || (GET_CODE (x) == NOTE
3603           && NOTE_LINE_NUMBER (x) == NOTE_INSN_DELETED_LABEL))
3604     ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3605   else
3606     output_operand_lossage ("`%l' operand isn't a label");
3607
3608   assemble_name (asm_out_file, buf);
3609 }
3610
3611 /* Print operand X using machine-dependent assembler syntax.
3612    The macro PRINT_OPERAND is defined just to control this function.
3613    CODE is a non-digit that preceded the operand-number in the % spec,
3614    such as 'z' if the spec was `%z3'.  CODE is 0 if there was no char
3615    between the % and the digits.
3616    When CODE is a non-letter, X is 0.
3617
3618    The meanings of the letters are machine-dependent and controlled
3619    by PRINT_OPERAND.  */
3620
3621 static void
3622 output_operand (x, code)
3623      rtx x;
3624      int code ATTRIBUTE_UNUSED;
3625 {
3626   if (x && GET_CODE (x) == SUBREG)
3627     x = alter_subreg (x);
3628
3629   /* If X is a pseudo-register, abort now rather than writing trash to the
3630      assembler file.  */
3631
3632   if (x && GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER)
3633     abort ();
3634
3635   PRINT_OPERAND (asm_out_file, x, code);
3636 }
3637
3638 /* Print a memory reference operand for address X
3639    using machine-dependent assembler syntax.
3640    The macro PRINT_OPERAND_ADDRESS exists just to control this function.  */
3641
3642 void
3643 output_address (x)
3644      rtx x;
3645 {
3646   walk_alter_subreg (x);
3647   PRINT_OPERAND_ADDRESS (asm_out_file, x);
3648 }
3649 \f
3650 /* Print an integer constant expression in assembler syntax.
3651    Addition and subtraction are the only arithmetic
3652    that may appear in these expressions.  */
3653
3654 void
3655 output_addr_const (file, x)
3656      FILE *file;
3657      rtx x;
3658 {
3659   char buf[256];
3660
3661  restart:
3662   switch (GET_CODE (x))
3663     {
3664     case PC:
3665       if (flag_pic)
3666         putc ('.', file);
3667       else
3668         abort ();
3669       break;
3670
3671     case SYMBOL_REF:
3672 #ifdef ASM_OUTPUT_SYMBOL_REF
3673       ASM_OUTPUT_SYMBOL_REF (file, x);
3674 #else
3675       assemble_name (file, XSTR (x, 0));
3676 #endif
3677       break;
3678
3679     case LABEL_REF:
3680       x = XEXP (x, 0);
3681       /* Fall through.  */
3682     case CODE_LABEL:
3683       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3684       assemble_name (file, buf);
3685       break;
3686
3687     case CONST_INT:
3688       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
3689       break;
3690
3691     case CONST:
3692       /* This used to output parentheses around the expression,
3693          but that does not work on the 386 (either ATT or BSD assembler).  */
3694       output_addr_const (file, XEXP (x, 0));
3695       break;
3696
3697     case CONST_DOUBLE:
3698       if (GET_MODE (x) == VOIDmode)
3699         {
3700           /* We can use %d if the number is one word and positive.  */
3701           if (CONST_DOUBLE_HIGH (x))
3702             fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3703                      CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
3704           else if (CONST_DOUBLE_LOW (x) < 0)
3705             fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
3706           else
3707             fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
3708         }
3709       else
3710         /* We can't handle floating point constants;
3711            PRINT_OPERAND must handle them.  */
3712         output_operand_lossage ("floating constant misused");
3713       break;
3714
3715     case PLUS:
3716       /* Some assemblers need integer constants to appear last (eg masm).  */
3717       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
3718         {
3719           output_addr_const (file, XEXP (x, 1));
3720           if (INTVAL (XEXP (x, 0)) >= 0)
3721             fprintf (file, "+");
3722           output_addr_const (file, XEXP (x, 0));
3723         }
3724       else
3725         {
3726           output_addr_const (file, XEXP (x, 0));
3727           if (GET_CODE (XEXP (x, 1)) != CONST_INT
3728               || INTVAL (XEXP (x, 1)) >= 0)
3729             fprintf (file, "+");
3730           output_addr_const (file, XEXP (x, 1));
3731         }
3732       break;
3733
3734     case MINUS:
3735       /* Avoid outputting things like x-x or x+5-x,
3736          since some assemblers can't handle that.  */
3737       x = simplify_subtraction (x);
3738       if (GET_CODE (x) != MINUS)
3739         goto restart;
3740
3741       output_addr_const (file, XEXP (x, 0));
3742       fprintf (file, "-");
3743       if ((GET_CODE (XEXP (x, 1)) == CONST_INT
3744            && INTVAL (XEXP (x, 1)) < 0)
3745           || GET_CODE (XEXP (x, 1)) != CONST_INT)
3746         {
3747           fprintf (file, "%s", ASM_OPEN_PAREN);
3748           output_addr_const (file, XEXP (x, 1));
3749           fprintf (file, "%s", ASM_CLOSE_PAREN);
3750         }
3751       else
3752         output_addr_const (file, XEXP (x, 1));
3753       break;
3754
3755     case ZERO_EXTEND:
3756     case SIGN_EXTEND:
3757       output_addr_const (file, XEXP (x, 0));
3758       break;
3759
3760     default:
3761 #ifdef OUTPUT_ADDR_CONST_EXTRA
3762       OUTPUT_ADDR_CONST_EXTRA (file, x, fail);
3763       break;
3764
3765     fail:
3766 #endif
3767       output_operand_lossage ("invalid expression as operand");
3768     }
3769 }
3770 \f
3771 /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
3772    %R prints the value of REGISTER_PREFIX.
3773    %L prints the value of LOCAL_LABEL_PREFIX.
3774    %U prints the value of USER_LABEL_PREFIX.
3775    %I prints the value of IMMEDIATE_PREFIX.
3776    %O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
3777    Also supported are %d, %x, %s, %e, %f, %g and %%.
3778
3779    We handle alternate assembler dialects here, just like output_asm_insn.  */
3780
3781 void
3782 asm_fprintf VPARAMS ((FILE *file, const char *p, ...))
3783 {
3784 #ifndef ANSI_PROTOTYPES
3785   FILE *file;
3786   const char *p;
3787 #endif
3788   va_list argptr;
3789   char buf[10];
3790   char *q, c;
3791
3792   VA_START (argptr, p);
3793
3794 #ifndef ANSI_PROTOTYPES
3795   file = va_arg (argptr, FILE *);
3796   p = va_arg (argptr, const char *);
3797 #endif
3798
3799   buf[0] = '%';
3800
3801   while ((c = *p++))
3802     switch (c)
3803       {
3804 #ifdef ASSEMBLER_DIALECT
3805       case '{':
3806         {
3807           int i;
3808
3809           /* If we want the first dialect, do nothing.  Otherwise, skip
3810              DIALECT_NUMBER of strings ending with '|'.  */
3811           for (i = 0; i < dialect_number; i++)
3812             {
3813               while (*p && *p++ != '|')
3814                 ;
3815
3816               if (*p == '|')
3817                 p++;
3818             }
3819         }
3820         break;
3821
3822       case '|':
3823         /* Skip to close brace.  */
3824         while (*p && *p++ != '}')
3825           ;
3826         break;
3827
3828       case '}':
3829         break;
3830 #endif
3831
3832       case '%':
3833         c = *p++;
3834         q = &buf[1];
3835         while ((c >= '0' && c <= '9') || c == '.')
3836           {
3837             *q++ = c;
3838             c = *p++;
3839           }
3840         switch (c)
3841           {
3842           case '%':
3843             fprintf (file, "%%");
3844             break;
3845
3846           case 'd':  case 'i':  case 'u':
3847           case 'x':  case 'p':  case 'X':
3848           case 'o':
3849             *q++ = c;
3850             *q = 0;
3851             fprintf (file, buf, va_arg (argptr, int));
3852             break;
3853
3854           case 'w':
3855             /* This is a prefix to the 'd', 'i', 'u', 'x', 'p', and 'X' cases,
3856                but we do not check for those cases.  It means that the value
3857                is a HOST_WIDE_INT, which may be either `int' or `long'.  */
3858
3859 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
3860 #else
3861 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
3862             *q++ = 'l';
3863 #else
3864             *q++ = 'l';
3865             *q++ = 'l';
3866 #endif
3867 #endif
3868
3869             *q++ = *p++;
3870             *q = 0;
3871             fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT));
3872             break;
3873
3874           case 'l':
3875             *q++ = c;
3876             *q++ = *p++;
3877             *q = 0;
3878             fprintf (file, buf, va_arg (argptr, long));
3879             break;
3880
3881           case 'e':
3882           case 'f':
3883           case 'g':
3884             *q++ = c;
3885             *q = 0;
3886             fprintf (file, buf, va_arg (argptr, double));
3887             break;
3888
3889           case 's':
3890             *q++ = c;
3891             *q = 0;
3892             fprintf (file, buf, va_arg (argptr, char *));
3893             break;
3894
3895           case 'O':
3896 #ifdef ASM_OUTPUT_OPCODE
3897             ASM_OUTPUT_OPCODE (asm_out_file, p);
3898 #endif
3899             break;
3900
3901           case 'R':
3902 #ifdef REGISTER_PREFIX
3903             fprintf (file, "%s", REGISTER_PREFIX);
3904 #endif
3905             break;
3906
3907           case 'I':
3908 #ifdef IMMEDIATE_PREFIX
3909             fprintf (file, "%s", IMMEDIATE_PREFIX);
3910 #endif
3911             break;
3912
3913           case 'L':
3914 #ifdef LOCAL_LABEL_PREFIX
3915             fprintf (file, "%s", LOCAL_LABEL_PREFIX);
3916 #endif
3917             break;
3918
3919           case 'U':
3920             fputs (user_label_prefix, file);
3921             break;
3922
3923 #ifdef ASM_FPRINTF_EXTENSIONS
3924             /* Upper case letters are reserved for general use by asm_fprintf
3925                and so are not available to target specific code.  In order to
3926                prevent the ASM_FPRINTF_EXTENSIONS macro from using them then,
3927                they are defined here.  As they get turned into real extensions
3928                to asm_fprintf they should be removed from this list.  */
3929           case 'A': case 'B': case 'C': case 'D': case 'E':
3930           case 'F': case 'G': case 'H': case 'J': case 'K':
3931           case 'M': case 'N': case 'P': case 'Q': case 'S':
3932           case 'T': case 'V': case 'W': case 'Y': case 'Z':
3933             break;
3934
3935           ASM_FPRINTF_EXTENSIONS (file, argptr, p)
3936 #endif
3937           default:
3938             abort ();
3939           }
3940         break;
3941
3942       default:
3943         fputc (c, file);
3944       }
3945   va_end (argptr);
3946 }
3947 \f
3948 /* Split up a CONST_DOUBLE or integer constant rtx
3949    into two rtx's for single words,
3950    storing in *FIRST the word that comes first in memory in the target
3951    and in *SECOND the other.  */
3952
3953 void
3954 split_double (value, first, second)
3955      rtx value;
3956      rtx *first, *second;
3957 {
3958   if (GET_CODE (value) == CONST_INT)
3959     {
3960       if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD))
3961         {
3962           /* In this case the CONST_INT holds both target words.
3963              Extract the bits from it into two word-sized pieces.
3964              Sign extend each half to HOST_WIDE_INT.  */
3965           unsigned HOST_WIDE_INT low, high;
3966           unsigned HOST_WIDE_INT mask, sign_bit, sign_extend;
3967
3968           /* Set sign_bit to the most significant bit of a word.  */
3969           sign_bit = 1;
3970           sign_bit <<= BITS_PER_WORD - 1;
3971
3972           /* Set mask so that all bits of the word are set.  We could
3973              have used 1 << BITS_PER_WORD instead of basing the
3974              calculation on sign_bit.  However, on machines where
3975              HOST_BITS_PER_WIDE_INT == BITS_PER_WORD, it could cause a
3976              compiler warning, even though the code would never be
3977              executed.  */
3978           mask = sign_bit << 1;
3979           mask--;
3980
3981           /* Set sign_extend as any remaining bits.  */
3982           sign_extend = ~mask;
3983
3984           /* Pick the lower word and sign-extend it.  */
3985           low = INTVAL (value);
3986           low &= mask;
3987           if (low & sign_bit)
3988             low |= sign_extend;
3989
3990           /* Pick the higher word, shifted to the least significant
3991              bits, and sign-extend it.  */
3992           high = INTVAL (value);
3993           high >>= BITS_PER_WORD - 1;
3994           high >>= 1;
3995           high &= mask;
3996           if (high & sign_bit)
3997             high |= sign_extend;
3998
3999           /* Store the words in the target machine order.  */
4000           if (WORDS_BIG_ENDIAN)
4001             {
4002               *first = GEN_INT (high);
4003               *second = GEN_INT (low);
4004             }
4005           else
4006             {
4007               *first = GEN_INT (low);
4008               *second = GEN_INT (high);
4009             }
4010         }
4011       else
4012         {
4013           /* The rule for using CONST_INT for a wider mode
4014              is that we regard the value as signed.
4015              So sign-extend it.  */
4016           rtx high = (INTVAL (value) < 0 ? constm1_rtx : const0_rtx);
4017           if (WORDS_BIG_ENDIAN)
4018             {
4019               *first = high;
4020               *second = value;
4021             }
4022           else
4023             {
4024               *first = value;
4025               *second = high;
4026             }
4027         }
4028     }
4029   else if (GET_CODE (value) != CONST_DOUBLE)
4030     {
4031       if (WORDS_BIG_ENDIAN)
4032         {
4033           *first = const0_rtx;
4034           *second = value;
4035         }
4036       else
4037         {
4038           *first = value;
4039           *second = const0_rtx;
4040         }
4041     }
4042   else if (GET_MODE (value) == VOIDmode
4043            /* This is the old way we did CONST_DOUBLE integers.  */
4044            || GET_MODE_CLASS (GET_MODE (value)) == MODE_INT)
4045     {
4046       /* In an integer, the words are defined as most and least significant.
4047          So order them by the target's convention.  */
4048       if (WORDS_BIG_ENDIAN)
4049         {
4050           *first = GEN_INT (CONST_DOUBLE_HIGH (value));
4051           *second = GEN_INT (CONST_DOUBLE_LOW (value));
4052         }
4053       else
4054         {
4055           *first = GEN_INT (CONST_DOUBLE_LOW (value));
4056           *second = GEN_INT (CONST_DOUBLE_HIGH (value));
4057         }
4058     }
4059   else
4060     {
4061 #ifdef REAL_ARITHMETIC
4062       REAL_VALUE_TYPE r;
4063       long l[2];
4064       REAL_VALUE_FROM_CONST_DOUBLE (r, value);
4065
4066       /* Note, this converts the REAL_VALUE_TYPE to the target's
4067          format, splits up the floating point double and outputs
4068          exactly 32 bits of it into each of l[0] and l[1] --
4069          not necessarily BITS_PER_WORD bits.  */
4070       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
4071
4072       /* If 32 bits is an entire word for the target, but not for the host,
4073          then sign-extend on the host so that the number will look the same
4074          way on the host that it would on the target.  See for instance
4075          simplify_unary_operation.  The #if is needed to avoid compiler
4076          warnings.  */
4077
4078 #if HOST_BITS_PER_LONG > 32
4079       if (BITS_PER_WORD < HOST_BITS_PER_LONG && BITS_PER_WORD == 32)
4080         {
4081           if (l[0] & ((long) 1 << 31))
4082             l[0] |= ((long) (-1) << 32);
4083           if (l[1] & ((long) 1 << 31))
4084             l[1] |= ((long) (-1) << 32);
4085         }
4086 #endif
4087
4088       *first = GEN_INT ((HOST_WIDE_INT) l[0]);
4089       *second = GEN_INT ((HOST_WIDE_INT) l[1]);
4090 #else
4091       if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
4092            || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
4093           && ! flag_pretend_float)
4094         abort ();
4095
4096       if (
4097 #ifdef HOST_WORDS_BIG_ENDIAN
4098           WORDS_BIG_ENDIAN
4099 #else
4100           ! WORDS_BIG_ENDIAN
4101 #endif
4102           )
4103         {
4104           /* Host and target agree => no need to swap.  */
4105           *first = GEN_INT (CONST_DOUBLE_LOW (value));
4106           *second = GEN_INT (CONST_DOUBLE_HIGH (value));
4107         }
4108       else
4109         {
4110           *second = GEN_INT (CONST_DOUBLE_LOW (value));
4111           *first = GEN_INT (CONST_DOUBLE_HIGH (value));
4112         }
4113 #endif /* no REAL_ARITHMETIC */
4114     }
4115 }
4116 \f
4117 /* Return nonzero if this function has no function calls.  */
4118
4119 int
4120 leaf_function_p ()
4121 {
4122   rtx insn;
4123   rtx link;
4124
4125   if (profile_flag || profile_block_flag || profile_arc_flag)
4126     return 0;
4127
4128   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4129     {
4130       if (GET_CODE (insn) == CALL_INSN
4131           && ! SIBLING_CALL_P (insn))
4132         return 0;
4133       if (GET_CODE (insn) == INSN
4134           && GET_CODE (PATTERN (insn)) == SEQUENCE
4135           && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN
4136           && ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
4137         return 0;
4138     }
4139   for (link = current_function_epilogue_delay_list;
4140        link;
4141        link = XEXP (link, 1))
4142     {
4143       insn = XEXP (link, 0);
4144
4145       if (GET_CODE (insn) == CALL_INSN
4146           && ! SIBLING_CALL_P (insn))
4147         return 0;
4148       if (GET_CODE (insn) == INSN
4149           && GET_CODE (PATTERN (insn)) == SEQUENCE
4150           && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN
4151           && ! SIBLING_CALL_P (XVECEXP (PATTERN (insn), 0, 0)))
4152         return 0;
4153     }
4154
4155   return 1;
4156 }
4157
4158 /* On some machines, a function with no call insns
4159    can run faster if it doesn't create its own register window.
4160    When output, the leaf function should use only the "output"
4161    registers.  Ordinarily, the function would be compiled to use
4162    the "input" registers to find its arguments; it is a candidate
4163    for leaf treatment if it uses only the "input" registers.
4164    Leaf function treatment means renumbering so the function
4165    uses the "output" registers instead.  */
4166
4167 #ifdef LEAF_REGISTERS
4168
4169 /* Return 1 if this function uses only the registers that can be
4170    safely renumbered.  */
4171
4172 int
4173 only_leaf_regs_used ()
4174 {
4175   int i;
4176   char *permitted_reg_in_leaf_functions = LEAF_REGISTERS;
4177
4178   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
4179     if ((regs_ever_live[i] || global_regs[i])
4180         && ! permitted_reg_in_leaf_functions[i])
4181       return 0;
4182
4183   if (current_function_uses_pic_offset_table
4184       && pic_offset_table_rtx != 0
4185       && GET_CODE (pic_offset_table_rtx) == REG
4186       && ! permitted_reg_in_leaf_functions[REGNO (pic_offset_table_rtx)])
4187     return 0;
4188
4189   return 1;
4190 }
4191
4192 /* Scan all instructions and renumber all registers into those
4193    available in leaf functions.  */
4194
4195 static void
4196 leaf_renumber_regs (first)
4197      rtx first;
4198 {
4199   rtx insn;
4200
4201   /* Renumber only the actual patterns.
4202      The reg-notes can contain frame pointer refs,
4203      and renumbering them could crash, and should not be needed.  */
4204   for (insn = first; insn; insn = NEXT_INSN (insn))
4205     if (INSN_P (insn))
4206       leaf_renumber_regs_insn (PATTERN (insn));
4207   for (insn = current_function_epilogue_delay_list;
4208        insn;
4209        insn = XEXP (insn, 1))
4210     if (INSN_P (XEXP (insn, 0)))
4211       leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0)));
4212 }
4213
4214 /* Scan IN_RTX and its subexpressions, and renumber all regs into those
4215    available in leaf functions.  */
4216
4217 void
4218 leaf_renumber_regs_insn (in_rtx)
4219      register rtx in_rtx;
4220 {
4221   register int i, j;
4222   register const char *format_ptr;
4223
4224   if (in_rtx == 0)
4225     return;
4226
4227   /* Renumber all input-registers into output-registers.
4228      renumbered_regs would be 1 for an output-register;
4229      they  */
4230
4231   if (GET_CODE (in_rtx) == REG)
4232     {
4233       int newreg;
4234
4235       /* Don't renumber the same reg twice.  */
4236       if (in_rtx->used)
4237         return;
4238
4239       newreg = REGNO (in_rtx);
4240       /* Don't try to renumber pseudo regs.  It is possible for a pseudo reg
4241          to reach here as part of a REG_NOTE.  */
4242       if (newreg >= FIRST_PSEUDO_REGISTER)
4243         {
4244           in_rtx->used = 1;
4245           return;
4246         }
4247       newreg = LEAF_REG_REMAP (newreg);
4248       if (newreg < 0)
4249         abort ();
4250       regs_ever_live[REGNO (in_rtx)] = 0;
4251       regs_ever_live[newreg] = 1;
4252       REGNO (in_rtx) = newreg;
4253       in_rtx->used = 1;
4254     }
4255
4256   if (INSN_P (in_rtx))
4257     {
4258       /* Inside a SEQUENCE, we find insns.
4259          Renumber just the patterns of these insns,
4260          just as we do for the top-level insns.  */
4261       leaf_renumber_regs_insn (PATTERN (in_rtx));
4262       return;
4263     }
4264
4265   format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
4266
4267   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
4268     switch (*format_ptr++)
4269       {
4270       case 'e':
4271         leaf_renumber_regs_insn (XEXP (in_rtx, i));
4272         break;
4273
4274       case 'E':
4275         if (NULL != XVEC (in_rtx, i))
4276           {
4277             for (j = 0; j < XVECLEN (in_rtx, i); j++)
4278               leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
4279           }
4280         break;
4281
4282       case 'S':
4283       case 's':
4284       case '0':
4285       case 'i':
4286       case 'w':
4287       case 'n':
4288       case 'u':
4289         break;
4290
4291       default:
4292         abort ();
4293       }
4294 }
4295 #endif