![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to final.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to final.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Convert RTL to assembler code and output it, for GNU compiler.
2: Copyright (C) 1987, 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
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)
9: any later version.
10:
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.
15:
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. */
19:
20:
21: /* This is the final pass of the compiler.
22: It looks at the rtl code for a function and outputs assembler code.
23:
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'.
29:
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.)
34:
35: Instructions to set the condition codes are omitted when it can be
36: seen that the condition codes already had the desired values.
37:
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.
41:
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. */
45:
46: #include "config.h"
47: #include "gvarargs.h"
48: #include "tree.h"
49: #include "rtl.h"
50: #include "regs.h"
51: #include "insn-config.h"
52: #include "insn-flags.h"
53: #include "insn-attr.h"
54: #include "insn-codes.h"
55: #include "recog.h"
56: #include "conditions.h"
57: #include "flags.h"
58: #include "real.h"
59: #include "hard-reg-set.h"
60: #include "defaults.h"
61:
62: #include <stdio.h>
63: #include <ctype.h>
64:
65: #include "output.h"
66:
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. */
71: #else
72: #include <stab.h> /* On BSD, use the system's stab.h. */
73: #endif /* not USG */
74: #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
75:
76: #ifdef XCOFF_DEBUGGING_INFO
77: #include "xcoffout.h"
78: #endif
79:
80: /* .stabd code for line number. */
81: #ifndef N_SLINE
82: #define N_SLINE 0x44
83: #endif
84:
85: /* .stabs code for included file name. */
86: #ifndef N_SOL
87: #define N_SOL 0x84
88: #endif
89:
90: #ifndef INT_TYPE_SIZE
91: #define INT_TYPE_SIZE BITS_PER_WORD
92: #endif
93:
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
98: #endif
99:
100: /* How to start an assembler comment. */
101: #ifndef ASM_COMMENT_START
102: #define ASM_COMMENT_START ";#"
103: #endif
104:
105: rtx peephole ();
106: void output_asm_insn ();
107: rtx alter_subreg ();
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 ();
118:
119: #ifdef HAVE_ATTR_length
120: static int asm_insn_count ();
121: #endif
122:
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. */
126: int leaf_function;
127:
128: int leaf_function_p ();
129:
130: #ifdef LEAF_REGISTERS
131: int only_leaf_regs_used ();
132: static void leaf_renumber_regs ();
133: void leaf_renumber_regs_insn ();
134: #endif
135:
136: #ifdef OUTPUT_COMPILER_STUB
137: extern void output_compiler_stub();
138: #endif
139:
140: /* Last insn processed by final_scan_insn. */
141: static rtx debug_insn = 0;
142:
143: /* Line number of last NOTE. */
144: static int last_linenum;
145:
146: /* Filename of last NOTE. */
147: static char *last_filename;
148:
149: /* Number of basic blocks seen so far;
150: used if profile_block_flag is set. */
151: static int count_basic_blocks;
152:
153: /* Nonzero while outputting an `asm' with operands.
154: This means that inconsistencies are the user's fault, so don't abort.
155: The precise value is the insn being output, to pass to error_for_asm. */
156: static rtx this_is_asm_operands;
157:
158: /* Number of operands of this insn, for an `asm' with operands. */
159: static int insn_noperands;
160:
161: /* Compare optimization flag. */
162:
163: static rtx last_ignored_compare = 0;
164:
165: /* Flag indicating this insn is the start of a new basic block. */
166:
167: static int new_block = 1;
168:
169: /* All the symbol-blocks (levels of scoping) in the compilation
170: are assigned sequence numbers in order of appearance of the
171: beginnings of the symbol-blocks. Both final and dbxout do this,
172: and assume that they will both give the same number to each block.
173: Final uses these sequence numbers to generate assembler label names
174: LBBnnn and LBEnnn for the beginning and end of the symbol-block.
175: Dbxout uses the sequence numbers to generate references to the same labels
176: from the dbx debugging information.
177:
178: Sdb records this level at the beginning of each function,
179: in order to find the current level when recursing down declarations.
180: It outputs the block beginning and endings
181: at the point in the asm file where the blocks would begin and end. */
182:
183: int next_block_index;
184:
185: /* Assign a unique number to each insn that is output.
186: This can be used to generate unique local labels. */
187:
188: static int insn_counter = 0;
189:
190: #ifdef HAVE_cc0
191: /* This variable contains machine-dependent flags (defined in tm.h)
192: set and examined by output routines
193: that describe how to interpret the condition codes properly. */
194:
195: CC_STATUS cc_status;
196:
197: /* During output of an insn, this contains a copy of cc_status
198: from before the insn. */
199:
200: CC_STATUS cc_prev_status;
201: #endif
202:
203: /* Indexed by hardware reg number, is 1 if that register is ever
204: used in the current function.
205:
206: In life_analysis, or in stupid_life_analysis, this is set
207: up to record the hard regs used explicitly. Reload adds
208: in the hard regs used for holding pseudo regs. Final uses
209: it to generate the code in the function prologue and epilogue
210: to save and restore registers as needed. */
211:
212: char regs_ever_live[FIRST_PSEUDO_REGISTER];
213:
214: /* Nonzero means current function must be given a frame pointer.
215: Set in stmt.c if anything is allocated on the stack there.
216: Set in reload1.c if anything is allocated on the stack there. */
217:
218: int frame_pointer_needed;
219:
220: /* Assign unique numbers to labels generated for profiling. */
221:
222: int profile_label_no;
223:
224: /* Length so far allocated in PENDING_BLOCKS. */
225:
226: static int max_block_depth;
227:
228: /* Stack of sequence numbers of symbol-blocks of which we have seen the
229: beginning but not yet the end. Sequence numbers are assigned at
230: the beginning; this stack allows us to find the sequence number
231: of a block that is ending. */
232:
233: static int *pending_blocks;
234:
235: /* Number of elements currently in use in PENDING_BLOCKS. */
236:
237: static int block_depth;
238:
239: /* Nonzero if have enabled APP processing of our assembler output. */
240:
241: static int app_on;
242:
243: /* If we are outputting an insn sequence, this contains the sequence rtx.
244: Zero otherwise. */
245:
246: rtx final_sequence;
247:
248: #ifdef ASSEMBLER_DIALECT
249:
250: /* Number of the assembler dialect to use, starting at 0. */
251: static int dialect_number;
252: #endif
253:
254: /* Indexed by line number, nonzero if there is a note for that line. */
255:
256: static char *line_note_exists;
257:
258: /* Linked list to hold line numbers for each basic block. */
259:
260: struct bb_list {
261: struct bb_list *next; /* pointer to next basic block */
262: int line_num; /* line number */
263: int file_label_num; /* LPBC<n> label # for stored filename */
264: int func_label_num; /* LPBC<n> label # for stored function name */
265: };
266:
267: static struct bb_list *bb_head = 0; /* Head of basic block list */
268: static struct bb_list **bb_tail = &bb_head; /* Ptr to store next bb ptr */
269: static int bb_file_label_num = -1; /* Current label # for file */
270: static int bb_func_label_num = -1; /* Current label # for func */
271:
272: /* Linked list to hold the strings for each file and function name output. */
273:
274: struct bb_str {
275: struct bb_str *next; /* pointer to next string */
276: char *string; /* string */
277: int label_num; /* label number */
278: int length; /* string length */
279: };
280:
281: static struct bb_str *sbb_head = 0; /* Head of string list. */
282: static struct bb_str **sbb_tail = &sbb_head; /* Ptr to store next bb str */
283: static int sbb_label_num = 0; /* Last label used */
284:
285: static int add_bb_string PROTO((char *, int));
286: static void add_bb PROTO((FILE *));
287:
288:
289: /* Initialize data in final at the beginning of a compilation. */
290:
291: void
292: init_final (filename)
293: char *filename;
294: {
295: next_block_index = 2;
296: app_on = 0;
297: max_block_depth = 20;
298: pending_blocks = (int *) xmalloc (20 * sizeof *pending_blocks);
299: final_sequence = 0;
300:
301: #ifdef ASSEMBLER_DIALECT
302: dialect_number = ASSEMBLER_DIALECT;
303: #endif
304: }
305:
306: /* Called at end of source file,
307: to output the block-profiling table for this entire compilation. */
308:
309: void
310: end_final (filename)
311: char *filename;
312: {
313: int i;
314:
315: if (profile_block_flag)
316: {
317: char name[20];
318: int align = exact_log2 (BIGGEST_ALIGNMENT / BITS_PER_UNIT);
319: int size = (INT_TYPE_SIZE / BITS_PER_UNIT) * count_basic_blocks;
320: int rounded = size;
321: struct bb_list *ptr;
322: struct bb_str *sptr;
323:
324: rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
325: rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
326: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
327:
328: data_section ();
329:
330: /* Output the main header, of 10 words:
331: 0: 1 if this file's initialized, else 0.
332: 1: address of file name (LPBX1).
333: 2: address of table of counts (LPBX2).
334: 3: number of counts in the table.
335: 4: always 0, for compatibility with Sun.
336:
337: The following are GNU extensions:
338:
339: 5: address of table of start addrs of basic blocks (LPBX3).
340: 6: Number of bytes in this header.
341: 7: address of table of function names (LPBX4).
342: 8: address of table of line numbers (LPBX5) or 0.
343: 9: address of table of file names (LPBX6) or 0. */
344:
345: ASM_OUTPUT_ALIGN (asm_out_file, align);
346:
347: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 0);
348: /* zero word */
349: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
350:
351: /* address of filename */
352: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 1);
353: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
354:
355: /* address of count table */
356: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
357: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
358:
359: /* count of the # of basic blocks */
360: assemble_integer (GEN_INT (count_basic_blocks), UNITS_PER_WORD, 1);
361:
362: /* zero word (link field) */
363: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
364:
365: /* address of basic block start address table */
366: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
367: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
368:
369: /* byte count for extended structure. */
370: assemble_integer (GEN_INT (10 * UNITS_PER_WORD), UNITS_PER_WORD, 1);
371:
372: /* address of function name table */
373: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 4);
374: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
375:
376: /* address of line number and filename tables if debugging. */
377: if (write_symbols != NO_DEBUG)
378: {
379: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5);
380: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
381: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 6);
382: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
383: }
384: else
385: {
386: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
387: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
388: }
389:
390: /* Output the file name changing the suffix to .d for Sun tcov
391: compatibility. */
392: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 1);
393: {
394: int len = strlen (filename);
395: char *data_file = (char *) alloca (len + 3);
396: strcpy (data_file, filename);
397: strip_off_ending (data_file, len);
398: strcat (data_file, ".d");
399: assemble_string (data_file, strlen (data_file) + 1);
400: }
401:
402: /* Make space for the table of counts. */
403: if (flag_no_common || size == 0)
404: {
405: /* Realign data section. */
406: ASM_OUTPUT_ALIGN (asm_out_file, align);
407: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 2);
408: if (size != 0)
409: assemble_zeros (size);
410: }
411: else
412: {
413: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 2);
414: #ifdef ASM_OUTPUT_SHARED_LOCAL
415: if (flag_shared_data)
416: ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
417: else
418: #endif
419: #ifdef ASM_OUTPUT_ALIGNED_LOCAL
420: ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, align);
421: #else
422: ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
423: #endif
424: }
425:
426: /* Output any basic block strings */
427: readonly_data_section ();
428: if (sbb_head)
429: {
430: ASM_OUTPUT_ALIGN (asm_out_file, align);
431: for (sptr = sbb_head; sptr != 0; sptr = sptr->next)
432: {
433: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBC", sptr->label_num);
434: assemble_string (sptr->string, sptr->length);
435: }
436: }
437:
438: /* Output the table of addresses. */
439: /* Realign in new section */
440: ASM_OUTPUT_ALIGN (asm_out_file, align);
441: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 3);
442: for (i = 0; i < count_basic_blocks; i++)
443: {
444: ASM_GENERATE_INTERNAL_LABEL (name, "LPB", i);
445: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name),
446: UNITS_PER_WORD, 1);
447: }
448:
449: /* Output the table of function names. */
450: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 4);
451: for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
452: {
453: if (ptr->func_label_num >= 0)
454: {
455: ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->func_label_num);
456: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name),
457: UNITS_PER_WORD, 1);
458: }
459: else
460: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
461: }
462:
463: for ( ; i < count_basic_blocks; i++)
464: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
465:
466: if (write_symbols != NO_DEBUG)
467: {
468: /* Output the table of line numbers. */
469: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 5);
470: for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
471: assemble_integer (GEN_INT (ptr->line_num), UNITS_PER_WORD, 1);
472:
473: for ( ; i < count_basic_blocks; i++)
474: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
475:
476: /* Output the table of file names. */
477: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LPBX", 6);
478: for ((ptr = bb_head), (i = 0); ptr != 0; (ptr = ptr->next), i++)
479: {
480: if (ptr->file_label_num >= 0)
481: {
482: ASM_GENERATE_INTERNAL_LABEL (name, "LPBC", ptr->file_label_num);
483: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name),
484: UNITS_PER_WORD, 1);
485: }
486: else
487: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
488: }
489:
490: for ( ; i < count_basic_blocks; i++)
491: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
492: }
493:
494: /* End with the address of the table of addresses,
495: so we can find it easily, as the last word in the file's text. */
496: ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 3);
497: assemble_integer (gen_rtx (SYMBOL_REF, Pmode, name), UNITS_PER_WORD, 1);
498: }
499: }
500:
501: /* Enable APP processing of subsequent output.
502: Used before the output from an `asm' statement. */
503:
504: void
505: app_enable ()
506: {
507: if (! app_on)
508: {
509: fprintf (asm_out_file, ASM_APP_ON);
510: app_on = 1;
511: }
512: }
513:
514: /* Enable APP processing of subsequent output.
515: Called from varasm.c before most kinds of output. */
516:
517: void
518: app_disable ()
519: {
520: if (app_on)
521: {
522: fprintf (asm_out_file, ASM_APP_OFF);
523: app_on = 0;
524: }
525: }
526:
527: /* Return the number of slots filled in the current
528: delayed branch sequence (we don't count the insn needing the
529: delay slot). Zero if not in a delayed branch sequence. */
530:
531: #ifdef DELAY_SLOTS
532: int
533: dbr_sequence_length ()
534: {
535: if (final_sequence != 0)
536: return XVECLEN (final_sequence, 0) - 1;
537: else
538: return 0;
539: }
540: #endif
541:
542: /* The next two pages contain routines used to compute the length of an insn
543: and to shorten branches. */
544:
545: /* Arrays for insn lengths, and addresses. The latter is referenced by
546: `insn_current_length'. */
547:
548: static short *insn_lengths;
549: int *insn_addresses;
550:
551: /* Address of insn being processed. Used by `insn_current_length'. */
552: int insn_current_address;
553:
554: /* Indicate the branch shortening hasn't yet been done. */
555:
556: void
557: init_insn_lengths ()
558: {
559: insn_lengths = 0;
560: }
561:
562: /* Obtain the current length of an insn. If branch shortening has been done,
563: get its actual length. Otherwise, get its maximum length. */
564:
565: int
566: get_attr_length (insn)
567: rtx insn;
568: {
569: #ifdef HAVE_ATTR_length
570: rtx body;
571: int i;
572: int length = 0;
573:
574: if (insn_lengths)
575: return insn_lengths[INSN_UID (insn)];
576: else
577: switch (GET_CODE (insn))
578: {
579: case NOTE:
580: case BARRIER:
581: case CODE_LABEL:
582: return 0;
583:
584: case CALL_INSN:
585: length = insn_default_length (insn);
586: break;
587:
588: case JUMP_INSN:
589: body = PATTERN (insn);
590: if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
591: {
592: /* This only takes room if jump tables go into the text section. */
593: #if !defined(READONLY_DATA_SECTION) || defined(JUMP_TABLES_IN_TEXT_SECTION)
594: length = (XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC)
595: * GET_MODE_SIZE (GET_MODE (body)));
596:
597: /* Be pessimistic and assume worst-case alignment. */
598: length += (GET_MODE_SIZE (GET_MODE (body)) - 1);
599: #else
600: return 0;
601: #endif
602: }
603: else
604: length = insn_default_length (insn);
605: break;
606:
607: case INSN:
608: body = PATTERN (insn);
609: if (GET_CODE (body) == USE || GET_CODE (body) == CLOBBER)
610: return 0;
611:
612: else if (GET_CODE (body) == ASM_INPUT || asm_noperands (body) >= 0)
613: length = asm_insn_count (body) * insn_default_length (insn);
614: else if (GET_CODE (body) == SEQUENCE)
615: for (i = 0; i < XVECLEN (body, 0); i++)
616: length += get_attr_length (XVECEXP (body, 0, i));
617: else
618: length = insn_default_length (insn);
619: }
620:
621: #ifdef ADJUST_INSN_LENGTH
622: ADJUST_INSN_LENGTH (insn, length);
623: #endif
624: return length;
625: #else /* not HAVE_ATTR_length */
626: return 0;
627: #endif /* not HAVE_ATTR_length */
628: }
629:
630: /* Make a pass over all insns and compute their actual lengths by shortening
631: any branches of variable length if possible. */
632:
633: /* Give a default value for the lowest address in a function. */
634:
635: #ifndef FIRST_INSN_ADDRESS
636: #define FIRST_INSN_ADDRESS 0
637: #endif
638:
639: void
640: shorten_branches (first)
641: rtx first;
642: {
643: #ifdef HAVE_ATTR_length
644: rtx insn;
645: int something_changed = 1;
646: int max_uid = 0;
647: char *varying_length;
648: rtx body;
649: int uid;
650:
651: /* Compute maximum UID and allocate arrays. */
652: for (insn = first; insn; insn = NEXT_INSN (insn))
653: if (INSN_UID (insn) > max_uid)
654: max_uid = INSN_UID (insn);
655:
656: max_uid++;
657: insn_lengths = (short *) oballoc (max_uid * sizeof (short));
658: insn_addresses = (int *) oballoc (max_uid * sizeof (int));
659: varying_length = (char *) oballoc (max_uid * sizeof (char));
660:
661: /* Compute initial lengths, addresses, and varying flags for each insn. */
662: for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
663: insn != 0;
664: insn_current_address += insn_lengths[uid], insn = NEXT_INSN (insn))
665: {
666: uid = INSN_UID (insn);
667: insn_addresses[uid] = insn_current_address;
668: insn_lengths[uid] = 0;
669: varying_length[uid] = 0;
670:
671: if (GET_CODE (insn) == NOTE || GET_CODE (insn) == BARRIER
672: || GET_CODE (insn) == CODE_LABEL)
673: continue;
674:
675: body = PATTERN (insn);
676: if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
677: {
678: /* This only takes room if read-only data goes into the text
679: section. */
680: #if !defined(READONLY_DATA_SECTION) || defined(JUMP_TABLES_IN_TEXT_SECTION)
681: int unitsize = GET_MODE_SIZE (GET_MODE (body));
682:
683: insn_lengths[uid] = (XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC)
684: * GET_MODE_SIZE (GET_MODE (body)));
685:
686: /* Account for possible alignment. */
687: insn_lengths[uid]
688: += unitsize - (insn_current_address & (unitsize - 1));
689: #else
690: ;
691: #endif
692: }
693: else if (asm_noperands (body) >= 0)
694: insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn);
695: else if (GET_CODE (body) == SEQUENCE)
696: {
697: int i;
698: int const_delay_slots;
699: #ifdef DELAY_SLOTS
700: const_delay_slots = const_num_delay_slots (XVECEXP (body, 0, 0));
701: #else
702: const_delay_slots = 0;
703: #endif
704: /* Inside a delay slot sequence, we do not do any branch shortening
705: if the shortening could change the number of delay slots
706: of the branch. */
707: for (i = 0; i < XVECLEN (body, 0); i++)
708: {
709: rtx inner_insn = XVECEXP (body, 0, i);
710: int inner_uid = INSN_UID (inner_insn);
711: int inner_length;
712:
713: if (asm_noperands (PATTERN (XVECEXP (body, 0, i))) >= 0)
714: inner_length = (asm_insn_count (PATTERN (inner_insn))
715: * insn_default_length (inner_insn));
716: else
717: inner_length = insn_default_length (inner_insn);
718:
719: insn_lengths[inner_uid] = inner_length;
720: if (const_delay_slots)
721: {
722: if ((varying_length[inner_uid]
723: = insn_variable_length_p (inner_insn)) != 0)
724: varying_length[uid] = 1;
725: insn_addresses[inner_uid] = (insn_current_address +
726: insn_lengths[uid]);
727: }
728: else
729: varying_length[inner_uid] = 0;
730: insn_lengths[uid] += inner_length;
731: }
732: }
733: else if (GET_CODE (body) != USE && GET_CODE (body) != CLOBBER)
734: {
735: insn_lengths[uid] = insn_default_length (insn);
736: varying_length[uid] = insn_variable_length_p (insn);
737: }
738:
739: /* If needed, do any adjustment. */
740: #ifdef ADJUST_INSN_LENGTH
741: ADJUST_INSN_LENGTH (insn, insn_lengths[uid]);
742: #endif
743: }
744:
745: /* Now loop over all the insns finding varying length insns. For each,
746: get the current insn length. If it has changed, reflect the change.
747: When nothing changes for a full pass, we are done. */
748:
749: while (something_changed)
750: {
751: something_changed = 0;
752: for (insn_current_address = FIRST_INSN_ADDRESS, insn = first;
753: insn != 0;
754: insn = NEXT_INSN (insn))
755: {
756: int new_length;
757: int tmp_length;
758:
759: uid = INSN_UID (insn);
760: insn_addresses[uid] = insn_current_address;
761: if (! varying_length[uid])
762: {
763: insn_current_address += insn_lengths[uid];
764: continue;
765: }
766: if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
767: {
768: int i;
769:
770: body = PATTERN (insn);
771: new_length = 0;
772: for (i = 0; i < XVECLEN (body, 0); i++)
773: {
774: rtx inner_insn = XVECEXP (body, 0, i);
775: int inner_uid = INSN_UID (inner_insn);
776: int inner_length;
777:
778: insn_addresses[inner_uid] = insn_current_address;
779:
780: /* insn_current_length returns 0 for insns with a
781: non-varying length. */
782: if (! varying_length[inner_uid])
783: inner_length = insn_lengths[inner_uid];
784: else
785: inner_length = insn_current_length (inner_insn);
786:
787: if (inner_length != insn_lengths[inner_uid])
788: {
789: insn_lengths[inner_uid] = inner_length;
790: something_changed = 1;
791: }
792: insn_current_address += insn_lengths[inner_uid];
793: new_length += inner_length;
794: }
795: }
796: else
797: {
798: new_length = insn_current_length (insn);
799: insn_current_address += new_length;
800: }
801:
802: #ifdef SHORTEN_WITH_ADJUST_INSN_LENGTH
803: #ifdef ADJUST_INSN_LENGTH
804: /* If needed, do any adjustment. */
805: tmp_length = new_length;
806: ADJUST_INSN_LENGTH (insn, new_length);
807: insn_current_address += (new_length - tmp_length);
808: #endif
809: #endif
810:
811: if (new_length != insn_lengths[uid])
812: {
813: insn_lengths[uid] = new_length;
814: something_changed = 1;
815: }
816: }
817: }
818: #endif /* HAVE_ATTR_length */
819: }
820:
821: #ifdef HAVE_ATTR_length
822: /* Given the body of an INSN known to be generated by an ASM statement, return
823: the number of machine instructions likely to be generated for this insn.
824: This is used to compute its length. */
825:
826: static int
827: asm_insn_count (body)
828: rtx body;
829: {
830: char *template;
831: int count = 1;
832:
833: for (template = decode_asm_operands (body, NULL_PTR, NULL_PTR,
834: NULL_PTR, NULL_PTR);
835: *template; template++)
836: if (*template == ';' || *template == '\n')
837: count++;
838:
839: return count;
840: }
841: #endif
842:
843: /* Output assembler code for the start of a function,
844: and initialize some of the variables in this file
845: for the new function. The label for the function and associated
846: assembler pseudo-ops have already been output in `assemble_start_function'.
847:
848: FIRST is the first insn of the rtl for the function being compiled.
849: FILE is the file to write assembler code to.
850: OPTIMIZE is nonzero if we should eliminate redundant
851: test and compare insns. */
852:
853: void
854: final_start_function (first, file, optimize)
855: rtx first;
856: FILE *file;
857: int optimize;
858: {
859: block_depth = 0;
860:
861: this_is_asm_operands = 0;
862:
863: #ifdef NON_SAVING_SETJMP
864: /* A function that calls setjmp should save and restore all the
865: call-saved registers on a system where longjmp clobbers them. */
866: if (NON_SAVING_SETJMP && current_function_calls_setjmp)
867: {
868: int i;
869:
870: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
871: if (!call_used_regs[i] && !call_fixed_regs[i])
872: regs_ever_live[i] = 1;
873: }
874: #endif
875:
876: /* Initial line number is supposed to be output
877: before the function's prologue and label
878: so that the function's address will not appear to be
879: in the last statement of the preceding function. */
880: if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
881: {
882: if (write_symbols == SDB_DEBUG)
883: /* For sdb, let's not, but say we did.
884: We need to set last_linenum for sdbout_function_begin,
885: but we can't have an actual line number before the .bf symbol.
886: (sdb_begin_function_line is not set,
887: and other compilers don't do it.) */
888: last_linenum = NOTE_LINE_NUMBER (first);
889: #ifdef XCOFF_DEBUGGING_INFO
890: else if (write_symbols == XCOFF_DEBUG)
891: {
892: last_linenum = NOTE_LINE_NUMBER (first);
893: xcoffout_output_first_source_line (file, last_linenum);
894: }
895: #endif
896: else
897: output_source_line (file, first);
898: }
899:
900: #ifdef LEAF_REG_REMAP
901: if (leaf_function)
902: leaf_renumber_regs (first);
903: #endif
904:
905: /* The Sun386i and perhaps other machines don't work right
906: if the profiling code comes after the prologue. */
907: #ifdef PROFILE_BEFORE_PROLOGUE
908: if (profile_flag)
909: profile_function (file);
910: #endif /* PROFILE_BEFORE_PROLOGUE */
911:
912: #ifdef FUNCTION_PROLOGUE
913: /* First output the function prologue: code to set up the stack frame. */
914: FUNCTION_PROLOGUE (file, get_frame_size ());
915: #endif
916:
917: #if defined (SDB_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
918: if (write_symbols == SDB_DEBUG || write_symbols == XCOFF_DEBUG)
919: next_block_index = 1;
920: #endif
921:
922: /* If the machine represents the prologue as RTL, the profiling code must
923: be emitted when NOTE_INSN_PROLOGUE_END is scanned. */
924: #ifdef HAVE_prologue
925: if (! HAVE_prologue)
926: #endif
927: profile_after_prologue (file);
928:
929: profile_label_no++;
930:
931: /* If we are doing basic block profiling, remember a printable version
932: of the function name. */
933: if (profile_block_flag)
934: {
935: char *junk = "function";
936: bb_func_label_num =
937: add_bb_string ((*decl_printable_name) (current_function_decl, &junk), FALSE);
938: }
939: }
940:
941: static void
942: profile_after_prologue (file)
943: FILE *file;
944: {
945: #ifdef FUNCTION_BLOCK_PROFILER
946: if (profile_block_flag)
947: {
948: FUNCTION_BLOCK_PROFILER (file, profile_label_no);
949: }
950: #endif /* FUNCTION_BLOCK_PROFILER */
951:
952: #ifndef PROFILE_BEFORE_PROLOGUE
953: if (profile_flag)
954: profile_function (file);
955: #endif /* not PROFILE_BEFORE_PROLOGUE */
956: }
957:
958: void
959: profile_function (file)
960: FILE *file;
961: {
962: int align = MIN (BIGGEST_ALIGNMENT, INT_TYPE_SIZE);
963: int sval = current_function_returns_struct;
964: int cxt = current_function_needs_context;
965:
966: data_section ();
967: ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
968: #ifdef PROFILE_LABEL_PREFIX
969: ASM_OUTPUT_INTERNAL_LABEL (file, "_LP", profile_label_no);
970: #else
971: ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no);
972: #endif
973: assemble_integer (const0_rtx, UNITS_PER_WORD, 1);
974:
975: text_section ();
976:
977: #ifdef STRUCT_VALUE_INCOMING_REGNUM
978: if (sval)
979: ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_INCOMING_REGNUM);
980: #else
981: #ifdef STRUCT_VALUE_REGNUM
982: if (sval)
983: ASM_OUTPUT_REG_PUSH (file, STRUCT_VALUE_REGNUM);
984: #endif
985: #endif
986:
987: #if 0
988: #ifdef STATIC_CHAIN_INCOMING_REGNUM
989: if (cxt)
990: ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_INCOMING_REGNUM);
991: #else
992: #ifdef STATIC_CHAIN_REGNUM
993: if (cxt)
994: ASM_OUTPUT_REG_PUSH (file, STATIC_CHAIN_REGNUM);
995: #endif
996: #endif
997: #endif /* 0 */
998:
999: FUNCTION_PROFILER (file, profile_label_no);
1000:
1001: #if 0
1002: #ifdef STATIC_CHAIN_INCOMING_REGNUM
1003: if (cxt)
1004: ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_INCOMING_REGNUM);
1005: #else
1006: #ifdef STATIC_CHAIN_REGNUM
1007: if (cxt)
1008: ASM_OUTPUT_REG_POP (file, STATIC_CHAIN_REGNUM);
1009: #endif
1010: #endif
1011: #endif /* 0 */
1012:
1013: #ifdef STRUCT_VALUE_INCOMING_REGNUM
1014: if (sval)
1015: ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_INCOMING_REGNUM);
1016: #else
1017: #ifdef STRUCT_VALUE_REGNUM
1018: if (sval)
1019: ASM_OUTPUT_REG_POP (file, STRUCT_VALUE_REGNUM);
1020: #endif
1021: #endif
1022: }
1023:
1024: /* Output assembler code for the end of a function.
1025: For clarity, args are same as those of `final_start_function'
1026: even though not all of them are needed. */
1027:
1028: void
1029: final_end_function (first, file, optimize)
1030: rtx first;
1031: FILE *file;
1032: int optimize;
1033: {
1034: if (app_on)
1035: {
1036: fprintf (file, ASM_APP_OFF);
1037: app_on = 0;
1038: }
1039:
1040: #ifdef SDB_DEBUGGING_INFO
1041: if (write_symbols == SDB_DEBUG)
1042: sdbout_end_function (last_linenum);
1043: #endif
1044:
1045: #ifdef DWARF_DEBUGGING_INFO
1046: if (write_symbols == DWARF_DEBUG)
1047: dwarfout_end_function ();
1048: #endif
1049:
1050: #ifdef XCOFF_DEBUGGING_INFO
1051: if (write_symbols == XCOFF_DEBUG)
1052: xcoffout_end_function (file, last_linenum);
1053: #endif
1054:
1055: #ifdef FUNCTION_EPILOGUE
1056: /* Finally, output the function epilogue:
1057: code to restore the stack frame and return to the caller. */
1058: FUNCTION_EPILOGUE (file, get_frame_size ());
1059: #endif
1060:
1061: #ifdef OUTPUT_COMPILER_STUB
1062: output_compiler_stub();
1063: #endif
1064:
1065: #ifdef SDB_DEBUGGING_INFO
1066: if (write_symbols == SDB_DEBUG)
1067: sdbout_end_epilogue ();
1068: #endif
1069:
1070: #ifdef DWARF_DEBUGGING_INFO
1071: if (write_symbols == DWARF_DEBUG)
1072: dwarfout_end_epilogue ();
1073: #endif
1074:
1075: #ifdef XCOFF_DEBUGGING_INFO
1076: if (write_symbols == XCOFF_DEBUG)
1077: xcoffout_end_epilogue (file);
1078: #endif
1079:
1080: bb_func_label_num = -1; /* not in function, nuke label # */
1081:
1082: /* If FUNCTION_EPILOGUE is not defined, then the function body
1083: itself contains return instructions wherever needed. */
1084: }
1085:
1086: /* Add a block to the linked list that remembers the current line/file/function
1087: for basic block profiling. Emit the label in front of the basic block and
1088: the instructions that increment the count field. */
1089:
1090: static void
1091: add_bb (file)
1092: FILE *file;
1093: {
1094: struct bb_list *ptr = (struct bb_list *) permalloc (sizeof (struct bb_list));
1095:
1096: /* Add basic block to linked list. */
1097: ptr->next = 0;
1098: ptr->line_num = last_linenum;
1099: ptr->file_label_num = bb_file_label_num;
1100: ptr->func_label_num = bb_func_label_num;
1101: *bb_tail = ptr;
1102: bb_tail = &ptr->next;
1103:
1104: /* Enable the table of basic-block use counts
1105: to point at the code it applies to. */
1106: ASM_OUTPUT_INTERNAL_LABEL (file, "LPB", count_basic_blocks);
1107:
1108: /* Before first insn of this basic block, increment the
1109: count of times it was entered. */
1110: #ifdef BLOCK_PROFILER
1111: BLOCK_PROFILER (file, count_basic_blocks);
1112: CC_STATUS_INIT;
1113: #endif
1114:
1115: new_block = 0;
1116: count_basic_blocks++;
1117: }
1118:
1119: /* Add a string to be used for basic block profiling. */
1120:
1121: static int
1122: add_bb_string (string, perm_p)
1123: char *string;
1124: int perm_p;
1125: {
1126: int len;
1127: struct bb_str *ptr = 0;
1128:
1129: if (!string)
1130: {
1131: string = "<unknown>";
1132: perm_p = TRUE;
1133: }
1134:
1135: /* Allocate a new string if the current string isn't permanent. If
1136: the string is permanent search for the same string in other
1137: allocations. */
1138:
1139: len = strlen (string) + 1;
1140: if (!perm_p)
1141: {
1142: char *p = (char *) permalloc (len);
1143: bcopy (string, p, len);
1144: string = p;
1145: }
1146: else
1147: for (ptr = sbb_head; ptr != (struct bb_str *)0; ptr = ptr->next)
1148: if (ptr->string == string)
1149: break;
1150:
1151: /* Allocate a new string block if we need to. */
1152: if (!ptr)
1153: {
1154: ptr = (struct bb_str *) permalloc (sizeof (*ptr));
1155: ptr->next = 0;
1156: ptr->length = len;
1157: ptr->label_num = sbb_label_num++;
1158: ptr->string = string;
1159: *sbb_tail = ptr;
1160: sbb_tail = &ptr->next;
1161: }
1162:
1163: return ptr->label_num;
1164: }
1165:
1166:
1167: /* Output assembler code for some insns: all or part of a function.
1168: For description of args, see `final_start_function', above.
1169:
1170: PRESCAN is 1 if we are not really outputting,
1171: just scanning as if we were outputting.
1172: Prescanning deletes and rearranges insns just like ordinary output.
1173: PRESCAN is -2 if we are outputting after having prescanned.
1174: In this case, don't try to delete or rearrange insns
1175: because that has already been done.
1176: Prescanning is done only on certain machines. */
1177:
1178: void
1179: final (first, file, optimize, prescan)
1180: rtx first;
1181: FILE *file;
1182: int optimize;
1183: int prescan;
1184: {
1185: register rtx insn;
1186: int max_line = 0;
1187:
1188: last_ignored_compare = 0;
1189: new_block = 1;
1190:
1191: /* Make a map indicating which line numbers appear in this function.
1192: When producing SDB debugging info, delete troublesome line number
1193: notes from inlined functions in other files as well as duplicate
1194: line number notes. */
1195: #ifdef SDB_DEBUGGING_INFO
1196: if (write_symbols == SDB_DEBUG)
1197: {
1198: rtx last = 0;
1199: for (insn = first; insn; insn = NEXT_INSN (insn))
1200: if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1201: {
1202: if ((RTX_INTEGRATED_P (insn)
1203: && strcmp (NOTE_SOURCE_FILE (insn), main_input_filename) != 0)
1204: || (last != 0
1205: && NOTE_LINE_NUMBER (insn) == NOTE_LINE_NUMBER (last)
1206: && NOTE_SOURCE_FILE (insn) == NOTE_SOURCE_FILE (last)))
1207: {
1208: NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1209: NOTE_SOURCE_FILE (insn) = 0;
1210: continue;
1211: }
1212: last = insn;
1213: if (NOTE_LINE_NUMBER (insn) > max_line)
1214: max_line = NOTE_LINE_NUMBER (insn);
1215: }
1216: }
1217: else
1218: #endif
1219: {
1220: for (insn = first; insn; insn = NEXT_INSN (insn))
1221: if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > max_line)
1222: max_line = NOTE_LINE_NUMBER (insn);
1223: }
1224:
1225: line_note_exists = (char *) oballoc (max_line + 1);
1226: bzero (line_note_exists, max_line + 1);
1227:
1228: for (insn = first; insn; insn = NEXT_INSN (insn))
1229: if (GET_CODE (insn) == NOTE && NOTE_LINE_NUMBER (insn) > 0)
1230: line_note_exists[NOTE_LINE_NUMBER (insn)] = 1;
1231:
1232: init_recog ();
1233:
1234: CC_STATUS_INIT;
1235:
1236: /* Output the insns. */
1237: for (insn = NEXT_INSN (first); insn;)
1238: insn = final_scan_insn (insn, file, optimize, prescan, 0);
1239:
1240: /* Do basic-block profiling here
1241: if the last insn was a conditional branch. */
1242: if (profile_block_flag && new_block)
1243: add_bb (file);
1244: }
1245:
1246: /* The final scan for one insn, INSN.
1247: Args are same as in `final', except that INSN
1248: is the insn being scanned.
1249: Value returned is the next insn to be scanned.
1250:
1251: NOPEEPHOLES is the flag to disallow peephole processing (currently
1252: used for within delayed branch sequence output). */
1253:
1254: rtx
1255: final_scan_insn (insn, file, optimize, prescan, nopeepholes)
1256: rtx insn;
1257: FILE *file;
1258: int optimize;
1259: int prescan;
1260: int nopeepholes;
1261: {
1262: register int i;
1263: insn_counter++;
1264:
1265: /* Ignore deleted insns. These can occur when we split insns (due to a
1266: template of "#") while not optimizing. */
1267: if (INSN_DELETED_P (insn))
1268: return NEXT_INSN (insn);
1269:
1270: switch (GET_CODE (insn))
1271: {
1272: case NOTE:
1273: if (prescan > 0)
1274: break;
1275:
1276: /* Align the beginning of a loop, for higher speed
1277: on certain machines. */
1278:
1279: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG && optimize > 0)
1280: {
1281: #ifdef ASM_OUTPUT_LOOP_ALIGN
1282: rtx next = next_nonnote_insn (insn);
1283: if (next && GET_CODE (next) == CODE_LABEL)
1284: {
1285: ASM_OUTPUT_LOOP_ALIGN (asm_out_file);
1286: }
1287: #endif
1288: break;
1289: }
1290: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
1291: break;
1292:
1293: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
1294: {
1295: #ifdef FUNCTION_END_PROLOGUE
1296: FUNCTION_END_PROLOGUE (file);
1297: #endif
1298: profile_after_prologue (file);
1299: break;
1300: }
1301:
1302: #ifdef FUNCTION_BEGIN_EPILOGUE
1303: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
1304: {
1305: FUNCTION_BEGIN_EPILOGUE (file);
1306: break;
1307: }
1308: #endif
1309:
1310: if (write_symbols == NO_DEBUG)
1311: break;
1312: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
1313: {
1314: #ifdef SDB_DEBUGGING_INFO
1315: if (write_symbols == SDB_DEBUG)
1316: sdbout_begin_function (last_linenum);
1317: #endif
1318: #ifdef XCOFF_DEBUGGING_INFO
1319: if (write_symbols == XCOFF_DEBUG)
1320: xcoffout_begin_function (file, last_linenum);
1321: #endif
1322: #ifdef DWARF_DEBUGGING_INFO
1323: if (write_symbols == DWARF_DEBUG)
1324: dwarfout_begin_function ();
1325: #endif
1326: break;
1327: }
1328: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
1329: break; /* An insn that was "deleted" */
1330: if (app_on)
1331: {
1332: fprintf (file, ASM_APP_OFF);
1333: app_on = 0;
1334: }
1335: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
1336: && (debug_info_level == DINFO_LEVEL_NORMAL
1337: || debug_info_level == DINFO_LEVEL_VERBOSE
1338: #ifdef DWARF_DEBUGGING_INFO
1339: || write_symbols == DWARF_DEBUG
1340: #endif
1341: )
1342: )
1343: {
1344: /* Beginning of a symbol-block. Assign it a sequence number
1345: and push the number onto the stack PENDING_BLOCKS. */
1346:
1347: if (block_depth == max_block_depth)
1348: {
1349: /* PENDING_BLOCKS is full; make it longer. */
1350: max_block_depth *= 2;
1351: pending_blocks
1352: = (int *) xrealloc (pending_blocks,
1353: max_block_depth * sizeof (int));
1354: }
1355: pending_blocks[block_depth++] = next_block_index;
1356:
1357: /* Output debugging info about the symbol-block beginning. */
1358:
1359: #ifdef SDB_DEBUGGING_INFO
1360: if (write_symbols == SDB_DEBUG)
1361: sdbout_begin_block (file, last_linenum, next_block_index);
1362: #endif
1363: #ifdef XCOFF_DEBUGGING_INFO
1364: if (write_symbols == XCOFF_DEBUG)
1365: xcoffout_begin_block (file, last_linenum, next_block_index);
1366: #endif
1367: #ifdef DBX_DEBUGGING_INFO
1368: if (write_symbols == DBX_DEBUG)
1369: ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index);
1370: #endif
1371: #ifdef DWARF_DEBUGGING_INFO
1372: if (write_symbols == DWARF_DEBUG && block_depth > 1)
1373: dwarfout_begin_block (next_block_index);
1374: #endif
1375:
1376: next_block_index++;
1377: }
1378: else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END
1379: && (debug_info_level == DINFO_LEVEL_NORMAL
1380: || debug_info_level == DINFO_LEVEL_VERBOSE
1381: #ifdef DWARF_DEBUGGING_INFO
1382: || write_symbols == DWARF_DEBUG
1383: #endif
1384: )
1385: )
1386: {
1387: /* End of a symbol-block. Pop its sequence number off
1388: PENDING_BLOCKS and output debugging info based on that. */
1389:
1390: --block_depth;
1391:
1392: #ifdef XCOFF_DEBUGGING_INFO
1393: if (write_symbols == XCOFF_DEBUG && block_depth >= 0)
1394: xcoffout_end_block (file, last_linenum, pending_blocks[block_depth]);
1395: #endif
1396: #ifdef DBX_DEBUGGING_INFO
1397: if (write_symbols == DBX_DEBUG && block_depth >= 0)
1398: ASM_OUTPUT_INTERNAL_LABEL (file, "LBE",
1399: pending_blocks[block_depth]);
1400: #endif
1401: #ifdef SDB_DEBUGGING_INFO
1402: if (write_symbols == SDB_DEBUG && block_depth >= 0)
1403: sdbout_end_block (file, last_linenum);
1404: #endif
1405: #ifdef DWARF_DEBUGGING_INFO
1406: if (write_symbols == DWARF_DEBUG && block_depth >= 1)
1407: dwarfout_end_block (pending_blocks[block_depth]);
1408: #endif
1409: }
1410: else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL
1411: && (debug_info_level == DINFO_LEVEL_NORMAL
1412: || debug_info_level == DINFO_LEVEL_VERBOSE))
1413: {
1414: #ifdef DWARF_DEBUGGING_INFO
1415: if (write_symbols == DWARF_DEBUG)
1416: dwarfout_label (insn);
1417: #endif
1418: }
1419: else if (NOTE_LINE_NUMBER (insn) > 0)
1420: /* This note is a line-number. */
1421: {
1422: register rtx note;
1423:
1424: #if 0 /* This is what we used to do. */
1425: output_source_line (file, insn);
1426: #endif
1427: int note_after = 0;
1428:
1429: /* If there is anything real after this note,
1430: output it. If another line note follows, omit this one. */
1431: for (note = NEXT_INSN (insn); note; note = NEXT_INSN (note))
1432: {
1433: if (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL)
1434: break;
1435: /* These types of notes can be significant
1436: so make sure the preceding line number stays. */
1437: else if (GET_CODE (note) == NOTE
1438: && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG
1439: || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END
1440: || NOTE_LINE_NUMBER (note) == NOTE_INSN_FUNCTION_BEG))
1441: break;
1442: else if (GET_CODE (note) == NOTE && NOTE_LINE_NUMBER (note) > 0)
1443: {
1444: /* Another line note follows; we can delete this note
1445: if no intervening line numbers have notes elsewhere. */
1446: int num;
1447: for (num = NOTE_LINE_NUMBER (insn) + 1;
1448: num < NOTE_LINE_NUMBER (note);
1449: num++)
1450: if (line_note_exists[num])
1451: break;
1452:
1453: if (num >= NOTE_LINE_NUMBER (note))
1454: note_after = 1;
1455: break;
1456: }
1457: }
1458:
1459: /* Output this line note
1460: if it is the first or the last line note in a row. */
1461: if (!note_after)
1462: output_source_line (file, insn);
1463: }
1464: break;
1465:
1466: case BARRIER:
1467: #ifdef ASM_OUTPUT_ALIGN_CODE
1468: /* Don't litter the assembler output with needless alignments. A
1469: BARRIER will be placed at the end of every function if HAVE_epilogue
1470: is true. */
1471: if (NEXT_INSN (insn))
1472: ASM_OUTPUT_ALIGN_CODE (file);
1473: #endif
1474: break;
1475:
1476: case CODE_LABEL:
1477: CC_STATUS_INIT;
1478: if (prescan > 0)
1479: break;
1480: new_block = 1;
1481: #ifdef SDB_DEBUGGING_INFO
1482: if (write_symbols == SDB_DEBUG && LABEL_NAME (insn))
1483: sdbout_label (insn);
1484: #endif
1485: #ifdef DWARF_DEBUGGING_INFO
1486: if (write_symbols == DWARF_DEBUG && LABEL_NAME (insn))
1487: dwarfout_label (insn);
1488: #endif
1489: if (app_on)
1490: {
1491: fprintf (file, ASM_APP_OFF);
1492: app_on = 0;
1493: }
1494: if (NEXT_INSN (insn) != 0
1495: && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN)
1496: {
1497: rtx nextbody = PATTERN (NEXT_INSN (insn));
1498:
1499: /* If this label is followed by a jump-table,
1500: make sure we put the label in the read-only section. Also
1501: possibly write the label and jump table together. */
1502:
1503: if (GET_CODE (nextbody) == ADDR_VEC
1504: || GET_CODE (nextbody) == ADDR_DIFF_VEC)
1505: {
1506: #ifndef JUMP_TABLES_IN_TEXT_SECTION
1507: readonly_data_section ();
1508: #ifdef READONLY_DATA_SECTION
1509: ASM_OUTPUT_ALIGN (file,
1510: exact_log2 (BIGGEST_ALIGNMENT
1511: / BITS_PER_UNIT));
1512: #endif /* READONLY_DATA_SECTION */
1513: #else /* JUMP_TABLES_IN_TEXT_SECTION */
1514: text_section ();
1515: #endif /* JUMP_TABLES_IN_TEXT_SECTION */
1516: #ifdef ASM_OUTPUT_CASE_LABEL
1517: ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
1518: NEXT_INSN (insn));
1519: #else
1520: ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
1521: #endif
1522: break;
1523: }
1524: }
1525:
1526: ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
1527: if (XSTR (insn, 4) && (XSTR (insn, 4))[0] == '*')
1528: assemble_label (XSTR (insn, 4));
1529: break;
1530:
1531: default:
1532: {
1533: register rtx body = PATTERN (insn);
1534: int insn_code_number;
1535: char *template;
1536: rtx note;
1537:
1538: /* An INSN, JUMP_INSN or CALL_INSN.
1539: First check for special kinds that recog doesn't recognize. */
1540:
1541: if (GET_CODE (body) == USE /* These are just declarations */
1542: || GET_CODE (body) == CLOBBER)
1543: break;
1544:
1545: #ifdef HAVE_cc0
1546: /* If there is a REG_CC_SETTER note on this insn, it means that
1547: the setting of the condition code was done in the delay slot
1548: of the insn that branched here. So recover the cc status
1549: from the insn that set it. */
1550:
1551: note = find_reg_note (insn, REG_CC_SETTER, NULL_RTX);
1552: if (note)
1553: {
1554: NOTICE_UPDATE_CC (PATTERN (XEXP (note, 0)), XEXP (note, 0));
1555: cc_prev_status = cc_status;
1556: }
1557: #endif
1558:
1559: /* Detect insns that are really jump-tables
1560: and output them as such. */
1561:
1562: if (GET_CODE (body) == ADDR_VEC || GET_CODE (body) == ADDR_DIFF_VEC)
1563: {
1564: register int vlen, idx;
1565:
1566: if (prescan > 0)
1567: break;
1568:
1569: if (app_on)
1570: {
1571: fprintf (file, ASM_APP_OFF);
1572: app_on = 0;
1573: }
1574:
1575: vlen = XVECLEN (body, GET_CODE (body) == ADDR_DIFF_VEC);
1576: for (idx = 0; idx < vlen; idx++)
1577: {
1578: if (GET_CODE (body) == ADDR_VEC)
1579: {
1580: #ifdef ASM_OUTPUT_ADDR_VEC_ELT
1581: ASM_OUTPUT_ADDR_VEC_ELT
1582: (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
1583: #else
1584: abort ();
1585: #endif
1586: }
1587: else
1588: {
1589: #ifdef ASM_OUTPUT_ADDR_DIFF_ELT
1590: ASM_OUTPUT_ADDR_DIFF_ELT
1591: (file,
1592: CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
1593: CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
1594: #else
1595: abort ();
1596: #endif
1597: }
1598: }
1599: #ifdef ASM_OUTPUT_CASE_END
1600: ASM_OUTPUT_CASE_END (file,
1601: CODE_LABEL_NUMBER (PREV_INSN (insn)),
1602: insn);
1603: #endif
1604:
1605: text_section ();
1606:
1607: break;
1608: }
1609:
1610: /* Do basic-block profiling when we reach a new block.
1611: Done here to avoid jump tables. */
1612: if (profile_block_flag && new_block)
1613: add_bb (file);
1614:
1615: if (GET_CODE (body) == ASM_INPUT)
1616: {
1617: /* There's no telling what that did to the condition codes. */
1618: CC_STATUS_INIT;
1619: if (prescan > 0)
1620: break;
1621: if (! app_on)
1622: {
1623: fprintf (file, ASM_APP_ON);
1624: app_on = 1;
1625: }
1626: fprintf (asm_out_file, "\t%s\n", XSTR (body, 0));
1627: break;
1628: }
1629:
1630: /* Detect `asm' construct with operands. */
1631: if (asm_noperands (body) >= 0)
1632: {
1633: int noperands = asm_noperands (body);
1634: rtx *ops;
1635: char *string;
1636:
1637: /* There's no telling what that did to the condition codes. */
1638: CC_STATUS_INIT;
1639: if (prescan > 0)
1640: break;
1641:
1642: /* alloca won't do here, since only return from `final'
1643: would free it. */
1644: if (noperands > 0)
1645: ops = (rtx *) xmalloc (noperands * sizeof (rtx));
1646:
1647: if (! app_on)
1648: {
1649: fprintf (file, ASM_APP_ON);
1650: app_on = 1;
1651: }
1652:
1653: /* Get out the operand values. */
1654: string = decode_asm_operands (body, ops, NULL_PTR,
1655: NULL_PTR, NULL_PTR);
1656: /* Inhibit aborts on what would otherwise be compiler bugs. */
1657: insn_noperands = noperands;
1658: this_is_asm_operands = insn;
1659: /* Output the insn using them. */
1660: output_asm_insn (string, ops);
1661: this_is_asm_operands = 0;
1662: if (noperands > 0)
1663: free (ops);
1664: break;
1665: }
1666:
1667: if (prescan <= 0 && app_on)
1668: {
1669: fprintf (file, ASM_APP_OFF);
1670: app_on = 0;
1671: }
1672:
1673: if (GET_CODE (body) == SEQUENCE)
1674: {
1675: /* A delayed-branch sequence */
1676: register int i;
1677: rtx next;
1678:
1679: if (prescan > 0)
1680: break;
1681: final_sequence = body;
1682:
1683: /* The first insn in this SEQUENCE might be a JUMP_INSN that will
1684: force the restoration of a comparison that was previously
1685: thought unnecessary. If that happens, cancel this sequence
1686: and cause that insn to be restored. */
1687:
1688: next = final_scan_insn (XVECEXP (body, 0, 0), file, 0, prescan, 1);
1689: if (next != XVECEXP (body, 0, 1))
1690: {
1691: final_sequence = 0;
1692: return next;
1693: }
1694:
1695: for (i = 1; i < XVECLEN (body, 0); i++)
1696: final_scan_insn (XVECEXP (body, 0, i), file, 0, prescan, 1);
1697: #ifdef DBR_OUTPUT_SEQEND
1698: DBR_OUTPUT_SEQEND (file);
1699: #endif
1700: final_sequence = 0;
1701:
1702: /* If the insn requiring the delay slot was a CALL_INSN, the
1703: insns in the delay slot are actually executed before the
1704: called function. Hence we don't preserve any CC-setting
1705: actions in these insns and the CC must be marked as being
1706: clobbered by the function. */
1707: if (GET_CODE (XVECEXP (body, 0, 0)) == CALL_INSN)
1708: CC_STATUS_INIT;
1709:
1710: /* Following a conditional branch sequence, we have a new basic
1711: block. */
1712: if (profile_block_flag)
1713: {
1714: rtx insn = XVECEXP (body, 0, 0);
1715: rtx body = PATTERN (insn);
1716:
1717: if ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
1718: && GET_CODE (SET_SRC (body)) != LABEL_REF)
1719: || (GET_CODE (insn) == JUMP_INSN
1720: && GET_CODE (body) == PARALLEL
1721: && GET_CODE (XVECEXP (body, 0, 0)) == SET
1722: && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF))
1723: new_block = 1;
1724: }
1725: break;
1726: }
1727:
1728: /* We have a real machine instruction as rtl. */
1729:
1730: body = PATTERN (insn);
1731:
1732: #ifdef HAVE_cc0
1733: /* Check for redundant test and compare instructions
1734: (when the condition codes are already set up as desired).
1735: This is done only when optimizing; if not optimizing,
1736: it should be possible for the user to alter a variable
1737: with the debugger in between statements
1738: and the next statement should reexamine the variable
1739: to compute the condition codes. */
1740:
1741: if (optimize
1742: && GET_CODE (body) == SET
1743: && GET_CODE (SET_DEST (body)) == CC0
1744: && insn != last_ignored_compare)
1745: {
1746: if (GET_CODE (SET_SRC (body)) == SUBREG)
1747: SET_SRC (body) = alter_subreg (SET_SRC (body));
1748: else if (GET_CODE (SET_SRC (body)) == COMPARE)
1749: {
1750: if (GET_CODE (XEXP (SET_SRC (body), 0)) == SUBREG)
1751: XEXP (SET_SRC (body), 0)
1752: = alter_subreg (XEXP (SET_SRC (body), 0));
1753: if (GET_CODE (XEXP (SET_SRC (body), 1)) == SUBREG)
1754: XEXP (SET_SRC (body), 1)
1755: = alter_subreg (XEXP (SET_SRC (body), 1));
1756: }
1757: if ((cc_status.value1 != 0
1758: && rtx_equal_p (SET_SRC (body), cc_status.value1))
1759: || (cc_status.value2 != 0
1760: && rtx_equal_p (SET_SRC (body), cc_status.value2)))
1761: {
1762: /* Don't delete insn if it has an addressing side-effect. */
1763: if (! FIND_REG_INC_NOTE (insn, 0)
1764: /* or if anything in it is volatile. */
1765: && ! volatile_refs_p (PATTERN (insn)))
1766: {
1767: /* We don't really delete the insn; just ignore it. */
1768: last_ignored_compare = insn;
1769: break;
1770: }
1771: }
1772: }
1773: #endif
1774:
1775: /* Following a conditional branch, we have a new basic block.
1776: But if we are inside a sequence, the new block starts after the
1777: last insn of the sequence. */
1778: if (profile_block_flag && final_sequence == 0
1779: && ((GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == SET
1780: && GET_CODE (SET_SRC (body)) != LABEL_REF)
1781: || (GET_CODE (insn) == JUMP_INSN && GET_CODE (body) == PARALLEL
1782: && GET_CODE (XVECEXP (body, 0, 0)) == SET
1783: && GET_CODE (SET_SRC (XVECEXP (body, 0, 0))) != LABEL_REF)))
1784: new_block = 1;
1785:
1786: #ifndef STACK_REGS
1787: /* Don't bother outputting obvious no-ops, even without -O.
1788: This optimization is fast and doesn't interfere with debugging.
1789: Don't do this if the insn is in a delay slot, since this
1790: will cause an improper number of delay insns to be written. */
1791: if (final_sequence == 0
1792: && prescan >= 0
1793: && GET_CODE (insn) == INSN && GET_CODE (body) == SET
1794: && GET_CODE (SET_SRC (body)) == REG
1795: && GET_CODE (SET_DEST (body)) == REG
1796: && REGNO (SET_SRC (body)) == REGNO (SET_DEST (body)))
1797: break;
1798: #endif
1799:
1800: #ifdef HAVE_cc0
1801: /* If this is a conditional branch, maybe modify it
1802: if the cc's are in a nonstandard state
1803: so that it accomplishes the same thing that it would
1804: do straightforwardly if the cc's were set up normally. */
1805:
1806: if (cc_status.flags != 0
1807: && GET_CODE (insn) == JUMP_INSN
1808: && GET_CODE (body) == SET
1809: && SET_DEST (body) == pc_rtx
1810: && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE
1811: /* This is done during prescan; it is not done again
1812: in final scan when prescan has been done. */
1813: && prescan >= 0)
1814: {
1815: /* This function may alter the contents of its argument
1816: and clear some of the cc_status.flags bits.
1817: It may also return 1 meaning condition now always true
1818: or -1 meaning condition now always false
1819: or 2 meaning condition nontrivial but altered. */
1820: register int result = alter_cond (XEXP (SET_SRC (body), 0));
1821: /* If condition now has fixed value, replace the IF_THEN_ELSE
1822: with its then-operand or its else-operand. */
1823: if (result == 1)
1824: SET_SRC (body) = XEXP (SET_SRC (body), 1);
1825: if (result == -1)
1826: SET_SRC (body) = XEXP (SET_SRC (body), 2);
1827:
1828: /* The jump is now either unconditional or a no-op.
1829: If it has become a no-op, don't try to output it.
1830: (It would not be recognized.) */
1831: if (SET_SRC (body) == pc_rtx)
1832: {
1833: PUT_CODE (insn, NOTE);
1834: NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1835: NOTE_SOURCE_FILE (insn) = 0;
1836: break;
1837: }
1838: else if (GET_CODE (SET_SRC (body)) == RETURN)
1839: /* Replace (set (pc) (return)) with (return). */
1840: PATTERN (insn) = body = SET_SRC (body);
1841:
1842: /* Rerecognize the instruction if it has changed. */
1843: if (result != 0)
1844: INSN_CODE (insn) = -1;
1845: }
1846:
1847: /* Make same adjustments to instructions that examine the
1848: condition codes without jumping (if this machine has them). */
1849:
1850: if (cc_status.flags != 0
1851: && GET_CODE (body) == SET)
1852: {
1853: switch (GET_CODE (SET_SRC (body)))
1854: {
1855: case GTU:
1856: case GT:
1857: case LTU:
1858: case LT:
1859: case GEU:
1860: case GE:
1861: case LEU:
1862: case LE:
1863: case EQ:
1864: case NE:
1865: {
1866: register int result;
1867: if (XEXP (SET_SRC (body), 0) != cc0_rtx)
1868: break;
1869: result = alter_cond (SET_SRC (body));
1870: if (result == 1)
1871: validate_change (insn, &SET_SRC (body), const_true_rtx, 0);
1872: else if (result == -1)
1873: validate_change (insn, &SET_SRC (body), const0_rtx, 0);
1874: else if (result == 2)
1875: INSN_CODE (insn) = -1;
1876: }
1877: }
1878: }
1879: #endif
1880:
1881: /* Do machine-specific peephole optimizations if desired. */
1882:
1883: if (optimize && !flag_no_peephole && !nopeepholes)
1884: {
1885: rtx next = peephole (insn);
1886: /* When peepholing, if there were notes within the peephole,
1887: emit them before the peephole. */
1888: if (next != 0 && next != NEXT_INSN (insn))
1889: {
1890: rtx prev = PREV_INSN (insn);
1891: rtx note;
1892:
1893: for (note = NEXT_INSN (insn); note != next;
1894: note = NEXT_INSN (note))
1895: final_scan_insn (note, file, optimize, prescan, nopeepholes);
1896:
1897: /* In case this is prescan, put the notes
1898: in proper position for later rescan. */
1899: note = NEXT_INSN (insn);
1900: PREV_INSN (note) = prev;
1901: NEXT_INSN (prev) = note;
1902: NEXT_INSN (PREV_INSN (next)) = insn;
1903: PREV_INSN (insn) = PREV_INSN (next);
1904: NEXT_INSN (insn) = next;
1905: PREV_INSN (next) = insn;
1906: }
1907:
1908: /* PEEPHOLE might have changed this. */
1909: body = PATTERN (insn);
1910: }
1911:
1912: /* Try to recognize the instruction.
1913: If successful, verify that the operands satisfy the
1914: constraints for the instruction. Crash if they don't,
1915: since `reload' should have changed them so that they do. */
1916:
1917: insn_code_number = recog_memoized (insn);
1918: insn_extract (insn);
1919: for (i = 0; i < insn_n_operands[insn_code_number]; i++)
1920: {
1921: if (GET_CODE (recog_operand[i]) == SUBREG)
1922: recog_operand[i] = alter_subreg (recog_operand[i]);
1923: else if (GET_CODE (recog_operand[i]) == PLUS
1924: || GET_CODE (recog_operand[i]) == MULT)
1925: recog_operand[i] = walk_alter_subreg (recog_operand[i]);
1926: }
1927:
1928: for (i = 0; i < insn_n_dups[insn_code_number]; i++)
1929: {
1930: if (GET_CODE (*recog_dup_loc[i]) == SUBREG)
1931: *recog_dup_loc[i] = alter_subreg (*recog_dup_loc[i]);
1932: else if (GET_CODE (*recog_dup_loc[i]) == PLUS
1933: || GET_CODE (*recog_dup_loc[i]) == MULT)
1934: *recog_dup_loc[i] = walk_alter_subreg (*recog_dup_loc[i]);
1935: }
1936:
1937: #ifdef REGISTER_CONSTRAINTS
1938: if (! constrain_operands (insn_code_number, 1))
1939: fatal_insn_not_found (insn);
1940: #endif
1941:
1942: /* Some target machines need to prescan each insn before
1943: it is output. */
1944:
1945: #ifdef FINAL_PRESCAN_INSN
1946: FINAL_PRESCAN_INSN (insn, recog_operand,
1947: insn_n_operands[insn_code_number]);
1948: #endif
1949:
1950: #ifdef HAVE_cc0
1951: cc_prev_status = cc_status;
1952:
1953: /* Update `cc_status' for this instruction.
1954: The instruction's output routine may change it further.
1955: If the output routine for a jump insn needs to depend
1956: on the cc status, it should look at cc_prev_status. */
1957:
1958: NOTICE_UPDATE_CC (body, insn);
1959: #endif
1960:
1961: debug_insn = insn;
1962:
1963: /* If the proper template needs to be chosen by some C code,
1964: run that code and get the real template. */
1965:
1966: template = insn_template[insn_code_number];
1967: if (template == 0)
1968: {
1969: template = (*insn_outfun[insn_code_number]) (recog_operand, insn);
1970:
1971: /* If the C code returns 0, it means that it is a jump insn
1972: which follows a deleted test insn, and that test insn
1973: needs to be reinserted. */
1974: if (template == 0)
1975: {
1976: if (prev_nonnote_insn (insn) != last_ignored_compare)
1977: abort ();
1978: new_block = 0;
1979: return prev_nonnote_insn (insn);
1980: }
1981: }
1982:
1983: /* If the template is the string "#", it means that this insn must
1984: be split. */
1985: if (template[0] == '#' && template[1] == '\0')
1986: {
1987: rtx new = try_split (body, insn, 0);
1988:
1989: /* If we didn't split the insn, go away. */
1990: if (new == insn && PATTERN (new) == body)
1991: abort ();
1992:
1993: new_block = 0;
1994: return new;
1995: }
1996:
1997: if (prescan > 0)
1998: break;
1999:
2000: /* Output assembler code from the template. */
2001:
2002: output_asm_insn (template, recog_operand);
2003:
2004: #if 0
2005: /* It's not at all clear why we did this and doing so interferes
2006: with tests we'd like to do to use REG_WAS_0 notes, so let's try
2007: with this out. */
2008:
2009: /* Mark this insn as having been output. */
2010: INSN_DELETED_P (insn) = 1;
2011: #endif
2012:
2013: debug_insn = 0;
2014: }
2015: }
2016: return NEXT_INSN (insn);
2017: }
2018:
2019: /* Output debugging info to the assembler file FILE
2020: based on the NOTE-insn INSN, assumed to be a line number. */
2021:
2022: static void
2023: output_source_line (file, insn)
2024: FILE *file;
2025: rtx insn;
2026: {
2027: char ltext_label_name[100];
2028: register char *filename = NOTE_SOURCE_FILE (insn);
2029:
2030: /* Remember filename for basic block profiling.
2031: Filenames are allocated on the permanent obstack
2032: or are passed in ARGV, so we don't have to save
2033: the string. */
2034:
2035: if (profile_block_flag && last_filename != filename)
2036: bb_file_label_num = add_bb_string (filename, TRUE);
2037:
2038: last_filename = filename;
2039: last_linenum = NOTE_LINE_NUMBER (insn);
2040:
2041: if (write_symbols != NO_DEBUG)
2042: {
2043: #ifdef SDB_DEBUGGING_INFO
2044: if (write_symbols == SDB_DEBUG
2045: #if 0 /* People like having line numbers even in wrong file! */
2046: /* COFF can't handle multiple source files--lose, lose. */
2047: && !strcmp (filename, main_input_filename)
2048: #endif
2049: /* COFF relative line numbers must be positive. */
2050: && last_linenum > sdb_begin_function_line)
2051: {
2052: #ifdef ASM_OUTPUT_SOURCE_LINE
2053: ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
2054: #else
2055: fprintf (file, "\t.ln\t%d\n",
2056: ((sdb_begin_function_line > -1)
2057: ? last_linenum - sdb_begin_function_line : 1));
2058: #endif
2059: }
2060: #endif
2061:
2062: #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
2063: if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
2064: dbxout_source_line (file, filename, NOTE_LINE_NUMBER (insn));
2065: #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
2066:
2067: #ifdef DWARF_DEBUGGING_INFO
2068: if (write_symbols == DWARF_DEBUG)
2069: dwarfout_line (filename, NOTE_LINE_NUMBER (insn));
2070: #endif
2071: }
2072: }
2073:
2074: /* If X is a SUBREG, replace it with a REG or a MEM,
2075: based on the thing it is a subreg of. */
2076:
2077: rtx
2078: alter_subreg (x)
2079: register rtx x;
2080: {
2081: register rtx y = SUBREG_REG (x);
2082: if (GET_CODE (y) == SUBREG)
2083: y = alter_subreg (y);
2084:
2085: if (GET_CODE (y) == REG)
2086: {
2087: /* If the containing reg really gets a hard reg, so do we. */
2088: PUT_CODE (x, REG);
2089: REGNO (x) = REGNO (y) + SUBREG_WORD (x);
2090: }
2091: else if (GET_CODE (y) == MEM)
2092: {
2093: register int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
2094: #if BYTES_BIG_ENDIAN
2095: offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))
2096: - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y))));
2097: #endif
2098: PUT_CODE (x, MEM);
2099: MEM_VOLATILE_P (x) = MEM_VOLATILE_P (y);
2100: XEXP (x, 0) = plus_constant (XEXP (y, 0), offset);
2101: }
2102:
2103: return x;
2104: }
2105:
2106: /* Do alter_subreg on all the SUBREGs contained in X. */
2107:
2108: static rtx
2109: walk_alter_subreg (x)
2110: rtx x;
2111: {
2112: switch (GET_CODE (x))
2113: {
2114: case PLUS:
2115: case MULT:
2116: XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
2117: XEXP (x, 1) = walk_alter_subreg (XEXP (x, 1));
2118: break;
2119:
2120: case MEM:
2121: XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
2122: break;
2123:
2124: case SUBREG:
2125: return alter_subreg (x);
2126: }
2127:
2128: return x;
2129: }
2130:
2131: #ifdef HAVE_cc0
2132:
2133: /* Given BODY, the body of a jump instruction, alter the jump condition
2134: as required by the bits that are set in cc_status.flags.
2135: Not all of the bits there can be handled at this level in all cases.
2136:
2137: The value is normally 0.
2138: 1 means that the condition has become always true.
2139: -1 means that the condition has become always false.
2140: 2 means that COND has been altered. */
2141:
2142: static int
2143: alter_cond (cond)
2144: register rtx cond;
2145: {
2146: int value = 0;
2147:
2148: if (cc_status.flags & CC_REVERSED)
2149: {
2150: value = 2;
2151: PUT_CODE (cond, swap_condition (GET_CODE (cond)));
2152: }
2153:
2154: if (cc_status.flags & CC_INVERTED)
2155: {
2156: value = 2;
2157: PUT_CODE (cond, reverse_condition (GET_CODE (cond)));
2158: }
2159:
2160: if (cc_status.flags & CC_NOT_POSITIVE)
2161: switch (GET_CODE (cond))
2162: {
2163: case LE:
2164: case LEU:
2165: case GEU:
2166: /* Jump becomes unconditional. */
2167: return 1;
2168:
2169: case GT:
2170: case GTU:
2171: case LTU:
2172: /* Jump becomes no-op. */
2173: return -1;
2174:
2175: case GE:
2176: PUT_CODE (cond, EQ);
2177: value = 2;
2178: break;
2179:
2180: case LT:
2181: PUT_CODE (cond, NE);
2182: value = 2;
2183: break;
2184: }
2185:
2186: if (cc_status.flags & CC_NOT_NEGATIVE)
2187: switch (GET_CODE (cond))
2188: {
2189: case GE:
2190: case GEU:
2191: /* Jump becomes unconditional. */
2192: return 1;
2193:
2194: case LT:
2195: case LTU:
2196: /* Jump becomes no-op. */
2197: return -1;
2198:
2199: case LE:
2200: case LEU:
2201: PUT_CODE (cond, EQ);
2202: value = 2;
2203: break;
2204:
2205: case GT:
2206: case GTU:
2207: PUT_CODE (cond, NE);
2208: value = 2;
2209: break;
2210: }
2211:
2212: if (cc_status.flags & CC_NO_OVERFLOW)
2213: switch (GET_CODE (cond))
2214: {
2215: case GEU:
2216: /* Jump becomes unconditional. */
2217: return 1;
2218:
2219: case LEU:
2220: PUT_CODE (cond, EQ);
2221: value = 2;
2222: break;
2223:
2224: case GTU:
2225: PUT_CODE (cond, NE);
2226: value = 2;
2227: break;
2228:
2229: case LTU:
2230: /* Jump becomes no-op. */
2231: return -1;
2232: }
2233:
2234: if (cc_status.flags & (CC_Z_IN_NOT_N | CC_Z_IN_N))
2235: switch (GET_CODE (cond))
2236: {
2237: case LE:
2238: case LEU:
2239: case GE:
2240: case GEU:
2241: case LT:
2242: case LTU:
2243: case GT:
2244: case GTU:
2245: abort ();
2246:
2247: case NE:
2248: PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? GE : LT);
2249: value = 2;
2250: break;
2251:
2252: case EQ:
2253: PUT_CODE (cond, cc_status.flags & CC_Z_IN_N ? LT : GE);
2254: value = 2;
2255: break;
2256: }
2257:
2258: if (cc_status.flags & CC_NOT_SIGNED)
2259: /* The flags are valid if signed condition operators are converted
2260: to unsigned. */
2261: switch (GET_CODE (cond))
2262: {
2263: case LE:
2264: PUT_CODE (cond, LEU);
2265: value = 2;
2266: break;
2267:
2268: case LT:
2269: PUT_CODE (cond, LTU);
2270: value = 2;
2271: break;
2272:
2273: case GT:
2274: PUT_CODE (cond, GTU);
2275: value = 2;
2276: break;
2277:
2278: case GE:
2279: PUT_CODE (cond, GEU);
2280: value = 2;
2281: break;
2282: }
2283:
2284: return value;
2285: }
2286: #endif
2287:
2288: /* Report inconsistency between the assembler template and the operands.
2289: In an `asm', it's the user's fault; otherwise, the compiler's fault. */
2290:
2291: void
2292: output_operand_lossage (str)
2293: char *str;
2294: {
2295: if (this_is_asm_operands)
2296: error_for_asm (this_is_asm_operands, "invalid `asm': %s", str);
2297: else
2298: abort ();
2299: }
2300:
2301: /* Output of assembler code from a template, and its subroutines. */
2302:
2303: /* Output text from TEMPLATE to the assembler output file,
2304: obeying %-directions to substitute operands taken from
2305: the vector OPERANDS.
2306:
2307: %N (for N a digit) means print operand N in usual manner.
2308: %lN means require operand N to be a CODE_LABEL or LABEL_REF
2309: and print the label name with no punctuation.
2310: %cN means require operand N to be a constant
2311: and print the constant expression with no punctuation.
2312: %aN means expect operand N to be a memory address
2313: (not a memory reference!) and print a reference
2314: to that address.
2315: %nN means expect operand N to be a constant
2316: and print a constant expression for minus the value
2317: of the operand, with no other punctuation. */
2318:
2319: void
2320: output_asm_insn (template, operands)
2321: char *template;
2322: rtx *operands;
2323: {
2324: register char *p;
2325: register int c, i;
2326:
2327: /* An insn may return a null string template
2328: in a case where no assembler code is needed. */
2329: if (*template == 0)
2330: return;
2331:
2332: p = template;
2333: putc ('\t', asm_out_file);
2334:
2335: #ifdef ASM_OUTPUT_OPCODE
2336: ASM_OUTPUT_OPCODE (asm_out_file, p);
2337: #endif
2338:
2339: while (c = *p++)
2340: switch (c)
2341: {
2342: #ifdef ASM_OUTPUT_OPCODE
2343: case '\n':
2344: putc (c, asm_out_file);
2345: while ((c = *p) == '\t')
2346: {
2347: putc (c, asm_out_file);
2348: p++;
2349: }
2350: ASM_OUTPUT_OPCODE (asm_out_file, p);
2351: break;
2352: #endif
2353:
2354: #ifdef ASSEMBLER_DIALECT
2355: case '{':
2356: /* If we want the first dialect, do nothing. Otherwise, skip
2357: DIALECT_NUMBER of strings ending with '|'. */
2358: for (i = 0; i < dialect_number; i++)
2359: {
2360: while (*p && *p++ != '|')
2361: ;
2362:
2363: if (*p == '|')
2364: p++;
2365: }
2366: break;
2367:
2368: case '|':
2369: /* Skip to close brace. */
2370: while (*p && *p++ != '}')
2371: ;
2372: break;
2373:
2374: case '}':
2375: break;
2376: #endif
2377:
2378: case '%':
2379: /* %% outputs a single %. */
2380: if (*p == '%')
2381: {
2382: p++;
2383: putc (c, asm_out_file);
2384: }
2385: /* %= outputs a number which is unique to each insn in the entire
2386: compilation. This is useful for making local labels that are
2387: referred to more than once in a given insn. */
2388: else if (*p == '=')
2389: {
2390: p++;
2391: fprintf (asm_out_file, "%d", insn_counter);
2392: }
2393: /* % followed by a letter and some digits
2394: outputs an operand in a special way depending on the letter.
2395: Letters `acln' are implemented directly.
2396: Other letters are passed to `output_operand' so that
2397: the PRINT_OPERAND macro can define them. */
2398: else if ((*p >= 'a' && *p <= 'z')
2399: || (*p >= 'A' && *p <= 'Z'))
2400: {
2401: int letter = *p++;
2402: c = atoi (p);
2403:
2404: if (! (*p >= '0' && *p <= '9'))
2405: output_operand_lossage ("operand number missing after %-letter");
2406: else if (this_is_asm_operands && c >= (unsigned) insn_noperands)
2407: output_operand_lossage ("operand number out of range");
2408: else if (letter == 'l')
2409: output_asm_label (operands[c]);
2410: else if (letter == 'a')
2411: output_address (operands[c]);
2412: else if (letter == 'c')
2413: {
2414: if (CONSTANT_ADDRESS_P (operands[c]))
2415: output_addr_const (asm_out_file, operands[c]);
2416: else
2417: output_operand (operands[c], 'c');
2418: }
2419: else if (letter == 'n')
2420: {
2421: if (GET_CODE (operands[c]) == CONST_INT)
2422: fprintf (asm_out_file,
2423: #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2424: "%d",
2425: #else
2426: "%ld",
2427: #endif
2428: - INTVAL (operands[c]));
2429: else
2430: {
2431: putc ('-', asm_out_file);
2432: output_addr_const (asm_out_file, operands[c]);
2433: }
2434: }
2435: else
2436: output_operand (operands[c], letter);
2437:
2438: while ((c = *p) >= '0' && c <= '9') p++;
2439: }
2440: /* % followed by a digit outputs an operand the default way. */
2441: else if (*p >= '0' && *p <= '9')
2442: {
2443: c = atoi (p);
2444: if (this_is_asm_operands && c >= (unsigned) insn_noperands)
2445: output_operand_lossage ("operand number out of range");
2446: else
2447: output_operand (operands[c], 0);
2448: while ((c = *p) >= '0' && c <= '9') p++;
2449: }
2450: /* % followed by punctuation: output something for that
2451: punctuation character alone, with no operand.
2452: The PRINT_OPERAND macro decides what is actually done. */
2453: #ifdef PRINT_OPERAND_PUNCT_VALID_P
2454: else if (PRINT_OPERAND_PUNCT_VALID_P (*p))
2455: output_operand (NULL_RTX, *p++);
2456: #endif
2457: else
2458: output_operand_lossage ("invalid %%-code");
2459: break;
2460:
2461: default:
2462: putc (c, asm_out_file);
2463: }
2464:
2465: if (flag_print_asm_name)
2466: {
2467: /* Annotate the assembly with a comment describing the pattern and
2468: alternative used. */
2469: if (debug_insn)
2470: {
2471: register int num = INSN_CODE (debug_insn);
2472: fprintf (asm_out_file, " %s %d %s",
2473: ASM_COMMENT_START, INSN_UID (debug_insn), insn_name[num]);
2474: if (insn_n_alternatives[num] > 1)
2475: fprintf (asm_out_file, "/%d", which_alternative + 1);
2476:
2477: /* Clear this so only the first assembler insn
2478: of any rtl insn will get the special comment for -dp. */
2479: debug_insn = 0;
2480: }
2481: }
2482:
2483: putc ('\n', asm_out_file);
2484: }
2485:
2486: /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */
2487:
2488: void
2489: output_asm_label (x)
2490: rtx x;
2491: {
2492: char buf[256];
2493:
2494: if (GET_CODE (x) == LABEL_REF)
2495: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2496: else if (GET_CODE (x) == CODE_LABEL)
2497: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
2498: else
2499: output_operand_lossage ("`%l' operand isn't a label");
2500:
2501: assemble_name (asm_out_file, buf);
2502: }
2503:
2504: /* Print operand X using machine-dependent assembler syntax.
2505: The macro PRINT_OPERAND is defined just to control this function.
2506: CODE is a non-digit that preceded the operand-number in the % spec,
2507: such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
2508: between the % and the digits.
2509: When CODE is a non-letter, X is 0.
2510:
2511: The meanings of the letters are machine-dependent and controlled
2512: by PRINT_OPERAND. */
2513:
2514: static void
2515: output_operand (x, code)
2516: rtx x;
2517: int code;
2518: {
2519: if (x && GET_CODE (x) == SUBREG)
2520: x = alter_subreg (x);
2521:
2522: /* If X is a pseudo-register, abort now rather than writing trash to the
2523: assembler file. */
2524:
2525: if (x && GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER)
2526: abort ();
2527:
2528: PRINT_OPERAND (asm_out_file, x, code);
2529: }
2530:
2531: /* Print a memory reference operand for address X
2532: using machine-dependent assembler syntax.
2533: The macro PRINT_OPERAND_ADDRESS exists just to control this function. */
2534:
2535: void
2536: output_address (x)
2537: rtx x;
2538: {
2539: walk_alter_subreg (x);
2540: PRINT_OPERAND_ADDRESS (asm_out_file, x);
2541: }
2542:
2543: /* Print an integer constant expression in assembler syntax.
2544: Addition and subtraction are the only arithmetic
2545: that may appear in these expressions. */
2546:
2547: void
2548: output_addr_const (file, x)
2549: FILE *file;
2550: rtx x;
2551: {
2552: char buf[256];
2553:
2554: restart:
2555: switch (GET_CODE (x))
2556: {
2557: case PC:
2558: if (flag_pic)
2559: putc ('.', file);
2560: else
2561: abort ();
2562: break;
2563:
2564: case SYMBOL_REF:
2565: assemble_name (file, XSTR (x, 0));
2566: break;
2567:
2568: case LABEL_REF:
2569: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2570: assemble_name (file, buf);
2571: break;
2572:
2573: case CODE_LABEL:
2574: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
2575: assemble_name (file, buf);
2576: break;
2577:
2578: case CONST_INT:
2579: fprintf (file,
2580: #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2581: "%d",
2582: #else
2583: "%ld",
2584: #endif
2585: INTVAL (x));
2586: break;
2587:
2588: case CONST:
2589: /* This used to output parentheses around the expression,
2590: but that does not work on the 386 (either ATT or BSD assembler). */
2591: output_addr_const (file, XEXP (x, 0));
2592: break;
2593:
2594: case CONST_DOUBLE:
2595: if (GET_MODE (x) == VOIDmode)
2596: {
2597: /* We can use %d if the number is one word and positive. */
2598: if (CONST_DOUBLE_HIGH (x))
2599: fprintf (file,
2600: #if HOST_BITS_PER_WIDE_INT == 64
2601: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
2602: "0x%lx%016lx",
2603: #else
2604: "0x%x%016x",
2605: #endif
2606: #else
2607: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
2608: "0x%lx%08lx",
2609: #else
2610: "0x%x%08x",
2611: #endif
2612: #endif
2613: CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2614: else if (CONST_DOUBLE_LOW (x) < 0)
2615: fprintf (file,
2616: #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2617: "0x%x",
2618: #else
2619: "0x%lx",
2620: #endif
2621: CONST_DOUBLE_LOW (x));
2622: else
2623: fprintf (file,
2624: #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
2625: "%d",
2626: #else
2627: "%ld",
2628: #endif
2629: CONST_DOUBLE_LOW (x));
2630: }
2631: else
2632: /* We can't handle floating point constants;
2633: PRINT_OPERAND must handle them. */
2634: output_operand_lossage ("floating constant misused");
2635: break;
2636:
2637: case PLUS:
2638: /* Some assemblers need integer constants to appear last (eg masm). */
2639: if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2640: {
2641: output_addr_const (file, XEXP (x, 1));
2642: if (INTVAL (XEXP (x, 0)) >= 0)
2643: fprintf (file, "+");
2644: output_addr_const (file, XEXP (x, 0));
2645: }
2646: else
2647: {
2648: output_addr_const (file, XEXP (x, 0));
2649: if (INTVAL (XEXP (x, 1)) >= 0)
2650: fprintf (file, "+");
2651: output_addr_const (file, XEXP (x, 1));
2652: }
2653: break;
2654:
2655: case MINUS:
2656: /* Avoid outputting things like x-x or x+5-x,
2657: since some assemblers can't handle that. */
2658: x = simplify_subtraction (x);
2659: if (GET_CODE (x) != MINUS)
2660: goto restart;
2661:
2662: output_addr_const (file, XEXP (x, 0));
2663: fprintf (file, "-");
2664: if (GET_CODE (XEXP (x, 1)) == CONST_INT
2665: && INTVAL (XEXP (x, 1)) < 0)
2666: {
2667: fprintf (file, ASM_OPEN_PAREN);
2668: output_addr_const (file, XEXP (x, 1));
2669: fprintf (file, ASM_CLOSE_PAREN);
2670: }
2671: else
2672: output_addr_const (file, XEXP (x, 1));
2673: break;
2674:
2675: case ZERO_EXTEND:
2676: case SIGN_EXTEND:
2677: output_addr_const (file, XEXP (x, 0));
2678: break;
2679:
2680: default:
2681: output_operand_lossage ("invalid expression as operand");
2682: }
2683: }
2684:
2685: /* A poor man's fprintf, with the added features of %I, %R, %L, and %U.
2686: %R prints the value of REGISTER_PREFIX.
2687: %L prints the value of LOCAL_LABEL_PREFIX.
2688: %U prints the value of USER_LABEL_PREFIX.
2689: %I prints the value of IMMEDIATE_PREFIX.
2690: %O runs ASM_OUTPUT_OPCODE to transform what follows in the string.
2691: Also supported are %d, %x, %s, %e, %f, %g and %%.
2692:
2693: We handle alternate assembler dialects here, just like output_asm_insn. */
2694:
2695: void
2696: asm_fprintf (va_alist)
2697: va_dcl
2698: {
2699: va_list argptr;
2700: FILE *file;
2701: char buf[10];
2702: char *p, *q, c;
2703: int i;
2704:
2705: va_start (argptr);
2706:
2707: file = va_arg (argptr, FILE *);
2708: p = va_arg (argptr, char *);
2709: buf[0] = '%';
2710:
2711: while (c = *p++)
2712: switch (c)
2713: {
2714: #ifdef ASSEMBLER_DIALECT
2715: case '{':
2716: /* If we want the first dialect, do nothing. Otherwise, skip
2717: DIALECT_NUMBER of strings ending with '|'. */
2718: for (i = 0; i < dialect_number; i++)
2719: {
2720: while (*p && *p++ != '|')
2721: ;
2722:
2723: if (*p == '|')
2724: p++;
2725: }
2726: break;
2727:
2728: case '|':
2729: /* Skip to close brace. */
2730: while (*p && *p++ != '}')
2731: ;
2732: break;
2733:
2734: case '}':
2735: break;
2736: #endif
2737:
2738: case '%':
2739: c = *p++;
2740: q = &buf[1];
2741: while ((c >= '0' && c <= '9') || c == '.')
2742: {
2743: *q++ = c;
2744: c = *p++;
2745: }
2746: switch (c)
2747: {
2748: case '%':
2749: fprintf (file, "%%");
2750: break;
2751:
2752: case 'd': case 'i': case 'u':
2753: case 'x': case 'p': case 'X':
2754: case 'o':
2755: *q++ = c;
2756: *q = 0;
2757: fprintf (file, buf, va_arg (argptr, int));
2758: break;
2759:
2760: case 'w':
2761: /* This is a prefix to the 'd', 'i', 'u', 'x', 'p', and 'X' cases,
2762: but we do not check for those cases. It means that the value
2763: is a HOST_WIDE_INT, which may be either `int' or `long'. */
2764:
2765: #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
2766: *q++ = 'l';
2767: #endif
2768:
2769: *q++ = *p++;
2770: *q = 0;
2771: fprintf (file, buf, va_arg (argptr, HOST_WIDE_INT));
2772: break;
2773:
2774: case 'l':
2775: *q++ = c;
2776: *q++ = *p++;
2777: *q = 0;
2778: fprintf (file, buf, va_arg (argptr, long));
2779: break;
2780:
2781: case 'e':
2782: case 'f':
2783: case 'g':
2784: *q++ = c;
2785: *q = 0;
2786: fprintf (file, buf, va_arg (argptr, double));
2787: break;
2788:
2789: case 's':
2790: *q++ = c;
2791: *q = 0;
2792: fprintf (file, buf, va_arg (argptr, char *));
2793: break;
2794:
2795: case 'O':
2796: #ifdef ASM_OUTPUT_OPCODE
2797: ASM_OUTPUT_OPCODE (asm_out_file, p);
2798: #endif
2799: break;
2800:
2801: case 'R':
2802: #ifdef REGISTER_PREFIX
2803: fprintf (file, "%s", REGISTER_PREFIX);
2804: #endif
2805: break;
2806:
2807: case 'I':
2808: #ifdef IMMEDIATE_PREFIX
2809: fprintf (file, "%s", IMMEDIATE_PREFIX);
2810: #endif
2811: break;
2812:
2813: case 'L':
2814: #ifdef LOCAL_LABEL_PREFIX
2815: fprintf (file, "%s", LOCAL_LABEL_PREFIX);
2816: #endif
2817: break;
2818:
2819: case 'U':
2820: #ifdef USER_LABEL_PREFIX
2821: fprintf (file, "%s", USER_LABEL_PREFIX);
2822: #endif
2823: break;
2824:
2825: case 'S':
2826: *q++ = c;
2827: *q = 0;
2828: assemble_name (file, va_arg (argptr, char*));
2829: break;
2830:
2831: default:
2832: abort ();
2833: }
2834: break;
2835:
2836: default:
2837: fputc (c, file);
2838: }
2839: }
2840:
2841: /* Split up a CONST_DOUBLE or integer constant rtx
2842: into two rtx's for single words,
2843: storing in *FIRST the word that comes first in memory in the target
2844: and in *SECOND the other. */
2845:
2846: void
2847: split_double (value, first, second)
2848: rtx value;
2849: rtx *first, *second;
2850: {
2851: if (GET_CODE (value) == CONST_INT)
2852: {
2853: /* The rule for using CONST_INT for a wider mode
2854: is that we regard the value as signed.
2855: So sign-extend it. */
2856: rtx high = (INTVAL (value) < 0 ? constm1_rtx : const0_rtx);
2857: #if WORDS_BIG_ENDIAN
2858: *first = high;
2859: *second = value;
2860: #else
2861: *first = value;
2862: *second = high;
2863: #endif
2864: }
2865: else if (GET_CODE (value) != CONST_DOUBLE)
2866: {
2867: #if WORDS_BIG_ENDIAN
2868: *first = const0_rtx;
2869: *second = value;
2870: #else
2871: *first = value;
2872: *second = const0_rtx;
2873: #endif
2874: }
2875: else if (GET_MODE (value) == VOIDmode
2876: /* This is the old way we did CONST_DOUBLE integers. */
2877: || GET_MODE_CLASS (GET_MODE (value)) == MODE_INT)
2878: {
2879: /* In an integer, the words are defined as most and least significant.
2880: So order them by the target's convention. */
2881: #if WORDS_BIG_ENDIAN
2882: *first = GEN_INT (CONST_DOUBLE_HIGH (value));
2883: *second = GEN_INT (CONST_DOUBLE_LOW (value));
2884: #else
2885: *first = GEN_INT (CONST_DOUBLE_LOW (value));
2886: *second = GEN_INT (CONST_DOUBLE_HIGH (value));
2887: #endif
2888: }
2889: else
2890: {
2891: #ifdef REAL_ARITHMETIC
2892: REAL_VALUE_TYPE r; HOST_WIDE_INT l[2];
2893: REAL_VALUE_FROM_CONST_DOUBLE (r, value);
2894: REAL_VALUE_TO_TARGET_DOUBLE (r, l);
2895: *first = GEN_INT (l[0]);
2896: *second = GEN_INT (l[1]);
2897: #else
2898: if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
2899: || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
2900: && ! flag_pretend_float)
2901: abort ();
2902:
2903: #if defined (HOST_WORDS_BIG_ENDIAN) == WORDS_BIG_ENDIAN
2904: /* Host and target agree => no need to swap. */
2905: *first = GEN_INT (CONST_DOUBLE_LOW (value));
2906: *second = GEN_INT (CONST_DOUBLE_HIGH (value));
2907: #else
2908: *second = GEN_INT (CONST_DOUBLE_LOW (value));
2909: *first = GEN_INT (CONST_DOUBLE_HIGH (value));
2910: #endif
2911: #endif /* no REAL_ARITHMETIC */
2912: }
2913: }
2914:
2915: /* Return nonzero if this function has no function calls. */
2916:
2917: int
2918: leaf_function_p ()
2919: {
2920: rtx insn;
2921:
2922: if (profile_flag || profile_block_flag)
2923: return 0;
2924:
2925: for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2926: {
2927: if (GET_CODE (insn) == CALL_INSN)
2928: return 0;
2929: if (GET_CODE (insn) == INSN
2930: && GET_CODE (PATTERN (insn)) == SEQUENCE
2931: && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == CALL_INSN)
2932: return 0;
2933: }
2934: for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
2935: {
2936: if (GET_CODE (XEXP (insn, 0)) == CALL_INSN)
2937: return 0;
2938: if (GET_CODE (XEXP (insn, 0)) == INSN
2939: && GET_CODE (PATTERN (XEXP (insn, 0))) == SEQUENCE
2940: && GET_CODE (XVECEXP (PATTERN (XEXP (insn, 0)), 0, 0)) == CALL_INSN)
2941: return 0;
2942: }
2943:
2944: return 1;
2945: }
2946:
2947: /* On some machines, a function with no call insns
2948: can run faster if it doesn't create its own register window.
2949: When output, the leaf function should use only the "output"
2950: registers. Ordinarily, the function would be compiled to use
2951: the "input" registers to find its arguments; it is a candidate
2952: for leaf treatment if it uses only the "input" registers.
2953: Leaf function treatment means renumbering so the function
2954: uses the "output" registers instead. */
2955:
2956: #ifdef LEAF_REGISTERS
2957:
2958: static char permitted_reg_in_leaf_functions[] = LEAF_REGISTERS;
2959:
2960: /* Return 1 if this function uses only the registers that can be
2961: safely renumbered. */
2962:
2963: int
2964: only_leaf_regs_used ()
2965: {
2966: int i;
2967:
2968: for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2969: {
2970: if ((regs_ever_live[i] || global_regs[i])
2971: && ! permitted_reg_in_leaf_functions[i])
2972: return 0;
2973: }
2974: return 1;
2975: }
2976:
2977: /* Scan all instructions and renumber all registers into those
2978: available in leaf functions. */
2979:
2980: static void
2981: leaf_renumber_regs (first)
2982: rtx first;
2983: {
2984: rtx insn;
2985:
2986: /* Renumber only the actual patterns.
2987: The reg-notes can contain frame pointer refs,
2988: and renumbering them could crash, and should not be needed. */
2989: for (insn = first; insn; insn = NEXT_INSN (insn))
2990: if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
2991: leaf_renumber_regs_insn (PATTERN (insn));
2992: for (insn = current_function_epilogue_delay_list; insn; insn = XEXP (insn, 1))
2993: if (GET_RTX_CLASS (GET_CODE (XEXP (insn, 0))) == 'i')
2994: leaf_renumber_regs_insn (PATTERN (XEXP (insn, 0)));
2995: }
2996:
2997: /* Scan IN_RTX and its subexpressions, and renumber all regs into those
2998: available in leaf functions. */
2999:
3000: void
3001: leaf_renumber_regs_insn (in_rtx)
3002: register rtx in_rtx;
3003: {
3004: register int i, j;
3005: register char *format_ptr;
3006:
3007: if (in_rtx == 0)
3008: return;
3009:
3010: /* Renumber all input-registers into output-registers.
3011: renumbered_regs would be 1 for an output-register;
3012: they */
3013:
3014: if (GET_CODE (in_rtx) == REG)
3015: {
3016: int newreg;
3017:
3018: /* Don't renumber the same reg twice. */
3019: if (in_rtx->used)
3020: return;
3021:
3022: newreg = REGNO (in_rtx);
3023: /* Don't try to renumber pseudo regs. It is possible for a pseudo reg
3024: to reach here as part of a REG_NOTE. */
3025: if (newreg >= FIRST_PSEUDO_REGISTER)
3026: {
3027: in_rtx->used = 1;
3028: return;
3029: }
3030: newreg = LEAF_REG_REMAP (newreg);
3031: if (newreg < 0)
3032: abort ();
3033: regs_ever_live[REGNO (in_rtx)] = 0;
3034: regs_ever_live[newreg] = 1;
3035: REGNO (in_rtx) = newreg;
3036: in_rtx->used = 1;
3037: }
3038:
3039: if (GET_RTX_CLASS (GET_CODE (in_rtx)) == 'i')
3040: {
3041: /* Inside a SEQUENCE, we find insns.
3042: Renumber just the patterns of these insns,
3043: just as we do for the top-level insns. */
3044: leaf_renumber_regs_insn (PATTERN (in_rtx));
3045: return;
3046: }
3047:
3048: format_ptr = GET_RTX_FORMAT (GET_CODE (in_rtx));
3049:
3050: for (i = 0; i < GET_RTX_LENGTH (GET_CODE (in_rtx)); i++)
3051: switch (*format_ptr++)
3052: {
3053: case 'e':
3054: leaf_renumber_regs_insn (XEXP (in_rtx, i));
3055: break;
3056:
3057: case 'E':
3058: if (NULL != XVEC (in_rtx, i))
3059: {
3060: for (j = 0; j < XVECLEN (in_rtx, i); j++)
3061: leaf_renumber_regs_insn (XVECEXP (in_rtx, i, j));
3062: }
3063: break;
3064:
3065: case 'S':
3066: case 's':
3067: case '0':
3068: case 'i':
3069: case 'w':
3070: case 'n':
3071: case 'u':
3072: break;
3073:
3074: default:
3075: abort ();
3076: }
3077: }
3078: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.