OSDN Git Service

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