OSDN Git Service

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