![[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 [Research Unix] / researchv10dc / cmd / gcc|
Return to final.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Convert RTL to assembler code and output it, for GNU compiler.
2: Copyright (C) 1987, 1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* This is the final pass of the compiler.
23: It looks at the rtl code for a function and outputs assembler code.
24:
25: Call `final_start_function' to output the assembler code for function entry,
26: `final' to output assembler code for some RTL code,
27: `final_end_function' to output assembler code for function exit.
28: If a function is compiled in several pieces, each piece is
29: output separately with `final'.
30:
31: Some optimizations are also done at this level.
32: Move instructions that were made unnecessary by good register allocation
33: are detected and omitted from the output. (Though most of these
34: are removed by the last jump pass.)
35:
36: Instructions to set the condition codes are omitted when it can be
37: seen that the condition codes already had the desired values.
38:
39: In some cases it is sufficient if the inherited condition codes
40: have related values, but this may require the following insn
41: (the one that tests the condition codes) to be modified.
42:
43: The code for the function prologue and epilogue are generated
44: directly as assembler code by the macros FUNCTION_PROLOGUE and
45: FUNCTION_EPILOGUE. Those instructions never exist as rtl. */
46:
47: #include <stdio.h>
48: #include "config.h"
49: #include "rtl.h"
50: #include "regs.h"
51: #include "insn-config.h"
52: #include "recog.h"
53: #include "conditions.h"
54: #include "gdbfiles.h"
55:
56: /* Get N_SLINE and N_SOL from stab.h if we can expect the file to exist. */
57: #ifndef NO_DBX_FORMAT
58: #include <stab.h>
59: #endif
60:
61: /* .stabd code for line number. */
62: #ifndef N_SLINE
63: #define N_SLINE 0x44
64: #endif
65:
66: /* .stabs code for included file name. */
67: #ifndef N_SOL
68: #define N_SOL 0x84
69: #endif
70:
71: #define min(A,B) ((A) < (B) ? (A) : (B))
72:
73: void output_asm_insn ();
74: static void alter_subreg ();
75: static int alter_cond ();
76: void output_asm_label ();
77: static void output_operand ();
78: void output_address ();
79: void output_addr_const ();
80: static void output_source_line ();
81:
82: static char *reg_name[] = REGISTER_NAMES;
83:
84: /* File in which assembler code is being written. */
85:
86: extern FILE *asm_out_file;
87:
88: /* All the symbol-blocks (levels of scoping) in the compilation
89: are assigned sequence numbers in order of appearance of the
90: beginnings of the symbol-blocks. Both final and dbxout do this,
91: and assume that they will both give the same number to each block.
92: Final uses these sequence numbers to generate assembler label names
93: LBBnnn and LBEnnn for the beginning and end of the symbol-block.
94: Dbxout uses the sequence nunbers to generate references to the same labels
95: from the dbx debugging information. */
96:
97: static next_block_index;
98:
99: /* Chain of all `struct gdbfile's. */
100:
101: struct gdbfile *gdbfiles;
102:
103: /* `struct gdbfile' for the last file we wrote a line number for. */
104:
105: static struct gdbfile *current_gdbfile;
106:
107: /* Filenum to assign to the next distinct source file encountered. */
108:
109: static int next_gdb_filenum;
110:
111: /* This variable contains machine-dependent flags (defined in tm-...h)
112: set and examined by output routines
113: that describe how to interpret the condition codes properly. */
114:
115: CC_STATUS cc_status;
116:
117: /* During output of an insn, this contains a copy of cc_status
118: from before the insn. */
119:
120: CC_STATUS cc_prev_status;
121:
122: /* Last source file name mentioned in a NOTE insn. */
123:
124: static char *lastfile;
125:
126: /* Indexed by hardware reg number, is 1 if that register is ever
127: used in the current function.
128:
129: In life_analysis, or in stupid_life_analysis, this is set
130: up to record the hard regs used explicitly. Reload adds
131: in the hard regs used for holding pseudo regs. Final uses
132: it to generate the code in the function prologue and epilogue
133: to save and restore registers as needed. */
134:
135: char regs_ever_live[FIRST_PSEUDO_REGISTER];
136:
137: /* Nonzero means current function must be given a frame pointer.
138: Set in stmt.c if anything is allocated on the stack there.
139: Set in reload1.c if anything is allocated on the stack there. */
140:
141: int frame_pointer_needed;
142:
143: /* Assign unique numbers to labels generated for profiling. */
144:
145: int profile_label_no;
146:
147: /* Length so far allocated in PENDING_BLOCKS. */
148:
149: static int max_block_depth;
150:
151: /* Stack of sequence numbers of symbol-blocks of which we have seen the
152: beginning but not yet the end. Sequence numbers are assigned at
153: the beginning; this stack allows us to find the sequence number
154: of a block that is ending. */
155:
156: static int *pending_blocks;
157:
158: /* Number of elements currently in use in PENDING_BLOCKS. */
159:
160: static int block_depth;
161:
162: /* Nonzero if have enabled APP processing of our assembler output. */
163:
164: static int app_on;
165:
166: /* Initialize data in final at the beginning of a compilation. */
167:
168: void
169: init_final (filename)
170: char *filename;
171: {
172: next_block_index = 2;
173: lastfile = filename;
174: app_on = 0;
175: max_block_depth = 20;
176: pending_blocks = (int *) xmalloc (20 * sizeof *pending_blocks);
177: gdbfiles = 0;
178: next_gdb_filenum = 0;
179: }
180:
181: /* Enable APP processing of subsequent output.
182: Used before the output from an `asm' statement. */
183:
184: void
185: app_enable ()
186: {
187: if (! app_on)
188: {
189: fprintf (asm_out_file, ASM_APP_ON);
190: app_on = 1;
191: }
192: }
193:
194: /* Enable APP processing of subsequent output.
195: Called from varasm.c before most kinds of output. */
196:
197: void
198: app_disable ()
199: {
200: if (app_on)
201: {
202: fprintf (asm_out_file, ASM_APP_OFF);
203: app_on = 0;
204: }
205: }
206:
207: /* Output assembler code for the start of a function,
208: and initialize some of the variables in this file
209: for the new function. The label for the function and associated
210: assembler pseudo-ops have already been output in `assemble_function'.
211:
212: FIRST is the first insn of the rtl for the function being compiled.
213: FILE is the file to write assembler code to.
214: WRITE_SYMBOLS is 1 for gdb symbols, 2 for dbx symbols.
215: OPTIMIZE is nonzero if we should eliminate redundant
216: test and compare insns. */
217:
218: void
219: final_start_function (first, file, write_symbols, optimize)
220: rtx first;
221: FILE *file;
222: int write_symbols;
223: int optimize;
224: {
225: extern int profile_flag;
226:
227: init_recog ();
228:
229: block_depth = 0;
230:
231: /* Record beginning of the symbol-block that's the entire function. */
232:
233: if (write_symbols == 1)
234: {
235: pending_blocks[block_depth++] = next_block_index;
236: fprintf (file, "\t.gdbbeg %d\n", next_block_index++);
237: }
238:
239: /* Initial line number is supposed to be output
240: before the function's prologue and label
241: so that the function's address will not appear to be
242: in the last statement of the preceding function. */
243: if (NOTE_LINE_NUMBER (first) != NOTE_INSN_DELETED)
244: output_source_line (file, first, write_symbols);
245:
246: #ifdef FUNCTION_PROLOGUE
247: /* First output the function prologue: code to set up the stack frame. */
248: FUNCTION_PROLOGUE (file, get_frame_size ());
249: #endif
250:
251: if (profile_flag)
252: {
253: int align = min (BIGGEST_ALIGNMENT, BITS_PER_WORD);
254: fprintf (file, "\t%s\n", DATA_SECTION_ASM_OP);
255: ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
256: ASM_OUTPUT_INTERNAL_LABEL (file, "LP", profile_label_no);
257: assemble_integer_zero ();
258: fprintf (file, "\t%s\n", TEXT_SECTION_ASM_OP);
259: FUNCTION_PROFILER (file, profile_label_no);
260: profile_label_no++;
261: }
262:
263: CC_STATUS_INIT;
264: }
265:
266: /* Output assembler code for the end of a function.
267: For clarity, args are same as those of `final_start_function'
268: even though not all of them are needed. */
269:
270: void
271: final_end_function (first, file, write_symbols, optimize)
272: rtx first;
273: FILE *file;
274: int write_symbols;
275: int optimize;
276: {
277: if (app_on)
278: {
279: fprintf (file, ASM_APP_OFF);
280: app_on = 0;
281: }
282:
283: if (write_symbols == 1)
284: fprintf (file, "\t.gdbend %d\n", pending_blocks[0]);
285:
286: #ifdef FUNCTION_EPILOGUE
287: /* Finally, output the function epilogue:
288: code to restore the stack frame and return to the caller. */
289: FUNCTION_EPILOGUE (file, get_frame_size ());
290: #endif
291:
292: /* If FUNCTION_EPILOGUE is not defined, then the function body
293: itself contains return instructions wherever needed. */
294: }
295:
296: /* Output assembler code for some insns: all or part of a function.
297: For description of args, see `final_start_function', above. */
298:
299: void
300: final (first, file, write_symbols, optimize)
301: rtx first;
302: FILE *file;
303: int write_symbols;
304: int optimize;
305: {
306: register rtx insn;
307: register int i;
308:
309: for (insn = NEXT_INSN (first); insn; insn = NEXT_INSN (insn))
310: {
311: switch (GET_CODE (insn))
312: {
313: case NOTE:
314: if (! write_symbols)
315: break;
316: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_FUNCTION_BEG)
317: abort (); /* Obsolete; shouldn't appear */
318: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG
319: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)
320: break;
321: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED)
322: break; /* An insn that was "deleted" */
323: if (app_on)
324: {
325: fprintf (file, ASM_APP_OFF);
326: app_on = 0;
327: }
328: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
329: {
330: /* Beginning of a symbol-block. Assign it a sequence number
331: and push the number onto the stack PENDING_BLOCKS. */
332:
333: if (block_depth == max_block_depth)
334: {
335: /* PENDING_BLOCKS is full; make it longer. */
336: max_block_depth *= 2;
337: pending_blocks
338: = (int *) xrealloc (pending_blocks,
339: max_block_depth * sizeof (int));
340: }
341: pending_blocks[block_depth++] = next_block_index;
342:
343: /* Output debugging info about the symbol-block beginning. */
344:
345: if (write_symbols == 2)
346: ASM_OUTPUT_INTERNAL_LABEL (file, "LBB", next_block_index);
347: else
348: fprintf (file, "\t.gdbbeg %d\n", next_block_index);
349: next_block_index++;
350: }
351: else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
352: {
353: /* End of a symbol-block. Pop its sequence number off
354: PENDING_BLOCKS and output debugging info based on that. */
355:
356: if (write_symbols == 2)
357: {
358: if (block_depth > 0)
359: ASM_OUTPUT_INTERNAL_LABEL (file, "LBE",
360: pending_blocks[--block_depth]);
361: }
362: else
363: fprintf (file, "\t.gdbend %d\n", pending_blocks[--block_depth]);
364: }
365: else if (NOTE_LINE_NUMBER (insn) > 0)
366: /* This note is a line-number. */
367: output_source_line (file, insn, write_symbols);
368: break;
369:
370: case BARRIER:
371: break;
372:
373: case CODE_LABEL:
374: if (app_on)
375: {
376: fprintf (file, ASM_APP_OFF);
377: app_on = 0;
378: }
379: #ifdef ASM_OUTPUT_CASE_LABEL
380: if (NEXT_INSN (insn) != 0
381: && GET_CODE (NEXT_INSN (insn)) == JUMP_INSN)
382: {
383: rtx nextbody = PATTERN (NEXT_INSN (insn));
384:
385: /* If this label is followed by a jump-table,
386: output the two of them together in a special way. */
387:
388: if (GET_CODE (nextbody) == ADDR_VEC
389: || GET_CODE (nextbody) == ADDR_DIFF_VEC)
390: {
391: ASM_OUTPUT_CASE_LABEL (file, "L", CODE_LABEL_NUMBER (insn),
392: NEXT_INSN (insn));
393: break;
394: }
395: }
396: #endif
397:
398: ASM_OUTPUT_INTERNAL_LABEL (file, "L", CODE_LABEL_NUMBER (insn));
399: CC_STATUS_INIT;
400: break;
401:
402: default:
403: {
404: register rtx body = PATTERN (insn);
405: int insn_code_number;
406: char *template;
407:
408: /* An INSN, JUMP_INSN or CALL_INSN.
409: First check for special kinds that recog doesn't recognize. */
410:
411: if (GET_CODE (body) == USE /* These are just declarations */
412: || GET_CODE (body) == CLOBBER)
413: break;
414: if (GET_CODE (body) == ASM_INPUT)
415: {
416: if (! app_on)
417: {
418: fprintf (file, ASM_APP_ON);
419: app_on = 1;
420: }
421: fprintf (asm_out_file, "\t%s\n", XSTR (body, 0));
422:
423: /* There's no telling what that did to the condition codes. */
424: CC_STATUS_INIT;
425: break;
426: }
427:
428: /* Detect `asm' construct with operands. */
429: if (asm_noperands (body) > 0)
430: {
431: int noperands = asm_noperands (body);
432: rtx *ops = (rtx *) malloc (noperands * sizeof (rtx));
433: char *string;
434:
435: if (! app_on)
436: {
437: fprintf (file, ASM_APP_ON);
438: app_on = 1;
439: }
440:
441: /* Get out the operand values. */
442: string = decode_asm_operands (body, ops, 0, 0, 0);
443: /* Output the insn using them. */
444: output_asm_insn (string, ops);
445:
446: /* There's no telling what that did to the condition codes. */
447: CC_STATUS_INIT;
448: break;
449: }
450:
451: if (app_on)
452: {
453: fprintf (file, ASM_APP_OFF);
454: app_on = 0;
455: }
456:
457: /* Detect insns that are really jump-tables
458: and output them as such. */
459:
460: if (GET_CODE (body) == ADDR_VEC)
461: {
462: enum machine_mode mode = GET_MODE (body);
463: register int vlen, idx;
464: vlen = XVECLEN (body, 0);
465: for (idx = 0; idx < vlen; idx++)
466: ASM_OUTPUT_ADDR_VEC_ELT (file,
467: CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
468: break;
469: }
470: if (GET_CODE (body) == ADDR_DIFF_VEC)
471: {
472: enum machine_mode mode = GET_MODE (body);
473: register int vlen, idx;
474: vlen = XVECLEN (body, 1);
475: for (idx = 0; idx < vlen; idx++)
476: ASM_OUTPUT_ADDR_DIFF_ELT (file,
477: CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 1, idx), 0)),
478: CODE_LABEL_NUMBER (XEXP (XEXP (body, 0), 0)));
479: break;
480: }
481:
482: /* We have a real machine instruction as rtl. */
483:
484: body = PATTERN (insn);
485:
486: /* Check for redundant move insns moving a reg into itself.
487: This takes little time and does not affect the semantics
488: so we do it even when `optimize' is 0.
489: It is not safe to do this for memory references;
490: we would not know if they were volatile. */
491: if (GET_CODE (body) == SET
492: && SET_DEST (body) == SET_SRC (body)
493: && GET_CODE (SET_DEST (body)) == REG)
494: break;
495:
496: /* Check for redundant test and compare instructions
497: (when the condition codes are already set up as desired).
498: This is done only when optimizing; if not optimizing,
499: it should be possible for the user to alter a variable
500: with the debugger in between statements
501: and the next statement should reexamine the variable
502: to compute the condition codes. */
503:
504: if (optimize
505: && GET_CODE (body) == SET
506: && GET_CODE (SET_DEST (body)) == CC0)
507: {
508: if (GET_CODE (SET_SRC (body)) == SUBREG)
509: alter_subreg (SET_SRC (body));
510: if ((cc_status.value1 != 0
511: && rtx_equal_p (SET_SRC (body), cc_status.value1))
512: || (cc_status.value2 != 0
513: && rtx_equal_p (SET_SRC (body), cc_status.value2)))
514: {
515: /* Don't delete insn if has an addressing side-effect */
516: if (! find_reg_note (insn, REG_INC, 0))
517: break;
518: }
519: }
520:
521: /* If this is a conditional branch, maybe modify it
522: if the cc's are in a nonstandard state
523: so that it accomplishes the same thing that it would
524: do straightforwardly if the cc's were set up normally. */
525:
526: if (cc_status.flags != 0
527: && GET_CODE (insn) == JUMP_INSN
528: && GET_CODE (body) == SET
529: && SET_DEST (body) == pc_rtx
530: && GET_CODE (SET_SRC (body)) == IF_THEN_ELSE)
531: {
532: /* This function may alter the contents of its argument
533: and clear some of the cc_status.flags bits.
534: It may also return 1 meaning condition now always true
535: or -1 meaning condition now always false
536: or 2 meaning condition nontrivial but altered. */
537: register int result = alter_cond (XEXP (SET_SRC (body), 0));
538: /* If condition now has fixed value, replace the IF_THEN_ELSE
539: with its then-operand or its else-operand. */
540: if (result == 1)
541: SET_SRC (body) = XEXP (SET_SRC (body), 1);
542: if (result == -1)
543: SET_SRC (body) = XEXP (SET_SRC (body), 2);
544: /* The jump is now either unconditional or a no-op.
545: If it has become a no-op, don't try to output it.
546: (It would not be recognized.) */
547: if (SET_SRC (body) == pc_rtx)
548: continue;
549: /* Rerecognize the instruction if it has changed. */
550: if (result != 0)
551: INSN_CODE (insn) = -1;
552: }
553:
554: /* Make same adjustments to instructions that examine the
555: condition codes without jumping. */
556:
557: if (cc_status.flags != 0
558: && GET_CODE (body) == SET)
559: switch (GET_CODE (SET_SRC (body)))
560: {
561: case GTU:
562: case GT:
563: case LTU:
564: case LT:
565: case GEU:
566: case GE:
567: case LEU:
568: case LE:
569: case EQ:
570: case NE:
571: {
572: register int result = alter_cond (SET_SRC (body));
573: if (result == 1)
574: SET_SRC (body) = gen_rtx (CONST_INT, VOIDmode, -1);
575: if (result == -1)
576: SET_SRC (body) = const0_rtx;
577: if (result != 0)
578: INSN_CODE (insn) = -1;
579: }
580: }
581:
582: /* Try to recognize the instruction.
583: If successful, verify that the operands satisfy the
584: constraints for the instruction. Crash if they don't,
585: since `reload' should have changed them so that they do. */
586:
587: insn_code_number = recog_memoized (insn);
588: insn_extract (insn);
589: for (i = 0; i < insn_n_operands[insn_code_number]; i++)
590: if (GET_CODE (recog_operand[i]) == SUBREG)
591: alter_subreg (recog_operand[i]);
592:
593: #ifdef REGISTER_CONSTRAINTS
594: if (! constrain_operands (insn_code_number))
595: abort ();
596: #endif
597:
598: cc_prev_status = cc_status;
599:
600: /* Update `cc_status' for this instruction.
601: The instruction's output routine may change it further.
602: This should be a no-op for jump instructions
603: because their output routines may need to examine `cc_status',
604: below. That's ok since jump insns don't normally alter
605: the condition codes. */
606:
607: NOTICE_UPDATE_CC (body);
608:
609: /* If the proper template needs to be chosen by some C code,
610: run that code and get the real template. */
611:
612: template = insn_template[insn_code_number];
613: if (template == 0)
614: template = insn_outfun[insn_code_number] (recog_operand, insn);
615:
616: /* Output assembler code from the template. */
617:
618: output_asm_insn (template, recog_operand);
619: }
620: }
621: }
622: }
623:
624: /* Set up FILENAME as the current file for GDB line-number output. */
625:
626: void
627: set_current_gdbfile (filename)
628: char *filename;
629: {
630: register struct gdbfile *f;
631: for (f = gdbfiles; f; f = f->next)
632: if (!strcmp (f->name, filename))
633: break;
634:
635: if (!f)
636: {
637: f = (struct gdbfile *) permalloc (sizeof (struct gdbfile));
638: f->next = gdbfiles;
639: gdbfiles = f;
640: f->name = filename;
641: f->filenum = next_gdb_filenum++;
642: f->nlines = 0;
643: }
644: current_gdbfile = f;
645: lastfile = filename;
646: }
647:
648: /* Output debugging info to the assembler file FILE
649: based on the NOTE-insn INSN, assumed to be a line number. */
650:
651: static void
652: output_source_line (file, insn, write_symbols)
653: FILE *file;
654: rtx insn;
655: int write_symbols;
656: {
657: register char *filename = NOTE_SOURCE_FILE (insn);
658: if (write_symbols == 1)
659: {
660: /* Output GDB-format line number info. */
661:
662: /* If this is not the same source file as last time,
663: find or assign a GDB-file-number to this file. */
664: if (filename && (lastfile == 0 || strcmp (filename, lastfile)
665: || current_gdbfile == 0))
666: set_current_gdbfile (filename);
667:
668: ++current_gdbfile->nlines;
669: fprintf (file, "\t.gdbline %d,%d\n",
670: current_gdbfile->filenum, NOTE_LINE_NUMBER (insn));
671: }
672: else
673: {
674: /* Write DBX line number data. */
675:
676: if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
677: #ifdef ASM_OUTPUT_SOURCE_FILENAME
678: ASM_OUTPUT_SOURCE_FILENAME (file, filename);
679: #else
680: fprintf (file, "\t.stabs \"%s\",%d,0,0,Ltext\n",
681: filename, N_SOL);
682: #endif
683: lastfile = filename;
684:
685: #ifdef ASM_OUTPUT_SOURCE_LINE
686: ASM_OUTPUT_SOURCE_LINE (file, NOTE_LINE_NUMBER (insn));
687: #else
688: fprintf (file, "\t.stabd %d,0,%d\n",
689: N_SLINE, NOTE_LINE_NUMBER (insn));
690: #endif
691: }
692: }
693:
694: /* If X is a SUBREG, replace it with a REG or a MEM,
695: based on the thing it is a subreg of. */
696:
697: static void
698: alter_subreg (x)
699: register rtx x;
700: {
701: register rtx y = SUBREG_REG (x);
702: if (GET_CODE (y) == SUBREG)
703: alter_subreg (y);
704:
705: if (GET_CODE (y) == REG)
706: {
707: /* If the containing reg really gets a hard reg, so do we. */
708: PUT_CODE (x, REG);
709: REGNO (x) = REGNO (y) + SUBREG_WORD (x);
710: }
711: else if (GET_CODE (y) == MEM)
712: {
713: register int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
714: #ifdef BYTES_BIG_ENDIAN
715: offset -= (min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x)))
716: - min (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (y))));
717: #endif
718: PUT_CODE (x, MEM);
719: XEXP (x, 0) = plus_constant (XEXP (y, 0), offset);
720: }
721: }
722:
723: /* Do alter_subreg on all the SUBREGs contained in X. */
724:
725: static rtx
726: walk_alter_subreg (x)
727: rtx x;
728: {
729: switch (GET_CODE (x))
730: {
731: case PLUS:
732: case MULT:
733: XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
734: XEXP (x, 1) = walk_alter_subreg (XEXP (x, 1));
735: break;
736:
737: case MEM:
738: XEXP (x, 0) = walk_alter_subreg (XEXP (x, 0));
739: break;
740:
741: case SUBREG:
742: alter_subreg (x);
743: }
744:
745: return x;
746: }
747:
748: /* Given BODY, the body of a jump instruction, alter the jump condition
749: as required by the bits that are set in cc_status.flags.
750: Not all of the bits there can be handled at this level in all cases.
751: The bits that are taken care of here are cleared.
752:
753: The value is normally 0.
754: In this case, COND itself has usually been altered.
755: 1 means that the condition has become always true.
756: -1 means that the condition has become always false. */
757:
758: static int
759: alter_cond (cond)
760: register rtx cond;
761: {
762: int value = 0;
763:
764: if (cc_status.flags & CC_REVERSED)
765: {
766: value = 2;
767: switch (GET_CODE (cond))
768: {
769: case LE:
770: PUT_CODE (cond, GE);
771: break;
772: case GE:
773: PUT_CODE (cond, LE);
774: break;
775: case LT:
776: PUT_CODE (cond, GT);
777: break;
778: case GT:
779: PUT_CODE (cond, LT);
780: break;
781: case LEU:
782: PUT_CODE (cond, GEU);
783: break;
784: case GEU:
785: PUT_CODE (cond, LEU);
786: break;
787: case LTU:
788: PUT_CODE (cond, GTU);
789: break;
790: case GTU:
791: PUT_CODE (cond, LTU);
792: break;
793: }
794: }
795:
796: if (cond != 0 && cc_status.flags & CC_NOT_POSITIVE)
797: switch (GET_CODE (cond))
798: {
799: case LE:
800: case LEU:
801: case GEU:
802: /* Jump becomes unconditional. */
803: return 1;
804:
805: case GT:
806: case GTU:
807: case LTU:
808: /* Jump becomes no-op. */
809: return -1;
810:
811: case GE:
812: PUT_CODE (cond, EQ);
813: value = 2;
814: break;
815:
816: case LT:
817: PUT_CODE (cond, NE);
818: value = 2;
819: break;
820: }
821:
822: if (cond != 0 && cc_status.flags & CC_NOT_NEGATIVE)
823: switch (GET_CODE (cond))
824: {
825: case GE:
826: case GEU:
827: /* Jump becomes unconditional. */
828: return 1;
829:
830: case LT:
831: case LTU:
832: /* Jump becomes no-op. */
833: return -1;
834:
835: case LE:
836: case LEU:
837: PUT_CODE (cond, EQ);
838: value = 2;
839: break;
840:
841: case GT:
842: case GTU:
843: PUT_CODE (cond, NE);
844: value = 2;
845: break;
846: }
847:
848: if (cond != 0 && cc_status.flags & CC_NO_OVERFLOW)
849: switch (GET_CODE (cond))
850: {
851: case GEU:
852: /* Jump becomes unconditional. */
853: return 1;
854:
855: case LEU:
856: PUT_CODE (cond, EQ);
857: value = 2;
858: break;
859:
860: case GTU:
861: PUT_CODE (cond, NE);
862: value = 2;
863: break;
864:
865: case LTU:
866: /* Jump becomes no-op. */
867: return -1;
868: }
869:
870: return value;
871: }
872:
873: /* Output of assembler code from a template, and its subroutines. */
874:
875: /* Output text from TEMPLATE to the assembler output file,
876: obeying %-directions to substitute operands taken from
877: the vector OPERANDS.
878:
879: %N (for N a digit) means print operand N in usual manner.
880: %lN means require operand N to be a CODE_LABEL or LABEL_REF
881: and print the label name with no punctuation.
882: %cN means require operand N to be a constant
883: and print the constant expression with no punctuation.
884: %aN means expect operand N to be a memory address
885: (not a memory reference!) and print a reference
886: to that address.
887: %nN means expect operand N to be a constant
888: and print a constant expression for minus the value
889: of the operand, with no other punctuation. */
890:
891: void
892: output_asm_insn (template, operands)
893: char *template;
894: rtx *operands;
895: {
896: register char *p;
897: register int c;
898:
899: /* An insn may return a null string template
900: in a case where no assembler code is needed. */
901: if (*template == 0)
902: return;
903:
904: p = template;
905: putc ('\t', asm_out_file);
906:
907: #ifdef ASM_OUTPUT_OPCODE
908: ASM_OUTPUT_OPCODE (asm_out_file, p);
909: #endif
910:
911: while (c = *p++)
912: {
913: #ifdef ASM_OUTPUT_OPCODE
914: if (c == '\n')
915: {
916: putc (c, asm_out_file);
917: while ((c = *p) == '\t')
918: {
919: putc (c, asm_out_file);
920: p++;
921: }
922: ASM_OUTPUT_OPCODE (asm_out_file, p);
923: }
924: else
925: #endif
926: if (c != '%')
927: putc (c, asm_out_file);
928: else
929: {
930: /* %% outputs a single %. */
931: if (*p == '%')
932: {
933: p++;
934: putc (c, asm_out_file);
935: }
936: /* % followed by a letter and some digits
937: outputs an operand in a special way depending on the letter.
938: Letters `acln' are implemented here.
939: Other letters are passed to `output_operand' so that
940: the PRINT_OPERAND macro can define them. */
941: else if ((*p >= 'a' && *p <= 'z')
942: || (*p >= 'A' && *p <= 'Z'))
943: {
944: int letter = *p++;
945: c = atoi (p);
946:
947: if (letter == 'l')
948: output_asm_label (operands[c]);
949: else if (letter == 'a')
950: output_address (operands[c]);
951: else if (letter == 'c')
952: {
953: if (CONSTANT_ADDRESS_P (operands[c]))
954: output_addr_const (asm_out_file, operands[c]);
955: else
956: output_operand (operands[c], 'c');
957: }
958: else if (letter == 'n')
959: {
960: if (GET_CODE (operands[c]) == CONST_INT)
961: fprintf (asm_out_file, "%d", - INTVAL (operands[c]));
962: else
963: {
964: putc ('-', asm_out_file);
965: output_addr_const (asm_out_file, operands[c]);
966: }
967: }
968: else if (*p >= '0' && *p <= '9')
969: output_operand (operands[c], letter);
970: else
971: /* No operand-number follows the letter. */
972: output_operand (0, letter);
973:
974: while ((c = *p) >= '0' && c <= '9') p++;
975: }
976: /* % followed by a digit outputs an operand the default way. */
977: else if (*p >= '0' && *p <= '9')
978: {
979: c = atoi (p);
980: output_operand (operands[c], 0);
981: while ((c = *p) >= '0' && c <= '9') p++;
982: }
983: /* % followed by punctuation: output something for that
984: punctuation character alone, with no operand.
985: The PRINT_OPERAND macro decides what is actually done. */
986: else
987: output_operand (0, *p++);
988: }
989: }
990:
991: putc ('\n', asm_out_file);
992: }
993:
994: /* Output a LABEL_REF, or a bare CODE_LABEL, as an assembler symbol. */
995:
996: void
997: output_asm_label (x)
998: rtx x;
999: {
1000: char buf[20];
1001:
1002: if (GET_CODE (x) == LABEL_REF)
1003: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
1004: else if (GET_CODE (x) == CODE_LABEL)
1005: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
1006: else
1007: abort ();
1008:
1009: assemble_name (asm_out_file, buf);
1010: }
1011:
1012: /* Print operand X using machine-dependent assembler syntax.
1013: The macro PRINT_OPERAND is defined just to control this function.
1014: CODE is a non-digit that preceded the operand-number in the % spec,
1015: such as 'z' if the spec was `%z3'. CODE is 0 if there was no char
1016: between the % and the digits.
1017: When CODE is a non-letter, X is 0.
1018:
1019: The meanings of the letters are machine-dependent and controlled
1020: by PRINT_OPERAND. */
1021:
1022: static void
1023: output_operand (x, code)
1024: rtx x;
1025: int code;
1026: {
1027: if (x && GET_CODE (x) == SUBREG)
1028: alter_subreg (x);
1029: PRINT_OPERAND (asm_out_file, x, code);
1030: }
1031:
1032: /* Print a memory reference operand for address X
1033: using machine-dependent assembler syntax.
1034: The macro PRINT_OPERAND_ADDRESS exists just to control this function. */
1035:
1036: void
1037: output_address (x)
1038: rtx x;
1039: {
1040: walk_alter_subreg (x);
1041: PRINT_OPERAND_ADDRESS (asm_out_file, x);
1042: }
1043:
1044: /* Print an integer constant expression in assembler syntax.
1045: Addition and subtraction are the only arithmetic
1046: that may appear in these expressions. */
1047:
1048: void
1049: output_addr_const (file, x)
1050: FILE *file;
1051: rtx x;
1052: {
1053: char buf[20];
1054:
1055: restart:
1056: switch (GET_CODE (x))
1057: {
1058: case SYMBOL_REF:
1059: assemble_name (file, XSTR (x, 0));
1060: break;
1061:
1062: case LABEL_REF:
1063: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
1064: assemble_name (asm_out_file, buf);
1065: break;
1066:
1067: case CODE_LABEL:
1068: ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (x));
1069: assemble_name (asm_out_file, buf);
1070: break;
1071:
1072: case CONST_INT:
1073: fprintf (file, "%d", INTVAL (x));
1074: break;
1075:
1076: case CONST:
1077: x = XEXP (x, 0);
1078: goto restart;
1079:
1080: case PLUS:
1081: output_addr_const (file, XEXP (x, 0));
1082: fprintf (file, "+");
1083: output_addr_const (file, XEXP (x, 1));
1084: break;
1085:
1086: case MINUS:
1087: output_addr_const (file, XEXP (x, 0));
1088: fprintf (file, "-");
1089: output_addr_const (file, XEXP (x, 1));
1090: break;
1091:
1092: default:
1093: abort ();
1094: }
1095: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.