OSDN Git Service

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