OSDN Git Service

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