![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c22.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / fc2|
Return to c22.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / fc2 |
1.1 ! root 1: /* ! 2: * C object code improver-- third part ! 3: */ ! 4: ! 5: #include "c2.h" ! 6: #include <stdio.h> ! 7: #include <ctype.h> ! 8: ! 9: rmove() ! 10: { ! 11: register struct node *p; ! 12: register int r, r1; ! 13: ! 14: clearreg(); ! 15: for (p=first.forw; p!=0; p = p->forw) { ! 16: if (debug) { ! 17: printf("Regs: "); ! 18: for (r=0; r<=NREG; r++) ! 19: if (regs[r][0]) { ! 20: r1=regs[r][0]; ! 21: printf("%d: %d%d %s\n", r, r1&0xF, r1>>4, regs[r]+1); ! 22: } ! 23: printf("-\n"); ! 24: } ! 25: switch (p->op) { ! 26: ! 27: case CVT: ! 28: case MOVZ: ! 29: splitrand(p); ! 30: repladdr(p); ! 31: r = isreg(regs[RT1]); ! 32: r1 = isreg(regs[RT2]); ! 33: dest(regs[RT2],p->subop, 1); ! 34: if (r>=0 && r1>=0) { ! 35: p->op = MOV; p->subop = LONG; ! 36: p->pop = 0; ! 37: nchange++; ! 38: goto case_mov; ! 39: } ! 40: if(p->op == CVT) { ! 41: if (r1>=0) savereg(r1, regs[RT1], p->subop); ! 42: } else ! 43: ccloc[0] = 0; ! 44: break; ! 45: ! 46: case MOV: ! 47: case_mov: ! 48: splitrand(p); ! 49: if ((r = findrand(regs[RT1],p->subop)) >= 0) { ! 50: if (r == isreg(regs[RT2])) ! 51: if(p->forw->op!=CBR) { ! 52: delnode(p); redunm++; nchange++; break; ! 53: } else { ! 54: p->op=TST; p->pop=0; ! 55: while(*p->code++ != ','); ! 56: redunm++; nchange++; ! 57: goto case_tst; ! 58: } ! 59: } ! 60: repladdr(p); ! 61: r = isreg(regs[RT1]); ! 62: r1 = isreg(regs[RT2]); ! 63: dest(regs[RT2],p->subop, 1); ! 64: if ((regs[ACC][0]) && equstr(regs[RT2],regs[ACC]+1)) { ! 65: *(short *)(regs[ACC]) = 0;} ! 66: ! 67: if (r>=0) { ! 68: if (r1>=0) { ! 69: if (r == r1 && p->forw->op!=CBR) { ! 70: delnode(p); redunm++; nchange++; break; ! 71: } ! 72: if(regs[r][0]) ! 73: savereg(r1, regs[r]+1, p->subop); ! 74: } else savereg(r, regs[RT2], p->subop); ! 75: } else if (r1>=0) savereg(r1, regs[RT1], p->subop); ! 76: else setcon(regs[RT1], regs[RT2], p->subop); ! 77: break; ! 78: ! 79: /* .rx,.wx or .rx,.rx,.wx */ ! 80: case ADD: ! 81: case SUB: ! 82: case AND: ! 83: case OR: ! 84: case XOR: ! 85: case MUL: ! 86: case DIV: ! 87: #ifdef EMOD ! 88: case EDIV: ! 89: case EMOD: ! 90: #endif EMOD ! 91: case SHAL: ! 92: case SHAR: ! 93: case SHL: ! 94: case SHR: ! 95: case ADDA: ! 96: case SUBA: ! 97: /* .rx,.wx */ ! 98: case MFPR: ! 99: case COM: ! 100: case NEG: ! 101: splitrand(p); ! 102: repladdr(p); ! 103: dest(lastrand,p->subop, p->op!=ADDA && p->op!=SUBA); ! 104: break; ! 105: ! 106: /* .mx or .wx */ ! 107: case STF: ! 108: if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) { ! 109: delnode(p); ! 110: nst++; nchange++; break; ! 111: } ! 112: savereg(ACC, p->code, p->subop); ! 113: case CLR: ! 114: case INC: ! 115: case DEC: ! 116: case CVFL: ! 117: dest(p->code,p->subop, 1); ! 118: if (p->op==CLR) ! 119: if ((r = isreg(p->code)) >= 0) ! 120: savereg(r, "$0", p->subop); ! 121: else ! 122: setcon("$0", p->code, p->subop); ! 123: break; ! 124: ! 125: /* .rx */ ! 126: case LDF: ! 127: if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) { ! 128: delnode(p); ! 129: nld++; nchange++; break; ! 130: } ! 131: savereg(ACC, p->code, p->subop); ! 132: goto case_tst; ! 133: case LNF: ! 134: if(equstr(p->code, regs[ACC]+1) && p->subop==regs[ACC][0]) { ! 135: p->op = NEGF; p->pop = 0; p->code = 0; ! 136: regs[ACC][0] = 0; ! 137: break; ! 138: } ! 139: case CVLF: ! 140: case LDFD: ! 141: case ADDF: ! 142: case SUBF: ! 143: case MULF: ! 144: case DIVF: ! 145: regs[ACC][0] = 0; ! 146: case TST: ! 147: case_tst: ! 148: case PUSH: ! 149: splitrand(p); ! 150: lastrand=regs[RT1+1]; /* fool repladdr into doing 1 operand */ ! 151: repladdr(p); ! 152: lastrand=regs[RT1]; ! 153: if (p->op==TST && equstr(lastrand, ccloc+1) ! 154: && ((0xf&(ccloc[0]>>4))==p->subop || equtype(ccloc[0],p->subop))) { ! 155: delnode(p); nrtst++; nchange++; break; ! 156: } ! 157: if (p->op==PUSH && p->subop!=LONG && ! 158: (isreg(lastrand)>=0 || *lastrand=='$')) { ! 159: p->subop = LONG; ! 160: p->pop = 0; ! 161: nchange++; ! 162: } ! 163: if (p->op==TST || p->op==PUSH) ! 164: setcc(lastrand,p->subop); ! 165: break; ! 166: ! 167: /* .rx,.rx,.rx */ ! 168: case PROBE: ! 169: case CASE: ! 170: /* .rx,.rx */ ! 171: case MTPR: ! 172: case CALLS: ! 173: case CALLF: ! 174: case CMP: ! 175: case BIT: ! 176: case CMPF: ! 177: case CMPF2: ! 178: splitrand(p); ! 179: /* fool repladdr into doing right number of operands */ ! 180: lastrand=byondrd(p); ! 181: if (p->op==CALLF || p->op==CALLS) clearreg(); ! 182: else repladdr(p); ! 183: case TSTF: ! 184: ccloc[0]=0; ! 185: case PUSHD: ! 186: break; ! 187: ! 188: /* acc only */ ! 189: case CVDF: ! 190: case NEGF: ! 191: case SINF: ! 192: case COSF: ! 193: case ATANF: ! 194: case LOGF: ! 195: case SQRTF: ! 196: case EXPF: ! 197: regs[ACC][0] = 0; ! 198: break; ! 199: ! 200: #ifndef EMOD ! 201: /* .rx,.rx,.wx,.wx */ ! 202: case EDIV: ! 203: splitrand(p); ! 204: lastrand = regs[RT3]; ! 205: repladdr(p); ! 206: dest(regs[RT3], p->subop, 1); ! 207: dest(regs[RT4], p->subop, 0); ! 208: break; ! 209: #endif EMOD ! 210: ! 211: /* .rx,.rx,.rx,wx */ ! 212: case EMUL: ! 213: splitrand(p); ! 214: lastrand = regs[RT4]; ! 215: repladdr(p); ! 216: dest(regs[RT4],QUAD, 1); /* fourth operand is a quad */ ! 217: break; ! 218: case CBR: ! 219: if (p->subop>=JBC) { ! 220: splitrand(p); ! 221: lastrand=regs[RT3]; /* 2 operands can be optimized */ ! 222: repladdr(p); ! 223: ccloc[0] = 0; ! 224: } else ! 225: reduncbr(p); ! 226: break; ! 227: ! 228: case JBR: ! 229: redunbr(p); ! 230: ! 231: default: ! 232: clearreg(); ! 233: } ! 234: } ! 235: } ! 236: ! 237: jumpsw() ! 238: { ! 239: register struct node *p, *p1, *pt; ! 240: register int t, nj; ! 241: ! 242: t = 0; ! 243: nj = 0; ! 244: for (p=first.forw; p!=0; p = p->forw) ! 245: p->seq = ++t; ! 246: for (p=first.forw; p!=0; p = p1) { ! 247: p1 = p->forw; ! 248: if (p->op == CBR && p1->op==JBR && p->ref && p1->ref ! 249: && abs(p->seq - p->ref->seq) > abs(p1->seq - p1->ref->seq)) { ! 250: if (p->ref==p1->ref) ! 251: continue; ! 252: p->subop = revbr[p->subop]; ! 253: p->pop=0; ! 254: pt = p1->ref; ! 255: p1->ref = p->ref; ! 256: p->ref = pt; ! 257: t = p1->labno; ! 258: p1->labno = p->labno; ! 259: p->labno = t; ! 260: #ifdef COPYCODE ! 261: if (p->labno == 0) { ! 262: pt = (struct node *)p1->code; p1->code = p->code; p->code = (char *)pt; ! 263: } ! 264: #endif ! 265: nrevbr++; ! 266: nj++; ! 267: } ! 268: } ! 269: return(nj); ! 270: } ! 271: ! 272: addaob() ! 273: { ! 274: register struct node *p, *p1, *p2, *p3; ! 275: ! 276: for (p = &first; (p1 = p->forw)!=0; p = p1) { ! 277: if (p->op==INC && p->subop==LONG) { ! 278: if (p1->op==LABEL && p1->refc==1 && p1->forw->op==CMP && p1->forw->subop==LONG ! 279: && (p2=p1->forw->forw)->op==CBR && p2->subop==JLE ! 280: && (p3=p2->ref->back)->op==JBR && p3->subop==0 && p3->ref==p1 ! 281: && p3->forw->op==LABEL && p3->forw==p2->ref) { ! 282: /* change INC LAB: CMP to LAB: INC CMP */ ! 283: p->back->forw=p1; p1->back=p->back; ! 284: p->forw=p1->forw; p1->forw->back=p; ! 285: p->back=p1; p1->forw=p; ! 286: p1=p->forw; ! 287: /* adjust beginning value by 1 */ ! 288: p2=alloc(sizeof first); p2->op = DEC; p2->subop = LONG; ! 289: p2->pop=0; ! 290: p2->forw=p3; p2->back=p3->back; p3->back->forw=p2; ! 291: p3->back=p2; p2->code=p->code; p2->labno=0; ! 292: } ! 293: if (p1->op==CMP && p1->subop==LONG && ! 294: (p2=p1->forw)->op==CBR && p2->forw->op!=CBR) { ! 295: register char *cp1,*cp2; ! 296: splitrand(p1); if (!equstr(p->code,regs[RT1])) continue; ! 297: if (p2->subop==JLE || p2->subop==JLT) { ! 298: if (p2->subop==JLE) p->op = AOBLEQ; else p->op = AOBLSS; p->subop = 0; ! 299: cp2=regs[RT1]; cp1=regs[RT2]; while (*cp2++= *cp1++); /* limit */ ! 300: cp2=regs[RT2]; cp1=p->code; while (*cp2++= *cp1++); /* index */ ! 301: p->pop=0; newcode(p); ! 302: p->labno = p2->labno; delnode(p2); delnode(p1); naob++; ! 303: } ! 304: } ! 305: } ! 306: } ! 307: } ! 308: ! 309: ispow2(n) register long n; {/* -1 -> no; else -> log to base 2 */ ! 310: register int log; ! 311: if (n==0 || n&(n-1)) return(-1); log=0; ! 312: for (;;) {n >>= 1; if (n==0) return(log); ++log; if (n== -1) return(log);} ! 313: } ! 314: ! 315: equop(p1, p2) ! 316: register struct node *p1, *p2; ! 317: { ! 318: register char *cp1, *cp2; ! 319: ! 320: if (p1->op != p2->op || p1->subop != p2->subop) ! 321: return(0); ! 322: if (p1->op>0 && p1->op<MOV) ! 323: return(0); ! 324: if (p1->op==MOVA && p1->labno!=p2->labno) return(0); ! 325: cp1 = p1->code; ! 326: cp2 = p2->code; ! 327: if (cp1==0 && cp2==0) ! 328: return(1); ! 329: if (cp1==0 || cp2==0) ! 330: return(0); ! 331: while (*cp1 == *cp2++) ! 332: if (*cp1++ == 0) ! 333: return(1); ! 334: return(0); ! 335: } ! 336: ! 337: delnode(p) register struct node *p; { ! 338: p->back->forw = p->forw; ! 339: p->forw->back = p->back; ! 340: } ! 341: ! 342: decref(p) ! 343: register struct node *p; ! 344: { ! 345: if (p && --p->refc <= 0) { ! 346: nrlab++; nchange++; ! 347: delnode(p); ! 348: } ! 349: } ! 350: ! 351: struct node * ! 352: nonlab(ap) ! 353: struct node *ap; ! 354: { ! 355: register struct node *p; ! 356: ! 357: p = ap; ! 358: while (p && p->op==LABEL) ! 359: p = p->forw; ! 360: return(p); ! 361: } ! 362: ! 363: clearuse() { ! 364: register struct node **i; ! 365: for (i=uses+NUSE; i>uses;) *--i=0; ! 366: useacc = 0; ! 367: } ! 368: ! 369: clearreg() { ! 370: register char **i; ! 371: for (i=regs+NREG+1; i>regs;){ **--i=0; **i=0; } ! 372: conloc[0] = 0; ccloc[0] = 0; ! 373: } ! 374: ! 375: savereg(ai, s, type) ! 376: register char *s; ! 377: { ! 378: register char *p, *sp; ! 379: ! 380: sp = p = regs[ai]; ! 381: /* if any indexing, must be parameter or local */ ! 382: /* indirection (as in "*-4(fp)") is ok, however */ ! 383: *p++ = type; ! 384: if (*s=='*' || *s=='$') ! 385: *p++ = *s++; ! 386: if (natural(s)) ! 387: strcpy(p, s); ! 388: else {*sp = 0; return;} ! 389: } ! 390: ! 391: dest(s,type, ccflg) ! 392: register char *s; ! 393: { ! 394: register int i; ! 395: ! 396: if ((i = isreg(s)) >= 0) { ! 397: *(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */ ! 398: if (DOUBLE==(type&0xF) || DOUBLE==((type>>4)&0xF) || type==QUAD) ! 399: *(short *)(regs[i+1]) = 0; ! 400: } ! 401: for (i=NREG; --i>=0;) ! 402: if (regs[i][1]=='*' && equstr(s, regs[i]+2)) ! 403: *(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */ ! 404: while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */ ! 405: *(short *)(regs[i]) = 0; ! 406: ! 407: if (!natural(s)) {/* wild store, everything except constants vanishes */ ! 408: for (i=NREG; --i>=0;) if (regs[i][1] != '$') *(short *)(regs[i]) = 0; ! 409: conloc[0] = 0; ccloc[0] = 0; ! 410: } else { ! 411: if(ccflg)setcc(s,type); /* natural destinations set condition codes */ ! 412: if (equstr(s, conloc)) ! 413: conloc[0] = 0; ! 414: } ! 415: } ! 416: ! 417: splitrand(p) struct node *p; { ! 418: /* separate operands at commas, set up 'regs' and 'lastrand' */ ! 419: register char *p1, *p2; register char **preg; ! 420: ! 421: preg=regs+RT1; ! 422: if (p1=p->code) while (*p1) { ! 423: lastrand=p2= *preg++; ! 424: while (*p1) if (','==(*p2++= *p1++)) {--p2; break;} ! 425: *p2=0; ! 426: } ! 427: while (preg<(regs+RT1+5)) *(*preg++)=0; ! 428: } ! 429: ! 430: compat(have, want) ! 431: register int have, want; ! 432: { ! 433: register int hsrc, hdst; ! 434: extern int bitsize[]; ! 435: ! 436: if (0==(want &= 0xF)) return(1); /* anything satisfies a wildcard want */ ! 437: hsrc=have&0xF; if (0==(hdst=((have>>4)&0xF)) || hdst>=OP2) hdst=hsrc; ! 438: if (want>=QUAD) ! 439: return(bitsize[hdst]==bitsize[want] && bitsize[hsrc]==bitsize[want]); ! 440: return(hsrc==want && hdst>=want && hdst<QUAD); ! 441: } ! 442: ! 443: equtype(t1,t2) {return(compat(t1,t2) && compat(t2,t1));} ! 444: ! 445: findrand(as, type) ! 446: char *as; ! 447: { ! 448: register char **i; ! 449: for (i = regs+NREG; --i>=regs;) { ! 450: if (**i && equstr(*i+1, as) && compat(**i,type)) ! 451: return(i-regs); ! 452: } ! 453: return(-1); ! 454: } ! 455: ! 456: isreg(s) ! 457: register char *s; ! 458: { ! 459: if (*s++!='r' || !isdigit(*s++)) return(-1); ! 460: if (*s==0) return(*--s-'0'); ! 461: if (*(s-1)=='1' && isdigit(*s++) && *s==0) return(10+*--s-'0'); ! 462: return(-1); ! 463: } ! 464: ! 465: /* ! 466: check() ! 467: { ! 468: register struct node *p, *lp; ! 469: ! 470: lp = &first; ! 471: for (p=first.forw; p!=0; p = p->forw) { ! 472: if (p->back != lp) ! 473: abort(-1); ! 474: lp = p; ! 475: } ! 476: } ! 477: */ ! 478: ! 479: newcode(p) struct node *p; { ! 480: register char *p1,*p2,**preg; ! 481: ! 482: preg=regs+RT1; p2=line; ! 483: while (*(p1= *preg++)) {while (*p2++= *p1++); *(p2-1)=',';} ! 484: *--p2=0; ! 485: p->code=copy(line); ! 486: } ! 487: ! 488: repladdr(p) ! 489: struct node *p; ! 490: { ! 491: register int r; ! 492: register char *p1; ! 493: register char **preg; ! 494: register int nrepl; ! 495: ! 496: preg=regs+RT1; nrepl=0; ! 497: while (lastrand!=(p1= *preg++)) ! 498: if (0<=(r=findrand(p1,p->subop))) { ! 499: *p1++='r'; if (r>9) {*p1++='1'; r -= 10;} *p1++=r+'0'; *p1=0; ! 500: nchange++; nrepl++; nsaddr++; ! 501: } ! 502: if (nrepl) newcode(p); ! 503: } ! 504: ! 505: /* conditional branches which are never/always taken */ ! 506: reduncbr(p) ! 507: register struct node *p; ! 508: { ! 509: register struct node *p1; ! 510: register char *ap1, *ap2; ! 511: ! 512: p1 = p->back; ! 513: if (p1->op==CMP) { ! 514: splitrand(p1); ! 515: ap1 = findcon(regs[RT1], p1->subop); ! 516: ap2 = findcon(regs[RT2], p1->subop); ! 517: } else { ! 518: if(!ccloc[0]) ! 519: return; ! 520: ap1 = findcon(ccloc+1, ccloc[0]); ! 521: ap2 = "$0"; ! 522: } ! 523: switch (compare(p->subop, ap1, ap2)) { ! 524: case 0: /* branch never taken */ ! 525: delnode(p); ! 526: nredunj++; ! 527: nchange++; ! 528: decref(p->ref); ! 529: if(p->forw->op!=CBR && (p1->op==TST || p1->op==CMP)) { ! 530: delnode(p1); ! 531: nrtst++; ! 532: } ! 533: break; ! 534: case 1: /* branch always taken */ ! 535: p->op = JBR; ! 536: p->subop = 0; ! 537: p->pop = 0; ! 538: nchange++; ! 539: if(nonlab(p->ref)->op!=CBR && (p1->op==TST || p1->op==CMP)) { ! 540: delnode(p1); ! 541: nrtst++; ! 542: } ! 543: } ! 544: } ! 545: ! 546: /* a jump to a redundant compare (start of a 'for') */ ! 547: redunbr(p) ! 548: register struct node *p; ! 549: { ! 550: register struct node *p1; ! 551: register char *ap1, *ap2; ! 552: ! 553: if ((p1 = p->ref) == 0) ! 554: return; ! 555: p1 = nonlab(p1); ! 556: if (p1->op==TST || p1->op==CMP) ! 557: splitrand(p1); ! 558: else ! 559: return; ! 560: if (p1->forw->op==CBR) { ! 561: ap1 = findcon(regs[RT1], p1->subop); ! 562: if (p1->op==TST) ! 563: ap2 = "$0"; ! 564: else ! 565: ap2 = findcon(regs[RT2], p1->subop); ! 566: p1 = p1->forw; ! 567: if (compare(p1->subop, ap1, ap2) > 0) { ! 568: nredunj++; ! 569: nchange++; ! 570: decref(p->ref); ! 571: p->ref = p1->ref; ! 572: p->labno = p1->labno; ! 573: #ifdef COPYCODE ! 574: if (p->labno == 0) ! 575: p->code = p1->code; ! 576: if (p->ref) ! 577: #endif ! 578: p->ref->refc++; ! 579: } ! 580: } else if (p1->op==TST && equstr(regs[RT1],ccloc+1) && ! 581: equtype(ccloc[0],p1->subop)) { ! 582: p1=insertl(p1->forw); decref(p->ref); p->ref=p1; ! 583: nrtst++; nchange++; ! 584: } ! 585: } ! 586: ! 587: char * ! 588: findcon(p, type) ! 589: register char *p; ! 590: { ! 591: register int r; ! 592: ! 593: if (*p=='$') ! 594: return(p); ! 595: if ((r = isreg(p)) >= 0 && compat(regs[r][0],type)) ! 596: return(regs[r]+1); ! 597: if (equstr(p, conloc)) ! 598: return(conval+1); ! 599: return(p); ! 600: } ! 601: ! 602: /* compare constants: 0 - branch taken; 1 - not taken; -1 - don't know */ ! 603: compare(op, acp1, acp2) ! 604: char *acp1, *acp2; ! 605: { ! 606: register char *cp1, *cp2; ! 607: register int n1, n2, sign; ! 608: ! 609: cp1 = acp1; ! 610: cp2 = acp2; ! 611: if (*cp1++ != '$' || *cp2++ != '$') ! 612: return(-1); ! 613: n1 = 0; sign=1; if (*cp1=='-') {++cp1; sign= -1;} ! 614: while (isdigit(*cp1)) {n1 *= 10; n1 += *cp1++ - '0';} ! 615: n1 *= sign; ! 616: n2 = 0; sign=1; if (*cp2=='-') {++cp2; sign= -1;} ! 617: while (isdigit(*cp2)) {n2 *= 10; n2 += *cp2++ - '0';} ! 618: n2 *= sign; ! 619: if (*cp1=='+') ! 620: cp1++; ! 621: if (*cp2=='+') ! 622: cp2++; ! 623: do { ! 624: if (*cp1++ != *cp2) ! 625: return(-1); ! 626: } while (*cp2++); ! 627: switch(op) { ! 628: ! 629: case JEQ: ! 630: return(n1 == n2); ! 631: case JNE: ! 632: return(n1 != n2); ! 633: case JLE: ! 634: return(n1 <= n2); ! 635: case JGE: ! 636: return(n1 >= n2); ! 637: case JLT: ! 638: return(n1 < n2); ! 639: case JGT: ! 640: return(n1 > n2); ! 641: case JLO: ! 642: return((unsigned)n1 < (unsigned)n2); ! 643: case JHI: ! 644: return((unsigned)n1 > (unsigned)n2); ! 645: case JLOS: ! 646: return((unsigned)n1 <= (unsigned)n2); ! 647: case JHIS: ! 648: return((unsigned)n1 >= (unsigned)n2); ! 649: } ! 650: return(-1); ! 651: } ! 652: ! 653: setcon(cv, cl, type) ! 654: register char *cv, *cl; ! 655: { ! 656: register char *p; ! 657: ! 658: if (*cv != '$') ! 659: return; ! 660: if (!natural(cl)) ! 661: return; ! 662: p = conloc; ! 663: while (*p++ = *cl++); ! 664: p = conval; ! 665: *p++ = type; ! 666: while (*p++ = *cv++); ! 667: } ! 668: ! 669: setcc(ap,type) ! 670: char *ap; ! 671: { ! 672: register char *p, *p1; ! 673: ! 674: p = ap; ! 675: if (!natural(p)) { ! 676: ccloc[0] = 0; ! 677: return; ! 678: } ! 679: p1 = ccloc; ! 680: *p1++ = type; ! 681: while (*p1++ = *p++); ! 682: } ! 683: ! 684: indexa(p) register char *p; {/* 1-> uses [r] addressing mode; 0->doesn't */ ! 685: while (*p) if (*p++=='[') return(1); ! 686: return(0); ! 687: } ! 688: ! 689: natural(p) ! 690: register char *p; ! 691: {/* 1->simple local, parameter, global, or register; 0->otherwise */ ! 692: ! 693: if (*p=='*' || *p=='(' || *p=='$') ! 694: return(0); ! 695: while (*p++); ! 696: p--; ! 697: if (*--p==']' || *p==')' && ! 698: !(*(p-2)=='f' || fortflg && (*--p=='1' || *p=='2') && *--p=='1')) ! 699: return(0); ! 700: return(1); ! 701: } ! 702: ! 703: /* ! 704: ** Tell if an argument is most likely static. ! 705: */ ! 706: ! 707: isstatic(cp) ! 708: register char *cp; ! 709: { ! 710: if (*cp == '_' || *cp == 'L') ! 711: return (1); ! 712: return (0); ! 713: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.