![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / pcc|
Return to local2.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / pcc |
1.1 root 1: #include "cpass2.h"
2: #include "ctype.h"
3: #ifndef lint
4: static char sccsid[] = "@(#)local2.c 1.1 86/02/03 Copyr 1985 Sun Micro";
5: #endif
6:
7: /*
8: * Copyright (c) 1985 by Sun Microsystems, Inc.
9: */
10:
11: # ifdef FORT
12: int ftlab1, ftlab2;
13: # endif
14: /* a lot of the machine dependent parts of the second pass */
15: #ifdef FORT
16: # define fltfun 0
17: #else
18: extern int fltfun;
19: #endif
20: # define BITMASK(n) ((1L<<(n))-1)
21:
22:
23: int toff = 0; /* number of stack locations used for args */
24: int maxtoff;
25: void stmove();
26: void eval_field();
27: void shiftreg();
28: void incraddr();
29:
30: /* everything you never wanted to know about condition codes */
31:
32: char *
33: ccodes[] = { "eq", "ne", "le", "lt", "ge", "gt", "ls", "cs", "cc", "hi" };
34:
35: char *
36: fccodes[] = { "eq", "neq", "le", "lt", "ge", "gt" };
37:
38: char *
39: fnegccodes[] = { "neq", "eq", "nle", "nlt", "nge", "ngt" };
40:
41: /* logical relations when compared in reverse order (cmp R,L) */
42:
43: #ifdef FORT
44: short revrel[] = { EQ, NE, GE, GT, LE, LT, UGE, UGT, ULE, ULT };
45: #else
46: extern short revrel[];
47: #endif
48:
49: /* negated logical relations -- integer comparisons only */
50:
51: int negrel[] = { NE, EQ, GT, GE, LT, LE, UGT, UGE, ULT, ULE } ;
52:
53: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
54:
55: zzzcode( p, c, cookie ) NODE *p;
56: {
57:
58: register m,temp;
59: NODE *s;
60:
61: switch( c ){
62: /* BCDEFGHIJKLMNOPRSTVWXabcdfglmrtv` '0-~ */
63:
64: case 'C':
65: switch (p->in.left->in.op) {
66:
67: case ICON: print_str("\tjbsr\t");
68: acon(p->in.left);
69: return;
70:
71: case REG:
72: if (indexreg(p->in.left)){
73: /* already in an address register */
74: print_str("\tjsr\t");
75: adrput(p->in.left);
76: putchar('@');
77: return;
78: } /* else fall through */
79:
80: case NAME:
81: case OREG: print_str("\tmovl\t");
82: adrput(p->in.left);
83: print_str(",a0\n\tjsr\ta0@");
84: return;
85:
86: default: cerror("bad subroutine name");
87: }
88:
89: case 'E': /* load doubles with overly complex addressing */
90: {
91: /*
92: * accomplished by simplifying addressing, then
93: * falling through to case 'D'.
94: */
95: expand(p, cookie, " lea AR,A2\n");
96: /*
97: * we would like, at this point, just to paint over
98: * p with the place where we have the address calculated
99: * and be done with it. too bad we can't: reclaim
100: * needs to look at it. So we must RECUR here
101: */
102: resc[1].tn.op = OREG;
103: resc[1].tn.lval = 0;
104: resc[1].tn.type = INCREF(DOUBLE);
105: zzzcode( &resc[1], 'D', cookie );
106: return;
107: }
108:
109:
110: case 'D': /* load-store doubles with auto-incr/decr addressing */
111: {
112: /* cases are: ASSIGN, or rewrite LEAF-node */
113: # define FORW 0
114: # define REVR 1
115: static char * lrewrite[] = { "\tmovl\tA.,A1\n\tmovl\tU.,U1\n",
116: "\tmovl\tU.,U1\n\tmovl\tA.,A1\n"};
117: static char * asreg[] = { "\tmovl\tAR,AL\n\tmovl\tUR,UL\n",
118: "\tmovl\tUR,UL\n\tmovl\tAR,AL\n"};
119: char **rstring;
120: NODE * q;
121: if (p->in.op == ASSIGN){
122: rstring = asreg; q = p->in.left;
123: } else {
124: rstring = lrewrite; q = p;
125: }
126: if (q->in.op == UNARY MUL && q->in.left->in.op == ASG MINUS)
127: expand( p, cookie, rstring[REVR] );
128: else
129: expand( p, cookie, rstring[FORW] );
130: # undef FORW
131: # undef REVR
132: }
133: return;
134:
135: case 'K':
136: /*
137: * 68881 floating point source operand
138: * This is essentially the same as AR, but
139: * in addition we check for the opportunity
140: * to use floating-point immediate mode.
141: * Only supported by the assembler in
142: * coprocessor instructions.
143: */
144: switch(optype(p->in.op)) {
145: case LTYPE:
146: break;
147: case UTYPE:
148: if (p->in.op != UNARY MUL)
149: p = p->in.left;
150: break;
151: case BITYPE:
152: p = p->in.right;
153: break;
154: }
155: if (p->in.op == FCON) {
156: floatimmed(p);
157: } else {
158: adrput(p);
159: }
160: return;
161:
162: case 'L':
163: m = p->in.left->in.type;
164: goto suffix;
165:
166: case 'R':
167: m = p->in.right->in.type;
168: goto suffix;
169:
170: case 'B':
171: m = p->in.type; /* fall into suffix: */
172:
173: suffix:
174: switch(m) {
175: case CHAR:
176: case UCHAR:
177: c = 'b';
178: break;
179: case SHORT:
180: case USHORT:
181: c = 'w';
182: break;
183: default:
184: c = 'l';
185: break;
186: }
187: putchar(c);
188: return;
189:
190: case 'F':
191: /*
192: * print type characters for the source operand of
193: * a 68881 floating point instruction.
194: */
195: switch(optype(p->in.op)) {
196: case LTYPE:
197: break;
198: case UTYPE:
199: if (p->in.op != UNARY MUL)
200: p = p->in.left;
201: break;
202: case BITYPE:
203: p = p->in.right;
204: break;
205: }
206: /*
207: * at this point, p is assumed to have matched
208: * the shape SFLOAT_SRCE (cf. special())
209: */
210: if (p->in.op == SCONV)
211: p = p->in.left;
212: goto float_suffix;
213:
214: case 'G':
215: /*
216: * print type character for the left subtree
217: */
218: p = p->in.left;
219: if (p->in.op == SCONV)
220: p = p->in.left;
221: goto float_suffix;
222:
223: case '.':
224: float_suffix:
225: if (p->in.op == REG && iscreg(p->tn.rval)) {
226: /*
227: * source is coprocessor reg; data
228: * is in extended precision
229: */
230: putchar('x');
231: return;
232: }
233: /*
234: * print type character for the root node
235: */
236: switch(BTYPE(p->in.type)) {
237: case CHAR:
238: c = 'b';
239: break;
240: case SHORT:
241: c = 'w';
242: break;
243: case FLOAT:
244: c = 's';
245: break;
246: case DOUBLE:
247: c = 'd';
248: break;
249: case UCHAR:
250: case USHORT:
251: /*
252: * the 68881 sign-extends integer operands
253: */
254: cerror("compiler botched unsigned operand");
255: /*NOTREACHED*/
256: default:
257: c = 'l';
258: break;
259: }
260: putchar(c);
261: return;
262:
263: case 'N': /* logical ops, turned into 0-1 */
264: /* use register given by RESC1 */
265: branch(m=getlab());
266: /* FALL THROUGH */
267:
268: make_boolean:
269: deflab( p->bn.label );
270: temp = getlr( p, '1' )->tn.rval;
271: printf( " clrl %s\n", rnames[temp]);
272: markused(temp);
273: deflab( m );
274: return;
275:
276: case 'H':
277: cbgen(p->in.op, p->in.left->in.type, p->bn.label,
278: p->bn.reversed, FCCODES);
279: return;
280:
281: case 'I':
282: cbgen(p->in.op, p->in.left->in.type, p->bn.label,
283: p->bn.reversed, CCODES);
284: return;
285:
286: /* stack management macros */
287: case '-':
288: print_str( "sp@-" );
289: case 'P':
290: toff += 4;
291: if (toff > maxtoff) maxtoff = toff;
292: return;
293:
294: case '0':
295: toff = 0; return;
296:
297: case '~':
298: /* complimented CR */
299: p->in.right->tn.lval = ~p->in.right->tn.lval;
300: conput( getlr( p, 'R' ) );
301: p->in.right->tn.lval = ~p->in.right->tn.lval;
302: return;
303:
304: case 'M':
305: /* negated CR */
306: p->in.right->tn.lval = -p->in.right->tn.lval;
307: case 'O':
308: conput( getlr( p, 'R' ) );
309: p->in.right->tn.lval = -p->in.right->tn.lval;
310: return;
311:
312: case 'T':
313: /* Truncate longs for type conversions:
314: INT|UNSIGNED -> CHAR|UCHAR|SHORT|USHORT
315: increment offset to second word */
316:
317: m = p->in.type;
318: p = p->in.left;
319: switch( p->in.op ){
320: case NAME:
321: case OREG:
322: if (p->in.type==SHORT || p->in.type==USHORT)
323: p->tn.lval += (m==CHAR || m==UCHAR) ? 1 : 0;
324: else p->tn.lval += (m==CHAR || m==UCHAR) ? 3 : 2;
325: return;
326: case REG:
327: return;
328: default:
329: cerror( "Illegal ZT type conversion" );
330: return;
331:
332: }
333:
334: case 't':
335: /*
336: * Lengthen little (unsigned) things. Try to be smart
337: * about instruction sequences.
338: */
339: s = p->in.left;
340: m = s->in.type;
341: if (ISUNSIGNED(m)){
342: /* zero-extending into temp register */
343: if ( istnode(s) && s->tn.rval == resc[0].tn.rval ){
344: /* must use andl instructions */
345: print_str_str( " andl #0x", (m==UCHAR)?"ff":"ffff");
346: } else {
347: print_str_str_nl( " moveq #0,", rnames[ resc[0].tn.rval ] );
348: printf( " mov%c ", (m==UCHAR)?'b':'w');
349: adrput( s );
350: }
351: putchar(','); print_str_nl(rnames[ resc[0].tn.rval ] );
352: } else {
353: /* sign-extending into temp register */
354: if (!(istnode(s) && s->tn.rval == resc[0].tn.rval) ){
355: /* not already in its register */
356: printf( " mov%c ", (m==CHAR)?'b':'w');
357: adrput( s );
358: putchar(','); print_str_nl(rnames[ resc[0].tn.rval ] );
359: }
360: /* sign-extend */
361: if (m == CHAR)
362: print_str_str_nl( " extw ", rnames[resc[0].tn.rval]);
363: if (p->in.type != SHORT && p->in.type != USHORT)
364: print_str_str_nl( " extl ", rnames[resc[0].tn.rval]);
365: }
366: return;
367:
368: case 'W': /* structure size */
369: if( p->in.op == STASG )
370: print_d(p->stn.stsize);
371: else cerror( "Not a structure" );
372: return;
373:
374: case 'S': /* structure assignment */
375: stmove( p, cookie );
376: return;
377:
378: case 'X':{ /* indexed effective address */
379: NODE fake,*lp,*rp;
380: int flags;
381: lp = p->in.left;
382: rp = p->in.right;
383: R2PACKFLGS(flags, rp->in.type == SHORT, 0, 0);
384: fake.in.op = OREG;
385: fake.tn.rval = R2PACK(lp->in.left->tn.rval, rp->tn.rval, flags);
386: fake.tn.name = "\0";
387: fake.tn.lval = lp->in.right->tn.lval;
388: oregput(&fake);
389: return;
390: }
391:
392: case 'a':
393: /* assign something to a bit field */
394: case 'b':
395: /* extract a bit field */
396: case 'c':
397: /* compare bit field with constant for CC only */
398: eval_field( p, c, cookie);
399: return;
400:
401: case 'f': /* floating-point operation */
402: /* since the floating-point format may be changed with a
403: * compile-time switch, we need to go think about this
404: */
405: floatcode( p, cookie );
406: fltused++;
407: return;
408: case 'g': /* floating-point conversion to normal register */
409: /* anything that looks like a floating type conversion
410: * or a floating-register load or store comes here.
411: */
412: floatconv( p, c, cookie );
413: fltused++;
414: return;
415:
416: case 'm': /* multiplication by a constant */
417: conmul( p, cookie );
418: return;
419:
420: case 'd': /* division by a constant */
421: condiv( p, cookie );
422: return;
423:
424: case 'r': /* remainder by a constant */
425: conrem( p, cookie );
426: return;
427:
428: case ' ': /* leaf-type for effect only */
429: /*
430: * usually this will generate NO code.
431: * the exception is INCR or ASG MINUS, as in
432: * *p++, *--p;
433: * these are recognized as side effects of addressing
434: * modes, so have not been dealt with by higher functions.
435: */
436: if (p->in.op == UNARY MUL){
437: if (p->in.left->in.op == INCR){
438: printf(" addql #%d, %s\n",
439: tlen(p), rnames[p->in.left->in.left->tn.rval]);
440: } else if (p->in.left->in.op == ASG MINUS){
441: printf(" subql #%d, %s\n",
442: tlen(p), rnames[p->in.left->in.left->tn.rval]);
443: }
444: }
445: return;
446:
447: case 'l': /* lea or addl instruction, as appropriate */
448: if (p->in.left->tn.rval == resc[0].tn.rval){
449: /* really a += */
450: expand( p, cookie, " addZR AR,A1\n");
451: } else {
452: /* really is a 3-address lea */
453: expand( p, cookie, " lea AL@(0,AR:ZR),A1\n");
454: }
455: return;
456:
457: case 'v': /* generate trapv for signed arithmetic */
458: trapv(p->in.type);
459: return;
460:
461: case 'V': /* generate bound-testing code */
462: bound_test(p, cookie);
463: return;
464:
465: default:
466: cerror( "illegal zzzcode" );
467: }
468: }
469:
470: #define checkout if (resc[opno].tn.op != REG) cerror("struct-assign botch")
471:
472: NODE *
473: cpytmp( l, opno ) NODE *l;
474: {
475: NODE *new;
476: print_str( (l->in.op == REG)||(ISPTR(l->in.type))? " movl " : " lea ");
477: adrput( l );
478: checkout;
479: new = &resc[opno];
480: new->tn.type = ISPTR(l->in.type)?l->in.type:INCREF(l->in.type);
481: markused(new->tn.rval);
482: putchar(','); print_str_nl(rnames[new->tn.rval] );
483: return new;
484: }
485:
486:
487: void
488: stmove( p , cookie ) register NODE *p;
489: {
490: register NODE *l, *r;
491: register size, i;
492: extern NODE resc[];
493: int opno = 1;
494: int rcopy;
495: int xsize;
496: int labl;
497: int loopcode;
498: register char *cnt, *lhs, *rhs;
499:
500: char **moves;
501: # define MOVBSTRNG 0
502: # define MOVWSTRNG 1
503: # define MOVLSTRNG 2
504: static char * asgstrings[] = {
505: " movb AR,AL\n",
506: " movw AR,AL\n",
507: " movl AR,AL\n",
508: };
509: static char * argstrings[] = {
510: " movb AR,sp@-\n",
511: " movw AR,sp@-\n",
512: " movl AR,sp@-\n",
513: };
514:
515: if( p->in.op == STASG ){
516: l = p->in.left;
517: r = p->in.right;
518: moves = asgstrings;
519: } else if( p->in.op == STARG ){ /* store an arg onto the stack */
520: /*
521: * "r" and "l" are obviously misnomers here.
522: * they should be "from" and, perhaps, "to".
523: */
524: r = p->in.left;
525: checkout;
526: l = &resc[opno++];
527: markused(l->tn.rval);
528: moves = argstrings;
529: } else
530: cerror( "STASG bad" );
531:
532: if ( r->in.op == ICON )
533: r->in.op = NAME;
534: /*
535: * avoid complicated memory operands
536: */
537: if (l->in.op == OREG && R2TEST(l->tn.rval)) {
538: l = cpytmp( l, opno++ );
539: }
540: if (r->in.op == OREG && R2TEST(r->tn.rval)) {
541: r = cpytmp( r, opno++ );
542: }
543: size = p->stn.stsize;
544: xsize = size + (size&1); /* must be even */
545:
546: /*
547: * now we make a totally arbitrary decision about
548: * when to loop, and when to emit straight-line code.
549: */
550:
551: if (size <= 8){
552: /* straight-line */
553: NODE xxx;
554:
555: /* the MIT strategy -- gross, no? */
556: if( l->in.op != REG && ISPTR(l->in.type))
557: l = cpytmp( l, opno++ );
558: if( r->in.op != REG && ISPTR(r->in.type))
559: r = cpytmp( r, opno++ );
560: xxx.in.op = STASG;
561: xxx.in.left = l;
562: xxx.in.right = r;
563: if( r->tn.op == REG ){
564: r->tn.op = OREG;
565: r->tn.type = DECREF(r->tn.type);
566: }
567: if( l->in.op == REG ) l->in.op = OREG;
568: r->tn.lval += size;
569: l->tn.lval += size;
570:
571: switch (size&03){
572: /* do special cases */
573: case 1:
574: case 3:
575: r->tn.lval -= 1;
576: l->tn.lval -= 1;
577: expand( &xxx, cookie, moves[MOVBSTRNG] );
578: if ((size&03) == 1) break;
579: /* case 3 falls through */
580: case 2:
581: r->tn.lval -= 2;
582: l->tn.lval -= 2;
583: expand( &xxx, cookie, moves[MOVWSTRNG] );
584: }
585: size -= size&03;
586: /* assert( size%4 == 0 ) */
587: while( size ){ /* simple load/store loop */
588: r->tn.lval -= 4;
589: l->tn.lval -= 4;
590: size -= 4;
591: expand( &xxx, cookie, moves[MOVLSTRNG] );
592: }
593: } else {
594: /* loop code */
595: loopcode = size >= 20;
596: if (loopcode) {
597: cnt = rnames[resc[0].tn.rval];
598: printf(" mov%c #%d,%s\n", (size<(1<<16))?'w':'l',
599: size/4-1, cnt);
600: }
601: if ( !istnode(l)){
602: if (l->tn.op==OREG && !R2TEST(l->tn.rval)
603: && istreg(l->tn.rval) && l->tn.lval==0)
604: l->tn.op=REG;
605: else
606: l = cpytmp( l, opno++ );
607: }
608: if ( !istnode(r) ){
609: r = cpytmp( r, opno++ );
610: rcopy = 1; /* this is not our real rhs */
611: } else
612: rcopy = 0;
613: lhs = rnames[l->tn.rval];
614: rhs = rnames[r->tn.rval];
615: if (p->in.op==STARG){
616: /*
617: * structure argument:
618: * push space on stack (lea sp@(size),sp)
619: * copy sp to a temp register we can bomb
620: * go for it.
621: */
622: if (xsize <(1<<16))
623: printf( " lea sp@(-%d),sp\n", xsize);
624: else
625: printf( " subl #%d,sp\n", xsize);
626: printf(" movl sp,%s\n", lhs);
627: }
628: if (loopcode) {
629: print_label(labl= getlab());
630: /* now emit the 2-instruction loop */
631: printf(" movl %s@+,%s@+\n", rhs, lhs);
632: printf(" dbra %s,L%d\n", cnt, labl);
633: if (size>=(1<<16)){
634: /* "long dbra" */
635: printf(" clrw %s\n", cnt);
636: printf(" subql #1,%s\n", cnt);
637: printf(" jcc L%d\n", labl);
638: }
639: } else {
640: /* use autoincrement mode in an unrolled loop */
641: int n;
642: for (n = 0; n < size/4; n++)
643: printf(" movl %s@+,%s@+\n", rhs, lhs);
644: }
645: switch (size&03) {
646: /* oops -- stuff leftover */
647: case 3:
648: printf(" movw %s@+,%s@+\n", rhs, lhs);
649: /* fall thorugh */
650: case 1:
651: printf(" movb %s@,%s@\n", rhs, lhs);
652: break;
653: case 2:
654: printf(" movw %s@,%s@\n", rhs, lhs);
655: break;
656: }
657: if (cookie&(INBREG|INTBREG) && !rcopy){
658: /* oh damn, must repair damage */
659: int temp;
660: temp = p->stn.stsize;
661: p->stn.stsize &= ~0x3;
662: if (size <(1<<16))
663: expand( p, FOREFF, " lea AR@(-ZW),AR\n");
664: else
665: expand( p, FOREFF, " subl #ZW,AR\n");
666: p->stn.stsize = temp;
667: }
668: }
669: if (p->in.op==STARG){
670: /* keep toff up-to-date */
671: if (xsize<3){
672: /* must pad */
673: printf(" subqw #2,sp\n");
674: xsize = 4;
675: }
676: toff += xsize;
677: if (toff>maxtoff) maxtoff= toff;
678: } else {
679: r = p->in.right;
680: if ( r->in.op == NAME )
681: r->in.op = ICON;
682: else if (!(cookie&SANY) && r->tn.op==OREG && !ISPTR(r->tn.type)){
683: /* we get to make up a (choke) address here */
684: if (r->tn.lval == 0){
685: r->in.op = REG;
686: r->tn.type = INCREF(r->tn.type);
687: } else
688: cerror("trapped in a multiple-structue-assigment");
689: }
690: }
691: }
692:
693: #undef checkout
694:
695: /*
696: * alignfield(p, byteoff)
697: * Align an operand for a 68020 bit field operation. If byteoff
698: * is nonzero, subtract it (it was previously added to the offset
699: * part of p->in.left, possibly resulting in an odd offset). Then
700: * longword-align the offset, assuming that names and activation
701: * records are longword-aligned.
702: */
703: static
704: alignfield(p, byteoff)
705: register NODE *p; /* assumed to be FLD op */
706: int byteoff;
707: {
708: register NODE *lp; /* assumed to be operand address */
709: int fieldoff, fieldsize, residue;
710:
711: lp = p->in.left;
712: switch( lp->in.op ){
713: case NAME:
714: case ICON:
715: case OREG:
716: if (byteoff) {
717: /* undo it */
718: lp->tn.lval -= byteoff;
719: }
720: residue = lp->tn.lval % (SZLONG/SZCHAR);
721: if (residue < 0) {
722: /*
723: * careful about AUTOs --
724: * the offsets are negative
725: */
726: residue += (SZLONG/SZCHAR);
727: }
728: fieldoff = UPKFOFF(p->tn.rval) + residue*SZCHAR;
729: fieldsize = UPKFSZ(p->tn.rval);
730: if (fieldoff + fieldsize <= SZLONG) {
731: /*
732: * take bytes away from the operand address,
733: * and put bits back in the field offset.
734: */
735: lp->tn.lval -= residue;
736: p->tn.rval = PKFIELD(fieldsize, fieldoff);
737: }
738: break;
739: default:
740: cerror( "illegal address in alignfield" );
741: break;
742: }
743: }
744:
745: expandfield(p)
746: register NODE *p;
747: {
748: printf( "{#%d:#%d}", UPKFOFF(p->tn.rval), UPKFSZ(p->tn.rval) );
749: }
750:
751: void
752: eval_field( p, c, cookie )
753: NODE *p;
754: char c;
755: {
756: register temp, m;
757: register NODE *l, *r;
758: int lobyte, hibyte;
759: char *regname;
760: NODE *fieldnode;
761: int conval;
762:
763: l = p->in.left;
764: r = p->in.right;
765: fieldnode = (c == 'b') ? p : p->in.left;
766: lobyte = (SZINT - fldshf - 1)/SZCHAR; /* byte containing low-order bit */
767: hibyte = (SZINT -fldshf -fldsz)/SZCHAR;/* byte containing high-order bit */
768: if (fieldnode->in.left->tn.op == REG){
769: if ( ISPTR(fieldnode->in.left->tn.type)){
770: fieldnode->in.left->tn.op = OREG;
771: } else {
772: /* always use longword accesses to registers */
773: hibyte = 0;
774: temp = SZINT;
775: p->in.type = UNSIGNED;
776: goto longonly;
777: }
778: }
779:
780: if (lobyte==hibyte){
781: /* ok to do byte accesses to memory */
782: temp = SZCHAR;
783: p->in.type = UCHAR;
784: } else if ((hibyte&1) || (hibyte < (lobyte-1))){
785: /* must do longword access */
786: hibyte = 0;
787: temp = SZINT;
788: p->in.type = UNSIGNED;
789: } else {
790: /* word access */
791: temp = SZSHORT;
792: p->in.type = USHORT;
793: }
794:
795: /* adjust shift value, paint over left type and address */
796: fldshf = temp - (SZINT-fldshf -(hibyte*SZCHAR));
797: if (hibyte){
798: incraddr( fieldnode, hibyte);
799: }
800:
801: longonly:
802:
803: switch (c){
804: case 'a':
805: /* assignment of a value to a bit field */
806: /* the two cases are: constant r-h-s, and variable r-h-s */
807: /* the constant case has several interesting sub-cases */
808: if (r->tn.op == ICON){
809: /* easy case */
810: conval = r->tn.lval;
811: m = r->tn.lval;
812: if (fldsz == 1) {
813: /* very easy case */
814: print_str_d( (m&1)?" bset #":" bclr #", fldshf); putchar(',');
815: adrput( l );
816: } else {
817: /*
818: * wide field:
819: * depending on field size and alignment, we may
820: * have to do word or longword accesses
821: */
822: if (m==0){
823: /* clearing entire field */
824: if (fldshf==0 && fldsz == temp){
825: /* no masking involved -- whole unit */
826: expand( p, cookie, " clrZB AL");
827: } else {
828: expand( p, cookie, " andZB #N,AL");
829: }
830: } else if ( m==-1 || m==BITMASK(fldsz)){
831: /* setting entire field */
832: if (fldshf==0 && fldsz == temp){
833: /* no masking involved -- whole unit */
834: if (fldsz == SZCHAR) {
835: expand( p, cookie, " st AL");
836: } else {
837: expand( p, cookie, " movZB #CR,AL");
838: }
839: } else {
840: expand( p, cookie, " orZB #M,AL" );
841: }
842: } else {
843: /* -- inserting value -- */
844: if (fldshf==0 && fldsz == temp){
845: /* no masking involved -- whole unit */
846: expand( p, cookie, " movZB #CR,AL");
847: } else {
848: m &= BITMASK(fldsz);
849: r->tn.lval = m<<fldshf;
850: expand(p, cookie, " andZB #N,AL\n orZB #CR,AL");
851: }
852: }
853: }
854: /* restore old ICON value in case we want to use it as
855: the result of the assignment */
856: r->tn.lval = conval;
857: } else {
858: /* non-constant */
859: /* there are only two cases here :
860: shifting and masking, or
861: not shifting or masking
862: */
863: if (fldsz == temp && fldshf == 0){
864: /* direct move */
865: expand( p, cookie, " movZB AR,AL");
866: } else if (use68020) {
867: /* the normal, ugly case, with 68020 instructions */
868: alignfield(fieldnode, hibyte);
869: expand( p, cookie, " bfins AR,AL");
870: expandfield(fieldnode);
871: } else {
872: /* the normal, ugly case, with 68010 instructions */
873: /* clear field in destination */
874: expand( p, cookie, " andZB #N,AL\n");
875: /* move value to temp and adjust */
876: temp = fldshf;
877: fldshf = 0;
878: if (r->tn.op == REG && istreg(r->tn.rval) && (cookie&FOREFF)){
879: /* do it in place */
880: regname = rnames[r->tn.rval];
881: /* mask source to the right number of bits, and */
882: expand( p, cookie, " andZB #M,AR\n");
883: /* shift into place */
884: shiftreg( temp, regname , -1, 0, 'l', UNSIGNED);
885: /* combine source into destination */
886: expand( p, cookie, " orZB AR,AL");
887: } else {
888: /* must copy over */
889: rmove( resc[0].tn.rval, r->tn.rval, UNSIGNED );
890: expand( p, cookie, " andZB #M,A1\n");
891: regname = rnames[ resc[0].tn.rval ];
892: shiftreg( temp, regname , -1, 0, 'l', UNSIGNED);
893: expand( p, cookie, " orZB A1,AL");
894: }
895: }
896: }
897: p->in.type = UNSIGNED;
898: return;
899:
900: case 'b':
901: /* extracting field value -- either for CC or for value */
902: if (cookie & FORCC){
903: compare_with_zero:
904: /* only extracting value to compare it with zero */
905: if (fldsz == 1){
906: /* snap case -- so long as fields are unsigned! */
907: print_str_d( " btst #", fldshf); putchar(',');
908: adrput( l );
909: } else if (fldsz == temp && fldshf == 0){
910: /* direct memory test */
911: expand( p, cookie, " tstZB AL");
912: } else {
913: /*
914: * move value into a register -- and with mask to set CC.
915: * We would have to worry about setting the N condition
916: * here, but our unsigned-ness prevents this from being
917: * a problem.
918: */
919: if (l->tn.op == REG && istreg(l->tn.rval)){
920: expand( p, cookie, " andl #M,AL");
921: } else {
922: expand( p, cookie,
923: " movZB AL,A1\n andZB #M,A1");
924: }
925: }
926: } else {
927: /* extracting value for value's sake */
928: if (l->tn.op == REG && istreg(l->tn.rval)){
929: regname = rnames[ l->tn.rval ];
930: if (use68020 && fldshf != 0) {
931: alignfield(fieldnode, hibyte);
932: expand( p, cookie, " bfextu AL");
933: expandfield(fieldnode);
934: putchar(','); print_str(regname);
935: } else {
936: shiftreg( -fldshf, regname , resc[0].tn.rval, 0, 'l', UNSIGNED);
937: fldshf = 0;
938: expand( p, cookie, " andl #M,AL");
939: }
940: } else {
941: regname = rnames[ resc[0].tn.rval ];
942: if (use68020 && fldshf != 0) {
943: alignfield(fieldnode, hibyte);
944: expand( p, cookie, " bfextu AL");
945: expandfield(fieldnode);
946: putchar(','); print_str(regname);
947: } else {
948: if (temp != SZINT){
949: print_str_str_nl(" moveq #0,", regname );
950: }
951: expand( p, cookie, " movZB AL,A1");
952: if (fldsz != temp || fldshf != 0){
953: putchar('\n');
954: shiftreg( -fldshf, regname, -1, 0, 'l', UNSIGNED);
955: fldshf = 0;
956: expand( p, cookie, " andZB #M,A1");
957: }
958: }
959: }
960: }
961:
962: fieldnode->in.type = UNSIGNED;
963: return;
964:
965: case 'c':
966: /* comparison of field value with constant value for CC only */
967: m = r->tn.lval;
968: if (m==0) goto compare_with_zero;
969: r->tn.lval = m << fldshf;
970: if (temp == fldsz && fldshf == 0 ){
971: /* compare directly to memory */
972: expand(p, cookie, " cmpZB #CR,AL");
973: } else if (l->tn.op == REG && istreg(l->tn.rval) && cookie&FOREFF){
974: /* munge in place */
975: expand( p, cookie," andZB #M,AL\n cmpZB #CR,AL");
976: } else {
977: /* move to register, mask, compare */
978: expand( p, cookie,
979: " movZB AL,A1\n andZB #M,A1\n cmpZB #CR,A1");
980: }
981: }
982:
983: }
984:
985: /* routine used by the field-evaluation code to emit shifting instructions.
986: "val" is the amount to shift, s is the name of the register to shift,
987: and "reg" is the register NUMBER of a helper, if one is available.
988: If val<0, we're doing right shifts
989: If needclr != 0, must clear lower word after swap.
990: */
991: void
992: shiftreg( val, s , reg, needclr, typechar, type )
993: char *s;
994: char typechar;
995: {
996: char *t;
997: char *shift = "lsll";
998: int lshift;
999: if (val < 0 ){
1000: shift = "lsrl";
1001: val = -val;
1002: lshift = 0;
1003: } else{
1004: lshift = 1;
1005: shift[0] = (ISUNSIGNED(type) || ISPTR(type))? 'l' : 'a';
1006: }
1007: shift[3] = typechar; /* ugly hack */
1008: if (val > 16 ){
1009: if (reg >= 0){
1010: printf(" movl #%d,%s\n", val, t=rnames[ reg ]);
1011: printf(" %s %s,%s\n", shift, t, s);
1012: trapv(type);
1013: return;
1014: }
1015: if (!(chk_ovfl && shift[0] == 'a')){
1016: print_str_str_nl(" swap ", s);
1017: if (needclr&&lshift)
1018: print_str_str_nl(" clrw ", s);
1019: val -= 16;
1020: }
1021: }
1022: while (val > 0){
1023: if (val> 8){
1024: printf(" %s #8,%s\n", shift, s);
1025: val -= 8;
1026: } else {
1027: if (val==1 && lshift)
1028: printf(" add%c %s,%s\n", typechar, s,s);
1029: else
1030: printf(" %s #%d,%s\n", shift, val, s);
1031: val = 0;
1032: }
1033: trapv(type);
1034: }
1035: }
1036:
1037: void
1038: incraddr( p , v)
1039: register NODE *p;
1040: long v;
1041: {
1042: /* bump the address p by the value b. */
1043: if( p->in.op == FLD ){
1044: p = p->in.left;
1045: }
1046: switch( p->in.op ){
1047: case NAME:
1048: case ICON:
1049: case OREG:
1050: p->tn.lval += v;
1051: break;
1052: default:
1053: cerror( "illegal incraddr address" );
1054: break;
1055:
1056: }
1057: }
1058:
1059: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
1060:
1061: insput( p ) register NODE *p;
1062: {
1063: #ifndef IEEECCODES
1064: printf(ccodes[p->in.op-EQ]);
1065: #else IEEECCODES
1066: if (ISFLOATING(p->in.left->in.type)) {
1067: printf(fccodes[p->in.op-EQ]);
1068: } else {
1069: printf(ccodes[p->in.op-EQ]);
1070: }
1071: #endif IEEECCODES
1072: }
1073:
1074: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
1075:
1076: /*
1077: * Generate conditional branches from a relational operator.
1078: * The exact form of the branch depends on:
1079: * 1. whether or not the compared operands have floating point types
1080: * 2. whether or not the coprocessor condition code is used
1081: * 3. whether the operator has been negated.
1082: */
1083:
1084: cbgen( o, type, label, reversed, mode )
1085: int o; /* relational op {EQ, NE, LT, LE, ...} */
1086: TWORD type; /* operand type - determines opcode */
1087: int label; /* destination label */
1088: int reversed; /* =1 if op is to be negated */
1089: int mode; /* if FCCODES, use coprocessor condition codes */
1090: {
1091: char *prefix;
1092: char *opname;
1093:
1094: #ifndef IEEECCODES
1095: if (reversed) {
1096: /* treat !(a < b) as (a >= b) */
1097: o = negrel[o-EQ];
1098: }
1099: if (mode == FCCODES) {
1100: prefix = "fj";
1101: opname = fccodes[o-EQ];
1102: } else {
1103: prefix = "j";
1104: opname = ccodes[o-EQ];
1105: }
1106: #else IEEECCODES
1107: if (ISFLOATING(type)) {
1108: prefix = (mode == FCCODES ? "fj" : "jf");
1109: opname = (reversed ? fnegccodes[o-EQ] : fccodes[o-EQ]);
1110: } else {
1111: prefix = "j";
1112: if (reversed)
1113: o = negrel[o-EQ];
1114: opname = ccodes[o-EQ];
1115: }
1116: #endif IEEECCODES
1117: printf(" %s%s L%d\n", prefix, opname, label);
1118: }
1119:
1120: /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
1121:
1122: #ifdef FORT
1123: branch(lab)
1124: int lab;
1125: {
1126: printf(" jra L%d\n", lab);
1127: }
1128: #endif FORT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.