OSDN Git Service

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