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 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 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 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 * 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 * 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 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 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 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 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 * 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 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 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 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 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 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 * 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 1070 clearuse() { 1071 register struct node **i; 1072 for (i=uses+NUSE; i>uses;) *--i=0; 1073 } 1074 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 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 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 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 1182 equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));} 1183 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 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 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 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 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 * 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 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 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 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 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 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 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 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 1494 isstatic(cp) 1495 register char *cp; 1496 { 1497 if (*cp == '_' || *cp == 'L' || (*cp++ == 'v' && *cp == '.')) 1498 return (1); 1499 return (0); 1500 } 1501 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