![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to h8300.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc / config / h8300|
Return to h8300.c CVS log | Up to [Apple XNU] / GNUtools / cc / config / h8300 |
1.1 root 1: /* Subroutines for insn-output.c for Hitachi H8/300.
2: Copyright (C) 1992,1993 Free Software Foundation, Inc.
3:
4: Contributed by Steve Chamberlain ([email protected]) and
5: Jim Wilson ([email protected]).
6:
7: This file is part of GNU CC.
8:
9: GNU CC is free software; you can redistribute it and/or modify
10: it under the terms of the GNU General Public License as published by
11: the Free Software Foundation; either version 2, or (at your option)
12: any later version.
13:
14: GNU CC is distributed in the hope that it will be useful,
15: but WITHOUT ANY WARRANTY; without even the implied warranty of
16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17: GNU General Public License for more details.
18:
19: You should have received a copy of the GNU General Public License
20: along with GNU CC; see the file COPYING. If not, write to
21: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22:
23: #include <stdio.h>
24: #include "config.h"
25: #include "rtl.h"
26: #include "regs.h"
27: #include "hard-reg-set.h"
28: #include "real.h"
29: #include "insn-config.h"
30: #include "conditions.h"
31: #include "insn-flags.h"
32: #include "output.h"
33: #include "insn-attr.h"
34: #include "flags.h"
35: #include "recog.h"
36: #include "expr.h"
37: #include "tree.h"
38:
39: /* Forward declarations. */
40: void print_operand_address ();
41: char *index ();
42:
43: /* True if a #pragma interrupt has been seen for the current function. */
44: int pragma_interrupt;
45:
46: /* True if a #pragma saveall has been seen for the current function. */
47: int pragma_saveall;
48:
49: char *names_big[]
50: = {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7"};
51:
52: char *
53: byte_reg (x, b)
54: rtx x;
55: int b;
56: {
57: static char *names_small[]
58: = {"r0l", "r0h", "r1l", "r1h", "r2l", "r2h", "r3l", "r3h",
59: "r4l", "r4h", "r5l", "r5h", "r6l", "r6h", "r7lBAD", "r7hBAD"};
60:
61: return names_small[REGNO (x) * 2 + b];
62: }
63:
64: /* REGNO must be saved/restored across calls if this macro is true. */
65: static int
66: word_reg_used (regno)
67: int regno;
68: {
69: if (regno < 7
70: && (pragma_interrupt || pragma_saveall
71: || (regno == FRAME_POINTER_REGNUM && regs_ever_live[regno])
72: || (regs_ever_live[regno] & ! call_used_regs[regno])))
73: return 1;
74: return 0;
75: }
76:
77: /* Output assembly language to FILE for the operation OP with operand size
78: SIZE. */
79: static void
80: dosize (file, op, size, fped)
81: FILE *file;
82: char *op;
83: unsigned int size;
84: int fped;
85: {
86: switch (size)
87: {
88: case 4:
89: case 3:
90: fprintf (file, "\t%ss\t#%d,sp\n", op, 2);
91: size -= 2;
92: /* Fall through... */
93: case 2:
94: case 1:
95: fprintf (file, "\t%ss\t#%d,sp\n", op, size);
96: size = 0;
97: break;
98: case 0:
99: break;
100: default:
101: fprintf (file, "\tmov.w\t#%d,r5\n\t%s.w\tr5,sp\n", size, op);
102: size = 0;
103: break;
104: }
105: }
106:
107: /* Output assembly language code for the function prologue. */
108: static int push_order[FIRST_PSEUDO_REGISTER]
109: = {6, 5, 4, 3, 2, 1, 0, -1, -1};
110: static int pop_order[FIRST_PSEUDO_REGISTER]
111: = {0, 1, 2, 3, 4, 5, 6, -1, -1};
112:
113: /* This is what the stack looks like after the prolog of
114: a function with a frame has been set up:
115:
116: <pushed args>
117: return pc
118: fp-> old fp
119: <locals>
120: <saved register-0>
121: <saved register-1>
122: sp-> <saved register-n>
123:
124:
125: This is what the stack looks like after the prolog of
126: a function which doesn't have a frame:
127:
128: <pushed args>
129: return pc
130: <locals>
131: <saved register-0>
132: sp-> <saved register-n>
133: */
134:
135: void
136: function_prologue (file, size)
137: FILE *file;
138: int size;
139: {
140: register int mask = 0;
141: int fsize = (size + 1) & -2;
142: int idx;
143:
144: if (frame_pointer_needed)
145: {
146: /* Push the fp. */
147: fprintf (file, "\tpush\t%s\n", names_big[FRAME_POINTER_REGNUM]);
148: fprintf (file, "\tmov.w\tr7,r6\n");
149:
150: /* Leave room for the locals. */
151: dosize (file, "sub", fsize, 1);
152:
153: /* Push the rest of the registers. */
154: for (idx = 0; idx < FIRST_PSEUDO_REGISTER; idx++)
155: {
156: int regno = push_order[idx];
157:
158: if (regno >= 0 && word_reg_used (regno)
159: && regno != FRAME_POINTER_REGNUM)
160: fprintf (file, "\tpush\t%s\n", names_big[regno]);
161: }
162: }
163: else
164: {
165: dosize (file, "sub", fsize, 0);
166: for (idx = 0; idx < FIRST_PSEUDO_REGISTER; idx++)
167: {
168: int regno = push_order[idx];
169:
170: if (regno >= 0 && word_reg_used (regno))
171: fprintf (file, "\tpush\t%s\n", names_big[regno]);
172: }
173: }
174: }
175:
176: /* Output assembly language code for the function epilogue. */
177:
178: void
179: function_epilogue (file, size)
180: FILE *file;
181: int size;
182: {
183: register int regno;
184: register int mask = 0;
185: int fsize = (size + 1) & -2;
186: int nregs;
187: int offset;
188: int idx;
189: rtx insn = get_last_insn ();
190:
191: /* If the last insn was a BARRIER, we don't have to write any code. */
192: if (GET_CODE (insn) == NOTE)
193: insn = prev_nonnote_insn (insn);
194: if (insn && GET_CODE (insn) == BARRIER)
195: return;
196:
197: nregs = 0;
198:
199: if (frame_pointer_needed)
200: {
201: /* Pop saved registers. */
202: for (idx = 0; idx < FIRST_PSEUDO_REGISTER; idx++)
203: {
204: regno = pop_order[idx];
205: if (regno >= 0 && regno != FRAME_POINTER_REGNUM
206: && word_reg_used (regno))
207: fprintf (file, "\tpop\t%s\n", names_big[regno]);
208: }
209: /* Deallocate locals. */
210: dosize (file, "add", fsize, 1);
211: /* Pop frame pointer. */
212: fprintf (file, "\tpop\t%s\n", names_big[FRAME_POINTER_REGNUM]);
213: }
214: else
215: {
216: /* Deallocate locals and pop saved registers. */
217: for (idx = 0; idx < FIRST_PSEUDO_REGISTER; idx++)
218: {
219: regno = pop_order[idx];
220: if (regno >= 0 && word_reg_used (regno))
221: fprintf (file, "\tpop\t%s\n", names_big[regno]);
222: }
223: dosize (file, "add", fsize, 0);
224: }
225: if (pragma_interrupt)
226: fprintf (file, "\trte\n");
227: else
228: fprintf (file, "\trts\n");
229:
230: pragma_interrupt = 0;
231: pragma_saveall = 0;
232: }
233:
234: /* Return true if VALUE is a valid constant for constraint 'P'. */
235:
236: int
237: potl8 (value)
238: {
239: switch (value)
240: {
241: case 1:
242: case 2:
243: case 4:
244: case 8:
245: case 16:
246: case 32:
247: case 64:
248: case 128:
249: return 1;
250: }
251: return 0;
252: }
253:
254: /* Return true if VALUE is a valid constant for constraint 'O'. */
255: int
256: potg8 (value)
257: int value;
258: {
259: switch (value)
260: {
261: case 256:
262: case 512:
263: case 1024:
264: case 2048:
265: case 4096:
266: case 8192:
267: case 16384:
268: case 32768:
269: return 1;
270: }
271: return 0;
272: }
273:
274: /* Return true is OP is a valid source operand for an integer move
275: instruction. */
276: int
277: general_operand_src (op, mode)
278: rtx op;
279: enum machine_mode mode;
280: {
281: /* We can't have a pre-dec as a source. */
282: if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == PRE_DEC)
283: return 0;
284: return general_operand (op, mode);
285: }
286:
287: /* Return true if OP is a valid destination operand for an integer move
288: instruction. */
289: int
290: general_operand_dst (op, mode)
291: rtx op;
292: enum machine_mode mode;
293: {
294: /* We can't have a post-inc as a dest. */
295: if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == POST_INC)
296: return 0;
297: return general_operand (op, mode);
298: }
299:
300: /* Handle machine specific pragmas for compatibility with existing
301: compilers for the H8/300
302:
303: pragma saveall generates prolog/epilog code which saves and
304: restores all the registers on function entry.
305:
306: pragma interrupt saves and restores all registers, and exits with
307: an rte instruction rather than an rts. A pointer to a function
308: with this attribute may be safely used in an interrupt vector. */
309: int
310: handle_pragma (file)
311: FILE *file;
312: {
313: int c;
314: char pbuf[20];
315: int psize;
316:
317: c = getc (file);
318: while (c == ' ' || c == '\t')
319: c = getc (file);
320:
321: if (c == '\n' || c == EOF)
322: return c;
323:
324: for (psize = 0; psize < sizeof (pbuf) - 1 && isalpha (c); psize++)
325: {
326: pbuf[psize] = c;
327: c = getc (file);
328: }
329:
330: pbuf[psize] = 0;
331:
332: if (strcmp (pbuf, "interrupt") == 0)
333: pragma_interrupt = 1;
334:
335: if (strcmp (pbuf, "saveall") == 0)
336: pragma_saveall = 1;
337:
338: return c;
339: }
340:
341: /* If the next arg with MODE and TYPE is to be passed in a register, return
342: the rtx to represent where it is passed. CUM represents the state after
343: the last argument. NAMED is not used. */
344:
345: rtx
346: function_arg (cum, mode, type, named)
347: CUMULATIVE_ARGS *cum;
348: enum machine_mode mode;
349: tree type;
350: int named;
351: {
352: rtx result = 0;
353: int libcall = 0;
354:
355: /* Right now reload has a problem with reg passing with small reg
356: classes. */
357:
358: if (cum->libcall || (named && TARGET_QUICKCALL))
359: libcall = 1;
360:
361: if (TARGET_NOQUICK)
362: libcall = 0;
363:
364: if (mode != VOIDmode && libcall && mode != DFmode && mode != SFmode)
365: {
366: switch (cum->nbytes)
367: {
368: case 0:
369: result = gen_rtx (REG, mode, 0);
370: break;
371: case 2:
372: result = gen_rtx (REG, mode, 1);
373: break;
374: case 4:
375: result = gen_rtx (REG, mode, 4);
376: break;
377: case 6:
378: result = gen_rtx (REG, mode, 5);
379: break;
380: default:
381: return 0;
382: }
383: }
384: return result;
385: }
386:
387: /* Documentation for the machine specific operand escapes:
388:
389: 'C' print (operand - 2).
390: 'E' low byte of reg or -ve lsb of constant
391: 'F' high byte of reg of -ve msb of constant
392:
393: 'G' negate constant
394: 'L' fake label, changed after used twice.
395: 'M' turn a 'M' constant into its negative mod 2.
396: 'T' print operand as a word
397: 'V' print log2 of constant - used for bset instructions
398: 'X' 8 bit register or other operand
399:
400: 'Y' print either l or h depending on whether last 'Z' operand < 8 or >= 8.
401: 'Z' print int & 7
402:
403: 'e' first word of 32 bit value
404: 'f' second word of 32 bit value
405:
406: 'j' print operand as condition code.
407: 'k' print operand as reverse condition code.
408:
409: 's' low byte of 16 bit value
410: 't' high byte of 16 bit value
411:
412: 'w' 1st byte of 32 bit value zzzzzzzz yyyyyyyy xxxxxxxx wwwwwwww
413: 'x' 2nd byte of 32 bit value
414: 'y' 3rd byte of 32 bit value
415: 'z' 4th byte of 32 bit value
416:
417: */
418:
419: /* Return assembly language string which identifies a comparison type. */
420:
421: char *
422: cond_string (code)
423: enum rtx_code code;
424: {
425: switch (code)
426: {
427: case NE:
428: return "ne";
429: case EQ:
430: return "eq";
431: case GE:
432: return "ge";
433: case GT:
434: return "gt";
435: case LE:
436: return "le";
437: case LT:
438: return "lt";
439: case GEU:
440: return "hs";
441: case GTU:
442: return "hi";
443: case LEU:
444: return "ls";
445: case LTU:
446: return "lo";
447: default:
448: abort ();
449: }
450: }
451:
452: /* Print operand X using operand code CODE to assembly language output file
453: FILE. */
454:
455: void
456: print_operand (file, x, code)
457: FILE *file;
458: rtx x;
459: int code;
460: {
461: /* This is used to general unique labels for the 'L' code. */
462: static int lab = 1000;
463:
464: /* This is used for communication between the 'P' and 'U' codes. */
465: static char *last_p;
466:
467: /* This is used for communication between the 'Z' and 'Y' codes. */
468: static int bitint;
469:
470: switch (code)
471: {
472: case 'L':
473: /* 'L' must always be used twice in a single pattern. It generates
474: the same lable twice, and then will generate a unique label the
475: next time it is used. */
476: asm_fprintf (file, "tl%d", (lab++) / 2);
477: break;
478:
479: case 'X':
480: if (GET_CODE (x) == REG)
481: fprintf (file, "%s", byte_reg (x, 0));
482: else
483: goto def;
484: break;
485:
486: case 'G':
487: if (GET_CODE (x) != CONST_INT)
488: abort ();
489: fprintf (file, "#%d", 0xff & (-INTVAL (x)));
490: break;
491:
492: case 'T':
493: if (GET_CODE (x) == REG)
494: fprintf (file, "%s", names_big[REGNO (x)]);
495: else
496: goto def;
497: break;
498:
499: case 'w':
500: if (GET_CODE (x) == CONST_INT)
501: fprintf (file, "#%d", INTVAL (x) & 0xff);
502: else
503: fprintf (file, "%s", byte_reg (x, 2));
504: break;
505:
506: case 'x':
507: if (GET_CODE (x) == CONST_INT)
508: fprintf (file, "#%d", (INTVAL (x) >> 8) & 0xff);
509: else
510: fprintf (file, "%s", byte_reg (x, 3));
511: break;
512:
513: case 'y':
514: if (GET_CODE (x) == CONST_INT)
515: fprintf (file, "#%d", (INTVAL (x) >> 16) & 0xff);
516: else
517: fprintf (file, "%s", byte_reg (x, 0));
518: break;
519:
520: case 'z':
521: if (GET_CODE (x) == CONST_INT)
522: fprintf (file, "#%d", (INTVAL (x) >> 24) & 0xff);
523: else
524: fprintf (file, "%s", byte_reg (x, 1));
525: break;
526:
527: /* FOR 16 bits. */
528: case 't':
529: if (GET_CODE (x) == CONST_INT)
530: fprintf (file, "#%d", (INTVAL (x) >> 8) & 0xff);
531: else
532: fprintf (file, "%s", byte_reg (x, 1));
533: break;
534:
535: case 's':
536: if (GET_CODE (x) == CONST_INT)
537: fprintf (file, "#%d", (INTVAL (x)) & 0xff);
538: else
539: fprintf (file, "%s", byte_reg (x, 0));
540: break;
541:
542: case 'u':
543: if (GET_CODE (x) != CONST_INT)
544: abort ();
545: fprintf (file, "%d", INTVAL (x));
546: break;
547:
548: case 'Z':
549: bitint = INTVAL (x);
550: fprintf (file, "#%d", bitint & 7);
551: break;
552:
553: case 'Y':
554: fprintf (file, "%c", bitint > 7 ? 'h' : 'l');
555: break;
556:
557: case 'O':
558: bitint = exact_log2 ((~INTVAL (x)) & 0xff);
559: if (bitint == -1)
560: abort ();
561: fprintf (file, "#%d", bitint & 7);
562: break;
563:
564: case 'V':
565: bitint = exact_log2 (INTVAL (x));
566: if (bitint == -1)
567: abort ();
568: fprintf (file, "#%d", bitint & 7);
569: break;
570:
571: case 'P':
572: if (REGNO (XEXP (XEXP (x, 0), 0)) == STACK_POINTER_REGNUM)
573: {
574: last_p = "";
575: fprintf (file, ".w");
576: }
577: else
578: {
579: last_p = "l";
580: fprintf (file, ".b");
581: }
582: break;
583:
584: case 'U':
585: fprintf (file, "%s%s", names_big[REGNO (x)], last_p);
586: break;
587:
588: case 'M':
589: /* For -4 and -2, the other 2 is handled separately. */
590: switch (INTVAL (x))
591: {
592: case -2:
593: case -4:
594: fprintf (file, "#2");
595: break;
596: case -1:
597: case -3:
598: fprintf (file, "#1");
599: break;
600:
601: default:
602: abort ();
603: }
604: break;
605:
606: case 'e':
607: switch (GET_CODE (x))
608: {
609: case REG:
610: fprintf (file, "%s", names_big[REGNO (x)]);
611: break;
612: case MEM:
613: x = adj_offsettable_operand (x, 0);
614: print_operand (file, x, 0);
615: break;
616: case CONST_INT:
617: fprintf (file, "#%d", ((INTVAL (x) >> 16) & 0xffff));
618: break;
619: default:
620: abort ();
621: break;
622: }
623: break;
624:
625: case 'f':
626: switch (GET_CODE (x))
627: {
628: case REG:
629: fprintf (file, "%s", names_big[REGNO (x) + 1]);
630: break;
631:
632: case MEM:
633: x = adj_offsettable_operand (x, 2);
634: print_operand (file, x, 0);
635: break;
636:
637: case CONST_INT:
638: fprintf (file, "#%d", INTVAL (x) & 0xffff);
639: break;
640:
641: default:
642: abort ();
643: }
644: break;
645:
646: case 'C':
647: fprintf (file, "#%d", INTVAL (x) - 2);
648: break;
649:
650: case 'E':
651: switch (GET_CODE (x))
652: {
653: case REG:
654: fprintf (file, "%sl", names_big[REGNO (x)]);
655: break;
656:
657: case CONST_INT:
658: fprintf (file, "#%d", (-INTVAL (x)) & 0xff);
659: break;
660:
661: default:
662: abort ();
663: }
664: break;
665:
666: case 'F':
667: switch (GET_CODE (x))
668: {
669: case REG:
670: fprintf (file, "%sh", names_big[REGNO (x)]);
671: break;
672:
673: case CONST_INT:
674: fprintf (file, "#%d", ((-INTVAL (x)) & 0xff00) >> 8);
675: break;
676:
677: default:
678: abort ();
679: }
680: break;
681:
682: case 'j':
683: asm_fprintf (file, cond_string (GET_CODE (x)));
684: break;
685:
686: case 'k':
687: asm_fprintf (file, cond_string (reverse_condition (GET_CODE (x))));
688: break;
689: def: ;
690: default:
691: switch (GET_CODE (x))
692: {
693: case REG:
694: fprintf (file, "%s", names_big[REGNO (x)]);
695: break;
696:
697: case MEM:
698: fprintf (file, "@");
699: output_address (XEXP (x, 0));
700: break;
701:
702: case CONST_INT:
703: case SYMBOL_REF:
704: case CONST:
705: case LABEL_REF:
706: fprintf (file, "#");
707: print_operand_address (file, x);
708: break;
709: }
710: }
711: }
712:
713: /* Output assembly language output for the address ADDR to FILE. */
714:
715: void
716: print_operand_address (file, addr)
717: FILE *file;
718: rtx addr;
719: {
720: switch (GET_CODE (addr))
721: {
722: case REG:
723: fprintf (file, "%s", names_big[REGNO (addr)]);
724: break;
725:
726: case PRE_DEC:
727: fprintf (file, "-%s", names_big[REGNO (XEXP (addr, 0))]);
728: break;
729:
730: case POST_INC:
731: fprintf (file, "%s+", names_big[REGNO (XEXP (addr, 0))]);
732: break;
733:
734: case PLUS:
735: fprintf (file, "(");
736: if (GET_CODE (XEXP (addr, 0)) == REG)
737: {
738: /* reg,foo */
739: print_operand_address (file, XEXP (addr, 1));
740: fprintf (file, ",");
741: print_operand_address (file, XEXP (addr, 0));
742: }
743: else
744: {
745: /* foo+k */
746: print_operand_address (file, XEXP (addr, 0));
747: fprintf (file, "+");
748: print_operand_address (file, XEXP (addr, 1));
749: }
750: fprintf (file, ")");
751: break;
752:
753: case CONST_INT:
754: if (INTVAL (addr) < 0)
755: {
756: int v = -INTVAL (addr);
757:
758: fprintf (file, "-%d", v);
759: }
760: else
761: fprintf (file, "%d", INTVAL (addr));
762: break;
763:
764: default:
765: output_addr_const (file, addr);
766: break;
767: }
768: }
769:
770: /* Output to FILE a reference to the user-level label NAME.
771: Strip off the section name if any. It is separated from the label name
772: by a space. */
773:
774: void
775: asm_output_labelref (file, name)
776: FILE *file;
777: char *name;
778: {
779: char *p;
780:
781: fputc ('_', file);
782:
783: for (p = name; *p; p++)
784: {
785: if (*p == ' ')
786: {
787: /* If we found a space in the name, then we've skipped over the
788: section encoding. */
789: fputs (p + 1, file);
790: return;
791: }
792: }
793:
794: /* No space, so no section. */
795: fputs (name, file);
796: }
797:
798: /* Output all insn addresses and their sizes into the assembly language
799: output file. This is helpful for debugging whether the length attributes
800: in the md file are correct. This is not meant to be a user selectable
801: option. */
802:
803: void
804: final_prescan_insn (insn, operand, num_operands)
805: rtx insn, *operand;
806: int num_operands;
807: {
808: /* This holds the last insn address. */
809: static int last_insn_address = 0;
810:
811: int uid = INSN_UID (insn);
812:
813: if (TARGET_ADDRESSES)
814: {
815: fprintf (asm_out_file, "; %d %d\n", insn_addresses[uid],
816: insn_addresses[uid] - last_insn_address);
817: last_insn_address = insn_addresses[uid];
818: }
819: }
820:
821: static void
822: shift_n_bits (lval, operand, f, notzero)
823: rtx lval;
824: rtx operand;
825: rtx (*f) ();
826: int notzero;
827: {
828: rtx label = gen_label_rtx ();
829: rtx bot = gen_label_rtx ();
830:
831: if (! notzero)
832: {
833: /* Have to put a zero test at the top. */
834: emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, lval));
835: emit_jump_insn (gen_beq (bot));
836: }
837: emit_label (label);
838: f (operand);
839: emit_insn (gen_rtx (SET, QImode, lval,
840: gen_rtx (MINUS, QImode, lval, const1_rtx)));
841: emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, lval));
842: emit_jump_insn (gen_bne (label));
843:
844: emit_label (bot);
845: /* We can't end an expand with a label. */
846: emit_move_insn (operand, operand);
847: }
848:
849: int
850: can_shift (code, operands, f, limit, fby_eight)
851: int code;
852: rtx operands[];
853: rtx (*f) ();
854: int limit;
855: rtx (*fby_eight) ();
856: {
857: extern int rtx_equal_function_value_matters;
858:
859: emit_move_insn (operands[0], operands[1]);
860:
861: if (GET_CODE (operands[2]) != CONST_INT)
862: {
863: rtx lval;
864:
865: /* Can't define expand a loop after rtl generation. */
866: if (! rtx_equal_function_value_matters)
867: return 0;
868:
869: lval = gen_reg_rtx (QImode);
870:
871: convert_move (lval, operands[2], 1);
872: shift_n_bits (lval, operands[0], f, 0);
873: }
874: else
875: {
876: int i;
877:
878: i = INTVAL (operands[2]);
879: if (i >= 8 && fby_eight)
880: {
881: fby_eight (operands[0]);
882: i -= 8;
883: }
884: if (i > limit)
885: {
886: rtx lval;
887:
888: /* Can't define expand a loop after rtl generation. */
889: if (! rtx_equal_function_value_matters)
890: return 0;
891: lval = gen_reg_rtx (QImode);
892: emit_move_insn (lval, gen_rtx (CONST_INT, VOIDmode, i));
893: shift_n_bits (lval, operands[0], f, 1);
894: }
895: else
896: {
897: while (i--)
898: f (operands[0]);
899: }
900: }
901: return 1;
902: }
903:
904: int
905: domovsi (operands)
906: rtx operands[];
907: {
908: rtx src = operands[1];
909: rtx dst = operands[0];
910:
911: if (push_operand (dst, GET_MODE (dst)))
912: {
913: /* Source must be a reg. */
914: if (! REG_P (src))
915: {
916: rtx tmp = gen_reg_rtx (GET_MODE (dst));
917:
918: emit_move_insn (tmp, src);
919: operands[1] = tmp;
920: }
921: }
922: return 0;
923: }
924:
925: int
926: io (FROM, TO)
927: {
928: int OFFSET = 0;
929:
930: if ((FROM) == ARG_POINTER_REGNUM && (TO) == FRAME_POINTER_REGNUM)
931: (OFFSET) = 2 + frame_pointer_needed * 2;
932: else
933: {
934: int regno;
935: int offset = 0;
936:
937: for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
938: if ((regs_ever_live[regno]
939: && (! call_used_regs[regno] || regno == FRAME_POINTER_REGNUM)))
940: offset += 2;
941:
942: (OFFSET) = offset + get_frame_size ();
943:
944: if ((FROM) == ARG_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM)
945: (OFFSET) += 2; /* Skip saved PC. */
946: }
947: return OFFSET;
948: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.