1 #ifndef lint
2 static char sccsid[] = "@(#)c21.c 4.25 07/15/92";
3 #endif
4 /* char C21[] = {"@(#)c21.c 1.83 80/10/16 21:18:22 JFR"}; /* sccs ident */
5
6 /*
7 * C object code improver-- second part
8 */
9
10 #include "c2.h"
11 #include <stdio.h>
12 #include <ctype.h>
13
14 #define NUSE 6
15 int ioflag;
16 int biti[NUSE] = {1,2,4,8,16,32};
17 int bitsize[] = { /* index by type codes */
18 0, /* 0 not allocated */
19 8, /* 1 BYTE */
20 16, /* 2 WORD */
21 32, /* 3 LONG */
22 32, /* 4 FFLOAT */
23 64, /* 5 DFLOAT */
24 64, /* 6 QUAD */
25 0, /* 7 OP2 */
26 0, /* 8 OP3 */
27 0, /* 9 OPB */
28 0, /* 10 OPX */
29 64, /* 11 GFLOAT */
30 128, /* 12 HFLOAT */
31 128 /* 13 OCTA */
32 };
33 int pos,siz; long f; /* for bit field communication */
34 struct node *uses[NUSE]; /* for backwards flow analysis */
35 char *lastrand; /* last operand of instruction */
36 struct node *bflow();
37 struct node *bicopt();
38 char *findcon();
39 char *strcpy();
40
redun3(p,split)41 redun3(p,split) register struct node *p; int split; {
42 /* check for 3 addr instr which should be 2 addr */
43 if (OP3==((p->subop>>4)&0xF)) {
44 if (split) splitrand(p);
45 if (equstr(regs[RT1],regs[RT3])
46 && (p->op==ADD || p->op==MUL || p->op==BIS || p->op==XOR)) {
47 register char *t=regs[RT1]; regs[RT1]=regs[RT2]; regs[RT2]=t;
48 }
49 if (equstr(regs[RT2],regs[RT3])) {
50 p->subop=(p->subop&0xF)|(OP2<<4); p->pop=0;
51 lastrand=regs[RT2]; *regs[RT3]=0; return(1);
52 }
53 } return(0);
54 }
55
bmove()56 bmove() {
57 register struct node *p, *lastp; register char *cp1,*cp2; register int r;
58 refcount();
59 for (p=lastp= &first; 0!=(p=p->forw); lastp=p);
60 clearreg(); clearuse();
61 for (p=lastp; p!= &first; p=p->back) {
62 if (debug) {
63 printf("Uses:\n");
64 for (r=NUSE;--r>=0;) if (uses[r])
65 printf("%d: %s\n",r,uses[r]->code? uses[r]->code:"");
66 printf("-\n");
67 }
68 r=(p->subop>>4)&0xF;
69 if (OP2==r && (cp1=p->code, *cp1++)=='$' && *cp1++=='0' && *cp1++==',' &&
70 !source(cp1)) {/* a no-op unless MUL or DIV */
71 if (p->op==MUL) {p->op=MOV; p->subop&=0xF; p->pop=0;}
72 else if (p->op==DIV) fprintf(stderr,"c2: zero divide\n");
73 else {delnode(p); redunm++; continue;}
74 }
75 if (OP3==r && 0!=redun3(p,1)) {newcode(p); redunm++;}
76 switch (p->op) {
77 case LABEL: case DLABEL:
78 for (r=NUSE; --r>=0;)
79 if (uses[r]) p->ref=(struct node *) (((int)p->ref)|biti[r]);
80 break;
81 case CALLS:
82 clearuse(); goto std;
83 case 0:
84 /*
85 * Be conservative -- if we don't know what it is, then we
86 * assume that it can set anything.
87 */
88 for ( r = 0; r < NUSE; ++r )
89 uses[r] = p;
90 break;
91 case SUB:
92 if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
93 if (*cp1++!='$') goto std; splitrand(p);
94 if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
95 char buf[C2_ASIZE]; cp2=buf; *cp2++='-';
96 cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
97 cp1="(fp),"; while (*cp2++= *cp1++); --cp2;
98 cp1=regs[RT3]; while (*cp2++= *cp1++);
99 p->code=copy(buf); p->combop=T(MOVA,LONG); p->pop=0;
100 } else if (*cp1++=='-' && 0<=(r=getnum(cp1))) {
101 p->op=ADD; p->pop=0; *--cp1='$'; p->code=cp1;
102 } goto std;
103 case ADD:
104 if ((p->subop&0xF)!=LONG) goto std; cp1=p->code;
105 if (*cp1++!='$') goto std; splitrand(p);
106 if (isstatic(cp1) && (r=isreg(regs[RT2]))>=0 && r<NUSE && uses[r]==p->forw)
107 {
108 /* address comp:
109 ** addl2 $_foo,r0 \ movab _foo[r0],bar
110 ** movl r0,bar /
111 */
112 register struct node *pnext = p->forw;
113 char buf[C2_ASIZE];
114
115 if (pnext->op == MOV && pnext->subop == LONG)
116 {
117 cp1 = ®s[RT1][1]; cp2 = &buf[0];
118 while (*cp2++ = *cp1++) ; cp2--;
119 splitrand(pnext);
120 if (r == isreg(regs[RT1]))
121 {
122 delnode(p); p = pnext;
123 p->op = MOVA; p->subop = BYTE;
124 p->pop = 0;
125 cp1 = regs[RT1]; *cp2++ = '[';
126 while (*cp2++ = *cp1++) ; cp2--;
127 *cp2++ = ']'; *cp2++ = ',';
128 cp1 = regs[RT2];
129 while (*cp2++ = *cp1++) ;
130 p->code = copy(buf);
131 }
132 }
133 }
134 else
135 if (equstr(regs[RT2],"fp") && !indexa(regs[RT1])) {/* address comp. */
136 cp2=cp1-1; cp1=regs[RT1]+1; while (*cp2++= *cp1++); --cp2;
137 cp1="(fp)"; while (*cp2++= *cp1++); *--cp2=',';
138 p->combop=T(MOVA,LONG); p->pop=0;
139 } else if (*cp1++=='-' && 0<=(r=getnum(cp1))) {
140 p->op=SUB; p->pop=0; *--cp1='$'; p->code=cp1;
141 }
142 /* fall thru ... */
143 case CASE:
144 default: std:
145 p=bflow(p); break;
146 case MUL:
147 {
148 /*
149 ** Change multiplication by constant powers of 2 to
150 ** shifts.
151 */
152 splitrand(p);
153 if (regs[RT1][0] != '$' || regs[RT1][1] == '-') goto std;
154 if ((r = ispow2(getnum(®s[RT1][1]))) < 0) goto std;
155 switch (r)
156 {
157 case 0: /* mull3 $1,x,y */
158 if (p->subop == U(LONG,OP3))
159 {
160 if (equstr(regs[RT2], regs[RT3]))
161 {
162 delnode(p); p = p->forw;
163 }
164 else
165 {
166 p->op = MOV; p->subop = LONG;
167 p->pop = 0; newcode(p); nchange++;
168 }
169 }
170 else
171 if (p->subop == U(LONG,OP2))
172 {
173 delnode(p); p = p->forw;
174 }
175 goto std;
176
177 case 1: /* mull2 $2,x */
178 if (p->subop == U(LONG, OP2) && !source(regs[RT2]))
179 {
180 strcpy(regs[RT1], regs[RT2]);
181 p->op = ADD; p->pop = 0; newcode(p); nchange++;
182 }
183 goto std;
184 }
185 if(p->subop==U(LONG,OP3)||(p->subop==U(LONG,OP2)&&!source(regs[RT2])))
186 {
187 if (p->subop == U(LONG,OP2))
188 strcpy(regs[RT3], regs[RT2]);
189 sprintf(regs[RT1], "$%d", r);
190 p->op = ASH; p->subop = LONG;
191 p->pop = 0; newcode(p); nchange++;
192 }
193 goto std;
194 }
195 case ASH:
196 {
197 /* address comp:
198 ** ashl $1,bar,r0 \ movl bar,r0
199 ** movab _foo[r0] / movaw _foo[r0]
200 **
201 ** ashl $2,r0,r0 \ moval _foo[r0]
202 ** movab _foo[r0] /
203 */
204 register struct node *pf;
205 register int shfrom, shto;
206 long shcnt;
207 char *regfrom;
208
209 splitrand(p);
210 if (regs[RT1][0] != '$') goto std;
211 if ((shcnt = getnum(®s[RT1][1])) < 1 || shcnt > 3) goto std;
212 if ((shfrom = isreg(regs[RT2])) >= 0)
213 regfrom = copy(regs[RT2]);
214 if ((shto = isreg(regs[RT3])) >= 0 && shto<NUSE)
215 {
216 int regnum;
217
218 if (uses[shto] != (pf = p->forw)) goto ashadd;
219 if (pf->op != MOVA && pf->op != PUSHA) goto ashadd;
220 if (pf->subop != BYTE) goto ashadd;
221 splitrand(pf);
222 if (!indexa(regs[RT1])) goto std;
223 cp2 = regs[RT1];
224 if(!isstatic(cp2)) goto std;
225 while (*cp2++ != '[') ;
226 if (*cp2++ != 'r' || !isdigit(*cp2)) goto std;
227 regnum = *cp2++ - '0';
228 if (isdigit(*cp2))
229 {
230 if (cp2[1] != ']') goto std;
231 regnum *= 10; regnum += *cp2 - '0';
232 }
233 if (regnum != shto) goto std;
234 if (shfrom >= 0) /* ashl $N,r*,r0 */
235 {
236 delnode(p);
237 p = pf;
238 if (shfrom != shto)
239 {
240 uses[shto] = NULL; splitrand(p);
241 cp2=regs[RT1]; while (*cp2++!='[');
242 cp1=regfrom; while (*cp2++= *cp1++);
243 *--cp2 = ']';
244 *++cp2 = '\0';
245 newcode(p);
246 }
247 if (p->op == MOVA)
248 {
249 int movato;
250
251 splitrand(p);
252 if ((movato = isreg(regs[RT2])) >= 0
253 && movato < NUSE)
254 /*
255 * this register is dead;
256 * resurrect it temporarily
257 */
258 uses[movato] = p;
259 }
260 }
261 else
262 {
263 p->op = MOV; splitrand(p);
264 strcpy(regs[RT1], regs[RT2]);
265 strcpy(regs[RT2], regs[RT3]);
266 regs[RT3][0] = '\0';
267 p->pop = 0; newcode(p);
268 }
269 switch (shcnt)
270 {
271 case 1: pf->subop = WORD; break;
272 case 2: pf->subop = LONG; break;
273 case 3: pf->subop = QUAD; break;
274 }
275 pf->pop = 0;
276 redunm++; nsaddr++; nchange++;
277 goto std;
278 }
279 ashadd:
280 /* at this point, RT2 and RT3 are guaranteed to be simple regs*/
281 if (shcnt == 1 && equstr(regs[RT2], regs[RT3]))
282 {
283 /*
284 ** quickie:
285 ** ashl $1,A,A > addl2 A,A
286 */
287 p->op = ADD; p->subop = U(LONG,OP2); p->pop = 0;
288 strcpy(regs[RT1], regs[RT2]); regs[RT3][0] = '\0';
289 newcode(p); nchange++;
290 }
291 goto std;
292 }
293
294 case EXTV:
295 case EXTZV:
296 {
297 /* bit tests:
298 ** extv A,$1,B,rC \
299 ** tstl rC > jbc A,B,D
300 ** jeql D /
301 **
302 ** also byte- and word-size fields:
303 ** extv $n*8,$8,A,B > cvtbl n+A,B
304 ** extv $n*16,$16,A,B > cvtwl 2n+A,B
305 ** extzv $n*8,$8,A,B > movzbl n+A,B
306 ** extzv $n*16,$16,A,B > movzwl 2n+A,B
307 */
308 register struct node *pf; /* forward node */
309 register struct node *pn; /* next node (after pf) */
310 int flen; /* field length */
311
312 splitrand(p);
313 if (regs[RT2][0] != '$') goto std;
314 if ((flen = getnum(®s[RT2][1])) < 0) goto std;
315 if (flen == 1)
316 {
317 register int extreg; /* reg extracted to */
318
319 extreg = isreg(regs[RT4]);
320 if (extreg < 0 || extreg >= NUSE) goto std;
321 if ((pf = p->forw)->op != TST) goto std;
322 if (uses[extreg] && uses[extreg] != pf) goto std;
323 splitrand(pf);
324 if (extreg != isreg(regs[RT1])) goto std;
325 if ((pn = pf->forw)->op != CBR) goto std;
326 if (pn->subop != JEQ && pn->subop != JNE) goto std;
327 delnode(p); delnode(pf);
328 pn->subop = (pn->subop == JEQ) ? JBC : JBS;
329 for(cp2=p->code; *cp2++!=',';);
330 for(cp1=cp2; *cp1++!=',';);
331 while (*cp1!=',') *cp2++= *cp1++; *cp2='\0';
332 pn->code = p->code; pn->pop = NULL;
333 uses[extreg] = NULL;
334 p = pn;
335 break;
336 }
337 else
338 if (flen == 8 || flen == 16)
339 {
340 register int boff; /* bit offset */
341 register int coff; /* chunk (byte or word) offset*/
342
343 if (regs[RT1][0] != '$') goto std;
344 if ((boff = getnum(®s[RT1][1])) < 0) goto std;
345 coff = boff / flen;
346 if (coff && (isreg(regs[RT3]) >= 0)) goto std;
347 if (boff < 0 || (boff % flen) != 0) goto std;
348 p->op = (p->op == EXTV) ? CVT : MOVZ;
349 p->subop = U((flen == 8 ? BYTE : WORD), LONG);
350 if (coff == 0)
351 strcpy(regs[RT1], regs[RT3]);
352 else
353 sprintf(regs[RT1], "%d%s%s",
354 (flen == 8 ? coff : 2*coff),
355 (regs[RT3][0] == '(' ? "" : "+"),
356 regs[RT3]);
357 strcpy(regs[RT2], regs[RT4]);
358 regs[RT3][0] = '\0'; regs[RT4][0] = '\0';
359 p->pop = 0; newcode(p);
360 }
361 nchange++;
362 goto std;
363 }
364
365 case CMP:
366 {
367 /* comparison to -63 to -1:
368 ** cmpl r0,$-1 > incl r0
369 ** jeql ...
370 **
371 ** cmpl r0,$-63 > addl2 $63,r0
372 ** jeql ...
373 */
374 register int num;
375 register int reg;
376 register struct node *regp = p->back;
377
378 if (p->forw->op != CBR) goto std;
379 if (p->forw->subop != JEQ && p->forw->subop != JNE) goto std;
380 splitrand(p);
381 if (strncmp(regs[RT2], "$-", 2) != 0) goto std;
382 reg = r = isreg(regs[RT1]);
383 if (r < 0) goto std;
384 if (r < NUSE && uses[r] != 0) goto std;
385 if (r >= NUSE && regp->op == MOV && p->subop == regp->subop)
386 {
387 if (*regp->code != 'r') goto std;
388 reg = regp->code[1] - '0';
389 if (isdigit(regp->code[2]) || reg >= NUSE || uses[reg])
390 goto std;
391 }
392 if (r >= NUSE) goto std;
393 if (reg != r)
394 sprintf(regs[RT1], "r%d", reg);
395 if ((num = getnum(®s[RT2][2])) <= 0 || num > 63) goto std;
396 if (num == 1)
397 {
398 p->op = INC; regs[RT2][0] = '\0';
399 }
400 else
401 {
402 register char *t;
403
404 t=regs[RT1];regs[RT1]=regs[RT2];regs[RT2]=t;
405 p->op = ADD; p->subop = U(p->subop, OP2);
406 for (t = ®s[RT1][2]; t[-1] = *t; t++) ;
407 }
408 p->pop = 0; newcode(p);
409 nchange++;
410 goto std;
411 }
412
413 case JSB:
414 if (equstr(p->code,"mcount")) {uses[0]=p; regs[0][0]= -1;}
415 goto std;
416 case JBR: case JMP:
417 clearuse();
418 if (p->subop==RET || p->subop==RSB) {uses[0]=p; regs[0][0]= -1; break;}
419 if (p->ref==0) goto std; /* jmp (r0) */
420 /* fall through */
421 case CBR:
422 if (p->ref->ref!=0) for (r=NUSE;--r>=0;)
423 if (biti[r] & (int)p->ref->ref) {uses[r]=p; regs[r][0]= -1;}
424 case EROU: case JSW:
425 case TEXT: case DATA: case BSS: case ALIGN: case WGEN: case END: ;
426 }
427 }
428 for (p= &first; p!=0; p=p->forw)
429 if (p->op==LABEL || p->op==DLABEL) p->ref=0; /* erase our tracks */
430 }
431
rmove()432 rmove()
433 {
434 register struct node *p;
435 register int r;
436 int r1;
437
438 clearreg();
439 for (p=first.forw; p!=0; p = p->forw) {
440 if (debug) {
441 if (*conloc) {
442 r1=conval[0];
443 printf("Con %s = %d%d %s\n", conloc, r1&0xF, r1>>4, conval+1);
444 }
445 printf("Regs:\n");
446 for (r=0; r<NREG; r++)
447 if (regs[r][0]) {
448 r1=regs[r][0];
449 printf("%d: %d%d %s\n", r, r1&0xF, r1>>4, regs[r]+1);
450 }
451 printf("-\n");
452 }
453 switch (p->op) {
454
455 case CVT:
456 splitrand(p); goto mov;
457
458 case MOV:
459 splitrand(p);
460 if ((r = findrand(regs[RT1],p->subop)) >= 0) {
461 if (r == isreg(regs[RT2]) && p->forw->op!=CBR) {
462 delnode(p); redunm++; break;
463 }
464 }
465 mov:
466 repladdr(p);
467 r = isreg(regs[RT1]);
468 r1 = isreg(regs[RT2]);
469 dest(regs[RT2],p->subop);
470 if (r>=0) {
471 if (r1>=0) savereg(r1, regs[r]+1, p->subop);
472 else if (p->op!=CVT) savereg(r, regs[RT2], p->subop);
473 } else if (r1>=0) savereg(r1, regs[RT1], p->subop);
474 else if (p->op!=CVT) setcon(regs[RT1], regs[RT2], p->subop);
475 break;
476
477 /* .rx,.wx */
478 case MFPR:
479 case COM:
480 case NEG:
481 /* .rx,.wx or .rx,.rx,.wx */
482 case ADD:
483 case SUB:
484 case BIC:
485 case BIS:
486 case XOR:
487 case MUL:
488 case DIV:
489 case ASH:
490 case MOVZ:
491 /* .rx,.rx,.rx,.wx */
492 case EXTV:
493 case EXTZV:
494 case INSV:
495 splitrand(p);
496 repladdr(p);
497 dest(lastrand,p->subop);
498 if (p->op==INSV) ccloc[0]=0;
499 break;
500
501 /* .mx or .wx */
502 case CLR:
503 case INC:
504 case DEC:
505 splitrand(p);
506 dest(lastrand,p->subop);
507 if (p->op==CLR)
508 if ((r = isreg(regs[RT1])) >= 0)
509 savereg(r, "$0", p->subop);
510 else
511 setcon("$0", regs[RT1], p->subop);
512 break;
513
514 /* .rx */
515 case TST:
516 case PUSH:
517 splitrand(p);
518 lastrand=regs[RT1+1]; /* fool repladdr into doing 1 operand */
519 repladdr(p);
520 if (p->op==TST && equstr(lastrand=regs[RT1], ccloc+1)
521 && ((0xf&(ccloc[0]>>4))==p->subop || equtype(ccloc[0],p->subop))
522 &&!source(lastrand)) {
523 delnode(p); p = p->back; nrtst++; nchange++;
524 }
525 setcc(lastrand,p->subop);
526 break;
527
528 /* .rx,.rx,.rx */
529 case PROBER:
530 case PROBEW:
531 case CASE:
532 case MOVC3:
533 /* .rx,.rx */
534 case MTPR:
535 case CALLS:
536 case CMP:
537 case BIT:
538 splitrand(p);
539 /* fool repladdr into doing right number of operands */
540 if (p->op==CASE || p->op==PROBER || p->op==PROBEW) lastrand=regs[RT4];
541 /* else if (p->op==CMPV || p->op==CMPZV) lastrand=regs[RT4+1]; */
542 else if (p->op==MOVC3) lastrand=regs[RT1];
543 else lastrand=regs[RT3];
544 repladdr(p);
545 if (p->op==CALLS || p->op==MOVC3) clearreg();
546 /*if (p->op==BIT) bitopt(p);*/
547 ccloc[0]=0; break;
548
549 case CBR:
550 if (p->subop>=JBC) {
551 splitrand(p);
552 if (p->subop<JBCC) lastrand=regs[RT3]; /* 2 operands can be optimized */
553 else lastrand=regs[RT2]; /* .mb destinations lose */
554 repladdr(p);
555 }
556 ccloc[0] = 0;
557 break;
558
559 case JBR:
560 redunbr(p);
561
562 /* .wx,.bb */
563 case SOB:
564
565 default:
566 clearreg();
567 }
568 }
569 }
570
571 char *
byondrd(p)572 byondrd(p) register struct node *p; {
573 /* return pointer to register which is "beyond last read/modify operand" */
574 if (OP2==(p->subop>>4)) return(regs[RT3]);
575 switch (p->op) {
576 case MFPR:
577 case JSB:
578 case PUSHA:
579 case TST: case INC: case DEC: case PUSH: return(regs[RT2]);
580 case MTPR:
581 case BIT: case CMP: case CALLS: return(regs[RT3]);
582 case PROBER: case PROBEW:
583 case CASE: case MOVC3: return(regs[RT4]);
584 }
585 return(lastrand);
586 }
587
588 struct node *
bflow(p)589 bflow(p)
590 register struct node *p;
591 {
592 register char *cp1,*cp2,**preg; register int r;
593 int flow= -1;
594 struct node *olduse=0;
595 splitrand(p);
596 if (p->op!=PUSH && p->subop && 0<=(r=isreg(lastrand)) && r<NUSE && uses[r]==p->forw) {
597 if ((p->op==CVT || p->op==MOVZ)
598 && (p->forw->op==CVT || p->forw->op==MOVZ)
599 && p->forw->subop&0xf
600 && equtype(p->subop,p->forw->subop)
601 && !source(cp1=regs[RT1])
602 && !indexa(cp1)) goto movit;
603 if (equtype(p->subop,regs[r][0])
604 || ((p->op==CVT || p->op==MOVZ)
605 && 0xf®s[r][0] && compat(0xf&(p->subop>>4),regs[r][0]))) {
606 register int r2;
607 if (regs[r][1]!=0) {/* send directly to destination */
608 if (p->op==INC || p->op==DEC) {
609 if (p->op==DEC) p->op=SUB; else p->op=ADD;
610 p->subop=(OP2<<4)+(p->subop&0xF); /* use 2 now, convert to 3 later */
611 p->pop=0;
612 cp1=lastrand; cp2=regs[RT2]; while (*cp2++= *cp1++); /* copy reg */
613 cp1=lastrand; *cp1++='$'; *cp1++='1'; *cp1=0;
614 }
615 cp1=regs[r]+1; cp2=lastrand;
616 if (OP2==(p->subop>>4)) {/* use 3 operand form of instruction */
617 p->pop=0;
618 p->subop += (OP3-OP2)<<4; lastrand=cp2=regs[RT3];
619 }
620 while (*cp2++= *cp1++);
621 if (p->op==MOVA && p->forw->op==PUSH) {
622 p->op=PUSHA; *regs[RT2]=0; p->pop=0;
623 } else if (p->op==MOV && p->forw->op==PUSH) {
624 p->op=PUSH ; *regs[RT2]=0; p->pop=0;
625 }
626 delnode(p->forw);
627 if (0<=(r2=isreg(lastrand)) && r2<NUSE) {
628 uses[r2]=uses[r]; uses[r]=0;
629 }
630 (void) redun3(p,0);
631 newcode(p); redunm++; flow=r;
632 } else if (p->op==MOV && p->forw->op!=EXTV && p->forw->op!=EXTZV) {
633 /* superfluous fetch */
634 int nmatch;
635 char src[C2_ASIZE];
636 movit:
637 cp2=src; cp1=regs[RT1]; while (*cp2++= *cp1++);
638 splitrand(p->forw);
639 if (p->forw->op != INC && p->forw->op != DEC)
640 lastrand=byondrd(p->forw);
641 nmatch=0;
642 for (preg=regs+RT1;*preg!=lastrand;preg++)
643 if (r==isreg(*preg)) {
644 cp2= *preg; cp1=src; while (*cp2++= *cp1++); ++nmatch;
645 }
646 if (nmatch==1) {
647 if (OP2==(p->forw->subop>>4) && equstr(src,regs[RT2])) {
648 p->forw->pop=0;
649 p->forw->subop += (OP3-OP2)<<4; cp1=regs[RT3];
650 *cp1++='r'; *cp1++=r+'0'; *cp1=0;
651 }
652 delnode(p); p=p->forw;
653 if (0<=(r2=isreg(src)) && r2<NUSE) {
654 uses[r2]=uses[r]; uses[r]=0;
655 }
656 (void) redun3(p,0);
657 newcode(p); redunm++;
658 return(p); /* avoid stale uses[] data */
659 } else splitrand(p);
660 }
661 } else if (p->op==MOV && (p->forw->op==CVT || p->forw->op==MOVZ)
662 && p->forw->subop&0xf /* if base or index, then forget it */
663 && compat(p->subop,p->forw->subop) && !source(cp1=regs[RT1])
664 && !indexa(cp1)) goto movit;
665 }
666 /* adjust 'lastrand' past any 'read' or 'modify' operands. */
667 lastrand=byondrd(p);
668 /* a 'write' clobbers the register. */
669 if (0<=(r=isreg(lastrand)) && r<NUSE
670 || OP2==(p->subop>>4) && 0<=(r=isreg(regs[RT2])) && r<NUSE && uses[r]==0) {
671 /* writing a dead register is useless, but watch side effects */
672 switch (p->op) {
673 case ACB:
674 case AOBLEQ: case AOBLSS: case SOBGTR: case SOBGEQ: break;
675 default:
676 if (uses[r]==0) {/* no direct uses, check for use of condition codes */
677 register struct node *q=p;
678 while ((q=nonlab(q->forw))->combop==JBR) q=q->ref; /* cc unused, unchanged */
679 if (q->op!=CBR) {/* ... and destroyed */
680 preg=regs+RT1;
681 while (cp1= *preg++) {
682 if (cp1==lastrand) {redunm++; delnode(p); return(p->forw);}
683 if (source(cp1) || equstr(cp1,lastrand)) break;
684 }
685 }
686 }
687 flow=r;
688 }
689 }
690 if (0<=(r=flow)) {
691 olduse=uses[r];
692 uses[r]=0;
693 regs[r][0]=regs[r][1]=0;
694 }
695 /* these two are here, rather than in bmove(),
696 /* because I decided that it was better to go for 3-address code
697 /* (save time) rather than fancy jbxx (save 1 byte)
698 /* on sequences like bisl2 $64,r0; movl r0,foo
699 */
700 if (p->op==BIC) {p=bicopt(p); splitrand(p); lastrand=byondrd(p);}
701 if (p->op==BIS) {(void) bixprep(p,JBSS); lastrand=byondrd(p);}
702 /* now look for 'read' or 'modify' (read & write) uses */
703 preg=regs+RT1;
704 while (*(cp1= *preg++)) {
705 /* check for r */
706 if (lastrand!=cp1 && 0<=(r=isreg(cp1)) && r<NUSE && uses[r]==0) {
707 uses[r]=p; cp2=regs[r]; *cp2++=p->subop;
708 if (p->op==ASH && preg==(regs+RT1+1)) cp2[-1]=BYTE; /* stupid DEC */
709 if (p->op==MOV || p->op==PUSH || p->op==CVT || p->op==MOVZ || p->op==COM || p->op==NEG) {
710 if (p->op==PUSH) cp1="-(sp)";
711 else {
712 cp1=regs[RT2];
713 if (0<=(r=isreg(cp1)) && r<NUSE && uses[r]==0)
714 uses[r]=olduse; /* reincarnation!! */
715 /* as in addl2 r0,r1; movl r1,r0; ret */
716 if (p->op!=MOV) cp1=0;
717 }
718 if (cp1) while (*cp2++= *cp1++);
719 else *cp2=0;
720 } else *cp2=0;
721 continue;
722 }
723 /* check for (r),(r)+,-(r),[r] */
724 do if (*cp1=='(' || *cp1=='[') {/* get register number */
725 char t;
726 cp2= ++cp1; while (*++cp1!=')' && *cp1!=']'); t= *cp1; *cp1=0;
727 if (0<=(r=isreg(cp2)) && r<NUSE && (uses[r]==0 || uses[r]==p)) {
728 uses[r]=p; regs[r][0]=(*--cp2=='[' ? OPX<<4 : OPB<<4);
729 }
730 *cp1=t;
731 } while (*++cp1);
732 }
733 /* pushax or movax possibility? */
734 cp1=regs[RT1];
735 if (*cp1++=='$' && isstatic(cp1) && natural(regs[RT1])) {
736 if (p->combop==T(MOV,LONG)) {
737 if (regs[RT1][1]=='L' && 0!=(p->labno=getnum(regs[RT1]+2))) {
738 cp1=p->code; while (*cp1++!=','); p->code= --cp1;
739 }
740 p->combop=T(MOVA,LONG); ++p->code; p->pop=0;
741 } else if (p->combop==T(PUSH,LONG)) {
742 p->combop=T(PUSHA,LONG); ++p->code; p->pop=0;
743 } else if ((p->combop&0xFFFF)==T(ADD,U(LONG,OP3))
744 && 0<=(r=isreg(regs[RT2]))) {
745 cp1=cp2=p->code; ++cp1;
746 do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]='[';
747 do *cp2++= *cp1; while (*cp1++!=','); cp2[-1]=']';
748 if (!equstr(regs[RT3],"-(sp)")) p->combop=T(MOVA,BYTE);
749 else {p->combop=T(PUSHA,BYTE); *cp2=0;}
750 if (r < NUSE && uses[r] == 0) {
751 uses[r]=p;
752 regs[r][0]=OPX<<4;
753 }
754 p->pop=0;
755 }
756 }
757 return(p);
758 }
759
ispow2(n)760 ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */
761 register int log;
762 if (n==0 || n&(n-1)) return(-1); log=0;
763 for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);}
764 }
765
766 #ifdef notdef
bitopt(p)767 bitopt(p) register struct node *p; {
768 /* change "bitx $<power_of_2>,a" followed by JEQ or JNE
769 /* into JBC or JBS. watch out for I/O registers. (?)
770 /* assumes that 'splitrand' has already been called.
771 */
772 register char *cp1,*cp2; int b;
773 cp1=regs[RT1]; cp2=regs[RT2];
774 if (*cp1++!='$' || !okio(cp2) || p->forw->op!=CBR || p->forw->subop&-2 ||
775 0>(b=ispow2(getnum(cp1)))) return;
776 if (p->subop!=BYTE && !(b==0 && p->subop==LONG) &&
777 (source(cp2) || indexa(cp2))) return;
778 if (b>=bitsize[p->subop]) {/* you dummy! */
779 if (source(cp2)) {/* side effect: auto increment or decrement */
780 p->pop=0;
781 p->op=TST; --cp1; while (*cp1++= *cp2++);
782 regs[RT2][0]=0; newcode(p);
783 } else delnode(p);
784 p = p->forw;
785 if (p->subop==JEQ) {p->combop=JBR; p->pop=0;}
786 else delnode(p);
787 nchange++; nbj++; return;
788 }
789 if (cp1=p->forw->code) {/* destination is not an internal label */
790 cp2=regs[RT3]; while (*cp2++= *cp1++);
791 }
792 if (b==0 && (p->subop==LONG || !(source(regs[RT2]) || indexa(regs[RT2])))) {
793 /* JLB optimization, ala BLISS */
794 cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++);
795 cp2=regs[RT2]; cp1=regs[RT3]; while (*cp2++= *cp1++);
796 *(regs[RT3])=0; p->forw->subop += JLBC-JBC;
797 p->forw->pop=0;
798 } else {
799 cp1=regs[RT1]+1;
800 if (b>9) *cp1++= b/10 +'0'; *cp1++= b%10 +'0'; *cp1=0; /* $<bit_number> */
801 }
802 nbj++; newcode(p); p->combop = p->forw->combop+((JBC-JEQ)<<8);
803 p->labno = p->forw->labno; delnode(p->forw);
804 p->pop=0;
805 }
806 #endif
807
isfield(n)808 isfield(n) register long n; {/* -1 -> no; else -> position of low bit */
809 register int p; register long t;
810 t= ((n-1)|n) +1;
811 if (n!=0 && (0==t || 0<=ispow2(t))) {
812 p=0; while(!(n&1)) {n >>= 1; ++p;} return(p);
813 } else return(-1);
814 }
815
bixprep(p,bix)816 bixprep(p,bix) register struct node *p; {
817 /* initial setup, single-bit checking for bisopt, bicopt.
818 /* return: 0->don't bother any more; 1->worthwhile trying
819 */
820 register char *cp1,*cp2;
821 splitrand(p); cp1=regs[RT1]; cp2=regs[RT2];
822 if (*cp1++!='$' || 0>(pos=isfield(f=getnum(cp1)))
823 || !okio(cp2) || indexa(cp2) || source(cp2) || !okio(lastrand)) return(0);
824 f |= f-1; if (++f==0) siz=32-pos; else siz=ispow2(f)-pos;
825 if (siz==1 && pos>5 && (p->subop>>4)==OP2 && (p->subop&0xF)!=BYTE
826 && pos<bitsize[p->subop&0xF]) {
827 p->ref = insertl(p->forw); p->combop = CBR | (bix<<8);
828 p->pop=0;
829 p->labno = p->ref->labno;
830 if (pos>9) {*cp1++= pos/10 +'0'; pos %= 10;}
831 *cp1++=pos+'0'; *cp1=0; newcode(p); nbj++; return(0);
832 }
833 return(1);
834 }
835
836
837 struct node *
bicopt(p)838 bicopt(p) register struct node *p; {
839 /* use field operations or MOVZ if possible. done as part of 'bflow'.
840 */
841 register char *cp1,*cp2; int r;
842 char src[C2_ASIZE];
843 char lhssiz, sop;
844 if (!bixprep(p,JBCC)) return(p);
845 if (f==0) {/* the BIC isolates low order bits */
846 siz=pos; pos=0;
847 if ((p->subop&0xF)==LONG && *(regs[RT2])!='$') {/* result of EXTZV is long */
848 /* save source of BICL in 'src' */
849 cp1=regs[RT2]; cp2=src; while (*cp2++= *cp1++);
850 if (p->back->op==ASH) {/* try for more */
851 splitrand(p->back); cp1=regs[RT1]; cp2=regs[RT3];
852 if (*cp1++=='$' && *(regs[RT2])!='$' && !indexa(regs[RT2])
853 && 0>(f=getnum(cp1)) && equstr(src,cp2)
854 && 0<=(r=isreg(cp2)) && r<NUSE
855 && siz-f <= 32) { /* a good ASH */
856 pos -= f; cp1=regs[RT2]; cp2=src; while (*cp2++= *cp1++);
857 delnode(p->back);
858 }
859 }
860 /*
861 * 'pos', 'siz' known; find out the size of the
862 * left-hand operand of what the bicl will turn into.
863 */
864 if (pos==0 && siz==16)
865 lhssiz = WORD; /* movzwl */
866 else
867 lhssiz = BYTE; /* movzbl or extzvl */
868 if (p->back->op==CVT || p->back->op==MOVZ) {/* greedy, aren't we? */
869 splitrand(p->back); cp1=regs[RT1]; cp2=regs[RT2];
870 /*
871 * If indexa(cp1) || autoid(cp1), the fold may
872 * still be OK if the CVT/MOVZ has the same
873 * size operand on its left size as what we
874 * will turn the bicl into.
875 * However, if the CVT is from a float or
876 * double, forget it!
877 */
878 sop = p->back->subop&0xF; /* type of LHS of CVT/MOVZ */
879 if (equstr(src,cp2) && okio(cp1)
880 && sop != FFLOAT && sop != DFLOAT
881 && sop != GFLOAT && sop != HFLOAT
882 && ((!indexa(cp1) && !autoid(cp1)) || lhssiz == sop)
883 && 0<=(r=isreg(cp2)) && r<NUSE
884 && bitsize[sop]>=(pos+siz)
885 && bitsize[p->back->subop>>4]>=(pos+siz)) {/* good CVT */
886 cp1=regs[RT1]; cp2=src; while (*cp2++= *cp1++);
887 delnode(p->back);
888 }
889 }
890 /* 'pos', 'siz' known; source of field is in 'src' */
891 splitrand(p); /* retrieve destination of BICL */
892 if ((siz==8 || siz==16) && pos==0) {
893 p->combop = T(MOVZ,U(lhssiz,LONG));
894 sprintf(line,"%s,%s",src,lastrand);
895 } else {
896 p->combop = T(EXTZV,LONG);
897 sprintf(line,"$%d,$%d,%s,%s",pos,siz,src,lastrand);
898 }
899 p->pop=0;
900 p->code = copy(line); nfield++; return(p);
901 }/* end EXTZV possibility */
902 }/* end low order bits */
903 /* unfortunately, INSV clears the condition codes, thus cannot be used */
904 /* else {/* see if BICL2 of positive field should be INSV $0 */
905 /* if (p->subop==(LONG | (OP2<<4)) && 6<=(pos+siz)) {
906 /* p->combop = INSV;
907 /* sprintf(line,"$0,$%d,$%d,%s",pos,siz,lastrand);
908 /* p->code = copy(line); nfield++; return(p);
909 /* }
910 /* }
911 */
912 return(p);
913 }
914
jumpsw()915 jumpsw()
916 {
917 register struct node *p, *p1;
918 register struct node *tp;
919 long tl;
920 char *tcp;
921 int ti;
922 int nj;
923
924 ti = 0;
925 nj = 0;
926 for (p=first.forw; p!=0; p = p->forw)
927 p->seq = ++ti;
928 for (p=first.forw; p!=0; p = p1) {
929 p1 = p->forw;
930 if (p->op == CBR && p1->op==JBR && p->ref && p1->ref
931 && abs(p->seq - p->ref->seq) > abs(p1->seq - p1->ref->seq)) {
932 if (p->ref==p1->ref)
933 continue;
934 p->subop = revbr[p->subop];
935 p->pop=0;
936 tp = p1->ref;
937 p1->ref = p->ref;
938 p->ref = tp;
939 tl = p1->labno;
940 p1->labno = p->labno;
941 p->labno = tl;
942 #ifdef COPYCODE
943 if (p->labno == 0) {
944 tcp = p1->code;
945 p1->code = p->code;
946 p->code = tcp;
947 }
948 #endif
949 nrevbr++;
950 nj++;
951 }
952 }
953 return(nj);
954 }
955
addsob()956 addsob()
957 {
958 register struct node *p, *p1, *p2, *p3;
959
960 for (p = &first; (p1 = p->forw)!=0; p = p1) {
961 if (p->combop==T(DEC,LONG) && p1->op==CBR) {
962 if (abs(p->seq - p1->ref->seq) > 8) continue;
963 if (p1->subop==JGE || p1->subop==JGT) {
964 if (p1->subop==JGE) p->combop=SOBGEQ; else p->combop=SOBGTR;
965 p->pop=0;
966 p->labno = p1->labno; delnode(p1); nsob++;
967 }
968 } else if (p->combop==T(INC,LONG)) {
969 if (p1->op==LABEL && p1->refc==1 && p1->forw->combop==T(CMP,LONG)
970 && (p2=p1->forw->forw)->combop==T(CBR,JLE)
971 && (p3=p2->ref->back)->combop==JBR && p3->ref==p1
972 && p3->forw->op==LABEL && p3->forw==p2->ref) {
973 /* change INC LAB: CMP to LAB: INC CMP */
974 p->back->forw=p1; p1->back=p->back;
975 p->forw=p1->forw; p1->forw->back=p;
976 p->back=p1; p1->forw=p;
977 p1=p->forw;
978 /* adjust beginning value by 1 */
979 p2=alloc(sizeof first); p2->combop=T(DEC,LONG);
980 p2->pop=0;
981 p2->forw=p3; p2->back=p3->back; p3->back->forw=p2;
982 p3->back=p2; p2->code=p->code; p2->labno=0;
983 }
984 if (p1->combop==T(CMP,LONG) && (p2=p1->forw)->op==CBR) {
985 register char *cp1,*cp2;
986 splitrand(p1); if (!equstr(p->code,regs[RT1])) continue;
987 if (abs(p->seq - p2->ref->seq)>8) {/* outside byte displ range */
988 if (p2->subop!=JLE) continue;
989 p->combop=T(ACB,LONG);
990 cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */
991 cp2=regs[RT2]; cp1="$1"; while (*cp2++= *cp1++); /* increment */
992 cp2=regs[RT3]; cp1=p->code; while (*cp2++= *cp1++); /* index */
993 p->pop=0; newcode(p);
994 p->labno = p2->labno; delnode(p2); delnode(p1); nsob++;
995 } else if (p2->subop==JLE || p2->subop==JLT) {
996 if (p2->subop==JLE) p->combop=AOBLEQ; else p->combop=AOBLSS;
997 cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */
998 cp2=regs[RT2]; cp1=p->code; while (*cp2++= *cp1++); /* index */
999 p->pop=0; newcode(p);
1000 p->labno = p2->labno; delnode(p2); delnode(p1); nsob++;
1001 }
1002 }
1003 }
1004 }
1005 }
1006
equop(p1,p2)1007 equop(p1, p2)
1008 register struct node *p1;
1009 struct node *p2;
1010 {
1011 register char *cp1, *cp2;
1012
1013 if (p1->combop != p2->combop)
1014 return(0);
1015 if (p1->combop == 0 && p1->pop != p2->pop)
1016 return(0);
1017 if (p1->op>0 && p1->op<MOV)
1018 return(0);
1019 switch (p1->combop) {
1020 case EROU: case JSW: case TEXT: case DATA:
1021 case BSS: case ALIGN: case WGEN: case END:
1022 /*
1023 * Consider all pseudo-ops to be unique.
1024 */
1025 return(0);
1026 }
1027 if (p1->op==MOVA && p1->labno!=p2->labno) return(0);
1028 cp1 = p1->code;
1029 cp2 = p2->code;
1030 if (cp1==0 && cp2==0)
1031 return(1);
1032 if (cp1==0 || cp2==0)
1033 return(0);
1034 while (*cp1 == *cp2++)
1035 if (*cp1++ == 0)
1036 return(1);
1037 return(0);
1038 }
1039
1040 #ifndef delnode
delnode(p)1041 delnode(p) register struct node *p; {
1042 p->back->forw = p->forw;
1043 p->forw->back = p->back;
1044 }
1045 #endif
1046
1047 #ifndef decref
decref(p)1048 decref(p)
1049 register struct node *p;
1050 {
1051 if (p && --p->refc <= 0) {
1052 nrlab++;
1053 delnode(p);
1054 }
1055 }
1056 #endif
1057
1058 struct node *
nonlab(ap)1059 nonlab(ap)
1060 struct node *ap;
1061 {
1062 register struct node *p;
1063
1064 p = ap;
1065 while (p && p->op==LABEL)
1066 p = p->forw;
1067 return(p);
1068 }
1069
clearuse()1070 clearuse() {
1071 register struct node **i;
1072 for (i=uses+NUSE; i>uses;) *--i=0;
1073 }
1074
clearreg()1075 clearreg() {
1076 register char **i;
1077 for (i=regs; i<regs+NREG; ++i) {
1078 **i = 0;
1079 *(*i+1) = 0;
1080 }
1081 conloc[0] = 0;
1082 ccloc[0] = 0;
1083 }
1084
savereg(ai,s,type)1085 savereg(ai, s, type)
1086 register char *s;
1087 {
1088 register char *p, *sp;
1089
1090 sp = p = regs[ai];
1091 if (source(s)) /* side effects in addressing */
1092 return;
1093 /* if any indexing, must be parameter or local */
1094 /* indirection (as in "*-4(fp)") is ok, however */
1095 *p++ = type;
1096 while (*p++ = *s)
1097 if (*s=='[' || *s++=='(' && *s!='a' && *s!='f') {*sp = 0; return;}
1098 }
1099
dest(s,type)1100 dest(s,type)
1101 register char *s;
1102 {
1103 register int i;
1104
1105 (void) source(s); /* handle addressing side effects */
1106 if (!natural(s)) {
1107 /* wild store, everything except constants vanishes */
1108 for (i=NREG; --i>=0;)
1109 if (regs[i][1] != '$')
1110 regs[i][0] = regs[i][1] = 0;
1111 conloc[0] = 0; ccloc[0] = 0;
1112 return;
1113 }
1114 if ((i = isreg(s)) >= 0) {
1115 /* if register destination, that reg is a goner */
1116 regs[i][0] = regs[i][1] = 0;
1117 switch(type & 0xF){
1118 case DFLOAT: /* clobber two at once */
1119 /*FALLTHROUGH*/
1120 case GFLOAT:
1121 regs[i+1][0] = regs[i+1][1] = 0;
1122 break;
1123 case HFLOAT: /* clobber four at once */
1124 regs[i+1][0] = regs[i+1][1] = 0;
1125 regs[i+2][0] = regs[i+2][1] = 0;
1126 regs[i+3][0] = regs[i+3][1] = 0;
1127 break;
1128 }
1129 switch((type>>4)&0xF){
1130 case DFLOAT: /* clobber two at once */
1131 /*FALLTHROUGH*/
1132 case GFLOAT:
1133 regs[i+1][0] = regs[i+1][1] = 0;
1134 break;
1135 case HFLOAT: /* clobber four at once */
1136 regs[i+1][0] = regs[i+1][1] = 0;
1137 regs[i+2][0] = regs[i+2][1] = 0;
1138 regs[i+3][0] = regs[i+3][1] = 0;
1139 break;
1140 }
1141 }
1142 for (i=NREG; --i>=0;)
1143 if (regs[i][1]=='*' && equstr(s, regs[i]+2))
1144 regs[i][0] = regs[i][1] = 0; /* previous indirection through destination is invalid */
1145 while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */
1146 regs[i][0] = regs[i][1] = 0;
1147 if (*conloc && equstr(conloc, s))
1148 conloc[0] = 0;
1149 setcc(s, type); /* natural destinations set condition codes */
1150 }
1151
1152 /* separate operands at commas, set up 'regs' and 'lastrand' */
1153 splitrand(p) struct node *p; {
1154 register char *p1, *p2;
1155 register char **preg;
1156
1157 preg = regs+RT1;
1158 if (p1 = p->code)
1159 while (*p1) {
1160 lastrand = p2 = *preg++;
1161 while (*p1)
1162 if (',' == (*p2++ = *p1++)) {
1163 --p2;
1164 break;
1165 }
1166 *p2 = 0;
1167 }
1168 while (preg < (regs+RT1+5))
1169 *(*preg++) = 0;
1170 }
1171
compat(have,want)1172 compat(have, want) {
1173 register int hsrc, hdst;
1174 if (0==(want &= 0xF)) return(1); /* anything satisfies a wildcard want */
1175 hsrc=have&0xF;
1176 if (0==(hdst=((have>>4)&0xF)) || (hdst>=OP2 && hdst<=OPX)) hdst=hsrc;
1177 if (want>=FFLOAT) return(hdst==want && hsrc==want);
1178 /* FLOAT, DFLOAT not compat: rounding */
1179 return(hsrc>=want && hdst>=want && hdst<FFLOAT);
1180 }
1181
equtype(t1,t2)1182 equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));}
1183
findrand(as,type)1184 findrand(as, type)
1185 char *as;
1186 {
1187 register char **i;
1188 for (i = regs+NREG; --i>=regs;) {
1189 if (**i && equstr(*i+1, as) && compat(**i,type))
1190 return(i-regs);
1191 }
1192 return(-1);
1193 }
1194
isreg(s)1195 isreg(s)
1196 register char *s;
1197 {
1198 if (*s++!='r' || !isdigit(*s++)) return(-1);
1199 if (*s==0) return(*--s-'0');
1200 if (*(s-1)=='1' && isdigit(*s++) && *s==0) return(10+*--s-'0');
1201 return(-1);
1202 }
1203
check()1204 check()
1205 {
1206 register struct node *p, *lp;
1207
1208 lp = &first;
1209 for (p=first.forw; p!=0; p = p->forw) {
1210 if (p->back != lp) {
1211 fprintf(stderr, "c2: failed internal consistency check -- help!\n");
1212 exit(-1);
1213 }
1214 lp = p;
1215 }
1216 }
1217
source(ap)1218 source(ap)
1219 char *ap;
1220 {
1221 register char *p1, *p2;
1222
1223 p1 = ap;
1224 p2 = p1;
1225 if (*p1==0)
1226 return(0);
1227 while (*p2++ && *(p2-1)!='[');
1228 if (*p1=='-' && *(p1+1)=='('
1229 || *p1=='*' && *(p1+1)=='-' && *(p1+2)=='('
1230 || *(p2-2)=='+') {
1231 while (*p1 && *p1++!='r');
1232 if (isdigit(*p1++))
1233 if (isdigit(*p1))
1234 regs[10+*p1-'0'][0] = regs[10+*p1-'0'][1] = 0;
1235 else {
1236 --p1;
1237 regs[*p1-'0'][0] = regs[*p1-'0'][1] = 0;
1238 }
1239 return(1);
1240 }
1241 return(0);
1242 }
1243
1244 newcode(p) struct node *p; {
1245 register char *p1,*p2,**preg;
1246 preg=regs+RT1; p2=line;
1247 while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';}
1248 *--p2=0;
1249 p->code=copy(line);
1250 }
1251
1252 repladdr(p)
1253 struct node *p;
1254 {
1255 register r;
1256 register char *p1;
1257 char **preg; int nrepl;
1258
1259 preg=regs+RT1; nrepl=0;
1260 while (lastrand!=(p1= *preg++))
1261 if (!source(p1) && 0<=(r=findrand(p1,p->subop))) {
1262 *p1++='r'; if (r>9) {*p1++='1'; r -= 10;} *p1++=r+'0'; *p1=0;
1263 nrepl++; nsaddr++;
1264 }
1265 if (nrepl) newcode(p);
1266 }
1267
1268 /* movedat()
1269 /* {
1270 /* register struct node *p1, *p2;
1271 /* struct node *p3;
1272 /* register seg;
1273 /* struct node data;
1274 /* struct node *datp;
1275 /*
1276 /* if (first.forw == 0)
1277 /* return;
1278 /* datp = &data;
1279 /* for (p1 = first.forw; p1!=0; p1 = p1->forw) {
1280 /* if (p1->op == DATA) {
1281 /* p2 = p1->forw;
1282 /* while (p2 && p2->op!=TEXT)
1283 /* p2 = p2->forw;
1284 /* if (p2==0)
1285 /* break;
1286 /* p3 = p1->back;
1287 /* p1->back->forw = p2->forw;
1288 /* p2->forw->back = p3;
1289 /* p2->forw = 0;
1290 /* datp->forw = p1;
1291 /* p1->back = datp;
1292 /* p1 = p3;
1293 /* datp = p2;
1294 /* }
1295 /* }
1296 /* if (data.forw) {
1297 /* datp->forw = first.forw;
1298 /* first.forw->back = datp;
1299 /* data.forw->back = &first;
1300 /* first.forw = data.forw;
1301 /* }
1302 /* seg = -1;
1303 /* for (p1 = first.forw; p1!=0; p1 = p1->forw) {
1304 /* if (p1->op==TEXT||p1->op==DATA||p1->op==BSS) {
1305 /* if (p1->op == seg || p1->forw&&p1->forw->op==seg) {
1306 /* p1->back->forw = p1->forw;
1307 /* p1->forw->back = p1->back;
1308 /* p1 = p1->back;
1309 /* continue;
1310 /* }
1311 /* seg = p1->op;
1312 /* }
1313 /* }
1314 /* }
1315 */
1316
redunbr(p)1317 redunbr(p)
1318 register struct node *p;
1319 {
1320 register struct node *p1;
1321 register char *ap1;
1322 char *ap2;
1323
1324 if ((p1 = p->ref) == 0)
1325 return;
1326 p1 = nonlab(p1);
1327 if (p1->op==TST) {
1328 splitrand(p1);
1329 savereg(RT2, "$0", p1->subop);
1330 } else if (p1->op==CMP)
1331 splitrand(p1);
1332 else
1333 return;
1334 if (p1->forw->op==CBR) {
1335 ap1 = findcon(RT1, p1->subop);
1336 ap2 = findcon(RT2, p1->subop);
1337 p1 = p1->forw;
1338 if (compare(p1->subop, ap1, ap2)) {
1339 nredunj++;
1340 nchange++;
1341 decref(p->ref);
1342 p->ref = p1->ref;
1343 p->labno = p1->labno;
1344 #ifdef COPYCODE
1345 if (p->labno == 0)
1346 p->code = p1->code;
1347 #endif
1348 if (p->ref)
1349 p->ref->refc++;
1350 }
1351 } else if (p1->op==TST && equstr(regs[RT1],ccloc+1) &&
1352 equtype(ccloc[0],p1->subop)) {
1353 p1=insertl(p1->forw);
1354 decref(p->ref);
1355 p->ref=p1;
1356 p->labno=p1->labno;
1357 nrtst++; nchange++;
1358 }
1359 }
1360
1361 char *
findcon(i,type)1362 findcon(i, type)
1363 {
1364 register char *p;
1365 register r;
1366
1367 p = regs[i];
1368 if (*p=='$')
1369 return(p);
1370 if ((r = isreg(p)) >= 0 && compat(regs[r][0],type))
1371 return(regs[r]+1);
1372 if (equstr(p, conloc))
1373 return(conval+1);
1374 return(p);
1375 }
1376
compare(opc,acp1,acp2)1377 compare(opc, acp1, acp2)
1378 char *acp1, *acp2;
1379 {
1380 register char *cp1, *cp2;
1381 register n1;
1382 int n2; int sign;
1383
1384 cp1 = acp1;
1385 cp2 = acp2;
1386 if (*cp1++ != '$' || *cp2++ != '$')
1387 return(0);
1388 n1 = 0; sign=1; if (*cp2=='-') {++cp2; sign= -1;}
1389 while (isdigit(*cp2)) {n1 *= 10; n1 += (*cp2++ - '0')*sign;}
1390 n2 = n1;
1391 n1 = 0; sign=1; if (*cp1=='-') {++cp1; sign= -1;}
1392 while (isdigit(*cp1)) {n1 *= 10; n1 += (*cp1++ - '0')*sign;}
1393 if (*cp1=='+')
1394 cp1++;
1395 if (*cp2=='+')
1396 cp2++;
1397 do {
1398 if (*cp1++ != *cp2)
1399 return(0);
1400 } while (*cp2++);
1401 switch(opc) {
1402
1403 case JEQ:
1404 return(n1 == n2);
1405 case JNE:
1406 return(n1 != n2);
1407 case JLE:
1408 return(n1 <= n2);
1409 case JGE:
1410 return(n1 >= n2);
1411 case JLT:
1412 return(n1 < n2);
1413 case JGT:
1414 return(n1 > n2);
1415 case JLO:
1416 return((unsigned) n1 < (unsigned) n2);
1417 case JHI:
1418 return((unsigned) n1 > (unsigned) n2);
1419 case JLOS:
1420 return((unsigned) n1 <= (unsigned) n2);
1421 case JHIS:
1422 return((unsigned) n1 >= (unsigned) n2);
1423 }
1424 return(0);
1425 }
1426
setcon(cv,cl,type)1427 setcon(cv, cl, type)
1428 register char *cv, *cl;
1429 {
1430 register char *p;
1431
1432 if (*cv != '$')
1433 return;
1434 if (!natural(cl))
1435 return;
1436 p = conloc;
1437 while (*p++ = *cl++);
1438 p = conval;
1439 *p++ = type;
1440 while (*p++ = *cv++);
1441 }
1442
equstr(p1,p2)1443 equstr(p1, p2)
1444 register char *p1, *p2;
1445 {
1446 do {
1447 if (*p1++ != *p2)
1448 return(0);
1449 } while (*p2++);
1450 return(1);
1451 }
1452
setcc(ap,type)1453 setcc(ap,type)
1454 char *ap;
1455 {
1456 register char *p, *p1;
1457
1458 p = ap;
1459 if (!natural(p)) {
1460 ccloc[0] = 0;
1461 return;
1462 }
1463 p1 = ccloc;
1464 *p1++ = type;
1465 while (*p1++ = *p++);
1466 }
1467
okio(p)1468 okio(p) register char *p; {/* 0->probable I/O space address; 1->not */
1469 if (ioflag && (!natural(p) || 0>getnum(p))) return(0);
1470 return(1);
1471 }
1472
indexa(p)1473 indexa(p) register char *p; {/* 1-> uses [r] addressing mode; 0->doesn't */
1474 while (*p) if (*p++=='[') return(1);
1475 return(0);
1476 }
1477
natural(p)1478 natural(p)
1479 register char *p;
1480 {/* 1->simple local, parameter, global, or register; 0->otherwise */
1481 if (*p=='*' || *p=='(' || *p=='-'&&p[1]=='(' || *p=='$'&&getnum(p+1))
1482 return(0);
1483 while (*p++);
1484 p--;
1485 if (*--p=='+' || *p==']' || *p==')' && p[-2]!='a' && p[-2]!='f')
1486 return(0);
1487 return(1);
1488 }
1489
1490 /*
1491 ** Tell if an argument is most likely static.
1492 */
1493
isstatic(cp)1494 isstatic(cp)
1495 register char *cp;
1496 {
1497 if (*cp == '_' || *cp == 'L' || (*cp++ == 'v' && *cp == '.'))
1498 return (1);
1499 return (0);
1500 }
1501
autoid(p)1502 autoid(p) register char *p; {/* 1-> uses autoincrement/autodecrement; 0->doesn't */
1503 if (*p == '-' && *(p+1) == '(') return(1);
1504 while (*p) p++;
1505 if (*--p == '+' && *--p == ')') return(1);
1506 return(0);
1507 }
1508