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