gcc/final.c

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