1 /* Convert RTL to assembler code and output it, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This is the final pass of the compiler.
22 It looks at the rtl code for a function and outputs assembler code.
24 Call `final_start_function' to output the assembler code for function entry,
25 `final' to output assembler code for some RTL code,
26 `final_end_function' to output assembler code for function exit.
27 If a function is compiled in several pieces, each piece is
28 output separately with `final'.
30 Some optimizations are also done at this level.
31 Move instructions that were made unnecessary by good register allocation
32 are detected and omitted from the output. (Though most of these
33 are removed by the last jump pass.)
35 Instructions to set the condition codes are omitted when it can be
36 seen that the condition codes already had the desired values.
38 In some cases it is sufficient if the inherited condition codes
39 have related values, but this may require the following insn
40 (the one that tests the condition codes) to be modified.
42 The code for the function prologue and epilogue are generated
43 directly as assembler code by the macros FUNCTION_PROLOGUE and
44 FUNCTION_EPILOGUE. Those instructions never exist as rtl. */
51 #include "insn-config.h"
52 #include "insn-flags.h"
53 #include "insn-attr.h"
54 #include "insn-codes.h"
56 #include "conditions.h"
59 #include "hard-reg-set.h"
67 /* Get N_SLINE and N_SOL from stab.h if we can expect the file to exist. */
68 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
69 #if defined (USG) || defined (NO_STAB_H)
70 #include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
72 #include <stab.h> /* On BSD, use the system's stab.h. */
74 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
76 #ifdef XCOFF_DEBUGGING_INFO
80 /* .stabd code for line number. */
85 /* .stabs code for included file name. */
91 #define INT_TYPE_SIZE BITS_PER_WORD
94 /* If we aren't using cc0, CC_STATUS_INIT shouldn't exist. So define a
95 null default for it to save conditionalization later. */
96 #ifndef CC_STATUS_INIT
97 #define CC_STATUS_INIT
100 /* How to start an assembler comment. */
101 #ifndef ASM_COMMENT_START
102 #define ASM_COMMENT_START ";#"
106 void output_asm_insn ();
108 static rtx walk_alter_subreg ();
109 static int alter_cond ();
110 void output_asm_label ();
111 static void output_operand ();
112 void output_address ();
113 void output_addr_const ();
114 static void output_source_line ();
115 rtx final_scan_insn ();
116 void profile_function ();
117 static void profile_after_prologue ();
119 #ifdef HAVE_ATTR_length
120 static int asm_insn_count ();
123 /* Nonzero means this function is a leaf function, with no function calls.
124 This variable exists to be examined in FUNCTION_PROLOGUE
125 and FUNCTION_EPILOGUE. Always zero, unless set by some action. */
128 int leaf_function_p ();
130 #ifdef LEAF_REGISTERS
131 int only_leaf_regs_used ();
132 static void leaf_renumber_regs ();
133 void leaf_renumber_regs_insn ();
136 /* Last insn processed by final_scan_insn. */
137 static rtx debug_insn = 0;
139 /* Line number of last NOTE. */
140 static int last_linenum;
142 /* Filename of last NOTE. */
143 static char *last_filename;
145 /* Number of basic blocks seen so far;
146 used if profile_block_flag is set. */
147 static int count_basic_blocks;
149 /* Nonzero while outputting an `asm' with operands.
150 This means that inconsistencies are the user's fault, so don't abort.
151 The precise value is the insn being output, to pass to error_for_asm. */
152 static rtx this_is_asm_operands;
154 /* Number of operands of this insn, for an `asm' with operands. */
155 static int insn_noperands;
157 /* Compare optimization flag. */
159 static rtx last_ignored_compare = 0;
161 /* Flag indicating this insn is the start of a new basic block. */
163 static int new_block = 1;
165 /* All the symbol-blocks (levels of scoping) in the compilation
166 are assigned sequence numbers in order of appearance of the
167 beginnings of the symbol-blocks. Both final and dbxout do this,
168 and assume that they will both give the same number to each block.
169 Final uses these sequence numbers to generate assembler label names
170 LBBnnn and LBEnnn for the beginning and end of the symbol-block.
171 Dbxout uses the sequence numbers to generate references to the same labels
172 from the dbx debugging information.
174 Sdb records this level at the beginning of each function,
175 in order to find the current level when recursing down declarations.
176 It outputs the block beginning and endings
177 at the point in the asm file where the blocks would begin and end. */
179 int next_block_index;
181 /* Assign a unique number to each insn that is output.
182 This can be used to generate unique local labels. */
184 static int insn_counter = 0;
187 /* This variable contains machine-dependent flags (defined in tm.h)
188 set and examined by output routines
189 that describe how to interpret the condition codes properly. */
193 /* During output of an insn, this contains a copy of cc_status
194 from before the insn. */
196 CC_STATUS cc_prev_status;
199 /* Indexed by hardware reg number, is 1 if that register is ever
200 used in the current function.
202 In life_analysis, or in stupid_life_analysis, this is set
203 up to record the hard regs used explicitly. Reload adds
204 in the hard regs used for holding pseudo regs. Final uses
205 it to generate the code in the function prologue and epilogue
206 to save and restore registers as needed. */
208 char regs_ever_live[FIRST_PSEUDO_REGISTER];
210 /* Nonzero means current function must be given a frame pointer.
211 Set in stmt.c if anything is allocated on the stack there.
212 Set in reload1.c if anything is allocated on the stack there. */
214 int frame_pointer_needed;
216 /* Assign unique numbers to labels generated for profiling. */
218 int profile_label_no;
220 /* Length so far allocated in PENDING_BLOCKS. */
222 static int max_block_depth;
224 /* Stack of sequence numbers of symbol-blocks of which we have seen the
225 beginning but not yet the end. Sequence numbers are assigned at
226 the beginning; this stack allows us to find the sequence number
227 of a block that is ending. */
229 static int *pending_blocks;
231 /* Number of elements currently in use in PENDING_BLOCKS. */
233 static int block_depth;
235 /* Nonzero if have enabled APP processing of our assembler output. */
239 /* If we are outputting an insn sequence, this contains the sequence rtx.
244 #ifdef ASSEMBLER_DIALECT
246 /* Number of the assembler dialect to use, starting at 0. */
247 static int dialect_number;
250 /* Indexed by line number, nonzero if there is a note for that line. */
252 static char *line_note_exists;
254 /* Linked list to hold line numbers for each basic block. */
257 struct bb_list *next; /* pointer to next basic block */
258 int line_num; /* line number */
259 int file_label_num; /* LPBC<n> label # for stored filename */
260 int func_label_num; /* LPBC<n> label # for stored function name */
263 static struct bb_list *bb_head = 0; /* Head of basic block list */
264 static struct bb_list **bb_tail = &bb_head; /* Ptr to store next bb ptr */
265 static int bb_file_label_num = -1; /* Current label # for file */
266 static int bb_func_label_num = -1; /* Current label # for func */
268 /* Linked list to hold the strings for each file and function name output. */
271 struct bb_str *next; /* pointer to next string */
272 char *string; /* string */
273 int label_num; /* label number */
274 int length; /* string length */
277 static struct bb_str *sbb_head = 0; /* Head of string list. */
278 static struct bb_str **sbb_tail = &sbb_head; /* Ptr to store next bb str */
279 static int sbb_label_num = 0; /* Last label used */
281 static int add_bb_string PROTO((char *, int));
282 static void add_bb PROTO((FILE *));
285 /* Initialize data in final at the beginning of a compilation. */
288 init_final (filename)
291 next_block_index = 2;
293 max_block_depth = 20;
294 pending_blocks = (int *) xmalloc (20 * sizeof *pending_blocks);
297 #ifdef ASSEMBLER_DIALECT
298 dialect_number = ASSEMBLER_DIALECT;
302 /* Called at end of source file,
303 to output the block-profiling table for this entire compilation. */
311 if (profile_block_flag)
314 int align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT);
315 int size = (INT_TYPE_SIZE / BITS_PER_UNIT) * count_basic_blocks;
320 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
321 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
322 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
326 /* Output the main header, of 10 words:
327 0: 1 if this file's initialized, else 0.
328 1: address of file name (LPBX1).
329 2: address of table of counts (LPBX2).
330 3: number of counts in the table.
331 4: always 0, for compatibility with Sun.
333 The following are GNU extensions:
335 5: address of table of start addrs of basic blocks (LPBX3).
336 6: Number of bytes in this header.
337 7: address of table of function names (LPBX4).
338 8: address of table of line numbers (LPBX5) or 0.
339 9: address of table of file names (LPBX6) or 0. */
341 ASM_OUTPUT_ALIGN (asm_out_file, align);
343 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 0);
345 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
347 /* address of filename */
348 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 1);
349 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
351 /* address of count table */
352 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
353 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
355 /* count of the # of basic blocks */
356 assemble_integer (GEN_INT (count_basic_blocks), UNITS_PER_WORD, 1);
358 /* zero word (link field) */
359 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
361 /* address of basic block start address table */
362 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
363 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
365 /* byte count for extended structure. */
366 assemble_integer (GEN_INT (10 * UNITS_PER_WORD), UNITS_PER_WORD, 1);
368 /* address of function name table */
369 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4);
370 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
372 /* address of line number and filename tables if debugging. */
373 if (write_symbols != NO_DEBUG)
375 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5);
376 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
377 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 6);
378 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
382 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
383 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
386 /* Output the file name changing the suffix to .d for Sun tcov
388 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 1);
390 int len = strlen (filename);
391 char *data_file = (char *) alloca (len + 3);
392 strcpy (data_file, filename);
393 strip_off_ending (data_file, len);
394 strcat (data_file, ".d");
395 assemble_string (data_file, strlen (data_file) + 1);
398 /* Make space for the table of counts. */
399 if (flag_no_common || size == 0)
401 /* Realign data section. */
402 ASM_OUTPUT_ALIGN (asm_out_file, align);
403 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 2);
405 assemble_zeros (size);
409 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
410 #ifdef ASM_OUTPUT_SHARED_LOCAL
411 if (flag_shared_data)
412 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
415 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
416 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, align);
418 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
422 /* Output any basic block strings */
423 readonly_data_section ();
426 ASM_OUTPUT_ALIGN (asm_out_file, align);
427 for (sptr = sbb_head; sptr != 0; sptr = sptr->next)
429 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBC", sptr->label_num);
430 assemble_string (sptr->string, sptr->length);
434 /* Output the table of addresses. */
435 /* Realign in new section */
436 ASM_OUTPUT_ALIGN (asm_out_file, align);
437 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 3);
438 for (i = 0; i < count_basic_blocks; i++)
440 ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i);
441 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name),
445 /* Output the table of function names. */
446 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 4);
447 for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
449 if (ptr->func_label_num >= 0)
451 ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->func_label_num);
452 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name),
456 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
459 for ( ; i < count_basic_blocks; i++)
460 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
462 if (write_symbols != NO_DEBUG)
464 /* Output the table of line numbers. */
465 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 5);
466 for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
467 assemble_integer (GEN_INT (ptr->line_num), UNITS_PER_WORD, 1);
469 for ( ; i < count_basic_blocks; i++)
470 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
472 /* Output the table of file names. */
473 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 6);
474 for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
476 if (ptr->file_label_num >= 0)
478 ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->file_label_num);
479 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name),
483 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
486 for ( ; i < count_basic_blocks; i++)
487 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
490 /* End with the address of the table of addresses,
491 so we can find it easily, as the last word in the file's text. */
492 ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
493 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
497 /* Enable APP processing of subsequent output.
498 Used before the output from an `asm' statement. */
505 fprintf (asm_out_file, ASM_APP_ON);
510 /* Enable APP processing of subsequent output.
511 Called from varasm.c before most kinds of output. */
518 fprintf (asm_out_file, ASM_APP_OFF);
523 /* Return the number of slots filled in the current
524 delayed branch sequence (we don't count the insn needing the
525 delay slot). Zero if not in a delayed branch sequence. */
529 dbr_sequence_length ()
531 if (final_sequence != 0)
532 return XVECLEN (final_sequence, 0) - 1;
538 /* The next two pages contain routines used to compute the length of an insn
539 and to shorten branches. */
541 /* Arrays for insn lengths, and addresses. The latter is referenced by
542 `insn_current_length'. */
544 static short *insn_lengths;
547 /* Address of insn being processed. Used by `insn_current_length'. */
548 int insn_current_address;
550 /* Indicate the branch shortening hasn't yet been done. */
558 /* Obtain the current length of an insn. If branch shortening has been done,
559 get its actual length. Otherwise, get its maximum length. */
562 get_attr_length (insn)
565 #ifdef HAVE_ATTR_length
571 return insn_lengths[INSN_UID (insn)];
573 switch (GET_CODE (insn))
581 length = insn_default_length (insn);
585 body = PATTERN (insn);
586 if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
588 /* This only takes room if jump tables go into the text section. */
589 #if !defined(READONLY_DATA_SECTION) || defined(JUMP_TABLES_IN_TEXT_SECTION)
590 length = (XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC)
591 * GET_MODE_SIZE (GET_MODE (body)));
593 /* Be pessimistic and assume worst-case alignment. */
594 length += (GET_MODE_SIZE (GET_MODE (body)) - 1);
600 length = insn_default_length (insn);
604 body = PATTERN (insn);
605 if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
608 else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
609 length = asm_insn_count (insn) * insn_default_length (insn);
610 else if (GET_CODE (body) == SEQUENCE)
611 for (i = 0; i < XVECLEN (body, 0); i++)
612 length += get_attr_length (XVECEXP (body, 0, i));
614 length = insn_default_length (insn);
617 #ifdef ADJUST_INSN_LENGTH
618 ADJUST_INSN_LENGTH (insn, length);
621 #else /* not HAVE_ATTR_length */
623 #endif /* not HAVE_ATTR_length */
626 /* Make a pass over all insns and compute their actual lengths by shortening
627 any branches of variable length if possible. */
629 /* Give a default value for the lowest address in a function. */
631 #ifndef FIRST_INSN_ADDRESS
632 #define FIRST_INSN_ADDRESS 0
636 shorten_branches (first)
639 #ifdef HAVE_ATTR_length
641 int something_changed = 1;
643 char *varying_length;
647 /* Compute maximum UID and allocate arrays. */
648 for (insn = first; insn; insn = NEXT_INSN (insn))
649 if (INSN_UID (insn) > max_uid)
650 max_uid = INSN_UID (insn);
653 insn_lengths = (short *) oballoc (max_uid * sizeof (short));
654 insn_addresses = (int *) oballoc (max_uid * sizeof (int));
655 varying_length = (char *) oballoc (max_uid * sizeof (char));
657 /* Compute initial lengths, addresses, and varying flags for each insn. */
658 for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
660 insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
662 uid = INSN_UID (insn);
663 insn_addresses[uid] = insn_current_address;
664 insn_lengths[uid] = 0;
665 varying_length[uid] = 0;
667 if (GET_CODE (insn) == NOTE || GET_CODE (insn) == BARRIER
668 || GET_CODE (insn) == CODE_LABEL)
671 body = PATTERN (insn);
672 if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
674 /* This only takes room if read-only data goes into the text
676 #if !defined(READONLY_DATA_SECTION) || defined(JUMP_TABLES_IN_TEXT_SECTION)
677 int unitsize = GET_MODE_SIZE (GET_MODE (body));
679 insn_lengths[uid] = (XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC)
680 * GET_MODE_SIZE (GET_MODE (body)));
682 /* Account for possible alignment. */
684 += unitsize - (insn_current_address & (unitsize - 1));
689 else if (asm_noperands (body) >= 0)
690 insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
691 else if (GET_CODE (body) == SEQUENCE)
694 int const_delay_slots;
696 const_delay_slots = const_num_delay_slots (XVECEXP (body, 0, 0));
698 const_delay_slots = 0;
700 /* Inside a delay slot sequence, we do not do any branch shortening
701 if the shortening could change the number of delay slots
703 for (i = 0; i < XVECLEN (body, 0); i++)
705 rtx inner_insn = XVECEXP (body, 0, i);
706 int inner_uid = INSN_UID (inner_insn);
709 if (asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0)
710 inner_length = (asm_insn_count (PATTERN (inner_insn))
711 * insn_default_length (inner_insn));
713 inner_length = insn_default_length (inner_insn);
715 insn_lengths[inner_uid] = inner_length;
716 if (const_delay_slots)
718 if ((varying_length[inner_uid]
719 = insn_variable_length_p (inner_insn)) != 0)
720 varying_length[uid] = 1;
721 insn_addresses[inner_uid] = (insn_current_address +
725 varying_length[inner_uid] = 0;
726 insn_lengths[uid] += inner_length;
729 else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
731 insn_lengths[uid] = insn_default_length (insn);
732 varying_length[uid] = insn_variable_length_p (insn);
735 /* If needed, do any adjustment. */
736 #ifdef ADJUST_INSN_LENGTH
737 ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
741 /* Now loop over all the insns finding varying length insns. For each,
742 get the current insn length. If it has changed, reflect the change.
743 When nothing changes for a full pass, we are done. */
745 while (something_changed)
747 something_changed = 0;
748 for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
750 insn = NEXT_INSN (insn))
755 uid = INSN_UID (insn);
756 insn_addresses[uid] = insn_current_address;
757 if (! varying_length[uid])
759 insn_current_address += insn_lengths[uid];
762 if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
766 body = PATTERN (insn);
768 for (i = 0; i < XVECLEN (body, 0); i++)
770 rtx inner_insn = XVECEXP (body, 0, i);
771 int inner_uid = INSN_UID (inner_insn);
774 insn_addresses[inner_uid] = insn_current_address;
776 /* insn_current_length returns 0 for insns with a
777 non-varying length. */
778 if (! varying_length[inner_uid])
779 inner_length = insn_lengths[inner_uid];
781 inner_length = insn_current_length (inner_insn);
783 if (inner_length != insn_lengths[inner_uid])
785 insn_lengths[inner_uid] = inner_length;
786 something_changed = 1;
788 insn_current_address += insn_lengths[inner_uid];
789 new_length += inner_length;
794 new_length = insn_current_length (insn);
795 insn_current_address += new_length;
798 #ifdef SHORTEN_WITH_ADJUST_INSN_LENGTH
799 #ifdef ADJUST_INSN_LENGTH
800 /* If needed, do any adjustment. */
801 tmp_length = new_length;
802 ADJUST_INSN_LENGTH (insn, new_length);
803 insn_current_address += (new_length - tmp_length);
807 if (new_length != insn_lengths[uid])
809 insn_lengths[uid] = new_length;
810 something_changed = 1;
814 #endif /* HAVE_ATTR_length */
817 #ifdef HAVE_ATTR_length
818 /* Given the body of an INSN known to be generated by an ASM statement, return
819 the number of machine instructions likely to be generated for this insn.
820 This is used to compute its length. */
823 asm_insn_count (body)
829 for (template = decode_asm_operands (body, NULL_PTR, NULL_PTR,
831 *template; template++)
832 if (*template == ';' || *template == '\n')
839 /* Output assembler code for the start of a function,
840 and initialize some of the variables in this file
841 for the new function. The label for the function and associated
842 assembler pseudo-ops have already been output in `assemble_start_function'.
844 FIRST is the first insn of the rtl for the function being compiled.
845 FILE is the file to write assembler code to.
846 OPTIMIZE is nonzero if we should eliminate redundant
847 test and compare insns. */
850 final_start_function (first, file, optimize)
857 this_is_asm_operands = 0;
859 #ifdef NON_SAVING_SETJMP
860 /* A function that calls setjmp should save and restore all the
861 call-saved registers on a system where longjmp clobbers them. */
862 if (NON_SAVING_SETJMP && current_function_calls_setjmp)
866 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
867 if (!call_used_regs[i] && !call_fixed_regs[i])
868 regs_ever_live[i] = 1;
872 /* Initial line number is supposed to be output
873 before the function's prologue and label
874 so that the function's address will not appear to be
875 in the last statement of the preceding function. */
876 if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
878 if (write_symbols == SDB_DEBUG)
879 /* For sdb, let's not, but say we did.
880 We need to set last_linenum for sdbout_function_begin,
881 but we can't have an actual line number before the .bf symbol.
882 (sdb_begin_function_line is not set,
883 and other compilers don't do it.) */
884 last_linenum = NOTE_LINE_NUMBER (first);
885 #ifdef XCOFF_DEBUGGING_INFO
886 else if (write_symbols == XCOFF_DEBUG)
888 last_linenum = NOTE_LINE_NUMBER (first);
889 xcoffout_output_first_source_line (file, last_linenum);
893 output_source_line (file, first);
896 #ifdef LEAF_REG_REMAP
898 leaf_renumber_regs (first);
901 /* The Sun386i and perhaps other machines don't work right
902 if the profiling code comes after the prologue. */
903 #ifdef PROFILE_BEFORE_PROLOGUE
905 profile_function (file);
906 #endif /* PROFILE_BEFORE_PROLOGUE */
908 #ifdef FUNCTION_PROLOGUE
909 /* First output the function prologue: code to set up the stack frame. */
910 FUNCTION_PROLOGUE (file, get_frame_size ());
913 #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
914 if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
915 next_block_index = 1;
918 /* If the machine represents the prologue as RTL, the profiling code must
919 be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
923 profile_after_prologue (file);
927 /* If we are doing basic block profiling, remember a printable version
928 of the function name. */
929 if (profile_block_flag)
931 char *junk = "function";
933 add_bb_string ((*decl_printable_name) (current_function_decl, &junk), FALSE);
938 profile_after_prologue (file)
941 #ifdef FUNCTION_BLOCK_PROFILER
942 if (profile_block_flag)
944 FUNCTION_BLOCK_PROFILER (file, profile_label_no);
946 #endif /* FUNCTION_BLOCK_PROFILER */
948 #ifndef PROFILE_BEFORE_PROLOGUE
950 profile_function (file);
951 #endif /* not PROFILE_BEFORE_PROLOGUE */
955 profile_function (file)
958 int align = MIN (BIGGEST_ALIGNMENT, INT_TYPE_SIZE);
959 int sval = current_function_returns_struct;
960 int cxt = current_function_needs_context;
963 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
964 ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no);
965 assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
969 #ifdef STRUCT_VALUE_INCOMING_REGNUM
971 ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM);
973 #ifdef STRUCT_VALUE_REGNUM
975 ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM);
980 #ifdef STATIC_CHAIN_INCOMING_REGNUM
982 ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM);
984 #ifdef STATIC_CHAIN_REGNUM
986 ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM);
991 FUNCTION_PROFILER (file, profile_label_no);
994 #ifdef STATIC_CHAIN_INCOMING_REGNUM
996 ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM);
998 #ifdef STATIC_CHAIN_REGNUM
1000 ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM);
1005 #ifdef STRUCT_VALUE_INCOMING_REGNUM
1007 ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM);
1009 #ifdef STRUCT_VALUE_REGNUM
1011 ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM);
1016 /* Output assembler code for the end of a function.
1017 For clarity, args are same as those of `final_start_function'
1018 even though not all of them are needed. */
1021 final_end_function (first, file, optimize)
1028 fprintf (file, ASM_APP_OFF);
1032 #ifdef SDB_DEBUGGING_INFO
1033 if (write_symbols == SDB_DEBUG)
1034 sdbout_end_function (last_linenum);
1037 #ifdef DWARF_DEBUGGING_INFO
1038 if (write_symbols == DWARF_DEBUG)
1039 dwarfout_end_function ();
1042 #ifdef XCOFF_DEBUGGING_INFO
1043 if (write_symbols == XCOFF_DEBUG)
1044 xcoffout_end_function (file, last_linenum);
1047 #ifdef FUNCTION_EPILOGUE
1048 /* Finally, output the function epilogue:
1049 code to restore the stack frame and return to the caller. */
1050 FUNCTION_EPILOGUE (file, get_frame_size ());
1053 #ifdef SDB_DEBUGGING_INFO
1054 if (write_symbols == SDB_DEBUG)
1055 sdbout_end_epilogue ();
1058 #ifdef DWARF_DEBUGGING_INFO
1059 if (write_symbols == DWARF_DEBUG)
1060 dwarfout_end_epilogue ();
1063 #ifdef XCOFF_DEBUGGING_INFO
1064 if (write_symbols == XCOFF_DEBUG)
1065 xcoffout_end_epilogue (file);
1068 bb_func_label_num = -1; /* not in function, nuke label # */
1070 /* If FUNCTION_EPILOGUE is not defined, then the function body
1071 itself contains return instructions wherever needed. */
1074 /* Add a block to the linked list that remembers the current line/file/function
1075 for basic block profiling. Emit the label in front of the basic block and
1076 the instructions that increment the count field. */
1082 struct bb_list *ptr = (struct bb_list *) permalloc (sizeof (struct bb_list));
1084 /* Add basic block to linked list. */
1086 ptr->line_num = last_linenum;
1087 ptr->file_label_num = bb_file_label_num;
1088 ptr->func_label_num = bb_func_label_num;
1090 bb_tail = &ptr->next;
1092 /* Enable the table of basic-block use counts
1093 to point at the code it applies to. */
1094 ASM_OUTPUT_INTERNAL_LABEL (file, "LPB", count_basic_blocks);
1096 /* Before first insn of this basic block, increment the
1097 count of times it was entered. */
1098 #ifdef BLOCK_PROFILER
1099 BLOCK_PROFILER (file, count_basic_blocks);
1104 count_basic_blocks++;
1107 /* Add a string to be used for basic block profiling. */
1110 add_bb_string (string, perm_p)
1115 struct bb_str *ptr = 0;
1119 string = "<unknown>";
1123 /* Allocate a new string if the current string isn't permanent. If
1124 the string is permanent search for the same string in other
1127 len = strlen (string) + 1;
1130 char *p = (char *) permalloc (len);
1131 bcopy (string, p, len);
1135 for (ptr = sbb_head; ptr != (struct bb_str *)0; ptr = ptr->next)
1136 if (ptr->string == string)
1139 /* Allocate a new string block if we need to. */
1142 ptr = (struct bb_str *) permalloc (sizeof (*ptr));
1145 ptr->label_num = sbb_label_num++;
1146 ptr->string = string;
1148 sbb_tail = &ptr->next;
1151 return ptr->label_num;
1155 /* Output assembler code for some insns: all or part of a function.
1156 For description of args, see `final_start_function', above.
1158 PRESCAN is 1 if we are not really outputting,
1159 just scanning as if we were outputting.
1160 Prescanning deletes and rearranges insns just like ordinary output.
1161 PRESCAN is -2 if we are outputting after having prescanned.
1162 In this case, don't try to delete or rearrange insns
1163 because that has already been done.
1164 Prescanning is done only on certain machines. */
1167 final (first, file, optimize, prescan)
1176 last_ignored_compare = 0;
1179 /* Make a map indicating which line numbers appear in this function.
1180 When producing SDB debugging info, delete troublesome line number
1181 notes from inlined functions in other files as well as duplicate
1182 line number notes. */
1183 #ifdef SDB_DEBUGGING_INFO
1184 if (write_symbols == SDB_DEBUG)
1187 for (insn = first; insn; insn = NEXT_INSN (insn))
1188 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1190 if ((RTX_INTEGRATED_P (insn)
1191 && strcmp (NOTE_SOURCE_FILE (insn), main_input_filename) != 0)
1193 && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last)
1194 && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last)))
1196 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1197 NOTE_SOURCE_FILE (insn) = 0;
1201 if (NOTE_LINE_NUMBER (insn) > max_line)
1202 max_line = NOTE_LINE_NUMBER (insn);
1208 for (insn = first; insn; insn = NEXT_INSN (insn))
1209 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > max_line)
1210 max_line = NOTE_LINE_NUMBER (insn);
1213 line_note_exists = (char *) oballoc (max_line + 1);
1214 bzero (line_note_exists, max_line + 1);
1216 for (insn = first; insn; insn = NEXT_INSN (insn))
1217 if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1218 line_note_exists[NOTE_LINE_NUMBER (insn)] = 1;
1224 /* Output the insns. */
1225 for (insn = NEXT_INSN (first); insn;)
1226 insn = final_scan_insn (insn, file, optimize, prescan, 0);
1228 /* Do basic-block profiling here
1229 if the last insn was a conditional branch. */
1230 if (profile_block_flag && new_block)
1234 /* The final scan for one insn, INSN.
1235 Args are same as in `final', except that INSN
1236 is the insn being scanned.
1237 Value returned is the next insn to be scanned.
1239 NOPEEPHOLES is the flag to disallow peephole processing (currently
1240 used for within delayed branch sequence output). */
1243 final_scan_insn (insn, file, optimize, prescan, nopeepholes)
1253 /* Ignore deleted insns. These can occur when we split insns (due to a
1254 template of "#") while not optimizing. */
1255 if (INSN_DELETED_P (insn))
1256 return NEXT_INSN (insn);
1258 switch (GET_CODE (insn))
1264 /* Align the beginning of a loop, for higher speed
1265 on certain machines. */
1267 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG && optimize > 0)
1269 #ifdef ASM_OUTPUT_LOOP_ALIGN
1270 rtx next = next_nonnote_insn (insn);
1271 if (next && GET_CODE (next) == CODE_LABEL)
1273 ASM_OUTPUT_LOOP_ALIGN (asm_out_file);
1278 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
1281 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
1283 #ifdef FUNCTION_END_PROLOGUE
1284 FUNCTION_END_PROLOGUE (file);
1286 profile_after_prologue (file);
1290 #ifdef FUNCTION_BEGIN_EPILOGUE
1291 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
1293 FUNCTION_BEGIN_EPILOGUE (file);
1298 if (write_symbols == NO_DEBUG)
1300 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
1302 #ifdef SDB_DEBUGGING_INFO
1303 if (write_symbols == SDB_DEBUG)
1304 sdbout_begin_function (last_linenum);
1306 #ifdef XCOFF_DEBUGGING_INFO
1307 if (write_symbols == XCOFF_DEBUG)
1308 xcoffout_begin_function (file, last_linenum);
1310 #ifdef DWARF_DEBUGGING_INFO
1311 if (write_symbols == DWARF_DEBUG)
1312 dwarfout_begin_function ();
1316 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
1317 break; /* An insn that was "deleted" */
1320 fprintf (file, ASM_APP_OFF);
1323 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
1324 && (debug_info_level == DINFO_LEVEL_NORMAL
1325 || debug_info_level == DINFO_LEVEL_VERBOSE
1326 #ifdef DWARF_DEBUGGING_INFO
1327 || write_symbols == DWARF_DEBUG
1332 /* Beginning of a symbol-block. Assign it a sequence number
1333 and push the number onto the stack PENDING_BLOCKS. */
1335 if (block_depth == max_block_depth)
1337 /* PENDING_BLOCKS is full; make it longer. */
1338 max_block_depth *= 2;
1340 = (int *) xrealloc (pending_blocks,
1341 max_block_depth * sizeof (int));
1343 pending_blocks[block_depth++] = next_block_index;
1345 /* Output debugging info about the symbol-block beginning. */
1347 #ifdef SDB_DEBUGGING_INFO
1348 if (write_symbols == SDB_DEBUG)
1349 sdbout_begin_block (file, last_linenum, next_block_index);
1351 #ifdef XCOFF_DEBUGGING_INFO
1352 if (write_symbols == XCOFF_DEBUG)
1353 xcoffout_begin_block (file, last_linenum, next_block_index);
1355 #ifdef DBX_DEBUGGING_INFO
1356 if (write_symbols == DBX_DEBUG)
1357 ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index);
1359 #ifdef DWARF_DEBUGGING_INFO
1360 if (write_symbols == DWARF_DEBUG && block_depth > 1)
1361 dwarfout_begin_block (next_block_index);
1366 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
1367 && (debug_info_level == DINFO_LEVEL_NORMAL
1368 || debug_info_level == DINFO_LEVEL_VERBOSE
1369 #ifdef DWARF_DEBUGGING_INFO
1370 || write_symbols == DWARF_DEBUG
1375 /* End of a symbol-block. Pop its sequence number off
1376 PENDING_BLOCKS and output debugging info based on that. */
1380 #ifdef XCOFF_DEBUGGING_INFO
1381 if (write_symbols == XCOFF_DEBUG && block_depth >= 0)
1382 xcoffout_end_block (file, last_linenum, pending_blocks[block_depth]);
1384 #ifdef DBX_DEBUGGING_INFO
1385 if (write_symbols == DBX_DEBUG && block_depth >= 0)
1386 ASM_OUTPUT_INTERNAL_LABEL (file, "LBE",
1387 pending_blocks[block_depth]);
1389 #ifdef SDB_DEBUGGING_INFO
1390 if (write_symbols == SDB_DEBUG && block_depth >= 0)
1391 sdbout_end_block (file, last_linenum);
1393 #ifdef DWARF_DEBUGGING_INFO
1394 if (write_symbols == DWARF_DEBUG && block_depth >= 1)
1395 dwarfout_end_block (pending_blocks[block_depth]);
1398 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL
1399 && (debug_info_level == DINFO_LEVEL_NORMAL
1400 || debug_info_level == DINFO_LEVEL_VERBOSE))
1402 #ifdef DWARF_DEBUGGING_INFO
1403 if (write_symbols == DWARF_DEBUG)
1404 dwarfout_label (insn);
1407 else if (NOTE_LINE_NUMBER (insn) > 0)
1408 /* This note is a line-number. */
1412 #if 0 /* This is what we used to do. */
1413 output_source_line (file, insn);
1417 /* If there is anything real after this note,
1418 output it. If another line note follows, omit this one. */
1419 for (note = NEXT_INSN (insn); note; note = NEXT_INSN (note))
1421 if (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL)
1423 /* These types of notes can be significant
1424 so make sure the preceding line number stays. */
1425 else if (GET_CODE (note) == NOTE
1426 && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG
1427 || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END
1428 || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG))
1430 else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0)
1432 /* Another line note follows; we can delete this note
1433 if no intervening line numbers have notes elsewhere. */
1435 for (num = NOTE_LINE_NUMBER (insn) + 1;
1436 num < NOTE_LINE_NUMBER (note);
1438 if (line_note_exists[num])
1441 if (num >= NOTE_LINE_NUMBER (note))
1447 /* Output this line note
1448 if it is the first or the last line note in a row. */
1450 output_source_line (file, insn);
1455 #ifdef ASM_OUTPUT_ALIGN_CODE
1456 /* Don't litter the assembler output with needless alignments. A
1457 BARRIER will be placed at the end of every function if HAVE_epilogue
1459 if (NEXT_INSN (insn))
1460 ASM_OUTPUT_ALIGN_CODE (file);
1469 #ifdef SDB_DEBUGGING_INFO
1470 if (write_symbols == SDB_DEBUG && LABEL_NAME (insn))
1471 sdbout_label (insn);
1473 #ifdef DWARF_DEBUGGING_INFO
1474 if (write_symbols == DWARF_DEBUG && LABEL_NAME (insn))
1475 dwarfout_label (insn);
1479 fprintf (file, ASM_APP_OFF);
1482 if (NEXT_INSN (insn) != 0
1483 && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN)
1485 rtx nextbody = PATTERN (NEXT_INSN (insn));
1487 /* If this label is followed by a jump-table,
1488 make sure we put the label in the read-only section. Also
1489 possibly write the label and jump table together. */
1491 if (GET_CODE (nextbody) == ADDR_VEC
1492 || GET_CODE (nextbody) == ADDR_DIFF_VEC)
1494 #ifndef JUMP_TABLES_IN_TEXT_SECTION
1495 readonly_data_section ();
1496 #ifdef READONLY_DATA_SECTION
1497 ASM_OUTPUT_ALIGN (file,
1498 exact_log2 (BIGGEST_ALIGNMENT
1500 #endif /* READONLY_DATA_SECTION */
1501 #else /* JUMP_TABLES_IN_TEXT_SECTION */
1503 #endif /* JUMP_TABLES_IN_TEXT_SECTION */
1504 #ifdef ASM_OUTPUT_CASE_LABEL
1505 ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
1508 ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
1514 ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
1519 register rtx body = PATTERN (insn);
1520 int insn_code_number;
1524 /* An INSN, JUMP_INSN or CALL_INSN.
1525 First check for special kinds that recog doesn't recognize. */
1527 if (GET_CODE (body) == USE /* These are just declarations */
1528 || GET_CODE (body) == CLOBBER)
1532 /* If there is a REG_CC_SETTER note on this insn, it means that
1533 the setting of the condition code was done in the delay slot
1534 of the insn that branched here. So recover the cc status
1535 from the insn that set it. */
1537 note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
1540 NOTICE_UPDATE_CC (PATTERN (XEXP (note, 0)), XEXP (note, 0));
1541 cc_prev_status = cc_status;
1545 /* Detect insns that are really jump-tables
1546 and output them as such. */
1548 if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
1550 register int vlen, idx;
1557 fprintf (file, ASM_APP_OFF);
1561 vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
1562 for (idx = 0; idx < vlen; idx++)
1564 if (GET_CODE (body) == ADDR_VEC)
1566 #ifdef ASM_OUTPUT_ADDR_VEC_ELT
1567 ASM_OUTPUT_ADDR_VEC_ELT
1568 (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
1575 #ifdef ASM_OUTPUT_ADDR_DIFF_ELT
1576 ASM_OUTPUT_ADDR_DIFF_ELT
1578 CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
1579 CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
1585 #ifdef ASM_OUTPUT_CASE_END
1586 ASM_OUTPUT_CASE_END (file,
1587 CODE_LABEL_NUMBER (PREV_INSN (insn)),
1596 /* Do basic-block profiling when we reach a new block.
1597 Done here to avoid jump tables. */
1598 if (profile_block_flag && new_block)
1601 if (GET_CODE (body) == ASM_INPUT)
1603 /* There's no telling what that did to the condition codes. */
1609 fprintf (file, ASM_APP_ON);
1612 fprintf (asm_out_file, "\t%s\n", XSTR (body, 0));
1616 /* Detect `asm' construct with operands. */
1617 if (asm_noperands (body) >= 0)
1619 int noperands = asm_noperands (body);
1623 /* There's no telling what that did to the condition codes. */
1628 /* alloca won't do here, since only return from `final'
1631 ops = (rtx *) xmalloc (noperands * sizeof (rtx));
1635 fprintf (file, ASM_APP_ON);
1639 /* Get out the operand values. */
1640 string = decode_asm_operands (body, ops, NULL_PTR,
1641 NULL_PTR, NULL_PTR);
1642 /* Inhibit aborts on what would otherwise be compiler bugs. */
1643 insn_noperands = noperands;
1644 this_is_asm_operands = insn;
1645 /* Output the insn using them. */
1646 output_asm_insn (string, ops);
1647 this_is_asm_operands = 0;
1653 if (prescan <= 0 && app_on)
1655 fprintf (file, ASM_APP_OFF);
1659 if (GET_CODE (body) == SEQUENCE)
1661 /* A delayed-branch sequence */
1667 final_sequence = body;
1669 /* The first insn in this SEQUENCE might be a JUMP_INSN that will
1670 force the restoration of a comparison that was previously
1671 thought unnecessary. If that happens, cancel this sequence
1672 and cause that insn to be restored. */
1674 next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, prescan, 1);
1675 if (next != XVECEXP (body, 0, 1))
1681 for (i = 1; i < XVECLEN (body, 0); i++)
1682 final_scan_insn (XVECEXP (body, 0, i), file, 0, prescan, 1);
1683 #ifdef DBR_OUTPUT_SEQEND
1684 DBR_OUTPUT_SEQEND (file);
1688 /* If the insn requiring the delay slot was a CALL_INSN, the
1689 insns in the delay slot are actually executed before the
1690 called function. Hence we don't preserve any CC-setting
1691 actions in these insns and the CC must be marked as being
1692 clobbered by the function. */
1693 if (GET_CODE (XVECEXP (body, 0, 0)) == CALL_INSN)
1696 /* Following a conditional branch sequence, we have a new basic
1698 if (profile_block_flag)
1700 rtx insn = XVECEXP (body, 0, 0);
1701 rtx body = PATTERN (insn);
1703 if ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
1704 && GET_CODE (SET_SRC (body)) != LABEL_REF)
1705 || (GET_CODE (insn) == JUMP_INSN
1706 && GET_CODE (body) == PARALLEL
1707 && GET_CODE (XVECEXP (body, 0, 0)) == SET
1708 && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF))
1714 /* We have a real machine instruction as rtl. */
1716 body = PATTERN (insn);
1719 /* Check for redundant test and compare instructions
1720 (when the condition codes are already set up as desired).
1721 This is done only when optimizing; if not optimizing,
1722 it should be possible for the user to alter a variable
1723 with the debugger in between statements
1724 and the next statement should reexamine the variable
1725 to compute the condition codes. */
1728 && GET_CODE (body) == SET
1729 && GET_CODE (SET_DEST (body)) == CC0
1730 && insn != last_ignored_compare)
1732 if (GET_CODE (SET_SRC (body)) == SUBREG)
1733 SET_SRC (body) = alter_subreg (SET_SRC (body));
1734 else if (GET_CODE (SET_SRC (body)) == COMPARE)
1736 if (GET_CODE (XEXP (SET_SRC (body), 0)) == SUBREG)
1737 XEXP (SET_SRC (body), 0)
1738 = alter_subreg (XEXP (SET_SRC (body), 0));
1739 if (GET_CODE (XEXP (SET_SRC (body), 1)) == SUBREG)
1740 XEXP (SET_SRC (body), 1)
1741 = alter_subreg (XEXP (SET_SRC (body), 1));
1743 if ((cc_status.value1 != 0
1744 && rtx_equal_p (SET_SRC (body), cc_status.value1))
1745 || (cc_status.value2 != 0
1746 && rtx_equal_p (SET_SRC (body), cc_status.value2)))
1748 /* Don't delete insn if it has an addressing side-effect. */
1749 if (! FIND_REG_INC_NOTE (insn, 0)
1750 /* or if anything in it is volatile. */
1751 && ! volatile_refs_p (PATTERN (insn)))
1753 /* We don't really delete the insn; just ignore it. */
1754 last_ignored_compare = insn;
1761 /* Following a conditional branch, we have a new basic block.
1762 But if we are inside a sequence, the new block starts after the
1763 last insn of the sequence. */
1764 if (profile_block_flag && final_sequence == 0
1765 && ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
1766 && GET_CODE (SET_SRC (body)) != LABEL_REF)
1767 || (GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == PARALLEL
1768 && GET_CODE (XVECEXP (body, 0, 0)) == SET
1769 && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF)))
1773 /* Don't bother outputting obvious no-ops, even without -O.
1774 This optimization is fast and doesn't interfere with debugging.
1775 Don't do this if the insn is in a delay slot, since this
1776 will cause an improper number of delay insns to be written. */
1777 if (final_sequence == 0
1779 && GET_CODE (insn) == INSN && GET_CODE (body) == SET
1780 && GET_CODE (SET_SRC (body)) == REG
1781 && GET_CODE (SET_DEST (body)) == REG
1782 && REGNO (SET_SRC (body)) == REGNO (SET_DEST (body)))
1787 /* If this is a conditional branch, maybe modify it
1788 if the cc's are in a nonstandard state
1789 so that it accomplishes the same thing that it would
1790 do straightforwardly if the cc's were set up normally. */
1792 if (cc_status.flags != 0
1793 && GET_CODE (insn) == JUMP_INSN
1794 && GET_CODE (body) == SET
1795 && SET_DEST (body) == pc_rtx
1796 && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE
1797 /* This is done during prescan; it is not done again
1798 in final scan when prescan has been done. */
1801 /* This function may alter the contents of its argument
1802 and clear some of the cc_status.flags bits.
1803 It may also return 1 meaning condition now always true
1804 or -1 meaning condition now always false
1805 or 2 meaning condition nontrivial but altered. */
1806 register int result = alter_cond (XEXP (SET_SRC (body), 0));
1807 /* If condition now has fixed value, replace the IF_THEN_ELSE
1808 with its then-operand or its else-operand. */
1810 SET_SRC (body) = XEXP (SET_SRC (body), 1);
1812 SET_SRC (body) = XEXP (SET_SRC (body), 2);
1814 /* The jump is now either unconditional or a no-op.
1815 If it has become a no-op, don't try to output it.
1816 (It would not be recognized.) */
1817 if (SET_SRC (body) == pc_rtx)
1819 PUT_CODE (insn, NOTE);
1820 NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1821 NOTE_SOURCE_FILE (insn) = 0;
1824 else if (GET_CODE (SET_SRC (body)) == RETURN)
1825 /* Replace (set (pc) (return)) with (return). */
1826 PATTERN (insn) = body = SET_SRC (body);
1828 /* Rerecognize the instruction if it has changed. */
1830 INSN_CODE (insn) = -1;
1833 /* Make same adjustments to instructions that examine the
1834 condition codes without jumping (if this machine has them). */
1836 if (cc_status.flags != 0
1837 && GET_CODE (body) == SET)
1839 switch (GET_CODE (SET_SRC (body)))
1852 register int result;
1853 if (XEXP (SET_SRC (body), 0) != cc0_rtx)
1855 result = alter_cond (SET_SRC (body));
1857 validate_change (insn, &SET_SRC (body), const_true_rtx, 0);
1858 else if (result == -1)
1859 validate_change (insn, &SET_SRC (body), const0_rtx, 0);
1860 else if (result == 2)
1861 INSN_CODE (insn) = -1;
1867 /* Do machine-specific peephole optimizations if desired. */
1869 if (optimize && !flag_no_peephole && !nopeepholes)
1871 rtx next = peephole (insn);
1872 /* When peepholing, if there were notes within the peephole,
1873 emit them before the peephole. */
1874 if (next != 0 && next != NEXT_INSN (insn))
1876 rtx prev = PREV_INSN (insn);
1879 for (note = NEXT_INSN (insn); note != next;
1880 note = NEXT_INSN (note))
1881 final_scan_insn (note, file, optimize, prescan, nopeepholes);
1883 /* In case this is prescan, put the notes
1884 in proper position for later rescan. */
1885 note = NEXT_INSN (insn);
1886 PREV_INSN (note) = prev;
1887 NEXT_INSN (prev) = note;
1888 NEXT_INSN (PREV_INSN (next)) = insn;
1889 PREV_INSN (insn) = PREV_INSN (next);
1890 NEXT_INSN (insn) = next;
1891 PREV_INSN (next) = insn;
1894 /* PEEPHOLE might have changed this. */
1895 body = PATTERN (insn);
1898 /* Try to recognize the instruction.
1899 If successful, verify that the operands satisfy the
1900 constraints for the instruction. Crash if they don't,
1901 since `reload' should have changed them so that they do. */
1903 insn_code_number = recog_memoized (insn);
1904 insn_extract (insn);
1905 for (i = 0; i < insn_n_operands[insn_code_number]; i++)
1907 if (GET_CODE (recog_operand[i]) == SUBREG)
1908 recog_operand[i] = alter_subreg (recog_operand[i]);
1909 else if (GET_CODE (recog_operand[i]) == PLUS
1910 || GET_CODE (recog_operand[i]) == MULT)
1911 recog_operand[i] = walk_alter_subreg (recog_operand[i]);
1914 for (i = 0; i < insn_n_dups[insn_code_number]; i++)
1916 if (GET_CODE (*recog_dup_loc[i]) == SUBREG)
1917 *recog_dup_loc[i] = alter_subreg (*recog_dup_loc[i]);
1918 else if (GET_CODE (*recog_dup_loc[i]) == PLUS
1919 || GET_CODE (*recog_dup_loc[i]) == MULT)
1920 *recog_dup_loc[i] = walk_alter_subreg (*recog_dup_loc[i]);
1923 #ifdef REGISTER_CONSTRAINTS
1924 if (! constrain_operands (insn_code_number, 1))
1925 fatal_insn_not_found (insn);
1928 /* Some target machines need to prescan each insn before
1931 #ifdef FINAL_PRESCAN_INSN
1932 FINAL_PRESCAN_INSN (insn, recog_operand,
1933 insn_n_operands[insn_code_number]);
1937 cc_prev_status = cc_status;
1939 /* Update `cc_status' for this instruction.
1940 The instruction's output routine may change it further.
1941 If the output routine for a jump insn needs to depend
1942 on the cc status, it should look at cc_prev_status. */
1944 NOTICE_UPDATE_CC (body, insn);
1949 /* If the proper template needs to be chosen by some C code,
1950 run that code and get the real template. */
1952 template = insn_template[insn_code_number];
1955 template = (*insn_outfun[insn_code_number]) (recog_operand, insn);
1957 /* If the C code returns 0, it means that it is a jump insn
1958 which follows a deleted test insn, and that test insn
1959 needs to be reinserted. */
1962 if (prev_nonnote_insn (insn) != last_ignored_compare)
1965 return prev_nonnote_insn (insn);
1969 /* If the template is the string "#", it means that this insn must
1971 if (template[0] == '#' && template[1] == '\0')
1973 rtx new = try_split (body, insn, 0);
1975 /* If we didn't split the insn, go away. */
1976 if (new == insn && PATTERN (new) == body)
1986 /* Output assembler code from the template. */
1988 output_asm_insn (template, recog_operand);
1991 /* It's not at all clear why we did this and doing so interferes
1992 with tests we'd like to do to use REG_WAS_0 notes, so let's try
1995 /* Mark this insn as having been output. */
1996 INSN_DELETED_P (insn) = 1;
2002 return NEXT_INSN (insn);
2005 /* Output debugging info to the assembler file FILE
2006 based on the NOTE-insn INSN, assumed to be a line number. */
2009 output_source_line (file, insn)
2013 char ltext_label_name[100];
2014 register char *filename = NOTE_SOURCE_FILE (insn);
2016 /* Remember filename for basic block profiling.
2017 Filenames are allocated on the permanent obstack
2018 or are passed in ARGV, so we don't have to save
2021 if (profile_block_flag && last_filename != filename)
2022 bb_file_label_num = add_bb_string (filename, TRUE);
2024 last_filename = filename;
2025 last_linenum = NOTE_LINE_NUMBER (insn);
2027 if (write_symbols != NO_DEBUG)
2029 #ifdef SDB_DEBUGGING_INFO
2030 if (write_symbols == SDB_DEBUG
2031 #if 0 /* People like having line numbers even in wrong file! */
2032 /* COFF can't handle multiple source files--lose, lose. */
2033 && !strcmp (filename, main_input_filename)
2035 /* COFF relative line numbers must be positive. */
2036 && last_linenum > sdb_begin_function_line)
2038 #ifdef ASM_OUTPUT_SOURCE_LINE
2039 ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
2041 fprintf (file, "\t.ln\t%d\n",
2042 ((sdb_begin_function_line > -1)
2043 ? last_linenum - sdb_begin_function_line : 1));
2048 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2049 if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2050 dbxout_source_line (file, filename, NOTE_LINE_NUMBER (insn));
2051 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
2053 #ifdef DWARF_DEBUGGING_INFO
2054 if (write_symbols == DWARF_DEBUG)
2055 dwarfout_line (filename, NOTE_LINE_NUMBER (insn));
2060 /* If X is a SUBREG, replace it with a REG or a MEM,
2061 based on the thing it is a subreg of. */
2067 register rtx y = SUBREG_REG (x);
2068 if (GET_CODE (y) == SUBREG)
2069 y = alter_subreg (y);
2071 if (GET_CODE (y) == REG)
2073 /* If the containing reg really gets a hard reg, so do we. */
2075 REGNO (x) = REGNO (y) + SUBREG_WORD (x);
2077 else if (GET_CODE (y) == MEM)
2079 register int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
2080 #if BYTES_BIG_ENDIAN
2081 offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))
2082 - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y))));
2085 MEM_VOLATILE_P (x) = MEM_VOLATILE_P (y);
2086 XEXP (x, 0) = plus_constant (XEXP (y, 0), offset);
2092 /* Do alter_subreg on all the SUBREGs contained in X. */
2095 walk_alter_subreg (x)
2098 switch (GET_CODE (x))
2102 XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
2103 XEXP (x, 1) = walk_alter_subreg (XEXP (x, 1));
2107 XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
2111 return alter_subreg (x);
2119 /* Given BODY, the body of a jump instruction, alter the jump condition
2120 as required by the bits that are set in cc_status.flags.
2121 Not all of the bits there can be handled at this level in all cases.
2123 The value is normally 0.
2124 1 means that the condition has become always true.
2125 -1 means that the condition has become always false.
2126 2 means that COND has been altered. */
2134 if (cc_status.flags & CC_REVERSED)
2137 PUT_CODE (cond, swap_condition (GET_CODE (cond)));
2140 if (cc_status.flags & CC_INVERTED)
2143 PUT_CODE (cond, reverse_condition (GET_CODE (cond)));
2146 if (cc_status.flags & CC_NOT_POSITIVE)
2147 switch (GET_CODE (cond))
2152 /* Jump becomes unconditional. */
2158 /* Jump becomes no-op. */
2162 PUT_CODE (cond, EQ);
2167 PUT_CODE (cond, NE);
2172 if (cc_status.flags & CC_NOT_NEGATIVE)
2173 switch (GET_CODE (cond))
2177 /* Jump becomes unconditional. */
2182 /* Jump becomes no-op. */
2187 PUT_CODE (cond, EQ);
2193 PUT_CODE (cond, NE);
2198 if (cc_status.flags & CC_NO_OVERFLOW)
2199 switch (GET_CODE (cond))
2202 /* Jump becomes unconditional. */
2206 PUT_CODE (cond, EQ);
2211 PUT_CODE (cond, NE);
2216 /* Jump becomes no-op. */
2220 if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N))
2221 switch (GET_CODE (cond))
2234 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
2239 PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE);
2244 if (cc_status.flags & CC_NOT_SIGNED)
2245 /* The flags are valid if signed condition operators are converted
2247 switch (GET_CODE (cond))
2250 PUT_CODE (cond, LEU);
2255 PUT_CODE (cond, LTU);
2260 PUT_CODE (cond, GTU);
2265 PUT_CODE (cond, GEU);
2274 /* Report inconsistency between the assembler template and the operands.
2275 In an `asm', it's the user's fault; otherwise, the compiler's fault. */
2278 output_operand_lossage (str)
2281 if (this_is_asm_operands)
2282 error_for_asm (this_is_asm_operands, "invalid `asm': %s", str);
2287 /* Output of assembler code from a template, and its subroutines. */
2289 /* Output text from TEMPLATE to the assembler output file,
2290 obeying %-directions to substitute operands taken from
2291 the vector OPERANDS.
2293 %N (for N a digit) means print operand N in usual manner.
2294 %lN means require operand N to be a CODE_LABEL or LABEL_REF
2295 and print the label name with no punctuation.
2296 %cN means require operand N to be a constant
2297 and print the constant expression with no punctuation.
2298 %aN means expect operand N to be a memory address
2299 (not a memory reference!) and print a reference
2301 %nN means expect operand N to be a constant
2302 and print a constant expression for minus the value
2303 of the operand, with no other punctuation. */
2306 output_asm_insn (template, operands)
2313 /* An insn may return a null string template
2314 in a case where no assembler code is needed. */
2319 putc ('\t', asm_out_file);
2321 #ifdef ASM_OUTPUT_OPCODE
2322 ASM_OUTPUT_OPCODE (asm_out_file, p);
2328 #ifdef ASM_OUTPUT_OPCODE
2330 putc (c, asm_out_file);
2331 while ((c = *p) == '\t')
2333 putc (c, asm_out_file);
2336 ASM_OUTPUT_OPCODE (asm_out_file, p);
2340 #ifdef ASSEMBLER_DIALECT
2342 /* If we want the first dialect, do nothing. Otherwise, skip
2343 DIALECT_NUMBER of strings ending with '|'. */
2344 for (i = 0; i < dialect_number; i++)
2346 while (*p && *p++ != '|')
2355 /* Skip to close brace. */
2356 while (*p && *p++ != '}')
2365 /* %% outputs a single %. */
2369 putc (c, asm_out_file);
2371 /* %= outputs a number which is unique to each insn in the entire
2372 compilation. This is useful for making local labels that are
2373 referred to more than once in a given insn. */
2377 fprintf (asm_out_file, "%d", insn_counter);
2379 /* % followed by a letter and some digits
2380 outputs an operand in a special way depending on the letter.
2381 Letters `acln' are implemented directly.
2382 Other letters are passed to `output_operand' so that
2383 the PRINT_OPERAND macro can define them. */
2384 else if ((*p >= 'a' && *p <= 'z')
2385 || (*p >= 'A' && *p <= 'Z'))
2390 if (! (*p >= '0' && *p <= '9'))
2391 output_operand_lossage ("operand number missing after %-letter");
2392 else if (this_is_asm_operands && c >= (unsigned) insn_noperands)
2393 output_operand_lossage ("operand number out of range");
2394 else if (letter == 'l')
2395 output_asm_label (operands[c]);
2396 else if (letter == 'a')
2397 output_address (operands[c]);
2398 else if (letter == 'c')
2400 if (CONSTANT_ADDRESS_P (operands[c]))
2401 output_addr_const (asm_out_file, operands[c]);
2403 output_operand (operands[c], 'c');
2405 else if (letter == 'n')
2407 if (GET_CODE (operands[c]) == CONST_INT)
2408 fprintf (asm_out_file,
2409 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2414 - INTVAL (operands[c]));
2417 putc ('-', asm_out_file);
2418 output_addr_const (asm_out_file, operands[c]);
2422 output_operand (operands[c], letter);
2424 while ((c = *p) >= '0' && c <= '9') p++;
2426 /* % followed by a digit outputs an operand the default way. */
2427 else if (*p >= '0' && *p <= '9')
2430 if (this_is_asm_operands && c >= (unsigned) insn_noperands)
2431 output_operand_lossage ("operand number out of range");
2433 output_operand (operands[c], 0);
2434 while ((c = *p) >= '0' && c <= '9') p++;
2436 /* % followed by punctuation: output something for that
2437 punctuation character alone, with no operand.
2438 The PRINT_OPERAND macro decides what is actually done. */
2439 #ifdef PRINT_OPERAND_PUNCT_VALID_P
2440 else if (PRINT_OPERAND_PUNCT_VALID_P (*p))
2441 output_operand (NULL_RTX, *p++);
2444 output_operand_lossage ("invalid %%-code");
2448 putc (c, asm_out_file);
2451 if (flag_print_asm_name)
2453 /* Annotate the assembly with a comment describing the pattern and
2454 alternative used. */
2457 register int num = INSN_CODE (debug_insn);
2458 fprintf (asm_out_file, " %s %d %s",
2459 ASM_COMMENT_START, INSN_UID (debug_insn), insn_name[num]);
2460 if (insn_n_alternatives[num] > 1)
2461 fprintf (asm_out_file, "/%d", which_alternative + 1);
2463 /* Clear this so only the first assembler insn
2464 of any rtl insn will get the special comment for -dp. */
2469 putc ('\n', asm_out_file);
2472 /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */
2475 output_asm_label (x)
2480 if (GET_CODE (x) == LABEL_REF)
2481 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2482 else if (GET_CODE (x) == CODE_LABEL)
2483 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
2485 output_operand_lossage ("`%l' operand isn't a label");
2487 assemble_name (asm_out_file, buf);
2490 /* Print operand X using machine-dependent assembler syntax.
2491 The macro PRINT_OPERAND is defined just to control this function.
2492 CODE is a non-digit that preceded the operand-number in the % spec,
2493 such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
2494 between the % and the digits.
2495 When CODE is a non-letter, X is 0.
2497 The meanings of the letters are machine-dependent and controlled
2498 by PRINT_OPERAND. */
2501 output_operand (x, code)
2505 if (x && GET_CODE (x) == SUBREG)
2506 x = alter_subreg (x);
2508 /* If X is a pseudo-register, abort now rather than writing trash to the
2511 if (x && GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER)
2514 PRINT_OPERAND (asm_out_file, x, code);
2517 /* Print a memory reference operand for address X
2518 using machine-dependent assembler syntax.
2519 The macro PRINT_OPERAND_ADDRESS exists just to control this function. */
2525 walk_alter_subreg (x);
2526 PRINT_OPERAND_ADDRESS (asm_out_file, x);
2529 /* Print an integer constant expression in assembler syntax.
2530 Addition and subtraction are the only arithmetic
2531 that may appear in these expressions. */
2534 output_addr_const (file, x)
2541 switch (GET_CODE (x))
2551 assemble_name (file, XSTR (x, 0));
2555 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2556 assemble_name (file, buf);
2560 ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
2561 assemble_name (file, buf);
2566 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2575 /* This used to output parentheses around the expression,
2576 but that does not work on the 386 (either ATT or BSD assembler). */
2577 output_addr_const (file, XEXP (x, 0));
2581 if (GET_MODE (x) == VOIDmode)
2583 /* We can use %d if the number is one word and positive. */
2584 if (CONST_DOUBLE_HIGH (x))
2586 #if HOST_BITS_PER_WIDE_INT == 64
2587 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
2593 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
2599 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2600 else if (CONST_DOUBLE_LOW (x) < 0)
2602 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2607 CONST_DOUBLE_LOW (x));
2610 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2615 CONST_DOUBLE_LOW (x));
2618 /* We can't handle floating point constants;
2619 PRINT_OPERAND must handle them. */
2620 output_operand_lossage ("floating constant misused");
2624 /* Some assemblers need integer constants to appear last (eg masm). */
2625 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2627 output_addr_const (file, XEXP (x, 1));
2628 if (INTVAL (XEXP (x, 0)) >= 0)
2629 fprintf (file, "+");
2630 output_addr_const (file, XEXP (x, 0));
2634 output_addr_const (file, XEXP (x, 0));
2635 if (INTVAL (XEXP (x, 1)) >= 0)
2636 fprintf (file, "+");
2637 output_addr_const (file, XEXP (x, 1));
2642 /* Avoid outputting things like x-x or x+5-x,
2643 since some assemblers can't handle that. */
2644 x = simplify_subtraction (x);
2645 if (GET_CODE (x) != MINUS)
2648 output_addr_const (file, XEXP (x, 0));
2649 fprintf (file, "-");
2650 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2651 && INTVAL (XEXP (x, 1)) < 0)
2653 fprintf (file, ASM_OPEN_PAREN);
2654 output_addr_const (file, XEXP (x, 1));
2655 fprintf (file, ASM_CLOSE_PAREN);
2658 output_addr_const (file, XEXP (x, 1));
2663 output_addr_const (file, XEXP (x, 0));
2667 output_operand_lossage ("invalid expression as operand");
2671 /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
2672 %R prints the value of REGISTER_PREFIX.
2673 %L prints the value of LOCAL_LABEL_PREFIX.
2674 %U prints the value of USER_LABEL_PREFIX.
2675 %I prints the value of IMMEDIATE_PREFIX.
2676 %O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
2677 Also supported are %d, %x, %s, %e, %f, %g and %%.
2679 We handle alternate assembler dialects here, just like output_asm_insn. */
2682 asm_fprintf (va_alist)
2693 file = va_arg (argptr, FILE *);
2694 p = va_arg (argptr, char *);
2700 #ifdef ASSEMBLER_DIALECT
2702 /* If we want the first dialect, do nothing. Otherwise, skip
2703 DIALECT_NUMBER of strings ending with '|'. */
2704 for (i = 0; i < dialect_number; i++)
2706 while (*p && *p++ != '|')
2715 /* Skip to close brace. */
2716 while (*p && *p++ != '}')
2727 while ((c >= '0' && c <= '9') || c == '.')
2735 fprintf (file, "%%");
2738 case 'd': case 'i': case 'u':
2739 case 'x': case 'p': case 'X':
2743 fprintf (file, buf, va_arg (argptr, int));
2747 /* This is a prefix to the 'd', 'i', 'u', 'x', 'p', and 'X' cases,
2748 but we do not check for those cases. It means that the value
2749 is a HOST_WIDE_INT, which may be either `int' or `long'. */
2751 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
2757 fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT));
2764 fprintf (file, buf, va_arg (argptr, long));
2772 fprintf (file, buf, va_arg (argptr, double));
2778 fprintf (file, buf, va_arg (argptr, char *));
2782 #ifdef ASM_OUTPUT_OPCODE
2783 ASM_OUTPUT_OPCODE (asm_out_file, p);
2788 #ifdef REGISTER_PREFIX
2789 fprintf (file, "%s", REGISTER_PREFIX);
2794 #ifdef IMMEDIATE_PREFIX
2795 fprintf (file, "%s", IMMEDIATE_PREFIX);
2800 #ifdef LOCAL_LABEL_PREFIX
2801 fprintf (file, "%s", LOCAL_LABEL_PREFIX);
2806 #ifdef USER_LABEL_PREFIX
2807 fprintf (file, "%s", USER_LABEL_PREFIX);
2821 /* Split up a CONST_DOUBLE or integer constant rtx
2822 into two rtx's for single words,
2823 storing in *FIRST the word that comes first in memory in the target
2824 and in *SECOND the other. */
2827 split_double (value, first, second)
2829 rtx *first, *second;
2831 if (GET_CODE (value) == CONST_INT)
2833 /* The rule for using CONST_INT for a wider mode
2834 is that we regard the value as signed.
2835 So sign-extend it. */
2836 rtx high = (INTVAL (value) < 0 ? constm1_rtx : const0_rtx);
2837 #if WORDS_BIG_ENDIAN
2845 else if (GET_CODE (value) != CONST_DOUBLE)
2847 #if WORDS_BIG_ENDIAN
2848 *first = const0_rtx;
2852 *second = const0_rtx;
2855 else if (GET_MODE (value) == VOIDmode
2856 /* This is the old way we did CONST_DOUBLE integers. */
2857 || GET_MODE_CLASS (GET_MODE (value)) == MODE_INT)
2859 /* In an integer, the words are defined as most and least significant.
2860 So order them by the target's convention. */
2861 #if WORDS_BIG_ENDIAN
2862 *first = GEN_INT (CONST_DOUBLE_HIGH (value));
2863 *second = GEN_INT (CONST_DOUBLE_LOW (value));
2865 *first = GEN_INT (CONST_DOUBLE_LOW (value));
2866 *second = GEN_INT (CONST_DOUBLE_HIGH (value));
2871 #ifdef REAL_ARITHMETIC
2872 REAL_VALUE_TYPE r; HOST_WIDE_INT l[2];
2873 REAL_VALUE_FROM_CONST_DOUBLE (r, value);
2874 REAL_VALUE_TO_TARGET_DOUBLE (r, l);
2875 *first = GEN_INT (l[0]);
2876 *second = GEN_INT (l[1]);
2878 if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
2879 || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
2880 && ! flag_pretend_float)
2883 #if defined (HOST_WORDS_BIG_ENDIAN) == WORDS_BIG_ENDIAN
2884 /* Host and target agree => no need to swap. */
2885 *first = GEN_INT (CONST_DOUBLE_LOW (value));
2886 *second = GEN_INT (CONST_DOUBLE_HIGH (value));
2888 *second = GEN_INT (CONST_DOUBLE_LOW (value));
2889 *first = GEN_INT (CONST_DOUBLE_HIGH (value));
2891 #endif /* no REAL_ARITHMETIC */
2895 /* Return nonzero if this function has no function calls. */
2902 if (profile_flag || profile_block_flag)
2905 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2907 if (GET_CODE (insn) == CALL_INSN)
2909 if (GET_CODE (insn) == INSN
2910 && GET_CODE (PATTERN (insn)) == SEQUENCE
2911 && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN)
2914 for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
2916 if (GET_CODE (XEXP (insn, 0)) == CALL_INSN)
2918 if (GET_CODE (XEXP (insn, 0)) == INSN
2919 && GET_CODE (PATTERN (XEXP (insn, 0))) == SEQUENCE
2920 && GET_CODE (XVECEXP (PATTERN (XEXP (insn, 0)), 0, 0)) == CALL_INSN)
2927 /* On some machines, a function with no call insns
2928 can run faster if it doesn't create its own register window.
2929 When output, the leaf function should use only the "output"
2930 registers. Ordinarily, the function would be compiled to use
2931 the "input" registers to find its arguments; it is a candidate
2932 for leaf treatment if it uses only the "input" registers.
2933 Leaf function treatment means renumbering so the function
2934 uses the "output" registers instead. */
2936 #ifdef LEAF_REGISTERS
2938 static char permitted_reg_in_leaf_functions[] = LEAF_REGISTERS;
2940 /* Return 1 if this function uses only the registers that can be
2941 safely renumbered. */
2944 only_leaf_regs_used ()
2948 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2950 if ((regs_ever_live[i] || global_regs[i])
2951 && ! permitted_reg_in_leaf_functions[i])
2957 /* Scan all instructions and renumber all registers into those
2958 available in leaf functions. */
2961 leaf_renumber_regs (first)
2966 /* Renumber only the actual patterns.
2967 The reg-notes can contain frame pointer refs,
2968 and renumbering them could crash, and should not be needed. */
2969 for (insn = first; insn; insn = NEXT_INSN (insn))
2970 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
2971 leaf_renumber_regs_insn (PATTERN (insn));
2972 for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
2973 if (GET_RTX_CLASS (GET_CODE (XEXP (insn, 0))) == 'i')
2974 leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0)));
2977 /* Scan IN_RTX and its subexpressions, and renumber all regs into those
2978 available in leaf functions. */
2981 leaf_renumber_regs_insn (in_rtx)
2982 register rtx in_rtx;
2985 register char *format_ptr;
2990 /* Renumber all input-registers into output-registers.
2991 renumbered_regs would be 1 for an output-register;
2994 if (GET_CODE (in_rtx) == REG)
2998 /* Don't renumber the same reg twice. */
3002 newreg = REGNO (in_rtx);
3003 /* Don't try to renumber pseudo regs. It is possible for a pseudo reg
3004 to reach here as part of a REG_NOTE. */
3005 if (newreg >= FIRST_PSEUDO_REGISTER)
3010 newreg = LEAF_REG_REMAP (newreg);
3013 regs_ever_live[REGNO (in_rtx)] = 0;
3014 regs_ever_live[newreg] = 1;
3015 REGNO (in_rtx) = newreg;
3019 if (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i')
3021 /* Inside a SEQUENCE, we find insns.
3022 Renumber just the patterns of these insns,
3023 just as we do for the top-level insns. */
3024 leaf_renumber_regs_insn (PATTERN (in_rtx));
3028 format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
3030 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
3031 switch (*format_ptr++)
3034 leaf_renumber_regs_insn (XEXP (in_rtx, i));
3038 if (NULL != XVEC (in_rtx, i))
3040 for (j = 0; j < XVECLEN (in_rtx, i); j++)
3041 leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));