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 (dest, seq, 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   /* We use max_log here to keep track of the maximum alignment we want to
 986      impose on the next CODE_LABEL (or the current one if we are processing
 987      the CODE_LABEL itself).  */
 988
 989   for (max_log = 0, insn = get_insns (), i = 1; insn; insn = NEXT_INSN (insn))
 990     {
 991       int log;
 992
 993       INSN_SHUID (insn) = i++;
 994       if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
 995         {
 996           /* reorg might make the first insn of a loop being run once only,
 997              and delete the label in front of it.  Then we want to apply
 998              the loop alignment to the new label created by reorg, which
 999              is separated by the former loop start insn from the
1000              NOTE_INSN_LOOP_BEG.  */
1001         }
1002       else if (GET_CODE (insn) == CODE_LABEL)
1003         {
1004           rtx next;
1005
1006           log = LABEL_ALIGN (insn);
1007           if (max_log < log)
1008             max_log = log;
1009           next = NEXT_INSN (insn);
1010 /* ADDR_VECs only take room if read-only data goes into the text section.  */
1011 #if !defined(READONLY_DATA_SECTION) || defined(JUMP_TABLES_IN_TEXT_SECTION)
1012           if (next && GET_CODE (next) == JUMP_INSN)
1013             {
1014               rtx nextbody = PATTERN (next);
1015               if (GET_CODE (nextbody) == ADDR_VEC
1016                   || GET_CODE (nextbody) == ADDR_DIFF_VEC)
1017                 {
1018                   log = ADDR_VEC_ALIGN (next);
1019                   if (max_log < log)
1020                     max_log = log;
1021                 }
1022             }
1023 #endif
1024           LABEL_TO_ALIGNMENT (insn) = max_log;
1025           max_log = 0;
1026         }
1027       else if (GET_CODE (insn) == BARRIER)
1028         {
1029           rtx label;
1030
1031           for (label = insn; label && GET_RTX_CLASS (GET_CODE (label)) != 'i';
1032                label = NEXT_INSN (label))
1033             if (GET_CODE (label) == CODE_LABEL)
1034               {
1035                 log = LABEL_ALIGN_AFTER_BARRIER (insn);
1036                 if (max_log < log)
1037                   max_log = log;
1038                 break;
1039               }
1040         }
1041       /* Again, we allow NOTE_INSN_LOOP_BEG - INSN - CODE_LABEL
1042          sequences in order to handle reorg output efficiently.  */
1043       else if (GET_CODE (insn) == NOTE
1044                && NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
1045         {
1046           rtx label;
1047
1048           for (label = insn; label; label = NEXT_INSN (label))
1049             if (GET_CODE (label) == CODE_LABEL)
1050               {
1051                 log = LOOP_ALIGN (insn);
1052                 if (max_log < log)
1053                   max_log = log;
1054                 break;
1055               }
1056         }
1057       else
1058         continue;
1059     }
1060 #ifdef HAVE_ATTR_length
1061
1062   /* Allocate the rest of the arrays.  */
1063   if (insn_lengths)
1064     free (insn_lengths);
1065   insn_lengths = (short *) xmalloc (max_uid * sizeof (short));
1066   if (insn_addresses)
1067     free (insn_addresses);
1068   insn_addresses = (int *) xmalloc (max_uid * sizeof (int));
1069   if (uid_align)
1070     free (uid_align);
1071   uid_align = (rtx *) xmalloc (max_uid * sizeof *uid_align);
1072
1073   varying_length = (char *) xmalloc (max_uid * sizeof (char));
1074
1075   bzero (varying_length, max_uid);
1076
1077   /* Initialize uid_align.  We scan instructions
1078      from end to start, and keep in align_tab[n] the last seen insn
1079      that does an alignment of at least n+1, i.e. the successor
1080      in the alignment chain for an insn that does / has a known
1081      alignment of n.  */
1082
1083   bzero ((char *) uid_align, max_uid * sizeof *uid_align);
1084
1085   for (i = MAX_CODE_ALIGN; --i >= 0; )
1086     align_tab[i] = NULL_RTX;
1087   seq = get_last_insn ();
1088   for (insn_current_address = 0; seq; seq = PREV_INSN (seq))
1089     {
1090       int uid = INSN_UID (seq);
1091       int log;
1092       log = (GET_CODE (seq) == CODE_LABEL ? LABEL_TO_ALIGNMENT (seq) : 0);
1093       uid_align[uid] = align_tab[0];
1094       insn_addresses[uid] = --insn_current_address;
1095       if (log)
1096         {
1097           /* Found an alignment label.  */
1098           uid_align[uid] = align_tab[log];
1099           for (i = log - 1; i >= 0; i--)
1100             align_tab[i] = seq;
1101         }
1102       if (GET_CODE (seq) != INSN || GET_CODE (PATTERN (seq)) != SEQUENCE)
1103         insn = seq;
1104       else
1105         {
1106           insn = XVECEXP (PATTERN (seq), 0, 0);
1107           uid = INSN_UID (insn);
1108         }
1109     }
1110
1111
1112   /* Compute initial lengths, addresses, and varying flags for each insn.  */
1113   for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
1114        insn != 0;
1115        insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
1116     {
1117       uid = INSN_UID (insn);
1118
1119       insn_lengths[uid] = 0;
1120
1121       if (GET_CODE (insn) == CODE_LABEL)
1122         {
1123           int log = LABEL_TO_ALIGNMENT (insn);
1124           if (log)
1125             {
1126               int align = 1 << log;
1127               int new_address = insn_current_address + align - 1 & -align;
1128               insn_lengths[uid] = new_address - insn_current_address;
1129               insn_current_address = new_address;
1130             }
1131         }
1132
1133       insn_addresses[uid] = insn_current_address;
1134
1135       if (GET_CODE (insn) == NOTE || GET_CODE (insn) == BARRIER
1136           || GET_CODE (insn) == CODE_LABEL)
1137         continue;
1138       if (INSN_DELETED_P (insn))
1139         continue;
1140
1141       body = PATTERN (insn);
1142       if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
1143         ; /* This should be handled by LABEL_ALIGN.  */
1144       else if (asm_noperands (body) >= 0)
1145         insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
1146       else if (GET_CODE (body) == SEQUENCE)
1147         {
1148           int i;
1149           int const_delay_slots;
1150 #ifdef DELAY_SLOTS
1151           const_delay_slots = const_num_delay_slots (XVECEXP (body, 0, 0));
1152 #else
1153           const_delay_slots = 0;
1154 #endif
1155           /* Inside a delay slot sequence, we do not do any branch shortening
1156              if the shortening could change the number of delay slots
1157              of the branch.  */
1158           for (i = 0; i < XVECLEN (body, 0); i++)
1159             {
1160               rtx inner_insn = XVECEXP (body, 0, i);
1161               int inner_uid = INSN_UID (inner_insn);
1162               int inner_length;
1163
1164               if (asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0)
1165                 inner_length = (asm_insn_count (PATTERN (inner_insn))
1166                                 * insn_default_length (inner_insn));
1167               else
1168                 inner_length = insn_default_length (inner_insn);
1169
1170               insn_lengths[inner_uid] = inner_length;
1171               if (const_delay_slots)
1172                 {
1173                   if ((varying_length[inner_uid]
1174                        = insn_variable_length_p (inner_insn)) != 0)
1175                     varying_length[uid] = 1;
1176                   insn_addresses[inner_uid] = (insn_current_address +
1177                                                insn_lengths[uid]);
1178                 }
1179               else
1180                 varying_length[inner_uid] = 0;
1181               insn_lengths[uid] += inner_length;
1182             }
1183         }
1184       else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
1185         {
1186           insn_lengths[uid] = insn_default_length (insn);
1187           varying_length[uid] = insn_variable_length_p (insn);
1188         }
1189
1190       /* If needed, do any adjustment.  */
1191 #ifdef ADJUST_INSN_LENGTH
1192       ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
1193 #endif
1194     }
1195
1196   /* Now loop over all the insns finding varying length insns.  For each,
1197      get the current insn length.  If it has changed, reflect the change.
1198      When nothing changes for a full pass, we are done.  */
1199
1200   while (something_changed)
1201     {
1202       something_changed = 0;
1203       insn_current_align = MAX_CODE_ALIGN - 1;
1204       for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
1205            insn != 0;
1206            insn = NEXT_INSN (insn))
1207         {
1208           int new_length;
1209 #ifdef SHORTEN_WITH_ADJUST_INSN_LENGTH
1210 #ifdef ADJUST_INSN_LENGTH
1211           int tmp_length;
1212 #endif
1213 #endif
1214           int length_align;
1215
1216           uid = INSN_UID (insn);
1217
1218           if (GET_CODE (insn) == CODE_LABEL)
1219             {
1220               int log = LABEL_TO_ALIGNMENT (insn);
1221               if (log > insn_current_align)
1222                 {
1223                   int align = 1 << log;
1224                   int new_address= insn_current_address + align - 1 & -align;
1225                   insn_lengths[uid] = new_address - insn_current_address;
1226                   insn_current_align = log;
1227                   insn_current_address = new_address;
1228                 }
1229               else
1230                 insn_lengths[uid] = 0;
1231               insn_addresses[uid] = insn_current_address;
1232               continue;
1233             }
1234
1235           length_align = INSN_LENGTH_ALIGNMENT (insn);
1236           if (length_align < insn_current_align)
1237             insn_current_align = length_align;
1238
1239           insn_last_address = insn_addresses[uid];
1240           insn_addresses[uid] = insn_current_address;
1241
1242           if (! varying_length[uid])
1243             {
1244               insn_current_address += insn_lengths[uid];
1245               continue;
1246             }
1247           if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
1248             {
1249               int i;
1250
1251               body = PATTERN (insn);
1252               new_length = 0;
1253               for (i = 0; i < XVECLEN (body, 0); i++)
1254                 {
1255                   rtx inner_insn = XVECEXP (body, 0, i);
1256                   int inner_uid = INSN_UID (inner_insn);
1257                   int inner_length;
1258
1259                   insn_addresses[inner_uid] = insn_current_address;
1260
1261                   /* insn_current_length returns 0 for insns with a
1262                      non-varying length.  */
1263                   if (! varying_length[inner_uid])
1264                     inner_length = insn_lengths[inner_uid];
1265                   else
1266                     inner_length = insn_current_length (inner_insn);
1267
1268                   if (inner_length != insn_lengths[inner_uid])
1269                     {
1270                       insn_lengths[inner_uid] = inner_length;
1271                       something_changed = 1;
1272                     }
1273                   insn_current_address += insn_lengths[inner_uid];
1274                   new_length += inner_length;
1275                 }
1276             }
1277           else
1278             {
1279               new_length = insn_current_length (insn);
1280               insn_current_address += new_length;
1281             }
1282
1283 #ifdef SHORTEN_WITH_ADJUST_INSN_LENGTH
1284 #ifdef ADJUST_INSN_LENGTH
1285           /* If needed, do any adjustment.  */
1286           tmp_length = new_length;
1287           ADJUST_INSN_LENGTH (insn, new_length);
1288           insn_current_address += (new_length - tmp_length);
1289 #endif
1290 #endif
1291
1292           if (new_length != insn_lengths[uid])
1293             {
1294               insn_lengths[uid] = new_length;
1295               something_changed = 1;
1296             }
1297         }
1298       /* For a non-optimizing compile, do only a single pass.  */
1299       if (!optimize)
1300         break;
1301     }
1302
1303   free (varying_length);
1304
1305 #endif /* HAVE_ATTR_length */
1306 }
1307
1308 #ifdef HAVE_ATTR_length
1309 /* Given the body of an INSN known to be generated by an ASM statement, return
1310    the number of machine instructions likely to be generated for this insn.
1311    This is used to compute its length.  */
1312
1313 static int
1314 asm_insn_count (body)
1315      rtx body;
1316 {
1317   char *template;
1318   int count = 1;
1319
1320   if (GET_CODE (body) == ASM_INPUT)
1321     template = XSTR (body, 0);
1322   else
1323     template = decode_asm_operands (body, NULL_PTR, NULL_PTR,
1324                                     NULL_PTR, NULL_PTR);
1325
1326   for ( ; *template; template++)
1327     if (IS_ASM_LOGICAL_LINE_SEPARATOR(*template) || *template == '\n')
1328       count++;
1329
1330   return count;
1331 }
1332 #endif
1333 \f
1334 /* Output assembler code for the start of a function,
1335    and initialize some of the variables in this file
1336    for the new function.  The label for the function and associated
1337    assembler pseudo-ops have already been output in `assemble_start_function'.
1338
1339    FIRST is the first insn of the rtl for the function being compiled.
1340    FILE is the file to write assembler code to.
1341    OPTIMIZE is nonzero if we should eliminate redundant
1342      test and compare insns.  */
1343
1344 void
1345 final_start_function (first, file, optimize)
1346      rtx first;
1347      FILE *file;
1348      int optimize;
1349 {
1350   block_depth = 0;
1351
1352   this_is_asm_operands = 0;
1353
1354 #ifdef NON_SAVING_SETJMP
1355   /* A function that calls setjmp should save and restore all the
1356      call-saved registers on a system where longjmp clobbers them.  */
1357   if (NON_SAVING_SETJMP && current_function_calls_setjmp)
1358     {
1359       int i;
1360
1361       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1362         if (!call_used_regs[i] && !call_fixed_regs[i])
1363           regs_ever_live[i] = 1;
1364     }
1365 #endif
1366
1367   /* Initial line number is supposed to be output
1368      before the function's prologue and label
1369      so that the function's address will not appear to be
1370      in the last statement of the preceding function.  */
1371   if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
1372     last_linenum = high_block_linenum = high_function_linenum
1373       = NOTE_LINE_NUMBER (first);
1374
1375 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
1376   /* Output DWARF definition of the function.  */
1377   if (dwarf2out_do_frame ())
1378     dwarf2out_begin_prologue ();
1379 #endif
1380
1381   /* For SDB and XCOFF, the function beginning must be marked between
1382      the function label and the prologue.  We always need this, even when
1383      -g1 was used.  Defer on MIPS systems so that parameter descriptions
1384      follow function entry.  */
1385 #if defined(SDB_DEBUGGING_INFO) && !defined(MIPS_DEBUGGING_INFO)
1386   if (write_symbols == SDB_DEBUG)
1387     sdbout_begin_function (last_linenum);
1388   else
1389 #endif
1390 #ifdef XCOFF_DEBUGGING_INFO
1391     if (write_symbols == XCOFF_DEBUG)
1392       xcoffout_begin_function (file, last_linenum);
1393     else
1394 #endif
1395       /* But only output line number for other debug info types if -g2
1396          or better.  */
1397       if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
1398         output_source_line (file, first);
1399
1400 #ifdef LEAF_REG_REMAP
1401   if (leaf_function)
1402     leaf_renumber_regs (first);
1403 #endif
1404
1405   /* The Sun386i and perhaps other machines don't work right
1406      if the profiling code comes after the prologue.  */
1407 #ifdef PROFILE_BEFORE_PROLOGUE
1408   if (profile_flag)
1409     profile_function (file);
1410 #endif /* PROFILE_BEFORE_PROLOGUE */
1411
1412 #if defined (DWARF2_UNWIND_INFO) && defined (HAVE_prologue)
1413   if (dwarf2out_do_frame ())
1414     dwarf2out_frame_debug (NULL_RTX);
1415 #endif
1416
1417 #ifdef FUNCTION_PROLOGUE
1418   /* First output the function prologue: code to set up the stack frame.  */
1419   FUNCTION_PROLOGUE (file, get_frame_size ());
1420 #endif
1421
1422 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1423   if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
1424     next_block_index = 1;
1425 #endif
1426
1427   /* If the machine represents the prologue as RTL, the profiling code must
1428      be emitted when NOTE_INSN_PROLOGUE_END is scanned.  */
1429 #ifdef HAVE_prologue
1430   if (! HAVE_prologue)
1431 #endif
1432     profile_after_prologue (file);
1433
1434   profile_label_no++;
1435
1436   /* If we are doing basic block profiling, remember a printable version
1437      of the function name.  */
1438   if (profile_block_flag)
1439     {
1440       bb_func_label_num
1441         = add_bb_string ((*decl_printable_name) (current_function_decl, 2), FALSE);
1442     }
1443 }
1444
1445 static void
1446 profile_after_prologue (file)
1447      FILE *file;
1448 {
1449 #ifdef FUNCTION_BLOCK_PROFILER
1450   if (profile_block_flag)
1451     {
1452       FUNCTION_BLOCK_PROFILER (file, count_basic_blocks);
1453     }
1454 #endif /* FUNCTION_BLOCK_PROFILER */
1455
1456 #ifndef PROFILE_BEFORE_PROLOGUE
1457   if (profile_flag)
1458     profile_function (file);
1459 #endif /* not PROFILE_BEFORE_PROLOGUE */
1460 }
1461
1462 static void
1463 profile_function (file)
1464      FILE *file;
1465 {
1466   int align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE);
1467 #if defined(ASM_OUTPUT_REG_PUSH)
1468 #if defined(STRUCT_VALUE_INCOMING_REGNUM) || defined(STRUCT_VALUE_REGNUM)
1469   int sval = current_function_returns_struct;
1470 #endif
1471 #if defined(STATIC_CHAIN_INCOMING_REGNUM) || defined(STATIC_CHAIN_REGNUM)
1472   int cxt = current_function_needs_context;
1473 #endif
1474 #endif /* ASM_OUTPUT_REG_PUSH */
1475
1476   data_section ();
1477   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
1478   ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no);
1479   assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, 1);
1480
1481   function_section (current_function_decl);
1482
1483 #if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1484   if (sval)
1485     ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM);
1486 #else
1487 #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1488   if (sval)
1489     {
1490       ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM);
1491     }
1492 #endif
1493 #endif
1494
1495 #if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1496   if (cxt)
1497     ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM);
1498 #else
1499 #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1500   if (cxt)
1501     {
1502       ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM);
1503     }
1504 #endif
1505 #endif
1506
1507   FUNCTION_PROFILER (file, profile_label_no);
1508
1509 #if defined(STATIC_CHAIN_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1510   if (cxt)
1511     ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM);
1512 #else
1513 #if defined(STATIC_CHAIN_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1514   if (cxt)
1515     {
1516       ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM);
1517     }
1518 #endif
1519 #endif
1520
1521 #if defined(STRUCT_VALUE_INCOMING_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1522   if (sval)
1523     ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM);
1524 #else
1525 #if defined(STRUCT_VALUE_REGNUM) && defined(ASM_OUTPUT_REG_PUSH)
1526   if (sval)
1527     {
1528       ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM);
1529     }
1530 #endif
1531 #endif
1532 }
1533
1534 /* Output assembler code for the end of a function.
1535    For clarity, args are same as those of `final_start_function'
1536    even though not all of them are needed.  */
1537
1538 void
1539 final_end_function (first, file, optimize)
1540      rtx first;
1541      FILE *file;
1542      int optimize;
1543 {
1544   if (app_on)
1545     {
1546       fputs (ASM_APP_OFF, file);
1547       app_on = 0;
1548     }
1549
1550 #ifdef SDB_DEBUGGING_INFO
1551   if (write_symbols == SDB_DEBUG)
1552     sdbout_end_function (high_function_linenum);
1553 #endif
1554
1555 #ifdef DWARF_DEBUGGING_INFO
1556   if (write_symbols == DWARF_DEBUG)
1557     dwarfout_end_function ();
1558 #endif
1559
1560 #ifdef XCOFF_DEBUGGING_INFO
1561   if (write_symbols == XCOFF_DEBUG)
1562     xcoffout_end_function (file, high_function_linenum);
1563 #endif
1564
1565 #ifdef FUNCTION_EPILOGUE
1566   /* Finally, output the function epilogue:
1567      code to restore the stack frame and return to the caller.  */
1568   FUNCTION_EPILOGUE (file, get_frame_size ());
1569 #endif
1570
1571 #ifdef SDB_DEBUGGING_INFO
1572   if (write_symbols == SDB_DEBUG)
1573     sdbout_end_epilogue ();
1574 #endif
1575
1576 #ifdef DWARF_DEBUGGING_INFO
1577   if (write_symbols == DWARF_DEBUG)
1578     dwarfout_end_epilogue ();
1579 #endif
1580
1581 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
1582   if (dwarf2out_do_frame ())
1583     dwarf2out_end_epilogue ();
1584 #endif
1585
1586 #ifdef XCOFF_DEBUGGING_INFO
1587   if (write_symbols == XCOFF_DEBUG)
1588     xcoffout_end_epilogue (file);
1589 #endif
1590
1591   bb_func_label_num = -1;       /* not in function, nuke label # */
1592
1593   /* If FUNCTION_EPILOGUE is not defined, then the function body
1594      itself contains return instructions wherever needed.  */
1595 }
1596 \f
1597 /* Add a block to the linked list that remembers the current line/file/function
1598    for basic block profiling.  Emit the label in front of the basic block and
1599    the instructions that increment the count field.  */
1600
1601 static void
1602 add_bb (file)
1603      FILE *file;
1604 {
1605   struct bb_list *ptr = (struct bb_list *) permalloc (sizeof (struct bb_list));
1606
1607   /* Add basic block to linked list.  */
1608   ptr->next = 0;
1609   ptr->line_num = last_linenum;
1610   ptr->file_label_num = bb_file_label_num;
1611   ptr->func_label_num = bb_func_label_num;
1612   *bb_tail = ptr;
1613   bb_tail = &ptr->next;
1614
1615   /* Enable the table of basic-block use counts
1616      to point at the code it applies to.  */
1617   ASM_OUTPUT_INTERNAL_LABEL (file, "LPB", count_basic_blocks);
1618
1619   /* Before first insn of this basic block, increment the
1620      count of times it was entered.  */
1621 #ifdef BLOCK_PROFILER
1622   BLOCK_PROFILER (file, count_basic_blocks);
1623 #endif
1624 #ifdef HAVE_cc0
1625   CC_STATUS_INIT;
1626 #endif
1627
1628   new_block = 0;
1629   count_basic_blocks++;
1630 }
1631
1632 /* Add a string to be used for basic block profiling.  */
1633
1634 static int
1635 add_bb_string (string, perm_p)
1636      char *string;
1637      int perm_p;
1638 {
1639   int len;
1640   struct bb_str *ptr = 0;
1641
1642   if (!string)
1643     {
1644       string = "<unknown>";
1645       perm_p = TRUE;
1646     }
1647
1648   /* Allocate a new string if the current string isn't permanent.  If
1649      the string is permanent search for the same string in other
1650      allocations.  */
1651
1652   len = strlen (string) + 1;
1653   if (!perm_p)
1654     {
1655       char *p = (char *) permalloc (len);
1656       bcopy (string, p, len);
1657       string = p;
1658     }
1659   else
1660     for (ptr = sbb_head; ptr != (struct bb_str *) 0; ptr = ptr->next)
1661       if (ptr->string == string)
1662         break;
1663
1664   /* Allocate a new string block if we need to.  */
1665   if (!ptr)
1666     {
1667       ptr = (struct bb_str *) permalloc (sizeof (*ptr));
1668       ptr->next = 0;
1669       ptr->length = len;
1670       ptr->label_num = sbb_label_num++;
1671       ptr->string = string;
1672       *sbb_tail = ptr;
1673       sbb_tail = &ptr->next;
1674     }
1675
1676   return ptr->label_num;
1677 }
1678
1679 \f
1680 /* Output assembler code for some insns: all or part of a function.
1681    For description of args, see `final_start_function', above.
1682
1683    PRESCAN is 1 if we are not really outputting,
1684      just scanning as if we were outputting.
1685    Prescanning deletes and rearranges insns just like ordinary output.
1686    PRESCAN is -2 if we are outputting after having prescanned.
1687    In this case, don't try to delete or rearrange insns
1688    because that has already been done.
1689    Prescanning is done only on certain machines.  */
1690
1691 void
1692 final (first, file, optimize, prescan)
1693      rtx first;
1694      FILE *file;
1695      int optimize;
1696      int prescan;
1697 {
1698   register rtx insn;
1699   int max_line = 0;
1700
1701   last_ignored_compare = 0;
1702   new_block = 1;
1703
1704   check_exception_handler_labels ();
1705
1706   /* Make a map indicating which line numbers appear in this function.
1707      When producing SDB debugging info, delete troublesome line number
1708      notes from inlined functions in other files as well as duplicate
1709      line number notes.  */
1710 #ifdef SDB_DEBUGGING_INFO
1711   if (write_symbols == SDB_DEBUG)
1712     {
1713       rtx last = 0;
1714       for (insn = first; insn; insn = NEXT_INSN (insn))
1715         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1716           {
1717             if ((RTX_INTEGRATED_P (insn)
1718                  && strcmp (NOTE_SOURCE_FILE (insn), main_input_filename) != 0)
1719                  || (last != 0
1720                      && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last)
1721                      && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last)))
1722               {
1723                 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1724                 NOTE_SOURCE_FILE (insn) = 0;
1725                 continue;
1726               }
1727             last = insn;
1728             if (NOTE_LINE_NUMBER (insn) > max_line)
1729               max_line = NOTE_LINE_NUMBER (insn);
1730           }
1731     }
1732   else
1733 #endif
1734     {
1735       for (insn = first; insn; insn = NEXT_INSN (insn))
1736         if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > max_line)
1737           max_line = NOTE_LINE_NUMBER (insn);
1738     }
1739
1740   line_note_exists = (char *) oballoc (max_line + 1);
1741   bzero (line_note_exists, max_line + 1);
1742
1743   for (insn = first; insn; insn = NEXT_INSN (insn))
1744     if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1745       line_note_exists[NOTE_LINE_NUMBER (insn)] = 1;
1746
1747   init_recog ();
1748
1749   CC_STATUS_INIT;
1750
1751   /* Output the insns.  */
1752   for (insn = NEXT_INSN (first); insn;)
1753     {
1754 #ifdef HAVE_ATTR_length
1755       insn_current_address = insn_addresses[INSN_UID (insn)];
1756 #endif
1757       insn = final_scan_insn (insn, file, optimize, prescan, 0);
1758     }
1759
1760   /* Do basic-block profiling here
1761      if the last insn was a conditional branch.  */
1762   if (profile_block_flag && new_block)
1763     add_bb (file);
1764 }
1765 \f
1766 /* The final scan for one insn, INSN.
1767    Args are same as in `final', except that INSN
1768    is the insn being scanned.
1769    Value returned is the next insn to be scanned.
1770
1771    NOPEEPHOLES is the flag to disallow peephole processing (currently
1772    used for within delayed branch sequence output).  */
1773
1774 rtx
1775 final_scan_insn (insn, file, optimize, prescan, nopeepholes)
1776      rtx insn;
1777      FILE *file;
1778      int optimize;
1779      int prescan;
1780      int nopeepholes;
1781 {
1782   register int i;
1783 #ifdef HAVE_cc0
1784   rtx set;
1785 #endif
1786
1787   insn_counter++;
1788
1789   /* Ignore deleted insns.  These can occur when we split insns (due to a
1790      template of "#") while not optimizing.  */
1791   if (INSN_DELETED_P (insn))
1792     return NEXT_INSN (insn);
1793
1794   switch (GET_CODE (insn))
1795     {
1796     case NOTE:
1797       if (prescan > 0)
1798         break;
1799
1800       /* Align the beginning of a loop, for higher speed
1801          on certain machines.  */
1802
1803       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
1804         break; /* This used to depend on optimize, but that was bogus.  */
1805       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
1806         break;
1807
1808       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG
1809           && ! exceptions_via_longjmp)
1810         {
1811           ASM_OUTPUT_INTERNAL_LABEL (file, "LEHB", NOTE_BLOCK_NUMBER (insn));
1812           add_eh_table_entry (NOTE_BLOCK_NUMBER (insn));
1813 #ifdef ASM_OUTPUT_EH_REGION_BEG
1814           ASM_OUTPUT_EH_REGION_BEG (file, NOTE_BLOCK_NUMBER (insn));
1815 #endif
1816           break;
1817         }
1818
1819       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END
1820           && ! exceptions_via_longjmp)
1821         {
1822           ASM_OUTPUT_INTERNAL_LABEL (file, "LEHE", NOTE_BLOCK_NUMBER (insn));
1823 #ifdef ASM_OUTPUT_EH_REGION_END
1824           ASM_OUTPUT_EH_REGION_END (file, NOTE_BLOCK_NUMBER (insn));
1825 #endif
1826           break;
1827         }
1828
1829       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
1830         {
1831 #ifdef FUNCTION_END_PROLOGUE
1832           FUNCTION_END_PROLOGUE (file);
1833 #endif
1834           profile_after_prologue (file);
1835           break;
1836         }
1837
1838 #ifdef FUNCTION_BEGIN_EPILOGUE
1839       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
1840         {
1841           FUNCTION_BEGIN_EPILOGUE (file);
1842           break;
1843         }
1844 #endif
1845
1846       if (write_symbols == NO_DEBUG)
1847         break;
1848       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
1849         {
1850 #if defined(SDB_DEBUGGING_INFO) && defined(MIPS_DEBUGGING_INFO)
1851           /* MIPS stabs require the parameter descriptions to be after the
1852              function entry point rather than before.  */
1853           if (write_symbols == SDB_DEBUG)
1854             sdbout_begin_function (last_linenum);
1855           else
1856 #endif
1857 #ifdef DWARF_DEBUGGING_INFO
1858           /* This outputs a marker where the function body starts, so it
1859              must be after the prologue.  */
1860           if (write_symbols == DWARF_DEBUG)
1861             dwarfout_begin_function ();
1862 #endif
1863           break;
1864         }
1865       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
1866         break;                  /* An insn that was "deleted" */
1867       if (app_on)
1868         {
1869           fputs (ASM_APP_OFF, file);
1870           app_on = 0;
1871         }
1872       if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
1873           && (debug_info_level == DINFO_LEVEL_NORMAL
1874               || debug_info_level == DINFO_LEVEL_VERBOSE
1875               || write_symbols == DWARF_DEBUG
1876               || write_symbols == DWARF2_DEBUG))
1877         {
1878           /* Beginning of a symbol-block.  Assign it a sequence number
1879              and push the number onto the stack PENDING_BLOCKS.  */
1880
1881           if (block_depth == max_block_depth)
1882             {
1883               /* PENDING_BLOCKS is full; make it longer.  */
1884               max_block_depth *= 2;
1885               pending_blocks
1886                 = (int *) xrealloc (pending_blocks,
1887                                     max_block_depth * sizeof (int));
1888             }
1889           pending_blocks[block_depth++] = next_block_index;
1890
1891           high_block_linenum = last_linenum;
1892
1893           /* Output debugging info about the symbol-block beginning.  */
1894
1895 #ifdef SDB_DEBUGGING_INFO
1896           if (write_symbols == SDB_DEBUG)
1897             sdbout_begin_block (file, last_linenum, next_block_index);
1898 #endif
1899 #ifdef XCOFF_DEBUGGING_INFO
1900           if (write_symbols == XCOFF_DEBUG)
1901             xcoffout_begin_block (file, last_linenum, next_block_index);
1902 #endif
1903 #ifdef DBX_DEBUGGING_INFO
1904           if (write_symbols == DBX_DEBUG)
1905             ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index);
1906 #endif
1907 #ifdef DWARF_DEBUGGING_INFO
1908           if (write_symbols == DWARF_DEBUG)
1909             dwarfout_begin_block (next_block_index);
1910 #endif
1911 #ifdef DWARF2_DEBUGGING_INFO
1912           if (write_symbols == DWARF2_DEBUG)
1913             dwarf2out_begin_block (next_block_index);
1914 #endif
1915
1916           next_block_index++;
1917         }
1918       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
1919                && (debug_info_level == DINFO_LEVEL_NORMAL
1920                    || debug_info_level == DINFO_LEVEL_VERBOSE
1921                    || write_symbols == DWARF_DEBUG
1922                    || write_symbols == DWARF2_DEBUG))
1923         {
1924           /* End of a symbol-block.  Pop its sequence number off
1925              PENDING_BLOCKS and output debugging info based on that.  */
1926
1927           --block_depth;
1928
1929 #ifdef XCOFF_DEBUGGING_INFO
1930           if (write_symbols == XCOFF_DEBUG && block_depth >= 0)
1931             xcoffout_end_block (file, high_block_linenum,
1932                                 pending_blocks[block_depth]);
1933 #endif
1934 #ifdef DBX_DEBUGGING_INFO
1935           if (write_symbols == DBX_DEBUG && block_depth >= 0)
1936             ASM_OUTPUT_INTERNAL_LABEL (file, "LBE",
1937                                        pending_blocks[block_depth]);
1938 #endif
1939 #ifdef SDB_DEBUGGING_INFO
1940           if (write_symbols == SDB_DEBUG && block_depth >= 0)
1941             sdbout_end_block (file, high_block_linenum,
1942                               pending_blocks[block_depth]);
1943 #endif
1944 #ifdef DWARF_DEBUGGING_INFO
1945           if (write_symbols == DWARF_DEBUG && block_depth >= 0)
1946             dwarfout_end_block (pending_blocks[block_depth]);
1947 #endif
1948 #ifdef DWARF2_DEBUGGING_INFO
1949           if (write_symbols == DWARF2_DEBUG && block_depth >= 0)
1950             dwarf2out_end_block (pending_blocks[block_depth]);
1951 #endif
1952         }
1953       else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL
1954                && (debug_info_level == DINFO_LEVEL_NORMAL
1955                    || debug_info_level == DINFO_LEVEL_VERBOSE))
1956         {
1957 #ifdef DWARF_DEBUGGING_INFO
1958           if (write_symbols == DWARF_DEBUG)
1959             dwarfout_label (insn);
1960 #endif
1961 #ifdef DWARF2_DEBUGGING_INFO
1962           if (write_symbols == DWARF2_DEBUG)
1963             dwarf2out_label (insn);
1964 #endif
1965         }
1966       else if (NOTE_LINE_NUMBER (insn) > 0)
1967         /* This note is a line-number.  */
1968         {
1969           register rtx note;
1970
1971 #if 0 /* This is what we used to do.  */
1972           output_source_line (file, insn);
1973 #endif
1974           int note_after = 0;
1975
1976           /* If there is anything real after this note,
1977              output it.  If another line note follows, omit this one.  */
1978           for (note = NEXT_INSN (insn); note; note = NEXT_INSN (note))
1979             {
1980               if (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL)
1981                 break;
1982               /* These types of notes can be significant
1983                  so make sure the preceding line number stays.  */
1984               else if (GET_CODE (note) == NOTE
1985                        && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG
1986                            || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END
1987                            || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG))
1988                 break;
1989               else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0)
1990                 {
1991                   /* Another line note follows; we can delete this note
1992                      if no intervening line numbers have notes elsewhere.  */
1993                   int num;
1994                   for (num = NOTE_LINE_NUMBER (insn) + 1;
1995                        num < NOTE_LINE_NUMBER (note);
1996                        num++)
1997                     if (line_note_exists[num])
1998                       break;
1999
2000                   if (num >= NOTE_LINE_NUMBER (note))
2001                     note_after = 1;
2002                   break;
2003                 }
2004             }
2005
2006           /* Output this line note
2007              if it is the first or the last line note in a row.  */
2008           if (!note_after)
2009             output_source_line (file, insn);
2010         }
2011       break;
2012
2013     case BARRIER:
2014 #if defined (DWARF2_UNWIND_INFO) && !defined (ACCUMULATE_OUTGOING_ARGS)
2015         /* If we push arguments, we need to check all insns for stack
2016            adjustments.  */
2017         if (dwarf2out_do_frame ())
2018           dwarf2out_frame_debug (insn);
2019 #endif
2020       break;
2021
2022     case CODE_LABEL:
2023       /* The target port might emit labels in the output function for
2024          some insn, e.g. sh.c output_branchy_insn.  */
2025       if (CODE_LABEL_NUMBER (insn) <= max_labelno)
2026         {
2027           int align = LABEL_TO_ALIGNMENT (insn);
2028
2029           if (align && NEXT_INSN (insn))
2030             ASM_OUTPUT_ALIGN (file, align);
2031         }
2032       CC_STATUS_INIT;
2033       if (prescan > 0)
2034         break;
2035       new_block = 1;
2036
2037 #ifdef FINAL_PRESCAN_LABEL
2038       FINAL_PRESCAN_INSN (insn, NULL_PTR, 0);
2039 #endif
2040
2041 #ifdef SDB_DEBUGGING_INFO
2042       if (write_symbols == SDB_DEBUG && LABEL_NAME (insn))
2043         sdbout_label (insn);
2044 #endif
2045 #ifdef DWARF_DEBUGGING_INFO
2046       if (write_symbols == DWARF_DEBUG && LABEL_NAME (insn))
2047         dwarfout_label (insn);
2048 #endif
2049 #ifdef DWARF2_DEBUGGING_INFO
2050       if (write_symbols == DWARF2_DEBUG && LABEL_NAME (insn))
2051         dwarf2out_label (insn);
2052 #endif
2053       if (app_on)
2054         {
2055           fputs (ASM_APP_OFF, file);
2056           app_on = 0;
2057         }
2058       if (NEXT_INSN (insn) != 0
2059           && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN)
2060         {
2061           rtx nextbody = PATTERN (NEXT_INSN (insn));
2062
2063           /* If this label is followed by a jump-table,
2064              make sure we put the label in the read-only section.  Also
2065              possibly write the label and jump table together.  */
2066
2067           if (GET_CODE (nextbody) == ADDR_VEC
2068               || GET_CODE (nextbody) == ADDR_DIFF_VEC)
2069             {
2070 #ifndef JUMP_TABLES_IN_TEXT_SECTION
2071               readonly_data_section ();
2072 #ifdef READONLY_DATA_SECTION
2073               ASM_OUTPUT_ALIGN (file,
2074                                 exact_log2 (BIGGEST_ALIGNMENT
2075                                             / BITS_PER_UNIT));
2076 #endif /* READONLY_DATA_SECTION */
2077 #else /* JUMP_TABLES_IN_TEXT_SECTION */
2078               function_section (current_function_decl);
2079 #endif /* JUMP_TABLES_IN_TEXT_SECTION */
2080 #ifdef ASM_OUTPUT_CASE_LABEL
2081               ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
2082                                      NEXT_INSN (insn));
2083 #else
2084               ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2085 #endif
2086               break;
2087             }
2088         }
2089
2090       ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
2091       break;
2092
2093     default:
2094       {
2095         register rtx body = PATTERN (insn);
2096         int insn_code_number;
2097         char *template;
2098 #ifdef HAVE_cc0
2099         rtx note;
2100 #endif
2101
2102         /* An INSN, JUMP_INSN or CALL_INSN.
2103            First check for special kinds that recog doesn't recognize.  */
2104
2105         if (GET_CODE (body) == USE /* These are just declarations */
2106             || GET_CODE (body) == CLOBBER)
2107           break;
2108
2109 #ifdef HAVE_cc0
2110         /* If there is a REG_CC_SETTER note on this insn, it means that
2111            the setting of the condition code was done in the delay slot
2112            of the insn that branched here.  So recover the cc status
2113            from the insn that set it.  */
2114
2115         note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
2116         if (note)
2117           {
2118             NOTICE_UPDATE_CC (PATTERN (XEXP (note, 0)), XEXP (note, 0));
2119             cc_prev_status = cc_status;
2120           }
2121 #endif
2122
2123         /* Detect insns that are really jump-tables
2124            and output them as such.  */
2125
2126         if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
2127           {
2128             register int vlen, idx;
2129
2130             if (prescan > 0)
2131               break;
2132
2133             if (app_on)
2134               {
2135                 fputs (ASM_APP_OFF, file);
2136                 app_on = 0;
2137               }
2138
2139             vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
2140             for (idx = 0; idx < vlen; idx++)
2141               {
2142                 if (GET_CODE (body) == ADDR_VEC)
2143                   {
2144 #ifdef ASM_OUTPUT_ADDR_VEC_ELT
2145                     ASM_OUTPUT_ADDR_VEC_ELT
2146                       (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
2147 #else
2148                     abort ();
2149 #endif
2150                   }
2151                 else
2152                   {
2153 #ifdef ASM_OUTPUT_ADDR_DIFF_ELT
2154                     ASM_OUTPUT_ADDR_DIFF_ELT
2155                       (file,
2156                        CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
2157                        CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
2158 #else
2159                     abort ();
2160 #endif
2161                   }
2162               }
2163 #ifdef ASM_OUTPUT_CASE_END
2164             ASM_OUTPUT_CASE_END (file,
2165                                  CODE_LABEL_NUMBER (PREV_INSN (insn)),
2166                                  insn);
2167 #endif
2168
2169             function_section (current_function_decl);
2170
2171             break;
2172           }
2173
2174         /* Do basic-block profiling when we reach a new block.
2175            Done here to avoid jump tables.  */
2176         if (profile_block_flag && new_block)
2177           add_bb (file);
2178
2179         if (GET_CODE (body) == ASM_INPUT)
2180           {
2181             /* There's no telling what that did to the condition codes.  */
2182             CC_STATUS_INIT;
2183             if (prescan > 0)
2184               break;
2185             if (! app_on)
2186               {
2187                 fputs (ASM_APP_ON, file);
2188                 app_on = 1;
2189               }
2190             fprintf (asm_out_file, "\t%s\n", XSTR (body, 0));
2191             break;
2192           }
2193
2194         /* Detect `asm' construct with operands.  */
2195         if (asm_noperands (body) >= 0)
2196           {
2197             int noperands = asm_noperands (body);
2198             rtx *ops = (rtx *) alloca (noperands * sizeof (rtx));
2199             char *string;
2200
2201             /* There's no telling what that did to the condition codes.  */
2202             CC_STATUS_INIT;
2203             if (prescan > 0)
2204               break;
2205
2206             if (! app_on)
2207               {
2208                 fputs (ASM_APP_ON, file);
2209                 app_on = 1;
2210               }
2211
2212             /* Get out the operand values.  */
2213             string = decode_asm_operands (body, ops, NULL_PTR,
2214                                           NULL_PTR, NULL_PTR);
2215             /* Inhibit aborts on what would otherwise be compiler bugs.  */
2216             insn_noperands = noperands;
2217             this_is_asm_operands = insn;
2218
2219             /* Output the insn using them.  */
2220             output_asm_insn (string, ops);
2221             this_is_asm_operands = 0;
2222             break;
2223           }
2224
2225         if (prescan <= 0 && app_on)
2226           {
2227             fputs (ASM_APP_OFF, file);
2228             app_on = 0;
2229           }
2230
2231         if (GET_CODE (body) == SEQUENCE)
2232           {
2233             /* A delayed-branch sequence */
2234             register int i;
2235             rtx next;
2236
2237             if (prescan > 0)
2238               break;
2239             final_sequence = body;
2240
2241             /* The first insn in this SEQUENCE might be a JUMP_INSN that will
2242                force the restoration of a comparison that was previously
2243                thought unnecessary.  If that happens, cancel this sequence
2244                and cause that insn to be restored.  */
2245
2246             next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, prescan, 1);
2247             if (next != XVECEXP (body, 0, 1))
2248               {
2249                 final_sequence = 0;
2250                 return next;
2251               }
2252
2253             for (i = 1; i < XVECLEN (body, 0); i++)
2254               {
2255                 rtx insn = XVECEXP (body, 0, i);
2256                 rtx next = NEXT_INSN (insn);
2257                 /* We loop in case any instruction in a delay slot gets
2258                    split.  */
2259                 do
2260                   insn = final_scan_insn (insn, file, 0, prescan, 1);
2261                 while (insn != next);
2262               }
2263 #ifdef DBR_OUTPUT_SEQEND
2264             DBR_OUTPUT_SEQEND (file);
2265 #endif
2266             final_sequence = 0;
2267
2268             /* If the insn requiring the delay slot was a CALL_INSN, the
2269                insns in the delay slot are actually executed before the
2270                called function.  Hence we don't preserve any CC-setting
2271                actions in these insns and the CC must be marked as being
2272                clobbered by the function.  */
2273             if (GET_CODE (XVECEXP (body, 0, 0)) == CALL_INSN)
2274               {
2275                 CC_STATUS_INIT;
2276               }
2277
2278             /* Following a conditional branch sequence, we have a new basic
2279                block.  */
2280             if (profile_block_flag)
2281               {
2282                 rtx insn = XVECEXP (body, 0, 0);
2283                 rtx body = PATTERN (insn);
2284
2285                 if ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
2286                      && GET_CODE (SET_SRC (body)) != LABEL_REF)
2287                     || (GET_CODE (insn) == JUMP_INSN
2288                         && GET_CODE (body) == PARALLEL
2289                         && GET_CODE (XVECEXP (body, 0, 0)) == SET
2290                         && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF))
2291                   new_block = 1;
2292               }
2293             break;
2294           }
2295
2296         /* We have a real machine instruction as rtl.  */
2297
2298         body = PATTERN (insn);
2299
2300 #ifdef HAVE_cc0
2301         set = single_set(insn);
2302
2303         /* Check for redundant test and compare instructions
2304            (when the condition codes are already set up as desired).
2305            This is done only when optimizing; if not optimizing,
2306            it should be possible for the user to alter a variable
2307            with the debugger in between statements
2308            and the next statement should reexamine the variable
2309            to compute the condition codes.  */
2310
2311         if (optimize)
2312           {
2313 #if 0
2314             rtx set = single_set(insn);
2315 #endif
2316
2317             if (set
2318                 && GET_CODE (SET_DEST (set)) == CC0
2319                 && insn != last_ignored_compare)
2320               {
2321                 if (GET_CODE (SET_SRC (set)) == SUBREG)
2322                   SET_SRC (set) = alter_subreg (SET_SRC (set));
2323                 else if (GET_CODE (SET_SRC (set)) == COMPARE)
2324                   {
2325                     if (GET_CODE (XEXP (SET_SRC (set), 0)) == SUBREG)
2326                       XEXP (SET_SRC (set), 0)
2327                         = alter_subreg (XEXP (SET_SRC (set), 0));
2328                     if (GET_CODE (XEXP (SET_SRC (set), 1)) == SUBREG)
2329                       XEXP (SET_SRC (set), 1)
2330                         = alter_subreg (XEXP (SET_SRC (set), 1));
2331                   }
2332                 if ((cc_status.value1 != 0
2333                      && rtx_equal_p (SET_SRC (set), cc_status.value1))
2334                     || (cc_status.value2 != 0
2335                         && rtx_equal_p (SET_SRC (set), cc_status.value2)))
2336                   {
2337                     /* Don't delete insn if it has an addressing side-effect.  */
2338                     if (! FIND_REG_INC_NOTE (insn, 0)
2339                         /* or if anything in it is volatile.  */
2340                         && ! volatile_refs_p (PATTERN (insn)))
2341                       {
2342                         /* We don't really delete the insn; just ignore it.  */
2343                         last_ignored_compare = insn;
2344                         break;
2345                       }
2346                   }
2347               }
2348           }
2349 #endif
2350
2351         /* Following a conditional branch, we have a new basic block.
2352            But if we are inside a sequence, the new block starts after the
2353            last insn of the sequence.  */
2354         if (profile_block_flag && final_sequence == 0
2355             && ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
2356                  && GET_CODE (SET_SRC (body)) != LABEL_REF)
2357                 || (GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == PARALLEL
2358                     && GET_CODE (XVECEXP (body, 0, 0)) == SET
2359                     && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF)))
2360           new_block = 1;
2361
2362 #ifndef STACK_REGS
2363         /* Don't bother outputting obvious no-ops, even without -O.
2364            This optimization is fast and doesn't interfere with debugging.
2365            Don't do this if the insn is in a delay slot, since this
2366            will cause an improper number of delay insns to be written.  */
2367         if (final_sequence == 0
2368             && prescan >= 0
2369             && GET_CODE (insn) == INSN && GET_CODE (body) == SET
2370             && GET_CODE (SET_SRC (body)) == REG
2371             && GET_CODE (SET_DEST (body)) == REG
2372             && REGNO (SET_SRC (body)) == REGNO (SET_DEST (body)))
2373           break;
2374 #endif
2375
2376 #ifdef HAVE_cc0
2377         /* If this is a conditional branch, maybe modify it
2378            if the cc's are in a nonstandard state
2379            so that it accomplishes the same thing that it would
2380            do straightforwardly if the cc's were set up normally.  */
2381
2382         if (cc_status.flags != 0
2383             && GET_CODE (insn) == JUMP_INSN
2384             && GET_CODE (body) == SET
2385             && SET_DEST (body) == pc_rtx
2386             && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE
2387             && GET_RTX_CLASS (GET_CODE (XEXP (SET_SRC (body), 0))) == '<'
2388             && XEXP (XEXP (SET_SRC (body), 0), 0) == cc0_rtx
2389             /* This is done during prescan; it is not done again
2390                in final scan when prescan has been done.  */
2391             && prescan >= 0)
2392           {
2393             /* This function may alter the contents of its argument
2394                and clear some of the cc_status.flags bits.
2395                It may also return 1 meaning condition now always true
2396                or -1 meaning condition now always false
2397                or 2 meaning condition nontrivial but altered.  */
2398             register int result = alter_cond (XEXP (SET_SRC (body), 0));
2399             /* If condition now has fixed value, replace the IF_THEN_ELSE
2400                with its then-operand or its else-operand.  */
2401             if (result == 1)
2402               SET_SRC (body) = XEXP (SET_SRC (body), 1);
2403             if (result == -1)
2404               SET_SRC (body) = XEXP (SET_SRC (body), 2);
2405
2406             /* The jump is now either unconditional or a no-op.
2407                If it has become a no-op, don't try to output it.
2408                (It would not be recognized.)  */
2409             if (SET_SRC (body) == pc_rtx)
2410               {
2411                 PUT_CODE (insn, NOTE);
2412                 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2413                 NOTE_SOURCE_FILE (insn) = 0;
2414                 break;
2415               }
2416             else if (GET_CODE (SET_SRC (body)) == RETURN)
2417               /* Replace (set (pc) (return)) with (return).  */
2418               PATTERN (insn) = body = SET_SRC (body);
2419
2420             /* Rerecognize the instruction if it has changed.  */
2421             if (result != 0)
2422               INSN_CODE (insn) = -1;
2423           }
2424
2425         /* Make same adjustments to instructions that examine the
2426            condition codes without jumping and instructions that
2427            handle conditional moves (if this machine has either one).  */
2428
2429         if (cc_status.flags != 0
2430             && set != 0)
2431           {
2432             rtx cond_rtx, then_rtx, else_rtx;
2433
2434             if (GET_CODE (insn) != JUMP_INSN
2435                 && GET_CODE (SET_SRC (set)) == IF_THEN_ELSE)
2436               {
2437                 cond_rtx = XEXP (SET_SRC (set), 0);
2438                 then_rtx = XEXP (SET_SRC (set), 1);
2439                 else_rtx = XEXP (SET_SRC (set), 2);
2440               }
2441             else
2442               {
2443                 cond_rtx = SET_SRC (set);
2444                 then_rtx = const_true_rtx;
2445                 else_rtx = const0_rtx;
2446               }
2447
2448             switch (GET_CODE (cond_rtx))
2449               {
2450               case GTU:
2451               case GT:
2452               case LTU:
2453               case LT:
2454               case GEU:
2455               case GE:
2456               case LEU:
2457               case LE:
2458               case EQ:
2459               case NE:
2460                 {
2461                   register int result;
2462                   if (XEXP (cond_rtx, 0) != cc0_rtx)
2463                     break;
2464                   result = alter_cond (cond_rtx);
2465                   if (result == 1)
2466                     validate_change (insn, &SET_SRC (set), then_rtx, 0);
2467                   else if (result == -1)
2468                     validate_change (insn, &SET_SRC (set), else_rtx, 0);
2469                   else if (result == 2)
2470                     INSN_CODE (insn) = -1;
2471                   if (SET_DEST (set) == SET_SRC (set))
2472                     {
2473                       PUT_CODE (insn, NOTE);
2474                       NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
2475                       NOTE_SOURCE_FILE (insn) = 0;
2476                     }
2477                 }
2478                 break;
2479
2480               default:
2481                 break;
2482               }
2483           }
2484
2485 #endif
2486
2487         /* Do machine-specific peephole optimizations if desired.  */
2488
2489         if (optimize && !flag_no_peephole && !nopeepholes)
2490           {
2491             rtx next = peephole (insn);
2492             /* When peepholing, if there were notes within the peephole,
2493                emit them before the peephole.  */
2494             if (next != 0 && next != NEXT_INSN (insn))
2495               {
2496                 rtx prev = PREV_INSN (insn);
2497                 rtx note;
2498
2499                 for (note = NEXT_INSN (insn); note != next;
2500                      note = NEXT_INSN (note))
2501                   final_scan_insn (note, file, optimize, prescan, nopeepholes);
2502
2503                 /* In case this is prescan, put the notes
2504                    in proper position for later rescan.  */
2505                 note = NEXT_INSN (insn);
2506                 PREV_INSN (note) = prev;
2507                 NEXT_INSN (prev) = note;
2508                 NEXT_INSN (PREV_INSN (next)) = insn;
2509                 PREV_INSN (insn) = PREV_INSN (next);
2510                 NEXT_INSN (insn) = next;
2511                 PREV_INSN (next) = insn;
2512               }
2513
2514             /* PEEPHOLE might have changed this.  */
2515             body = PATTERN (insn);
2516           }
2517
2518         /* Try to recognize the instruction.
2519            If successful, verify that the operands satisfy the
2520            constraints for the instruction.  Crash if they don't,
2521            since `reload' should have changed them so that they do.  */
2522
2523         insn_code_number = recog_memoized (insn);
2524         insn_extract (insn);
2525         for (i = 0; i < insn_n_operands[insn_code_number]; i++)
2526           {
2527             if (GET_CODE (recog_operand[i]) == SUBREG)
2528               recog_operand[i] = alter_subreg (recog_operand[i]);
2529             else if (GET_CODE (recog_operand[i]) == PLUS
2530                      || GET_CODE (recog_operand[i]) == MULT)
2531               recog_operand[i] = walk_alter_subreg (recog_operand[i]);
2532           }
2533
2534         for (i = 0; i < insn_n_dups[insn_code_number]; i++)
2535           {
2536             if (GET_CODE (*recog_dup_loc[i]) == SUBREG)
2537               *recog_dup_loc[i] = alter_subreg (*recog_dup_loc[i]);
2538             else if (GET_CODE (*recog_dup_loc[i]) == PLUS
2539                      || GET_CODE (*recog_dup_loc[i]) == MULT)
2540               *recog_dup_loc[i] = walk_alter_subreg (*recog_dup_loc[i]);
2541           }
2542
2543 #ifdef REGISTER_CONSTRAINTS
2544         if (! constrain_operands (insn_code_number, 1))
2545           fatal_insn_not_found (insn);
2546 #endif
2547
2548         /* Some target machines need to prescan each insn before
2549            it is output.  */
2550
2551 #ifdef FINAL_PRESCAN_INSN
2552         FINAL_PRESCAN_INSN (insn, recog_operand,
2553                             insn_n_operands[insn_code_number]);
2554 #endif
2555
2556 #ifdef HAVE_cc0
2557         cc_prev_status = cc_status;
2558
2559         /* Update `cc_status' for this instruction.
2560            The instruction's output routine may change it further.
2561            If the output routine for a jump insn needs to depend
2562            on the cc status, it should look at cc_prev_status.  */
2563
2564         NOTICE_UPDATE_CC (body, insn);
2565 #endif
2566
2567         debug_insn = insn;
2568
2569 #if defined (DWARF2_UNWIND_INFO) && !defined (ACCUMULATE_OUTGOING_ARGS)
2570         /* If we push arguments, we want to know where the calls are.  */
2571         if (GET_CODE (insn) == CALL_INSN && dwarf2out_do_frame ())
2572           dwarf2out_frame_debug (insn);
2573 #endif
2574
2575         /* If the proper template needs to be chosen by some C code,
2576            run that code and get the real template.  */
2577
2578         template = insn_template[insn_code_number];
2579         if (template == 0)
2580           {
2581             template = (*insn_outfun[insn_code_number]) (recog_operand, insn);
2582
2583             /* If the C code returns 0, it means that it is a jump insn
2584                which follows a deleted test insn, and that test insn
2585                needs to be reinserted.  */
2586             if (template == 0)
2587               {
2588                 if (prev_nonnote_insn (insn) != last_ignored_compare)
2589                   abort ();
2590                 new_block = 0;
2591                 return prev_nonnote_insn (insn);
2592               }
2593           }
2594
2595         /* If the template is the string "#", it means that this insn must
2596            be split.  */
2597         if (template[0] == '#' && template[1] == '\0')
2598           {
2599             rtx new = try_split (body, insn, 0);
2600
2601             /* If we didn't split the insn, go away.  */
2602             if (new == insn && PATTERN (new) == body)
2603               abort ();
2604
2605 #ifdef HAVE_ATTR_length
2606             /* This instruction should have been split in shorten_branches,
2607                to ensure that we would have valid length info for the
2608                splitees.  */
2609             abort ();
2610 #endif
2611
2612             new_block = 0;
2613             return new;
2614           }
2615
2616         if (prescan > 0)
2617           break;
2618
2619         /* Output assembler code from the template.  */
2620
2621         output_asm_insn (template, recog_operand);
2622
2623 #if defined (DWARF2_UNWIND_INFO)
2624 #if !defined (ACCUMULATE_OUTGOING_ARGS)
2625         /* If we push arguments, we need to check all insns for stack
2626            adjustments.  */
2627         if (GET_CODE (insn) == INSN && dwarf2out_do_frame ())
2628           dwarf2out_frame_debug (insn);
2629 #else
2630 #if defined (HAVE_prologue)
2631         /* If this insn is part of the prologue, emit DWARF v2
2632            call frame info.  */
2633         if (RTX_FRAME_RELATED_P (insn) && dwarf2out_do_frame ())
2634           dwarf2out_frame_debug (insn);
2635 #endif
2636 #endif
2637 #endif
2638
2639 #if 0
2640         /* It's not at all clear why we did this and doing so interferes
2641            with tests we'd like to do to use REG_WAS_0 notes, so let's try
2642            with this out.  */
2643
2644         /* Mark this insn as having been output.  */
2645         INSN_DELETED_P (insn) = 1;
2646 #endif
2647
2648         debug_insn = 0;
2649       }
2650     }
2651   return NEXT_INSN (insn);
2652 }
2653 \f
2654 /* Output debugging info to the assembler file FILE
2655    based on the NOTE-insn INSN, assumed to be a line number.  */
2656
2657 static void
2658 output_source_line (file, insn)
2659      FILE *file;
2660      rtx insn;
2661 {
2662   register char *filename = NOTE_SOURCE_FILE (insn);
2663
2664   /* Remember filename for basic block profiling.
2665      Filenames are allocated on the permanent obstack
2666      or are passed in ARGV, so we don't have to save
2667      the string.  */
2668
2669   if (profile_block_flag && last_filename != filename)
2670     bb_file_label_num = add_bb_string (filename, TRUE);
2671
2672   last_filename = filename;
2673   last_linenum = NOTE_LINE_NUMBER (insn);
2674   high_block_linenum = MAX (last_linenum, high_block_linenum);
2675   high_function_linenum = MAX (last_linenum, high_function_linenum);
2676
2677   if (write_symbols != NO_DEBUG)
2678     {
2679 #ifdef SDB_DEBUGGING_INFO
2680       if (write_symbols == SDB_DEBUG
2681 #if 0 /* People like having line numbers even in wrong file!  */
2682           /* COFF can't handle multiple source files--lose, lose.  */
2683           && !strcmp (filename, main_input_filename)
2684 #endif
2685           /* COFF relative line numbers must be positive.  */
2686           && last_linenum > sdb_begin_function_line)
2687         {
2688 #ifdef ASM_OUTPUT_SOURCE_LINE
2689           ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
2690 #else
2691           fprintf (file, "\t.ln\t%d\n",
2692                    ((sdb_begin_function_line > -1)
2693                     ? last_linenum - sdb_begin_function_line : 1));
2694 #endif
2695         }
2696 #endif
2697
2698 #if defined (DBX_DEBUGGING_INFO)
2699       if (write_symbols == DBX_DEBUG)
2700         dbxout_source_line (file, filename, NOTE_LINE_NUMBER (insn));
2701 #endif
2702
2703 #if defined (XCOFF_DEBUGGING_INFO)
2704       if (write_symbols == XCOFF_DEBUG)
2705         xcoffout_source_line (file, filename, insn);
2706 #endif
2707
2708 #ifdef DWARF_DEBUGGING_INFO
2709       if (write_symbols == DWARF_DEBUG)
2710         dwarfout_line (filename, NOTE_LINE_NUMBER (insn));
2711 #endif
2712
2713 #ifdef DWARF2_DEBUGGING_INFO
2714       if (write_symbols == DWARF2_DEBUG)
2715         dwarf2out_line (filename, NOTE_LINE_NUMBER (insn));
2716 #endif
2717     }
2718 }
2719 \f
2720 /* If X is a SUBREG, replace it with a REG or a MEM,
2721    based on the thing it is a subreg of.  */
2722
2723 rtx
2724 alter_subreg (x)
2725      register rtx x;
2726 {
2727   register rtx y = SUBREG_REG (x);
2728   if (GET_CODE (y) == SUBREG)
2729     y = alter_subreg (y);
2730
2731   if (GET_CODE (y) == REG)
2732     {
2733       /* If the containing reg really gets a hard reg, so do we.  */
2734       PUT_CODE (x, REG);
2735       REGNO (x) = REGNO (y) + SUBREG_WORD (x);
2736     }
2737   else if (GET_CODE (y) == MEM)
2738     {
2739       register int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
2740       if (BYTES_BIG_ENDIAN)
2741         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))
2742                    - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y))));
2743       PUT_CODE (x, MEM);
2744       MEM_VOLATILE_P (x) = MEM_VOLATILE_P (y);
2745       XEXP (x, 0) = plus_constant (XEXP (y, 0), offset);
2746     }
2747
2748   return x;
2749 }
2750
2751 /* Do alter_subreg on all the SUBREGs contained in X.  */
2752
2753 static rtx
2754 walk_alter_subreg (x)
2755      rtx x;
2756 {
2757   switch (GET_CODE (x))
2758     {
2759     case PLUS:
2760     case MULT:
2761       XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
2762       XEXP (x, 1) = walk_alter_subreg (XEXP (x, 1));
2763       break;
2764
2765     case MEM:
2766       XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
2767       break;
2768
2769     case SUBREG:
2770       return alter_subreg (x);
2771
2772     default:
2773       break;
2774     }
2775
2776   return x;
2777 }
2778 \f
2779 #ifdef HAVE_cc0
2780
2781 /* Given BODY, the body of a jump instruction, alter the jump condition
2782    as required by the bits that are set in cc_status.flags.
2783    Not all of the bits there can be handled at this level in all cases.
2784
2785    The value is normally 0.
2786    1 means that the condition has become always true.
2787    -1 means that the condition has become always false.
2788    2 means that COND has been altered.  */
2789
2790 static int
2791 alter_cond (cond)
2792      register rtx cond;
2793 {
2794   int value = 0;
2795
2796   if (cc_status.flags & CC_REVERSED)
2797     {
2798       value = 2;
2799       PUT_CODE (cond, swap_condition (GET_CODE (cond)));
2800     }
2801
2802   if (cc_status.flags & CC_INVERTED)
2803     {
2804       value = 2;
2805       PUT_CODE (cond, reverse_condition (GET_CODE (cond)));
2806     }
2807
2808   if (cc_status.flags & CC_NOT_POSITIVE)
2809     switch (GET_CODE (cond))
2810       {
2811       case LE:
2812       case LEU:
2813       case GEU:
2814         /* Jump becomes unconditional.  */
2815         return 1;
2816
2817       case GT:
2818       case GTU:
2819       case LTU:
2820         /* Jump becomes no-op.  */
2821         return -1;
2822
2823       case GE:
2824         PUT_CODE (cond, EQ);
2825         value = 2;
2826         break;
2827
2828       case LT:
2829         PUT_CODE (cond, NE);
2830         value = 2;
2831         break;
2832
2833       default:
2834         break;
2835       }
2836
2837   if (cc_status.flags & CC_NOT_NEGATIVE)
2838     switch (GET_CODE (cond))
2839       {
2840       case GE:
2841       case GEU:
2842         /* Jump becomes unconditional.  */
2843         return 1;
2844
2845       case LT:
2846       case LTU:
2847         /* Jump becomes no-op.  */
2848         return -1;
2849
2850       case LE:
2851       case LEU:
2852         PUT_CODE (cond, EQ);
2853         value = 2;
2854         break;
2855
2856       case GT:
2857       case GTU:
2858         PUT_CODE (cond, NE);
2859         value = 2;
2860         break;
2861
2862       default:
2863         break;
2864       }
2865
2866   if (cc_status.flags & CC_NO_OVERFLOW)
2867     switch (GET_CODE (cond))
2868       {
2869       case GEU:
2870         /* Jump becomes unconditional.  */
2871         return 1;
2872
2873       case LEU:
2874         PUT_CODE (cond, EQ);
2875         value = 2;
2876         break;
2877
2878       case GTU:
2879         PUT_CODE (cond, NE);
2880         value = 2;
2881         break;
2882
2883       case LTU:
2884         /* Jump becomes no-op.  */
2885         return -1;
2886
2887       default:
2888         break;
2889       }
2890
2891   if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N))
2892     switch (GET_CODE (cond))
2893       {
2894       default:
2895         abort ();
2896
2897       case NE:
2898         PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
2899         value = 2;
2900         break;
2901
2902       case EQ:
2903         PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE);
2904         value = 2;
2905         break;
2906       }
2907
2908   if (cc_status.flags & CC_NOT_SIGNED)
2909     /* The flags are valid if signed condition operators are converted
2910        to unsigned.  */
2911     switch (GET_CODE (cond))
2912       {
2913       case LE:
2914         PUT_CODE (cond, LEU);
2915         value = 2;
2916         break;
2917
2918       case LT:
2919         PUT_CODE (cond, LTU);
2920         value = 2;
2921         break;
2922
2923       case GT:
2924         PUT_CODE (cond, GTU);
2925         value = 2;
2926         break;
2927
2928       case GE:
2929         PUT_CODE (cond, GEU);
2930         value = 2;
2931         break;
2932
2933       default:
2934         break;
2935       }
2936
2937   return value;
2938 }
2939 #endif
2940 \f
2941 /* Report inconsistency between the assembler template and the operands.
2942    In an `asm', it's the user's fault; otherwise, the compiler's fault.  */
2943
2944 void
2945 output_operand_lossage (str)
2946      char *str;
2947 {
2948   if (this_is_asm_operands)
2949     error_for_asm (this_is_asm_operands, "invalid `asm': %s", str);
2950   else
2951     abort ();
2952 }
2953 \f
2954 /* Output of assembler code from a template, and its subroutines.  */
2955
2956 /* Output text from TEMPLATE to the assembler output file,
2957    obeying %-directions to substitute operands taken from
2958    the vector OPERANDS.
2959
2960    %N (for N a digit) means print operand N in usual manner.
2961    %lN means require operand N to be a CODE_LABEL or LABEL_REF
2962       and print the label name with no punctuation.
2963    %cN means require operand N to be a constant
2964       and print the constant expression with no punctuation.
2965    %aN means expect operand N to be a memory address
2966       (not a memory reference!) and print a reference
2967       to that address.
2968    %nN means expect operand N to be a constant
2969       and print a constant expression for minus the value
2970       of the operand, with no other punctuation.  */
2971
2972 static void
2973 output_asm_name ()
2974 {
2975   if (flag_print_asm_name)
2976     {
2977       /* Annotate the assembly with a comment describing the pattern and
2978          alternative used.  */
2979       if (debug_insn)
2980         {
2981           register int num = INSN_CODE (debug_insn);
2982           fprintf (asm_out_file, " %s %d %s",
2983                    ASM_COMMENT_START, INSN_UID (debug_insn), insn_name[num]);
2984           if (insn_n_alternatives[num] > 1)
2985             fprintf (asm_out_file, "/%d", which_alternative + 1);
2986
2987           /* Clear this so only the first assembler insn
2988              of any rtl insn will get the special comment for -dp.  */
2989           debug_insn = 0;
2990         }
2991     }
2992 }
2993
2994 void
2995 output_asm_insn (template, operands)
2996      char *template;
2997      rtx *operands;
2998 {
2999   register char *p;
3000   register int c;
3001
3002   /* An insn may return a null string template
3003      in a case where no assembler code is needed.  */
3004   if (*template == 0)
3005     return;
3006
3007   p = template;
3008   putc ('\t', asm_out_file);
3009
3010 #ifdef ASM_OUTPUT_OPCODE
3011   ASM_OUTPUT_OPCODE (asm_out_file, p);
3012 #endif
3013
3014   while ((c = *p++))
3015     switch (c)
3016       {
3017       case '\n':
3018         output_asm_name ();
3019         putc (c, asm_out_file);
3020 #ifdef ASM_OUTPUT_OPCODE
3021         while ((c = *p) == '\t')
3022           {
3023             putc (c, asm_out_file);
3024             p++;
3025           }
3026         ASM_OUTPUT_OPCODE (asm_out_file, p);
3027 #endif
3028         break;
3029
3030 #ifdef ASSEMBLER_DIALECT
3031       case '{':
3032         {
3033           register int i;
3034
3035           /* If we want the first dialect, do nothing.  Otherwise, skip
3036              DIALECT_NUMBER of strings ending with '|'.  */
3037           for (i = 0; i < dialect_number; i++)
3038             {
3039               while (*p && *p++ != '|')
3040                 ;
3041
3042               if (*p == '|')
3043                 p++;
3044             }
3045         }
3046         break;
3047
3048       case '|':
3049         /* Skip to close brace.  */
3050         while (*p && *p++ != '}')
3051           ;
3052         break;
3053
3054       case '}':
3055         break;
3056 #endif
3057
3058       case '%':
3059         /* %% outputs a single %.  */
3060         if (*p == '%')
3061           {
3062             p++;
3063             putc (c, asm_out_file);
3064           }
3065         /* %= outputs a number which is unique to each insn in the entire
3066            compilation.  This is useful for making local labels that are
3067            referred to more than once in a given insn.  */
3068         else if (*p == '=')
3069           {
3070             p++;
3071             fprintf (asm_out_file, "%d", insn_counter);
3072           }
3073         /* % followed by a letter and some digits
3074            outputs an operand in a special way depending on the letter.
3075            Letters `acln' are implemented directly.
3076            Other letters are passed to `output_operand' so that
3077            the PRINT_OPERAND macro can define them.  */
3078         else if ((*p >= 'a' && *p <= 'z')
3079                  || (*p >= 'A' && *p <= 'Z'))
3080           {
3081             int letter = *p++;
3082             c = atoi (p);
3083
3084             if (! (*p >= '0' && *p <= '9'))
3085               output_operand_lossage ("operand number missing after %-letter");
3086             else if (this_is_asm_operands && c >= (unsigned) insn_noperands)
3087               output_operand_lossage ("operand number out of range");
3088             else if (letter == 'l')
3089               output_asm_label (operands[c]);
3090             else if (letter == 'a')
3091               output_address (operands[c]);
3092             else if (letter == 'c')
3093               {
3094                 if (CONSTANT_ADDRESS_P (operands[c]))
3095                   output_addr_const (asm_out_file, operands[c]);
3096                 else
3097                   output_operand (operands[c], 'c');
3098               }
3099             else if (letter == 'n')
3100               {
3101                 if (GET_CODE (operands[c]) == CONST_INT)
3102                   fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC,
3103                            - INTVAL (operands[c]));
3104                 else
3105                   {
3106                     putc ('-', asm_out_file);
3107                     output_addr_const (asm_out_file, operands[c]);
3108                   }
3109               }
3110             else
3111               output_operand (operands[c], letter);
3112
3113             while ((c = *p) >= '0' && c <= '9') p++;
3114           }
3115         /* % followed by a digit outputs an operand the default way.  */
3116         else if (*p >= '0' && *p <= '9')
3117           {
3118             c = atoi (p);
3119             if (this_is_asm_operands && c >= (unsigned) insn_noperands)
3120               output_operand_lossage ("operand number out of range");
3121             else
3122               output_operand (operands[c], 0);
3123             while ((c = *p) >= '0' && c <= '9') p++;
3124           }
3125         /* % followed by punctuation: output something for that
3126            punctuation character alone, with no operand.
3127            The PRINT_OPERAND macro decides what is actually done.  */
3128 #ifdef PRINT_OPERAND_PUNCT_VALID_P
3129         else if (PRINT_OPERAND_PUNCT_VALID_P (*p))
3130           output_operand (NULL_RTX, *p++);
3131 #endif
3132         else
3133           output_operand_lossage ("invalid %%-code");
3134         break;
3135
3136       default:
3137         putc (c, asm_out_file);
3138       }
3139
3140   output_asm_name ();
3141
3142   putc ('\n', asm_out_file);
3143 }
3144 \f
3145 /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol.  */
3146
3147 void
3148 output_asm_label (x)
3149      rtx x;
3150 {
3151   char buf[256];
3152
3153   if (GET_CODE (x) == LABEL_REF)
3154     ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
3155   else if (GET_CODE (x) == CODE_LABEL)
3156     ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3157   else
3158     output_operand_lossage ("`%l' operand isn't a label");
3159
3160   assemble_name (asm_out_file, buf);
3161 }
3162
3163 /* Print operand X using machine-dependent assembler syntax.
3164    The macro PRINT_OPERAND is defined just to control this function.
3165    CODE is a non-digit that preceded the operand-number in the % spec,
3166    such as 'z' if the spec was `%z3'.  CODE is 0 if there was no char
3167    between the % and the digits.
3168    When CODE is a non-letter, X is 0.
3169
3170    The meanings of the letters are machine-dependent and controlled
3171    by PRINT_OPERAND.  */
3172
3173 static void
3174 output_operand (x, code)
3175      rtx x;
3176      int code;
3177 {
3178   if (x && GET_CODE (x) == SUBREG)
3179     x = alter_subreg (x);
3180
3181   /* If X is a pseudo-register, abort now rather than writing trash to the
3182      assembler file.  */
3183
3184   if (x && GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER)
3185     abort ();
3186
3187   PRINT_OPERAND (asm_out_file, x, code);
3188 }
3189
3190 /* Print a memory reference operand for address X
3191    using machine-dependent assembler syntax.
3192    The macro PRINT_OPERAND_ADDRESS exists just to control this function.  */
3193
3194 void
3195 output_address (x)
3196      rtx x;
3197 {
3198   walk_alter_subreg (x);
3199   PRINT_OPERAND_ADDRESS (asm_out_file, x);
3200 }
3201 \f
3202 /* Print an integer constant expression in assembler syntax.
3203    Addition and subtraction are the only arithmetic
3204    that may appear in these expressions.  */
3205
3206 void
3207 output_addr_const (file, x)
3208      FILE *file;
3209      rtx x;
3210 {
3211   char buf[256];
3212
3213  restart:
3214   switch (GET_CODE (x))
3215     {
3216     case PC:
3217       if (flag_pic)
3218         putc ('.', file);
3219       else
3220         abort ();
3221       break;
3222
3223     case SYMBOL_REF:
3224       assemble_name (file, XSTR (x, 0));
3225       break;
3226
3227     case LABEL_REF:
3228       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
3229       assemble_name (file, buf);
3230       break;
3231
3232     case CODE_LABEL:
3233       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
3234       assemble_name (file, buf);
3235       break;
3236
3237     case CONST_INT:
3238       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
3239       break;
3240
3241     case CONST:
3242       /* This used to output parentheses around the expression,
3243          but that does not work on the 386 (either ATT or BSD assembler).  */
3244       output_addr_const (file, XEXP (x, 0));
3245       break;
3246
3247     case CONST_DOUBLE:
3248       if (GET_MODE (x) == VOIDmode)
3249         {
3250           /* We can use %d if the number is one word and positive.  */
3251           if (CONST_DOUBLE_HIGH (x))
3252             fprintf (file, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3253                      CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
3254           else if  (CONST_DOUBLE_LOW (x) < 0)
3255             fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
3256           else
3257             fprintf (file, HOST_WIDE_INT_PRINT_DEC, CONST_DOUBLE_LOW (x));
3258         }
3259       else
3260         /* We can't handle floating point constants;
3261            PRINT_OPERAND must handle them.  */
3262         output_operand_lossage ("floating constant misused");
3263       break;
3264
3265     case PLUS:
3266       /* Some assemblers need integer constants to appear last (eg masm).  */
3267       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
3268         {
3269           output_addr_const (file, XEXP (x, 1));
3270           if (INTVAL (XEXP (x, 0)) >= 0)
3271             fprintf (file, "+");
3272           output_addr_const (file, XEXP (x, 0));
3273         }
3274       else
3275         {
3276           output_addr_const (file, XEXP (x, 0));
3277           if (INTVAL (XEXP (x, 1)) >= 0)
3278             fprintf (file, "+");
3279           output_addr_const (file, XEXP (x, 1));
3280         }
3281       break;
3282
3283     case MINUS:
3284       /* Avoid outputting things like x-x or x+5-x,
3285          since some assemblers can't handle that.  */
3286       x = simplify_subtraction (x);
3287       if (GET_CODE (x) != MINUS)
3288         goto restart;
3289
3290       output_addr_const (file, XEXP (x, 0));
3291       fprintf (file, "-");
3292       if (GET_CODE (XEXP (x, 1)) == CONST_INT
3293           && INTVAL (XEXP (x, 1)) < 0)
3294         {
3295           fprintf (file, ASM_OPEN_PAREN);
3296           output_addr_const (file, XEXP (x, 1));
3297           fprintf (file, ASM_CLOSE_PAREN);
3298         }
3299       else
3300         output_addr_const (file, XEXP (x, 1));
3301       break;
3302
3303     case ZERO_EXTEND:
3304     case SIGN_EXTEND:
3305       output_addr_const (file, XEXP (x, 0));
3306       break;
3307
3308     default:
3309       output_operand_lossage ("invalid expression as operand");
3310     }
3311 }
3312 \f
3313 /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
3314    %R prints the value of REGISTER_PREFIX.
3315    %L prints the value of LOCAL_LABEL_PREFIX.
3316    %U prints the value of USER_LABEL_PREFIX.
3317    %I prints the value of IMMEDIATE_PREFIX.
3318    %O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
3319    Also supported are %d, %x, %s, %e, %f, %g and %%.
3320
3321    We handle alternate assembler dialects here, just like output_asm_insn.  */
3322
3323 void
3324 asm_fprintf VPROTO((FILE *file, char *p, ...))
3325 {
3326 #ifndef __STDC__
3327   FILE *file;
3328   char *p;
3329 #endif
3330   va_list argptr;
3331   char buf[10];
3332   char *q, c;
3333
3334   VA_START (argptr, p);
3335
3336 #ifndef __STDC__
3337   file = va_arg (argptr, FILE *);
3338   p = va_arg (argptr, char *);
3339 #endif
3340
3341   buf[0] = '%';
3342
3343   while ((c = *p++))
3344     switch (c)
3345       {
3346 #ifdef ASSEMBLER_DIALECT
3347       case '{':
3348         {
3349           int i;
3350
3351           /* If we want the first dialect, do nothing.  Otherwise, skip
3352              DIALECT_NUMBER of strings ending with '|'.  */
3353           for (i = 0; i < dialect_number; i++)
3354             {
3355               while (*p && *p++ != '|')
3356                 ;
3357
3358               if (*p == '|')
3359                 p++;
3360           }
3361         }
3362         break;
3363
3364       case '|':
3365         /* Skip to close brace.  */
3366         while (*p && *p++ != '}')
3367           ;
3368         break;
3369
3370       case '}':
3371         break;
3372 #endif
3373
3374       case '%':
3375         c = *p++;
3376         q = &buf[1];
3377         while ((c >= '0' && c <= '9') || c == '.')
3378           {
3379             *q++ = c;
3380             c = *p++;
3381           }
3382         switch (c)
3383           {
3384           case '%':
3385             fprintf (file, "%%");
3386             break;
3387
3388           case 'd':  case 'i':  case 'u':
3389           case 'x':  case 'p':  case 'X':
3390           case 'o':
3391             *q++ = c;
3392             *q = 0;
3393             fprintf (file, buf, va_arg (argptr, int));
3394             break;
3395
3396           case 'w':
3397             /* This is a prefix to the 'd', 'i', 'u', 'x', 'p', and 'X' cases,
3398                but we do not check for those cases.  It means that the value
3399                is a HOST_WIDE_INT, which may be either `int' or `long'.  */
3400
3401 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
3402 #else
3403 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
3404             *q++ = 'l';
3405 #else
3406             *q++ = 'l';
3407             *q++ = 'l';
3408 #endif
3409 #endif
3410
3411             *q++ = *p++;
3412             *q = 0;
3413             fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT));
3414             break;
3415
3416           case 'l':
3417             *q++ = c;
3418             *q++ = *p++;
3419             *q = 0;
3420             fprintf (file, buf, va_arg (argptr, long));
3421             break;
3422
3423           case 'e':
3424           case 'f':
3425           case 'g':
3426             *q++ = c;
3427             *q = 0;
3428             fprintf (file, buf, va_arg (argptr, double));
3429             break;
3430
3431           case 's':
3432             *q++ = c;
3433             *q = 0;
3434             fprintf (file, buf, va_arg (argptr, char *));
3435             break;
3436
3437           case 'O':
3438 #ifdef ASM_OUTPUT_OPCODE
3439             ASM_OUTPUT_OPCODE (asm_out_file, p);
3440 #endif
3441             break;
3442
3443           case 'R':
3444 #ifdef REGISTER_PREFIX
3445             fprintf (file, "%s", REGISTER_PREFIX);
3446 #endif
3447             break;
3448
3449           case 'I':
3450 #ifdef IMMEDIATE_PREFIX
3451             fprintf (file, "%s", IMMEDIATE_PREFIX);
3452 #endif
3453             break;
3454
3455           case 'L':
3456 #ifdef LOCAL_LABEL_PREFIX
3457             fprintf (file, "%s", LOCAL_LABEL_PREFIX);
3458 #endif
3459             break;
3460
3461           case 'U':
3462 #ifdef USER_LABEL_PREFIX
3463             fprintf (file, "%s", USER_LABEL_PREFIX);
3464 #endif
3465             break;
3466
3467           default:
3468             abort ();
3469           }
3470         break;
3471
3472       default:
3473         fputc (c, file);
3474       }
3475 }
3476 \f
3477 /* Split up a CONST_DOUBLE or integer constant rtx
3478    into two rtx's for single words,
3479    storing in *FIRST the word that comes first in memory in the target
3480    and in *SECOND the other.  */
3481
3482 void
3483 split_double (value, first, second)
3484      rtx value;
3485      rtx *first, *second;
3486 {
3487   if (GET_CODE (value) == CONST_INT)
3488     {
3489       if (HOST_BITS_PER_WIDE_INT >= (2 * BITS_PER_WORD))
3490         {
3491           /* In this case the CONST_INT holds both target words.
3492              Extract the bits from it into two word-sized pieces.  */
3493           rtx low, high;
3494           HOST_WIDE_INT word_mask;
3495           /* Avoid warnings for shift count >= BITS_PER_WORD.  */
3496           int shift_count = BITS_PER_WORD - 1;
3497
3498           word_mask = (HOST_WIDE_INT) 1 << shift_count;
3499           word_mask |= word_mask - 1;
3500           low = GEN_INT (INTVAL (value) & word_mask);
3501           high = GEN_INT ((INTVAL (value) >> (shift_count + 1)) & word_mask);
3502           if (WORDS_BIG_ENDIAN)
3503             {
3504               *first = high;
3505               *second = low;
3506             }
3507           else
3508             {
3509               *first = low;
3510               *second = high;
3511             }
3512         }
3513       else
3514         {
3515           /* The rule for using CONST_INT for a wider mode
3516              is that we regard the value as signed.
3517              So sign-extend it.  */
3518           rtx high = (INTVAL (value) < 0 ? constm1_rtx : const0_rtx);
3519           if (WORDS_BIG_ENDIAN)
3520             {
3521               *first = high;
3522               *second = value;
3523             }
3524           else
3525             {
3526               *first = value;
3527               *second = high;
3528             }
3529         }
3530     }
3531   else if (GET_CODE (value) != CONST_DOUBLE)
3532     {
3533       if (WORDS_BIG_ENDIAN)
3534         {
3535           *first = const0_rtx;
3536           *second = value;
3537         }
3538       else
3539         {
3540           *first = value;
3541           *second = const0_rtx;
3542         }
3543     }
3544   else if (GET_MODE (value) == VOIDmode
3545            /* This is the old way we did CONST_DOUBLE integers.  */
3546            || GET_MODE_CLASS (GET_MODE (value)) == MODE_INT)
3547     {
3548       /* In an integer, the words are defined as most and least significant.
3549          So order them by the target's convention.  */
3550       if (WORDS_BIG_ENDIAN)
3551         {
3552           *first = GEN_INT (CONST_DOUBLE_HIGH (value));
3553           *second = GEN_INT (CONST_DOUBLE_LOW (value));
3554         }
3555       else
3556         {
3557           *first = GEN_INT (CONST_DOUBLE_LOW (value));
3558           *second = GEN_INT (CONST_DOUBLE_HIGH (value));
3559         }
3560     }
3561   else
3562     {
3563 #ifdef REAL_ARITHMETIC
3564       REAL_VALUE_TYPE r; long l[2];
3565       REAL_VALUE_FROM_CONST_DOUBLE (r, value);
3566
3567       /* Note, this converts the REAL_VALUE_TYPE to the target's
3568          format, splits up the floating point double and outputs
3569          exactly 32 bits of it into each of l[0] and l[1] --
3570          not necessarily BITS_PER_WORD bits.  */
3571       REAL_VALUE_TO_TARGET_DOUBLE (r, l);
3572
3573       *first = GEN_INT ((HOST_WIDE_INT) l[0]);
3574       *second = GEN_INT ((HOST_WIDE_INT) l[1]);
3575 #else
3576       if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
3577            || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
3578           && ! flag_pretend_float)
3579       abort ();
3580
3581       if (
3582 #ifdef HOST_WORDS_BIG_ENDIAN
3583           WORDS_BIG_ENDIAN
3584 #else
3585           ! WORDS_BIG_ENDIAN
3586 #endif
3587           )
3588         {
3589           /* Host and target agree => no need to swap.  */
3590           *first = GEN_INT (CONST_DOUBLE_LOW (value));
3591           *second = GEN_INT (CONST_DOUBLE_HIGH (value));
3592         }
3593       else
3594         {
3595           *second = GEN_INT (CONST_DOUBLE_LOW (value));
3596           *first = GEN_INT (CONST_DOUBLE_HIGH (value));
3597         }
3598 #endif /* no REAL_ARITHMETIC */
3599     }
3600 }
3601 \f
3602 /* Return nonzero if this function has no function calls.  */
3603
3604 int
3605 leaf_function_p ()
3606 {
3607   rtx insn;
3608
3609   if (profile_flag || profile_block_flag || profile_arc_flag)
3610     return 0;
3611
3612   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3613     {
3614       if (GET_CODE (insn) == CALL_INSN)
3615         return 0;
3616       if (GET_CODE (insn) == INSN
3617           && GET_CODE (PATTERN (insn)) == SEQUENCE
3618           && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN)
3619         return 0;
3620     }
3621   for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
3622     {
3623       if (GET_CODE (XEXP (insn, 0)) == CALL_INSN)
3624         return 0;
3625       if (GET_CODE (XEXP (insn, 0)) == INSN
3626           && GET_CODE (PATTERN (XEXP (insn, 0))) == SEQUENCE
3627           && GET_CODE (XVECEXP (PATTERN (XEXP (insn, 0)), 0, 0)) == CALL_INSN)
3628         return 0;
3629     }
3630
3631   return 1;
3632 }
3633
3634 /* On some machines, a function with no call insns
3635    can run faster if it doesn't create its own register window.
3636    When output, the leaf function should use only the "output"
3637    registers.  Ordinarily, the function would be compiled to use
3638    the "input" registers to find its arguments; it is a candidate
3639    for leaf treatment if it uses only the "input" registers.
3640    Leaf function treatment means renumbering so the function
3641    uses the "output" registers instead.  */
3642
3643 #ifdef LEAF_REGISTERS
3644
3645 static char permitted_reg_in_leaf_functions[] = LEAF_REGISTERS;
3646
3647 /* Return 1 if this function uses only the registers that can be
3648    safely renumbered.  */
3649
3650 int
3651 only_leaf_regs_used ()
3652 {
3653   int i;
3654
3655   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
3656     {
3657       if ((regs_ever_live[i] || global_regs[i])
3658           && ! permitted_reg_in_leaf_functions[i])
3659         return 0;
3660     }
3661   return 1;
3662 }
3663
3664 /* Scan all instructions and renumber all registers into those
3665    available in leaf functions.  */
3666
3667 static void
3668 leaf_renumber_regs (first)
3669      rtx first;
3670 {
3671   rtx insn;
3672
3673   /* Renumber only the actual patterns.
3674      The reg-notes can contain frame pointer refs,
3675      and renumbering them could crash, and should not be needed.  */
3676   for (insn = first; insn; insn = NEXT_INSN (insn))
3677     if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
3678       leaf_renumber_regs_insn (PATTERN (insn));
3679   for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
3680     if (GET_RTX_CLASS (GET_CODE (XEXP (insn, 0))) == 'i')
3681       leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0)));
3682 }
3683
3684 /* Scan IN_RTX and its subexpressions, and renumber all regs into those
3685    available in leaf functions.  */
3686
3687 void
3688 leaf_renumber_regs_insn (in_rtx)
3689      register rtx in_rtx;
3690 {
3691   register int i, j;
3692   register char *format_ptr;
3693
3694   if (in_rtx == 0)
3695     return;
3696
3697   /* Renumber all input-registers into output-registers.
3698      renumbered_regs would be 1 for an output-register;
3699      they  */
3700
3701   if (GET_CODE (in_rtx) == REG)
3702     {
3703       int newreg;
3704
3705       /* Don't renumber the same reg twice.  */
3706       if (in_rtx->used)
3707         return;
3708
3709       newreg = REGNO (in_rtx);
3710       /* Don't try to renumber pseudo regs.  It is possible for a pseudo reg
3711          to reach here as part of a REG_NOTE.  */
3712       if (newreg >= FIRST_PSEUDO_REGISTER)
3713         {
3714           in_rtx->used = 1;
3715           return;
3716         }
3717       newreg = LEAF_REG_REMAP (newreg);
3718       if (newreg < 0)
3719         abort ();
3720       regs_ever_live[REGNO (in_rtx)] = 0;
3721       regs_ever_live[newreg] = 1;
3722       REGNO (in_rtx) = newreg;
3723       in_rtx->used = 1;
3724     }
3725
3726   if (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i')
3727     {
3728       /* Inside a SEQUENCE, we find insns.
3729          Renumber just the patterns of these insns,
3730          just as we do for the top-level insns.  */
3731       leaf_renumber_regs_insn (PATTERN (in_rtx));
3732       return;
3733     }
3734
3735   format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
3736
3737   for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
3738     switch (*format_ptr++)
3739       {
3740       case 'e':
3741         leaf_renumber_regs_insn (XEXP (in_rtx, i));
3742         break;
3743
3744       case 'E':
3745         if (NULL != XVEC (in_rtx, i))
3746           {
3747             for (j = 0; j < XVECLEN (in_rtx, i); j++)
3748               leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
3749           }
3750         break;
3751
3752       case 'S':
3753       case 's':
3754       case '0':
3755       case 'i':
3756       case 'w':
3757       case 'n':
3758       case 'u':
3759         break;
3760
3761       default:
3762         abort ();
3763       }
3764 }
3765 #endif