gcc/final.c

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