![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clipper.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc / config / clipper|
Return to clipper.c CVS log | Up to [Apple XNU] / GNUtools / cc / config / clipper |
1.1 root 1: /* Subroutines for insn-output.c for Clipper
2: Copyright (C) 1987, 1988, 1991 Free Software Foundation, Inc.
3:
4: Contributed by Holger Teutsch ([email protected])
5:
6: This file is part of GNU CC.
7:
8: GNU CC is free software; you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation; either version 2, or (at your option)
11: any later version.
12:
13: GNU CC is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with GNU CC; see the file COPYING. If not, write to
20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21:
22: #include <stdio.h>
23: #include "config.h"
24: #include "rtl.h"
25: #include "regs.h"
26: #include "hard-reg-set.h"
27: #include "real.h"
28: #include "insn-config.h"
29: #include "conditions.h"
30: #include "insn-flags.h"
31: #include "output.h"
32: #include "insn-attr.h"
33: #include "tree.h"
34: #include "c-tree.h"
35: #include "expr.h"
36: #include "flags.h"
37: #include "machmode.h"
38:
39: extern char regs_ever_live[];
40:
41: extern int frame_pointer_needed;
42:
43: static int frame_size;
44:
45: /*
46: * compute size of a clipper stack frame where 'lsize' is the required
47: * space for local variables.
48: */
49:
50: int
51: clipper_frame_size (lsize)
52: int lsize;
53: {
54: int i,size; /* total size of frame */
55: int save_size;
56: save_size = 0; /* compute size for reg saves */
57:
58: for (i = 16; i < 32; i++)
59: if (regs_ever_live[i] && !call_used_regs[i])
60: save_size += 8;
61:
62: for (i = 0; i < 16; i++)
63: if (regs_ever_live[i] && !call_used_regs[i])
64: save_size += 4;
65:
66: size = lsize + save_size;
67:
68: size = (size + 7) & ~7; /* align to 64 Bit */
69: return size;
70: }
71:
72: /*
73: * prologue and epilogue output
74: * function is entered with pc pushed, i.e. stack is 32 bit aligned
75: *
76: * current_function_args_size == 0 means that the current function's args
77: * are passed totally in registers i.e fp is not used as ap.
78: * If frame_size is also 0 the current function does not push anything and
79: * can run with misaligned stack -> subq $4,sp / add $4,sp on entry and exit
80: * can be omitted.
81: *
82: */
83: void
84: output_function_prologue (file, lsize)
85: FILE *file;
86: int lsize; /* size for locals */
87: {
88: int i, offset;
89: int size;
90:
91: frame_size = size = clipper_frame_size (lsize);
92:
93: if (frame_pointer_needed)
94: {
95: fputs ("\tpushw fp,sp\n", file);
96: fputs ("\tmovw sp,fp\n", file);
97: }
98: else if (size != 0 || current_function_args_size != 0)
99: {
100: size += 4; /* keep stack aligned */
101: frame_size = size; /* must push data or access args */
102: }
103:
104: if (size)
105: {
106: if (size < 16)
107: fprintf (file, "\tsubq $%d,sp\n", size);
108: else
109: fprintf (file, "\tsubi $%d,sp\n", size);
110:
111: /* register save slots are relative to sp, because we have small positive
112: displacements and this works whether we have a frame pointer or not */
113:
114: offset = 0;
115: for (i = 16; i < 32; i++)
116: if (regs_ever_live[i] && !call_used_regs[i])
117: {
118: if (offset == 0)
119: fprintf (file, "\tstord f%d,(sp)\n", i-16);
120: else
121: fprintf (file, "\tstord f%d,%d(sp)\n", i-16, offset);
122: offset += 8;
123: }
124:
125: for (i = 0; i < 16; i++)
126: if (regs_ever_live[i] && !call_used_regs[i])
127: {
128: if (offset == 0)
129: fprintf (file, "\tstorw r%d,(sp)\n", i);
130: else
131: fprintf (file, "\tstorw r%d,%d(sp)\n", i, offset);
132: offset += 4;
133: }
134: }
135: }
136:
137: void
138: output_function_epilogue (file, size)
139: FILE *file;
140: int size; /* ignored */
141: {
142: int i, offset;
143:
144: if (frame_pointer_needed)
145: {
146: offset = -frame_size;
147:
148: for (i = 16; i < 32; i++)
149: if (regs_ever_live[i] && !call_used_regs[i])
150: {
151: fprintf (file, "\tloadd %d(fp),f%d\n", offset, i-16);
152: offset += 8;
153: }
154:
155: for (i = 0; i < 16; i++)
156: if (regs_ever_live[i] && !call_used_regs[i])
157: {
158: fprintf (file, "\tloadw %d(fp),r%d\n", offset, i);
159: offset += 4;
160: }
161:
162: fputs ("\tmovw fp,sp\n\tpopw sp,fp\n\tret sp\n",
163: file);
164: }
165:
166: else /* no frame pointer */
167: {
168: offset = 0;
169:
170: for (i = 16; i < 32; i++)
171: if (regs_ever_live[i] && !call_used_regs[i])
172: {
173: if (offset == 0)
174: fprintf (file, "\tloadd (sp),f%d\n", i-16);
175: else
176: fprintf (file, "\tloadd %d(sp),f%d\n", offset, i-16);
177: offset += 8;
178: }
179:
180: for (i = 0; i < 16; i++)
181: if (regs_ever_live[i] && !call_used_regs[i])
182: {
183: if (offset == 0)
184: fprintf (file, "\tloadw (sp),r%d\n", i);
185: else
186: fprintf (file, "\tloadw %d(sp),r%d\n", offset, i);
187: offset += 4;
188: }
189:
190: if (frame_size > 0)
191: {
192: if (frame_size < 16)
193: fprintf (file, "\taddq $%d,sp\n", frame_size);
194: else
195: fprintf (file, "\taddi $%d,sp\n", frame_size);
196: }
197:
198: fputs ("\tret sp\n", file);
199: }
200: }
201:
202: /*
203: * blockmove
204: *
205: * clipper_movstr ()
206: */
207: void
208: clipper_movstr (operands)
209: rtx *operands;
210: {
211: rtx dst,src,cnt,tmp,top,bottom,xops[3];
212: int align;
213: int fixed;
214:
215: extern FILE *asm_out_file;
216:
217: dst = operands[0];
218: src = operands[1];
219: /* don't change this operands[2]; gcc 2.3.3 doesn't honor clobber note */
220: align = INTVAL (operands[3]);
221: tmp = operands[4];
222: cnt = operands[5];
223:
224: if (GET_CODE (operands[2]) == CONST_INT) /* fixed size move */
225: {
226: if ((fixed = INTVAL (operands[2])) <= 0)
227: abort ();
228:
229: if (fixed <16)
230: output_asm_insn ("loadq %2,%5", operands);
231: else
232: output_asm_insn ("loadi %2,%5", operands);
233: }
234: else
235: {
236: fixed = 0;
237: bottom = (rtx)gen_label_rtx (); /* need a bottom label */
238: xops[0] = cnt; xops[1] = bottom;
239: output_asm_insn ("movw %2,%5", operands); /* count is scratch reg 5 */
240: output_asm_insn ("brle %l1", xops);
241: }
242:
243:
244: top = (rtx)gen_label_rtx (); /* top of loop label */
245: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (top));
246:
247:
248: xops[0] = src; xops[1] = tmp; xops[2] = dst;
249:
250: if (fixed && (align & 0x3) == 0) /* word aligned move with known size */
251: {
252: if (fixed >= 4)
253: {
254: rtx xops1[2];
255: output_asm_insn(
256: "loadw %a0,%1\n\taddq $4,%0\n\tstorw %1,%a2\n\taddq $4,%2",
257: xops);
258:
259: xops1[0] = cnt; xops1[1] = top;
260: output_asm_insn ("subq $4,%0\n\tbrgt %l1", xops1);
261: }
262:
263: if (fixed & 0x2)
264: {
265: output_asm_insn ("loadh %a0,%1\n\tstorh %1,%a2", xops);
266: if (fixed & 0x1)
267: output_asm_insn ("loadb 2%a0,%1\n\tstorb %1,2%a2", xops);
268: }
269: else
270: if (fixed & 0x1)
271: output_asm_insn ("loadb %a0,%1\n\tstorb %1,%a2", xops);
272: }
273: else
274: {
275: output_asm_insn(
276: "loadb %a0,%1\n\taddq $1,%0\n\tstorb %1,%a2\n\taddq $1,%2",
277: xops);
278:
279: xops[0] = cnt; xops[1] = top;
280: output_asm_insn ("subq $1,%0\n\tbrgt %l1", xops);
281: }
282:
283: if (fixed == 0)
284: ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "L", CODE_LABEL_NUMBER (bottom));
285: }
286:
287:
288: print_operand_address (file, addr)
289: FILE *file;
290: register rtx addr;
291: {
292: rtx op0,op1;
293:
294: retry:
295: switch (GET_CODE (addr))
296: {
297: case REG:
298: fprintf (file, "(%s)", reg_names[REGNO (addr)]);
299: break;
300:
301: case PLUS:
302: /* can be 'symbol + reg' or 'reg + reg' */
303:
304: op0 = XEXP (addr, 0);
305: op1 = XEXP (addr, 1);
306:
307: if (GET_CODE (op0) == REG && GET_CODE (op1) == REG)
308: {
309: fprintf (file, "[%s](%s)",
310: reg_names[REGNO (op0)], reg_names[REGNO (op1)]);
311: break;
312: }
313:
314: if (GET_CODE (op0) == REG && CONSTANT_ADDRESS_P (op1))
315: {
316: output_addr_const (file, op1);
317: fprintf (file, "(%s)", reg_names[REGNO (op0)]);
318: break;
319: }
320:
321: if (GET_CODE (op1) == REG && CONSTANT_ADDRESS_P (op0))
322: {
323: output_addr_const (file, op0);
324: fprintf (file, "(%s)", reg_names[REGNO (op1)]);
325: break;
326: }
327: abort (); /* Oh no */
328:
329: default:
330: output_addr_const (file, addr);
331: }
332: }
333:
334:
335: char *
336: rev_cond_name (op)
337: rtx op;
338: {
339: switch (GET_CODE (op))
340: {
341: case EQ:
342: return "ne";
343: case NE:
344: return "eq";
345: case LT:
346: return "ge";
347: case LE:
348: return "gt";
349: case GT:
350: return "le";
351: case GE:
352: return "lt";
353: case LTU:
354: return "geu";
355: case LEU:
356: return "gtu";
357: case GTU:
358: return "leu";
359: case GEU:
360: return "ltu";
361:
362: default:
363: abort ();
364: }
365: }
366:
367:
368: /* Do what is necessary for `va_start'. The argument is ignored;
369: We fill in an initial va_list. A pointer to this constructor
370: is returned. */
371:
372:
373: struct rtx_def *
374: clipper_builtin_saveregs (arglist)
375: tree arglist;
376: {
377: extern int current_function_varargs;
378: rtx block, addr, argsize, scratch, r0_addr,r1_addr,f0_addr,f1_addr;
379:
380: /* Allocate the va_list constructor + save area for r0,r1,f0,f1 */
381:
382: block = assign_stack_local (BLKmode,
383: (6 + 6) * UNITS_PER_WORD, 2 * BITS_PER_WORD);
384:
385: RTX_UNCHANGING_P (block) = 1;
386: RTX_UNCHANGING_P (XEXP (block, 0)) = 1;
387:
388: addr = copy_to_reg (XEXP (block, 0));
389:
390: f0_addr = gen_rtx (PLUS, Pmode, addr, gen_rtx (CONST_INT, Pmode, 24));
391: f1_addr = gen_rtx (PLUS, Pmode, addr, gen_rtx (CONST_INT, Pmode, 32));
392: r0_addr = gen_rtx (PLUS, Pmode, addr, gen_rtx (CONST_INT, Pmode, 40));
393: r1_addr = gen_rtx (PLUS, Pmode, addr, gen_rtx (CONST_INT, Pmode, 44));
394:
395:
396: /* Store float regs */
397:
398: emit_move_insn (gen_rtx (MEM, DFmode, f0_addr), gen_rtx (REG, DFmode, 16));
399: emit_move_insn (gen_rtx (MEM, DFmode, f1_addr), gen_rtx (REG, DFmode, 17));
400:
401: /* Store int regs */
402:
403: emit_move_insn (gen_rtx (MEM, SImode, r0_addr), gen_rtx (REG, SImode, 0));
404: emit_move_insn (gen_rtx (MEM, SImode, r1_addr), gen_rtx (REG, SImode, 1));
405:
406: /* Store the arg pointer in the __va_stk member. */
407:
408: emit_move_insn (gen_rtx (MEM, SImode, addr),
409: copy_to_reg (virtual_incoming_args_rtx));
410:
411:
412: /* now move addresses of the saved regs into the pointer array */
413:
414: scratch = gen_reg_rtx (Pmode);
415:
416: emit_move_insn (scratch, r0_addr);
417: emit_move_insn (gen_rtx (MEM, SImode,
418: gen_rtx (PLUS, Pmode, addr,
419: gen_rtx (CONST_INT, Pmode, 4))),
420: scratch);
421:
422: emit_move_insn (scratch, f0_addr);
423: emit_move_insn (gen_rtx (MEM, SImode,
424: gen_rtx (PLUS, Pmode, addr,
425: gen_rtx (CONST_INT, Pmode, 8))),
426: scratch);
427:
428: emit_move_insn (scratch, r1_addr);
429: emit_move_insn (gen_rtx (MEM, SImode,
430: gen_rtx (PLUS, Pmode, addr,
431: gen_rtx (CONST_INT, Pmode, 12))),
432: scratch);
433:
434: emit_move_insn (scratch, f1_addr);
435: emit_move_insn (gen_rtx (MEM, SImode,
436: gen_rtx (PLUS, Pmode, addr,
437: gen_rtx (CONST_INT, Pmode, 16))),
438: scratch);
439:
440: /* Return the address of the va_list constructor, but don't put it in a
441: register. This fails when not optimizing and produces worse code when
442: optimizing. */
443:
444: return XEXP (block, 0);
445: }
446:
447:
448: /* Return truth value of whether OP can be used as an word register
449: operand. Reject (SUBREG:SI (REG:SF )) */
450:
451: int
452: int_reg_operand (op, mode)
453: rtx op;
454: enum machine_mode mode;
455: {
456: return (register_operand (op, mode) &&
457: (GET_CODE (op) != SUBREG ||
458: GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) == MODE_INT));
459: }
460:
461: /* Return truth value of whether OP can be used as a float register
462: operand. Reject (SUBREG:SF (REG:SI )) )) */
463:
464: int
465: fp_reg_operand (op, mode)
466: rtx op;
467: enum machine_mode mode;
468: {
469: return (register_operand (op, mode) &&
470: (GET_CODE (op) != SUBREG ||
471: GET_MODE_CLASS (GET_MODE (SUBREG_REG (op))) == MODE_FLOAT));
472: }
473:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.