OSDN Git Service

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