![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gencode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / ccom / vax|
Return to gencode.c CVS log | Up to [Research Unix] / researchv8dc / cmd / ccom / vax |
1.1 ! root 1: #include "gencode.h" ! 2: #define fieldbotch(p) if(p->in.left->in.op == FLD) {rewritefld(p); longjmp(back, 1);} ! 3: jmp_buf back; ! 4: int acnt, Pflag, bbcnt; ! 5: ! 6: gencode(p) ! 7: NODE *p; ! 8: { NODE *q; ! 9: ret s; ! 10: int svtemp, svregvar, i, svbb; ! 11: extern int bothdebug; ! 12: svtemp = tmpoff; ! 13: svregvar = regvar; ! 14: svbb = ++bbcnt; ! 15: if(setjmp(back)) { ! 16: pr("#\treg\t%d\n", ++acnt)/*, prtree(q), putchar('\n')*/; ! 17: if(acnt > 20) { ! 18: prtree(q); ! 19: outpr(); ! 20: tmpoff = svtemp; ! 21: bbcnt = svbb; ! 22: uerror("expression too complicated"); ! 23: return; ! 24: } ! 25: } ! 26: else ! 27: q = copytree(p); ! 28: buf = bufs[1]; ! 29: prptr = prbuf; ! 30: if(Pflag && q->in.op != INIT) { ! 31: pr("#\tincl\tlocprof+%d\n", 4*(svbb+3)); ! 32: } ! 33: /*printx("#%d ", acnt), prtree(q), printx("\n"), outpr();*/ ! 34: s = doit(q, 0, 0, REGMASK); ! 35: if(s.flag & FAIL) ! 36: uerror("codegen failed at top level"); ! 37: acnt = ntree = 0; ! 38: if(Pflag && q->in.op != INIT) ! 39: printx("#%d ", svbb), prtree(q), printx("\n"); ! 40: outpr(); ! 41: tmpoff = svtemp; ! 42: regvar = svregvar; ! 43: if(M32 && !bothdebug) ! 44: for(i = 0; i < NRGS; i++) ! 45: busy[i] = 0; ! 46: } ! 47: ! 48: ret ! 49: doit(p, flag, dest, regmask) ! 50: NODE *p; ! 51: ret dest; ! 52: { ret s, t, x, y; ! 53: char *pp; ! 54: NODE snode, *q; ! 55: int i, j, svmask = regmask; ! 56: switch(p->in.op) { ! 57: default: ! 58: pr("#\tweird??? %d\n", p->in.op); ! 59: return(dest); ! 60: case ASG AND: ! 61: fieldbotch(p) ! 62: if(dest.ans && p->in.left->in.op == STAR) ! 63: longjmp(back, mediumstar(p)); ! 64: flag |= DESTISLEFT; ! 65: flag &= ~CC; ! 66: case AND: ! 67: if((flag & CC)) { ! 68: if(p->in.left->in.op == CONV && incrsize(p->in.left->in.left) < 4) ! 69: p->in.left = p->in.left->in.left; ! 70: if(p->in.right->in.op == CONV ! 71: && incrsize(p->in.right->in.left) < 4) ! 72: p->in.right = p->in.right->in.left; ! 73: } ! 74: t = doit(p->in.left, VALUE|USED, 0, regmask); ! 75: if(t.flag & FAIL) ! 76: return(t); ! 77: regmask &= ~t.regmask; ! 78: s = doit(p->in.right, VALUE|USED, 0, regmask); ! 79: if(s.flag & FAIL) ! 80: goto binfail; ! 81: if(flag & CC) { ! 82: if(incrsize(p->in.left) <= incrsize(p->in.right)) ! 83: i = childtype(p); ! 84: else ! 85: i = type(p->in.right); ! 86: pr("#\tbit%c\t%s,%s\n", i, str(s), str(t)); ! 87: dest.ans = 0; ! 88: dest.flag = CC; ! 89: dest.regmask = 0; ! 90: return(dest); ! 91: } ! 92: regmask &= ~s.regmask; ! 93: #if VAX==1 ! 94: /* p->in.right->in.op == COMPL is a useful special case */ ! 95: if((flag & DESTISLEFT) && dest.ans == 0) ! 96: dest = x = t; ! 97: if(dest.ans == 0) ! 98: if(s.flag & SCRATCH) ! 99: dest = x = s; ! 100: else if(t.flag & SCRATCH) { ! 101: dest = t; ! 102: x = allocreg(p, regmask); ! 103: } ! 104: else ! 105: dest = x = allocreg(p, regmask); ! 106: else ! 107: x = allocreg(p, regmask); ! 108: if(p->in.right->in.op == ICON) { ! 109: x = tostack(); /* to get a buf */ ! 110: sprintx(str(x), "$%d", -p->in.right->tn.lval - 1); ! 111: } ! 112: else ! 113: pr("#\tmcom%c\t%s,%s\n", childtype(p), str(s), str(x)); ! 114: if(strcmp(str(t), str(dest)) == 0) ! 115: pr("#\tbic%c2\t%s,%s\n", childtype(p), str(x), str(dest)); ! 116: else if(flag & DESTISLEFT) { ! 117: pr("#\tbic%c2\t%s,%s\n", childtype(p), str(x), str(t)); ! 118: if(strcmp(str(t), str(dest))) { ! 119: x = t; ! 120: goto movexdest; ! 121: } ! 122: } ! 123: else ! 124: pr("#\tbic%c3\t%s,%s,%s\n", childtype(p), str(x), ! 125: str(t), str(dest)); ! 126: dest.flag |= CC; ! 127: return(dest); ! 128: #endif ! 129: case CALL: ! 130: call: ! 131: s.flag = funargs(p->in.right, regmask); ! 132: if(s.flag & FAIL) ! 133: return(s); ! 134: i = p->stn.argsize/32; ! 135: called: ! 136: s = doit(p->in.left, VALUE|ASADDR|USED, 0, regmask); ! 137: pp = str(s); ! 138: aftercall: ! 139: if(svmask != REGMASK) { ! 140: s.flag = FAIL; ! 141: return(s); ! 142: } ! 143: x = specialreg(p, regmask); ! 144: if(M32 && (p->in.op == STCALL || p->in.op == UNARY STCALL)) ! 145: pr("#\tmovaw\t%d(%%fp),%%r2\n", gimmetemp(p->stn.stsize/SZINT)); ! 146: pr(VAX? "#\tcalls\t$%d,%s\n": "#\tcall\t&%d,%s\n", i, pp); ! 147: if(flag & ASADDR) { ! 148: strcat(str(x), ")"); ! 149: strshift(str(x), 1); ! 150: str(x)[0] = '('; ! 151: } ! 152: if(dest.ans == 0 && (VAX || !(flag & TOSTACK))) ! 153: if(flag & DESTISLEFT) ! 154: dest = doit(p->in.left->in.op == CONV? ! 155: p->in.left->in.left: ! 156: p->in.left, 0/* ? */, 0, regmask & ~x.regmask); ! 157: else ! 158: return(x); ! 159: movexdest: /* type(p), not childtype, for a = a % b */ ! 160: if(strcmp(str(x), str(dest)) == 0) ! 161: return(x); ! 162: if((flag & TOSTACK) && incrsize(p) == 4) ! 163: pr("#\tpush%c\t%s\n", type(p), str(x)); ! 164: else if(x.flag & ICON0) ! 165: pr("#\tclr%c\t%s\n", type(p), str(dest)); ! 166: else if(VAX && isfloat(p) != isfloat(p->in.left) ! 167: && p->in.op != CALL && p->in.op != UNARY CALL) ! 168: pr("#\tcvt%c%c\t%s,%s\n", childtype(p), type(p), str(x), str(dest)); ! 169: else if(VAX && (flag & TOSTACK) && (incrsize(p) != 8)) ! 170: pr("#\tcvt%cl\t%s,-(sp)\n", type(p), str(x)); ! 171: else { ! 172: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(dest)); ! 173: dest = simpler(x, dest); ! 174: } ! 175: dest.flag |= CC; ! 176: return(dest); ! 177: case CMP: ! 178: if(p->in.left->in.op == CONV && p->in.right->in.op == CONV ! 179: && childtype(p->in.left) == childtype(p->in.right)) { ! 180: p->in.left = p->in.left->in.left; ! 181: p->in.right = p->in.right->in.left; ! 182: } ! 183: else if(p->in.left->in.op == CONV && p->in.right->in.op == ICON ! 184: && p->in.right->tn.lval >= 0 ! 185: && ((incrsize(p->in.left->in.left) == 1 ! 186: && p->in.right->tn.lval < 128) ! 187: || (incrsize(p->in.left->in.left) == 2 ! 188: && p->in.right->tn.lval < 32768))) ! 189: p->in.left = p->in.left->in.left; ! 190: /* the above rewriting depends on childype being of p->left */ ! 191: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 192: if(s.flag & FAIL) ! 193: return(s); ! 194: regmask &= ~s.regmask; ! 195: t = doit(p->in.right, VALUE|USED, 0, regmask); ! 196: if(t.flag & FAIL) { ! 197: totemp(p, LEFT); ! 198: longjmp(back, 1); ! 199: } ! 200: pr("#\tcmp%c\t%s,%s\n", childtype(p), str(s), str(t)); ! 201: dest.ans = dest.regmask = 0; ! 202: dest.flag = CC; ! 203: return(dest); ! 204: case COMOP: /* qnodes lurking underneath */ ! 205: if(p->in.left->in.op == GENLAB) { ! 206: if(dest.ans == 0) { ! 207: dest = allocreg(p, regmask); ! 208: } ! 209: t = doit(p->in.left, VALUE|(flag & CC), dest, regmask); ! 210: } ! 211: else ! 212: t = doit(p->in.left, 0, 0, regmask); ! 213: if(t.flag & FAIL) ! 214: return(t); ! 215: s = doit(p->in.right, VALUE|(flag & (USED|CC)), dest, regmask); ! 216: if(s.flag & FAIL) ! 217: return(s); ! 218: if(flag & ASADDR) { ! 219: dest.ans = 0; ! 220: i = (s.flag & (ISREG|CANINDIR|SCRATCH)); ! 221: j = s.regmask; ! 222: buf = str(s); ! 223: goto convbuf; ! 224: } ! 225: return(s); ! 226: case COMPL: ! 227: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 228: if(s.flag & FAIL) ! 229: return(s); ! 230: if(dest.ans == 0) ! 231: if(s.flag & SCRATCH) ! 232: dest = s; ! 233: else ! 234: dest = allocreg(p, regmask & ~s.regmask); ! 235: pr("#\tmcom%c\t%s,%s\n", childtype(p), str(s), str(dest)); ! 236: dest.flag |= CC; ! 237: return(dest); ! 238: case CONV: ! 239: if(p->in.left->in.op == ASSIGN && p->in.left->in.left->in.op == STAR) { ! 240: if(dest.ans == 0) { ! 241: dest = allocreg(p, regmask); ! 242: s = doit(p->in.left, VALUE|USED, dest, regmask); ! 243: } ! 244: else { ! 245: x = allocreg(p, regmask); ! 246: s = doit(p->in.left, VALUE|USED, x, regmask & ~x.regmask); ! 247: } ! 248: if(s.flag & FAIL) { ! 249: asgwrite(p->in.left); ! 250: longjmp(back, 1); ! 251: } ! 252: } ! 253: else ! 254: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 255: if(childtype(p) == type(p) && dest.ans == 0) ! 256: return(s); ! 257: if(s.flag & FAIL) ! 258: return(s); ! 259: if(dest.ans == 0) ! 260: if(s.flag & SCRATCH) ! 261: dest = checksize(p, s, regmask); ! 262: else ! 263: dest = allocreg(p, regmask); ! 264: if(isunsigned(p->in.left) && incrsize(p) > incrsize(p->in.left)) { ! 265: if(type(p) != 'f' && type(p) != 'd') ! 266: pp = "movz"; ! 267: else { /* uns to float or double */ ! 268: rewriteconv(p); ! 269: longjmp(back, 1); ! 270: } ! 271: } ! 272: else ! 273: pp = VAX? "cvt": "movb"; ! 274: if(isfloat(p) != isfloat(p->in.left)) ! 275: goto cvtop; ! 276: if(incrsize(p) < incrsize(p->in.left)) { ! 277: if(isfloat(p)) ! 278: goto cvtop; ! 279: pr("#\tmov%c\t%s,%s\n", type(p), str(s), str(dest)); ! 280: dest = simpler(s, dest); ! 281: } ! 282: else if(incrsize(p) > incrsize(p->in.left)) ! 283: cvtop: ! 284: pr("#\t%s%c%c\t%s,%s\n", pp, childtype(p), type(p), str(s), str(dest)); ! 285: else { /* types were the same, but dest.ans != 0 */ ! 286: pr("#\tmov%c\t%s,%s\n", type(p), str(s), str(dest)); ! 287: dest = simpler(s, dest); ! 288: } ! 289: if(M32 && (flag & TOSTACK)) ! 290: pr("#\tpushw\t%s\n", str(dest)); ! 291: dest.flag |= CC; ! 292: return(dest); ! 293: case DECR: ! 294: i = -1; ! 295: pp = "sub"; ! 296: incrop: ! 297: if(p->in.type == TFLOAT) ! 298: uerror("no float ++/--"); ! 299: fieldbotch(p) ! 300: /* if the dest uses regs, it may be from a qnode, so that reg ! 301: * shouldn't be used (i?*a->b++:x()) where b has offset > 0 ! 302: */ ! 303: s = doit(p->in.left, USED, 0, dest.ans? regmask & ~dest.regmask: regmask); ! 304: if(s.flag & FAIL) ! 305: return(s); ! 306: t = doit(p->in.right, 0, 0, 0); ! 307: if(flag & VALUE) { ! 308: if(dest.ans == 0) ! 309: dest = allocreg(p, regmask & ~s.regmask); ! 310: pr("#\tmov%c\t%s,%s\n", childtype(p), str(s), str(dest)); ! 311: if(t.flag & ICON1) { ! 312: if(i == 1) ! 313: pp = "inc"; ! 314: else ! 315: pp = "dec"; ! 316: pr("#\t%s%c\t%s\n", pp, childtype(p), str(s)); ! 317: } ! 318: else ! 319: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), ! 320: str(t), str(s)); ! 321: if(flag & ASADDR) { ! 322: if(dest.flag & ISREG) { ! 323: sprintx(buf, "0(%s)", str(dest)); ! 324: done(dest, CANINDIR, dest.regmask); ! 325: } ! 326: if(dest.flag & CANINDIR) { ! 327: sprintx(buf, "*%s", str(dest)); ! 328: done(dest, 0, dest.regmask); ! 329: } ! 330: uerror("weird asaddr in incrop"); ! 331: } ! 332: dest.flag &= ~CC; ! 333: return(dest); ! 334: } ! 335: if(t.flag & ICON1) { ! 336: if(i == 1) ! 337: pp = "inc"; ! 338: else ! 339: pp = "dec"; ! 340: pr("#\t%s%c\t%s\n", pp, childtype(p), str(s)); ! 341: } ! 342: else ! 343: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), str(t), str(s)); ! 344: if(dest.ans) { ! 345: x = s; ! 346: goto movexdest; ! 347: } ! 348: s.flag &= ~CC; ! 349: return(s); ! 350: case ASG DIV: ! 351: fieldbotch(p) ! 352: if(rewriteasgop(p)) ! 353: goto assign; ! 354: flag |= DESTISLEFT; ! 355: case DIV: ! 356: /* trees wrong: uns/=int and int/=uns */ ! 357: if(!isunsigned(p->in.right) && !isunsigned(p->in.left)) { ! 358: pp = "div"; ! 359: goto binop; ! 360: } ! 361: pp = "udiv"; ! 362: #if M32==1 ! 363: goto binop; ! 364: #else if VAX==1 ! 365: unsdiv: ! 366: if(incrsize(p->in.right) != 4) { ! 367: snode.in.op = CONV; ! 368: snode.in.left = p->in.right; ! 369: snode.in.type = TULONG; ! 370: s = doit(&snode, VALUE|TOSTACK, tostack(), regmask); ! 371: } ! 372: else ! 373: s = doit(p->in.right, TOSTACK, tostack(), regmask); ! 374: if(s.flag & FAIL) ! 375: return(s); ! 376: regmask &= ~s.regmask; ! 377: if(incrsize(p->in.left) != 4) { ! 378: snode.in.op = CONV; ! 379: snode.in.left = p->in.left; ! 380: snode.in.type = TULONG; ! 381: t = doit(&snode, VALUE|TOSTACK, tostack(), regmask); ! 382: } ! 383: else ! 384: t = doit(p->in.left, TOSTACK, tostack(), regmask); ! 385: if(t.flag & FAIL) { ! 386: if(dest.ans || svmask != REGMASK) { ! 387: t = doit(p->in.left, VALUE|TOSTACK, tostack(), svmask); ! 388: if(t.flag & FAIL) ! 389: return(t); ! 390: } ! 391: totemp(p, RIGHT); ! 392: longjmp(back, 1); ! 393: } ! 394: i = 2; ! 395: goto aftercall; ! 396: #endif ! 397: case ASG ER: ! 398: fieldbotch(p) ! 399: flag |= DESTISLEFT; ! 400: case ER: ! 401: pp = "xor"; ! 402: binop: ! 403: if((flag & DESTISLEFT) && dest.ans && p->in.left->in.op == STAR) ! 404: longjmp(back, mediumstar(p)); ! 405: t = doit(p->in.left, VALUE|USED, 0, regmask); ! 406: if(t.flag & FAIL) { ! 407: return(t); ! 408: } ! 409: regmask &= ~t.regmask; ! 410: s = doit(p->in.right, VALUE|USED, 0, regmask); ! 411: if(s.flag & FAIL) { ! 412: binfail: ! 413: if(dest.ans || svmask != REGMASK) { ! 414: s = doit(p->in.right, VALUE|USED, 0, svmask); ! 415: if(s.flag & FAIL) ! 416: return(s); ! 417: } ! 418: /* *foo op= expr requires care */ ! 419: if((flag & DESTISLEFT) && p->in.left->in.op == STAR) ! 420: totemp(p->in.left, LEFT); ! 421: else ! 422: totemp(p, LEFT); ! 423: longjmp(back, 1); ! 424: } ! 425: if(type(p) != childtype(p)) { ! 426: x = allocreg(p, regmask); ! 427: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), str(s), ! 428: str(t), str(x)); ! 429: if(dest.ans == 0) ! 430: dest = x; ! 431: if(!isfloat(p) && !isfloat(p->in.left) ! 432: && incrsize(p) < incrsize(p->in.left)) { ! 433: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(dest)); ! 434: dest = simpler(x, dest); ! 435: } ! 436: else ! 437: pr("#\tcvt%c%c\t%s,%s\n", childtype(p), type(p), ! 438: str(x), str(dest)); ! 439: dest.flag |= CC; ! 440: return(dest); ! 441: } ! 442: if(dest.ans == 0) ! 443: if((t.flag & SCRATCH) || (flag & DESTISLEFT)) { ! 444: twoop: ! 445: dest = t; ! 446: if(*pp == 'a' && (s.flag & ICON1)) ! 447: pr("#\tinc%c\t%s\n", childtype(p), str(t)); ! 448: else if(*pp == 's' && (s.flag & ICON1)) ! 449: pr("#\tdec%c\t%s\n", childtype(p), str(t)); ! 450: else ! 451: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), ! 452: str(s), str(t)); ! 453: if(flag & ASADDR) ! 454: goto binopaddr; ! 455: if(flag & TOSTACK) ! 456: pr("#\tpush%c\t%s\n", type(p), str(t)); ! 457: dest.flag |= CC; ! 458: return(dest); ! 459: } ! 460: else if(s.flag & SCRATCH) ! 461: dest = s; ! 462: else ! 463: dest = allocreg(p, regmask); ! 464: if(dest.ans && (flag & DESTISLEFT)) { ! 465: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), str(s), str(t)); ! 466: x = t; ! 467: goto movexdest; ! 468: } ! 469: if((dope[p->in.op] & (COMMFLG|MULFLG)) && strcmp(str(s), str(dest)) == 0) { ! 470: dest = s; ! 471: s = t; ! 472: t = dest; ! 473: goto twoop; ! 474: } ! 475: if(strcmp(str(t), str(dest)) == 0) ! 476: goto twoop; ! 477: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), str(s), str(t), str(dest)); ! 478: if(M32 && (flag & TOSTACK)) { ! 479: pr("#\tpushw\t%s\n", str(dest)); ! 480: return(dest); ! 481: } ! 482: binopaddr: ! 483: if(flag & ASADDR) { ! 484: if(dest.flag & ISREG) { ! 485: strcat(str(dest), ")"); ! 486: strshift(str(dest), 1); ! 487: str(dest)[0] = '('; ! 488: return(dest); ! 489: } ! 490: if(dest.flag & CANINDIR) { ! 491: strshift(str(dest), 1); ! 492: str(dest)[0] = '*'; ! 493: dest.flag &= ~CANINDIR; ! 494: return(dest); ! 495: } ! 496: dest.flag = FAIL; /* doubtful */ ! 497: return(dest); ! 498: } ! 499: dest.flag |= CC; ! 500: return(dest); ! 501: case FLD: ! 502: /* this is rvalues */ ! 503: s = doit(p->in.left, USED, 0, regmask); ! 504: if(s.flag & FAIL) ! 505: return(s); ! 506: if(dest.ans == 0) ! 507: dest = allocreg(p, regmask); ! 508: if((s.flag & INDEX) && p->in.left->in.op == STAR ! 509: && incrsize(p->in.left) != 1) { ! 510: /* over-enthusiastic use of index mode */ ! 511: if(dest.flag & SCRATCH) ! 512: x = dest; ! 513: else ! 514: x = allocreg(p, regmask); ! 515: pr("#\tmov%c\t%s,%s\n", childtype(p), str(s), str(x)); ! 516: s = x; ! 517: } ! 518: #if VAX==1 ! 519: pr("#\text%sv\t$%d,$%d,%s,%s\n", isunsigned(p->in.left)? "z": "", ! 520: p->tn.rval/64, p->tn.rval%64, str(s), str(dest)); ! 521: #else if M32==1 ! 522: i = p->tn.rval % 64; ! 523: j = 32 - p->tn.rval/64 - i; ! 524: pr("#\textzv\t&%d,&%d,%s,%s\n", j, i, str(s), str(dest)); ! 525: #endif ! 526: dest.flag |= CC; ! 527: return(dest); ! 528: case GENBR: ! 529: if(p->in.left->in.op == CONV) ! 530: p->in.left = p->in.left->in.left; ! 531: s = doit(p->in.left, CC|VALUE|USED, 0, regmask); ! 532: pp = genjmp(p->bn.lop); ! 533: if(s.flag & CC) ! 534: pr("#\t%s\t", pp); ! 535: else if(VAX) ! 536: pr("#\ttst%c\t%s\n#\t%s\t", childtype(p), str(s), pp); ! 537: else if(M32) ! 538: pr("#\tcmp%c\t%s,&0\n#\t%s\t", childtype(p), str(s), pp); ! 539: pr(VAX? "L%d\n": ".L%d\n", p->bn.label); ! 540: s.flag |= CC; /* ?? */ ! 541: if(Pflag) { ! 542: ++bbcnt; ! 543: pr("#\tincl\tlocprof+%d\n", 4*(bbcnt+3)); ! 544: } ! 545: return(s); ! 546: case GENLAB: ! 547: s = doit(p->in.left, flag, dest, regmask); ! 548: pr(VAX? "#L%d:\n": "#.L%d:\n", p->bn.label); ! 549: if(M32 && (flag & TOSTACK)) ! 550: pr("#\tpushw\t%s\n", str(s)); ! 551: if(Pflag) { ! 552: ++bbcnt; ! 553: pr("#\tincl\tlocprof+%d\n", 4*(bbcnt+3)); ! 554: } ! 555: return(s); ! 556: case GENUBR: ! 557: s = doit(p->in.left, flag & CC, dest, regmask); ! 558: if((flag & CC) && !(s.flag & CC)) ! 559: pr("#\ttst%c\t%s\n", childtype(p), str(s)); ! 560: pr(VAX? "#\tjbr\tL%d\n": "#\tjmp\t.L%d\n", p->bn.label); ! 561: return(s); ! 562: case ICON: ! 563: if(p->tn.name) ! 564: if(p->tn.lval) ! 565: sprintx(buf, "%s+%d", p->tn.name, p->tn.lval); ! 566: else ! 567: sprintx(buf, "%s", p->tn.name); ! 568: else ! 569: sprintx(buf, "%d", p->tn.lval); ! 570: if(!(flag & ASADDR)) { ! 571: strshift(buf, 1);; ! 572: buf[0] = VAX? '$': '&'; ! 573: } ! 574: i = 0; ! 575: if(VAX && p->tn.name == 0) ! 576: if(p->tn.lval == 0) ! 577: i = ICON0; ! 578: else if(p->tn.lval == 1) ! 579: i = ICON1; ! 580: j = 0; ! 581: convbuf: /* the cookie is in buf */ ! 582: if(dest.ans == 0 && !(flag & TOSTACK)) { ! 583: if(p->in.op == ICON || !(flag & ASADDR)) { ! 584: done(s, i, j); ! 585: } ! 586: if(i & CANINDIR) { ! 587: strshift(buf, 1); ! 588: buf[0] = '*'; ! 589: done(s, i & ~CANINDIR, j); ! 590: } ! 591: if(i & ISREG) { ! 592: strcat(buf, ")"); ! 593: strshift(buf, 1); ! 594: buf[0] = '('; ! 595: done(s, i, j); ! 596: } ! 597: pp = buf; ! 598: buf += BUF; ! 599: s = allocreg(p, regmask); ! 600: pr("#\tmov%c\t%s,%s\n", type(p), pp, str(s)); ! 601: flag &= ~ASADDR; ! 602: goto inreg; ! 603: } ! 604: if(flag & TOSTACK) ! 605: if(incrsize(p) == 4) ! 606: pr(VAX? "#\tpushl\t%s\n": "#\tpushw\t%s\n", buf); ! 607: else if(incrsize(p) == 8) ! 608: pr("#\tmovd\t%s,%s\n", buf, str(dest)); ! 609: else ! 610: pr("#\tcvt%cl\t%s,%s\n", type(p), buf, str(dest)); ! 611: else if(i & ICON0) ! 612: pr("#\tclr%c\t%s\n", type(p), str(dest)); ! 613: else { ! 614: pr("#\tmov%c\t%s,%s\n", type(p), buf, str(dest)); ! 615: if(!(dest.flag & INDEX) || !index(str(dest), '+') ! 616: && !index(str(dest), '-')) ! 617: ; ! 618: else if(!(i & INDEX) || !index(buf, '+') ! 619: && !index(buf, '-')) { ! 620: done(s, (i|CC), j); ! 621: } ! 622: else ! 623: dest.flag |= USED; ! 624: } ! 625: dest.flag |= CC; ! 626: return(dest); ! 627: case INCR: ! 628: i = 1; ! 629: pp = "add"; ! 630: goto incrop; ! 631: case INIT: /* knows it is ICON */ ! 632: s = doit(p->in.left, ASADDR, 0, 0); ! 633: pr(VAX? "#\t.long\t%s\n": "#\t.word\t%s\n", str(s)); ! 634: return(dest); ! 635: case ASG LS: ! 636: if(VAX && incrsize(p) != 4) ! 637: lsconv(p); ! 638: if(rewriteasgop(p)) ! 639: goto assign; ! 640: fieldbotch(p) ! 641: flag |= DESTISLEFT; ! 642: if(dest.ans && p->in.left->in.op == STAR) ! 643: longjmp(back, mediumstar(p)); ! 644: case LS: /* stupid vax */ ! 645: #if M32==1 ! 646: pp = "LLS"; ! 647: shiftop: ! 648: #endif ! 649: if(VAX && incrsize(p) != 4) ! 650: lsconv(p); ! 651: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 652: if(s.flag & FAIL) ! 653: return(s); ! 654: regmask &= ~s.regmask; ! 655: t = doit(p->in.right, VALUE|USED, 0, regmask); ! 656: if(t.flag & FAIL) ! 657: goto binfail; ! 658: if(dest.ans == 0) ! 659: if((s.flag & SCRATCH) || (flag & DESTISLEFT)) ! 660: dest = s; ! 661: else ! 662: dest = allocreg(p, regmask); ! 663: #if VAX==1 ! 664: if(incrsize(p) != 4) { /* stupid vax */ ! 665: x = allocreg(p, regmask); ! 666: pr("#\tashl\t%s,%s,%s\n", str(t), str(s), str(x)); ! 667: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(dest)); ! 668: if(flag & DESTISLEFT) ! 669: pr("#\tmovl\t%s,%s\n", str(x), str(s)); ! 670: dest.flag |= CC; ! 671: return(dest); ! 672: } ! 673: if(p->in.right->in.op == ICON && (i = p->in.right->tn.lval) <= 4 ! 674: && (dest.flag & ISREG)) { ! 675: if(strcmp(str(s), str(dest))) { ! 676: i--; ! 677: pr("#\taddl3\t%s,%s,%s\n", str(s), str(s), str(dest)); ! 678: } ! 679: while(i-- > 0) ! 680: pr("#\taddl2\t%s,%s\n", str(dest), str(dest)); ! 681: } ! 682: else if(flag & DESTISLEFT) ! 683: pr("#\tashl\t%s,%s,%s\n", str(t), str(s), str(s)); ! 684: else ! 685: pr("#\tashl\t%s,%s,%s\n", str(t), str(s), str(dest)); ! 686: if((flag & DESTISLEFT) && strcmp(str(dest), str(s))) ! 687: pr("#\tmovl\t%s,%s\n", str(s), str(dest)); ! 688: #else if M32==1 ! 689: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p) + UP, str(t), str(s), ! 690: str(dest)); ! 691: if(flag & TOSTACK) ! 692: pr("#\tpush%c\t%s\n", type(p), str(dest)); ! 693: #endif ! 694: dest.flag |= CC; ! 695: return(dest); ! 696: case ASG MINUS: ! 697: fieldbotch(p) ! 698: if(rewriteasgop(p)) ! 699: goto assign; ! 700: flag |= DESTISLEFT; ! 701: case MINUS: ! 702: pp = "sub"; ! 703: /* you won't believe this: type x[], *y where type is shorter than ! 704: * int, generates subx $_x,y which the assembler barfs on. ! 705: * instead, generate crummy code (stupid assembler) ! 706: */ ! 707: if(incrsize(p) < 4) { ! 708: if(p->in.left->in.op == ICON && p->in.left->tn.name) { ! 709: p->in.left->in.type = TINT; ! 710: totemp(p, LEFT); ! 711: } ! 712: if(p->in.right->in.op == ICON && p->in.right->tn.name) { ! 713: p->in.right->in.type = TINT; ! 714: totemp(p, RIGHT); ! 715: } ! 716: } ! 717: goto binop; ! 718: case ASG MOD: ! 719: fieldbotch(p) ! 720: if(rewriteasgop(p)) ! 721: goto assign; ! 722: if(dest.ans && p->in.left->in.op == STAR) ! 723: longjmp(back, mediumstar(p)); ! 724: flag |= DESTISLEFT; ! 725: case MOD: ! 726: #if M32==1 ! 727: if(isunsigned(p->in.right) || isunsigned(p->in.left)) ! 728: pp = "umod"; ! 729: else ! 730: pp = "mod"; ! 731: goto binop; ! 732: #else if VAX==1 ! 733: if(isunsigned(p->in.right) || isunsigned(p->in.left)) { ! 734: pp = "urem"; ! 735: goto unsdiv; ! 736: } ! 737: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 738: if(s.flag & FAIL) ! 739: return(s); ! 740: regmask &= ~s.regmask; ! 741: t = doit(p->in.right, VALUE|USED, 0, regmask); ! 742: if(t.flag & FAIL) ! 743: goto binfail; ! 744: regmask &= ~t.regmask; ! 745: x = allocreg(p, regmask); ! 746: pr("#\tdiv%c3\t%s,%s,%s\n", childtype(p), str(t), str(s), str(x)); ! 747: pr("#\tmul%c2\t%s,%s\n", childtype(p), str(t), str(x)); ! 748: pr("#\tsub%c3\t%s,%s,%s\n", childtype(p), str(x), str(s), str(x)); ! 749: if(dest.ans) ! 750: goto movexdest; ! 751: if(flag & DESTISLEFT) { ! 752: dest = s; ! 753: goto movexdest; ! 754: } ! 755: x.flag |= CC; ! 756: return(x); ! 757: #endif ! 758: case ASG MUL: ! 759: fieldbotch(p) ! 760: if(rewriteasgop(p)) ! 761: goto assign; ! 762: flag |= DESTISLEFT; ! 763: case MUL: ! 764: pp = "mul"; ! 765: goto binop; ! 766: case NAME: /* ASADDR? */ ! 767: if(p->tn.lval && p->tn.name) ! 768: sprintx(buf, "%s+%d", p->tn.name, p->tn.lval); ! 769: else if(p->tn.name) ! 770: sprintx(buf, "%s", p->tn.name); ! 771: else if(p->tn.lval) ! 772: sprintf(buf, "%d", p->tn.lval); ! 773: else ! 774: sprintx(buf, "0"); ! 775: j = 0; ! 776: i = CANINDIR; ! 777: goto convbuf; ! 778: case ASG OR: ! 779: fieldbotch(p) ! 780: flag |= DESTISLEFT; ! 781: case OR: ! 782: pp = VAX? "bis": "or"; ! 783: goto binop; ! 784: case ASG PLUS: ! 785: fieldbotch(p) ! 786: if(rewriteasgop(p)) ! 787: goto assign; ! 788: flag |= DESTISLEFT; ! 789: case PLUS: ! 790: pp = "add"; ! 791: goto binop; ! 792: case REG: ! 793: sprintx(buf, "%s", regnames[p->tn.rval]); ! 794: j = 0; ! 795: i = ISREG; ! 796: if(p->tn.lval == 1) ! 797: i |= SCRATCH; ! 798: goto convbuf; ! 799: case RNODE: case SNODE: ! 800: x = specialreg(p, 3); ! 801: x.regmask = 0; ! 802: if(dest.ans) ! 803: goto movexdest; ! 804: return(x); ! 805: case QNODE: ! 806: return(specialreg(p, regmask)); ! 807: case ASG RS: ! 808: fieldbotch(p) ! 809: if(VAX && incrsize(p) != 4) ! 810: lsconv(p); ! 811: if(rewriteasgop(p)) ! 812: goto assign; ! 813: flag |= DESTISLEFT; ! 814: case RS: /* all right shifts are unsigned */ ! 815: if(incrsize(p) != 4) ! 816: lsconv(p); ! 817: #if M32==1 ! 818: pp = "LRS"; ! 819: goto shiftop; ! 820: #else if VAX==1 ! 821: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 822: if(s.flag & FAIL) ! 823: return(s); ! 824: if(p->in.left->in.op == ICON || ! 825: (s.flag & INDEX) && p->in.left->in.op == STAR ! 826: && incrsize(p->in.left) != 1 || ! 827: (s.flag & AUTO) && incrsize(p->in.left) != 1) { ! 828: /* over-enthusiastic use of index mode */ ! 829: /* 12 >> i generates a byte immediate */ ! 830: if((s.flag & INDEX) && (flag & DESTISLEFT)) {/* *a++ >>= 1 */ ! 831: lsconv(p); /* not best */ ! 832: longjmp(back, 1); ! 833: } ! 834: if((flag & DESTISLEFT) && dest.ans == 0) { ! 835: dest = s; ! 836: regmask &= ~s.regmask; ! 837: } ! 838: if(dest.flag & SCRATCH) ! 839: x = dest; ! 840: else ! 841: x = allocreg(p, regmask); ! 842: pr("#\tmovl\t%s,%s\n", str(s), str(x)); ! 843: s = x; ! 844: } ! 845: regmask &= ~s.regmask; ! 846: if(dest.ans == 0) ! 847: if((flag & DESTISLEFT) || (s.flag & SCRATCH)) ! 848: dest = s; ! 849: else ! 850: dest = allocreg(p, regmask); ! 851: dest.flag |= CC; ! 852: regmask &= ~dest.regmask; ! 853: if(incrsize(p) != 4) ! 854: x = allocreg(p, regmask); ! 855: else ! 856: x = dest; ! 857: if(p->in.right->in.op == ICON && (i = p->in.right->tn.lval) >= 0) { ! 858: pr("#\textzv\t$%d,$%d,%s,%s\n", i, 32 - i, str(s), str(x)); ! 859: goto movexdest; ! 860: } ! 861: t = doit(p->in.right, VALUE|USED, 0, regmask); ! 862: if(t.flag & FAIL) ! 863: goto binfail; ! 864: y = allocreg(p, regmask & ~t.regmask); ! 865: pr("#\tsubl3\t%s,$32,%s\n", str(t), str(y)); ! 866: pr("#\textzv\t%s,%s,%s,%s\n", str(t), str(y), str(s), str(x)); ! 867: goto movexdest; ! 868: #endif ! 869: case STAR: ! 870: switch(p->in.left->in.op) { ! 871: case ICON: /* as in foo((a, a)), where a is a struct */ ! 872: s = doit(p->in.left, VALUE, 0, regmask); ! 873: sprintx(buf, "%s", str(s)+1); ! 874: i = j = 0; ! 875: goto convbuf; ! 876: case VAUTO: ! 877: case VPARAM: ! 878: case NAME: ! 879: s = doit(p->in.left, VALUE, 0, regmask); ! 880: sprintx(buf, "*%s", str(s)); ! 881: j = i = 0; ! 882: goto convbuf; ! 883: case REG: ! 884: s = doit(p->in.left, VALUE, 0, regmask); ! 885: inreg: ! 886: if(s.flag & ISREG) { ! 887: sprintx(buf, VAX? "(%s)": "0(%s)", str(s)); ! 888: j = s.regmask; ! 889: i = CANINDIR; ! 890: goto convbuf; ! 891: } ! 892: else if(s.flag & CANINDIR) { ! 893: sprintx(buf, "*%s", str(s)); ! 894: j = s.regmask; ! 895: i = 0; ! 896: goto convbuf; ! 897: } ! 898: else { ! 899: s.flag = FAIL; ! 900: return(s); ! 901: } ! 902: } ! 903: q = p->in.left; ! 904: if(VAX && q->in.op == INCR && !(flag & INDEX) ! 905: && q->in.right->in.op == ICON && q->in.left->in.op == REG ! 906: && incrsize(p) == (int) q->in.right->tn.lval) { ! 907: s = doit(q->in.left, VALUE, 0, regmask); ! 908: sprintx(buf, "(%s)+", str(s)); ! 909: i = INDEX|AUTO; ! 910: j = s.regmask; ! 911: goto convbuf; ! 912: } ! 913: if(VAX && q->in.op == PLUS && q->in.left->in.op == LS ! 914: && !(flag & INDEX) ! 915: && q->in.left->in.right->in.op == ICON ! 916: && shiftsize(p) == (int) q->in.left->in.right->tn.lval) { ! 917: s = doit(q->in.left->in.left, VALUE|USED, 0, regmask); ! 918: if(s.flag & FAIL) ! 919: return(s); ! 920: regmask &= ~s.regmask; ! 921: if(!(s.flag & ISREG)) { ! 922: x = allocreg(p, regmask); ! 923: pr("#\tmov%c\t%s,%s\n", childtype(q), str(s), str(x)); ! 924: regmask |= s.regmask; ! 925: regmask &= ~x.regmask; ! 926: s = x; ! 927: if(!(s.flag & ISREG)) { ! 928: s.flag = FAIL; ! 929: return(s); ! 930: } ! 931: } ! 932: t = doit(q->in.right, ASADDR|USED, 0, regmask); ! 933: sprintx(buf, "%s[%s]", str(t), str(s)); ! 934: i = INDEX; ! 935: j = s.regmask | t.regmask; ! 936: goto convbuf; ! 937: } ! 938: if(q->in.op == PLUS && q->in.right->in.op == ICON) { ! 939: s = doit(q->in.left, VALUE|USED, 0, regmask); ! 940: if(s.flag & FAIL) ! 941: return(s); ! 942: if(!(s.flag & ISREG)) { ! 943: x = allocreg(p, regmask); ! 944: pr("#\tmov%c\t%s,%s\n", childtype(q), str(s), str(x)); ! 945: s = x; ! 946: if(!(s.flag & ISREG)) { ! 947: s.flag = FAIL; ! 948: return(s); ! 949: } ! 950: } ! 951: regmask &= ~s.regmask; ! 952: t = doit(q->in.right, ASADDR|USED, 0, regmask); ! 953: sprintx(buf, "%s(%s)", str(t), str(s)); ! 954: i = CANINDIR; ! 955: j = s.regmask; ! 956: goto convbuf; ! 957: } ! 958: if(q->in.op == MINUS && q->in.right->in.op == ICON) { ! 959: s = doit(q->in.left, VALUE|USED, 0, regmask); ! 960: if(s.flag & FAIL) ! 961: return(s); ! 962: if(!(s.flag & ISREG)) { ! 963: x = allocreg(p, regmask); ! 964: pr("#\tmov%c\t%s,%s\n", childtype(q), str(s), str(x)); ! 965: s = x; ! 966: if(!(s.flag & ISREG)) { ! 967: s.flag = FAIL; ! 968: return(s); ! 969: } ! 970: } ! 971: regmask &= ~s.regmask; ! 972: sprintx(buf, "%d(%s)", -q->in.right->tn.lval, str(s)); ! 973: i = CANINDIR; ! 974: j = s.regmask; ! 975: goto convbuf; ! 976: } ! 977: if(VAX && q->in.op == ASG MINUS && !(flag & (INDEX|USED)) ! 978: && q->in.right->in.op == ICON && q->in.left->in.op == REG ! 979: && incrsize(p) == (int) q->in.right->tn.lval) { ! 980: s = doit(q->in.left, VALUE, 0, regmask); ! 981: sprintx(buf, "-(%s)", str(s)); ! 982: i = INDEX|AUTO; ! 983: j = s.regmask; ! 984: goto convbuf; ! 985: } ! 986: if(VAX && q->in.op == PLUS && q->in.left->in.op == REG ! 987: && !(flag & INDEX) && q->in.right->in.op == REG ! 988: && incrsize(p) == 1) { ! 989: sprintx(buf, "(r%d)[r%d]", q->in.right->tn.rval, ! 990: q->in.left->tn.rval); ! 991: i = INDEX; ! 992: j = 0; ! 993: goto convbuf; ! 994: } ! 995: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 996: if(s.flag & FAIL) ! 997: return(s); ! 998: regmask &= ~s.regmask; ! 999: if(s.flag & CANINDIR) { ! 1000: sprintx(buf, "*%s", str(s)); ! 1001: i = 0; ! 1002: j = s.regmask; ! 1003: goto convbuf; ! 1004: } ! 1005: if(!(s.flag & ISREG)) { ! 1006: x = allocreg(p, regmask); ! 1007: pr("#\tmov%c\t%s,%s\n", childtype(q), str(s), str(x)); ! 1008: regmask |= s.regmask; ! 1009: regmask &= ~x.regmask; ! 1010: s = x; ! 1011: } ! 1012: if(!(s.flag & ISREG)) { ! 1013: s.flag = FAIL; ! 1014: return(s); ! 1015: } ! 1016: sprintx(buf, VAX? "(%s)": "0(%s)", str(s)); ! 1017: i = 0; ! 1018: j = s.regmask; ! 1019: goto convbuf; ! 1020: case STASG: ! 1021: if(regmask != REGMASK) { ! 1022: s.flag = FAIL; ! 1023: return(s); ! 1024: } ! 1025: if(p->stn.stsize/8 == 4) { ! 1026: i = VAX? 'l': 'w'; ! 1027: stasg: ! 1028: s = doit(p->in.left, VALUE|ASADDR|USED, 0, regmask); ! 1029: if(s.flag & FAIL) ! 1030: return(s); ! 1031: regmask &= ~s.regmask; ! 1032: t = doit(p->in.right, VALUE|ASADDR|USED, 0, regmask); ! 1033: if(t.flag & FAIL) { ! 1034: totemp(p, LEFT); ! 1035: longjmp(back, 1); ! 1036: } ! 1037: pr("#\tmov%c\t%s,%s\n", i, str(t), str(s)); ! 1038: s.regmask = s.flag = 0; ! 1039: return(simpler(t, s)); ! 1040: } ! 1041: else if(VAX && p->stn.stsize/8 == 8) { ! 1042: i = 'q'; ! 1043: goto stasg; ! 1044: } ! 1045: #if VAX==1 ! 1046: s = doit(p->in.right, VALUE|USED, 0, regmask); ! 1047: if(s.flag & INDEX) { ! 1048: /* over-enthusiastic use of index mode */ ! 1049: x = allocreg(p, regmask); ! 1050: pr("#\tmovl\t%s,%s\n", str(s), str(x)); ! 1051: s = x; ! 1052: } ! 1053: regmask &= ~s.regmask; ! 1054: t = doit(p->in.left, VALUE|USED, 0, regmask); ! 1055: if(t.flag & FAIL) { ! 1056: totemp(p, RIGHT); ! 1057: longjmp(back, 1); ! 1058: } ! 1059: if(t.flag & INDEX) { ! 1060: /* over-enthusiastic use of index mode */ ! 1061: x = allocreg(p, regmask); ! 1062: pr("#\tmovl\t%s,%s\n", str(t), str(x)); ! 1063: t = x; ! 1064: } ! 1065: t = indirit(t); ! 1066: if(t.flag & FAIL) { ! 1067: if(p->in.left->in.op != STAR) ! 1068: uerror("codegen failure in struct asg"); ! 1069: totemp(p->in.left, LEFT); ! 1070: longjmp(back, 1); ! 1071: } ! 1072: if(p->in.right->in.op == STASG) { /* secret knowledge */ ! 1073: pr("#\tsubl2\t$%d,r3\n", p->stn.stsize/8); ! 1074: pr("#\tmovc3\t$%d,(r3),%s\n", p->stn.stsize/8, str(t)); ! 1075: } ! 1076: else { ! 1077: s = indirit(s); ! 1078: if(s.flag & FAIL) { ! 1079: if(p->in.right->in.op != STAR) ! 1080: uerror("codgen fail in stasg"); ! 1081: totemp(p->in.right, LEFT); ! 1082: longjmp(back, 1); ! 1083: } ! 1084: pr("#\tmovc3\t$%d,%s,%s\n", p->stn.stsize/8, str(s), str(t)); ! 1085: } ! 1086: t.regmask = t.flag = 0; ! 1087: #else if M32==1 ! 1088: x = allocreg(p, regmask); /* gets reg 0 */ ! 1089: s = doit(p->in.right, VALUE, x, regmask); ! 1090: regmask &= ~x.regmask; ! 1091: y = allocreg(p, regmask); /* gets reg 1 */ ! 1092: i = p->stn.stsize/32; ! 1093: if(p->in.right->in.op == STASG && i >= 7) { /* secret knowledge */ ! 1094: pr("#\tsubw3\t&%d,%%r1,%%r0\n", p->stn.stsize/8); ! 1095: } ! 1096: t = doit(p->in.left, VALUE, y, regmask); ! 1097: if(t.flag & FAIL) ! 1098: stasgrewrite(p); ! 1099: if(i >= 7) { ! 1100: pr("#\tmovw\t&%d,%%r2\n", i); ! 1101: pr("#\tMOVBLW\n"); ! 1102: } ! 1103: else ! 1104: while(--i >= 0) ! 1105: pr("#\tmovw\t%d(%r0),%d(%r1)\n", 4 * i, 4 * i); ! 1106: #endif ! 1107: return(t); ! 1108: case STCALL: ! 1109: goto call; ! 1110: case VAUTO: ! 1111: sprintx(buf, "%d(%s)", p->tn.lval, frameptr); ! 1112: j = 0; ! 1113: i = CANINDIR; ! 1114: goto convbuf; ! 1115: case VPARAM: ! 1116: sprintx(buf, "%d(%s)", p->tn.lval, argptr); ! 1117: j = 0; ! 1118: i = CANINDIR; ! 1119: goto convbuf; ! 1120: case UNARY AND: ! 1121: s = doit(p->in.left, USED, 0, regmask); ! 1122: if(s.flag & FAIL) ! 1123: return(s); ! 1124: regmask &= ~s.regmask; ! 1125: if(dest.ans == 0) { ! 1126: dest = allocreg(p, regmask); ! 1127: } ! 1128: if(s.flag & ISREG) { ! 1129: x = alloctmp(p); ! 1130: pr("#\tmov%c\t%s,%s\n", childtype(p), str(s), str(x)); ! 1131: s = x; ! 1132: } ! 1133: if(flag & TOSTACK) ! 1134: pr(VAX? "#\tpushal\t%s\n": "#\tpushaw\t%s\n", str(s)); ! 1135: else ! 1136: pr("#\tmova%c\t%s,%s\n", type(p), str(s), str(dest)); ! 1137: if(flag & ASADDR) { ! 1138: if(dest.flag & ISREG) { ! 1139: strcat(str(dest), ")"); ! 1140: strshift(str(dest), 1); ! 1141: str(dest)[0] = '('; ! 1142: } ! 1143: else { ! 1144: strshift(str(dest), 1); ! 1145: str(dest)[0] = '*'; ! 1146: } ! 1147: } ! 1148: return(dest); ! 1149: case UNARY CALL: ! 1150: i = 0; ! 1151: goto called; ! 1152: case UNARY MINUS: ! 1153: s = doit(p->in.left, VALUE|USED, 0, regmask); ! 1154: if(s.flag & FAIL) ! 1155: return(s); ! 1156: if(dest.ans == 0) ! 1157: if(s.flag & SCRATCH) ! 1158: dest = s; ! 1159: else ! 1160: dest = allocreg(p, regmask & ~s.regmask); ! 1161: pr("#\tmneg%c\t%s,%s\n", childtype(p), str(s), str(dest)); ! 1162: dest.flag |= CC; ! 1163: return(dest); ! 1164: case UNARY STCALL: ! 1165: i = 0; ! 1166: goto called; ! 1167: case ASSIGN: ! 1168: assign: ! 1169: if(p->in.left->in.op == QNODE && dest.ans) { ! 1170: s = doit(p->in.right, VALUE|(flag&USED? USED: 0), ! 1171: dest, regmask); ! 1172: return(s); ! 1173: } ! 1174: if(p->in.left->in.op == RNODE || p->in.left->in.op == SNODE) { ! 1175: s = doit(p->in.right, VALUE|(flag&USED? USED: 0), ! 1176: dest, regmask); ! 1177: if(s.flag & FAIL) ! 1178: return(s); ! 1179: x = s; ! 1180: dest = doit(p->in.left, USED, 0, 0); ! 1181: goto movexdest; ! 1182: } ! 1183: if(p->in.left->in.op == FLD) { ! 1184: s = doit(p->in.left->in.left, INDEX, 0, regmask); ! 1185: regmask &= ~s.regmask; ! 1186: if(p->in.right->in.op == ASSIGN) { ! 1187: x = allocreg(p->in.right, regmask); ! 1188: t = doit(p->in.right, VALUE|USED, x, regmask & ~x.regmask); ! 1189: } ! 1190: else ! 1191: t = doit(p->in.right, VALUE|USED, 0, regmask); ! 1192: if(t.flag & FAIL) { ! 1193: totemp(p->in.left, LEFT); ! 1194: longjmp(back, 1); ! 1195: } ! 1196: i = VAX? '$': '&'; ! 1197: pr("#\tinsv\t%s,%c%d,%c%d,%s\n", str(t), i, ! 1198: p->in.left->tn.rval/64, i, ! 1199: p->in.left->tn.rval % 64, str(s)); ! 1200: if(dest.ans) ! 1201: pr("#\tmovl\t%s,%s\n", str(t), str(dest)); ! 1202: t.flag |= CC; ! 1203: return(t); ! 1204: } ! 1205: if(dest.ans && p->in.left->in.op == STAR) { ! 1206: if(dest.flag & SCRATCH) ! 1207: x = dest; ! 1208: else ! 1209: x = allocreg(p, regmask); ! 1210: s = doit(p->in.right, VALUE|USED, x, regmask); ! 1211: if(s.flag & FAIL) ! 1212: return(s); ! 1213: regmask &= ~s.regmask; ! 1214: t = doit(p->in.left, USED, 0, regmask); ! 1215: if(t.flag & FAIL) { ! 1216: /* did we fail because of a dest, or was it us? */ ! 1217: if(dest.ans || svmask != REGMASK) { ! 1218: t = doit(p->in.left, USED, 0, svmask); ! 1219: if(t.flag & FAIL) { ! 1220: return(t); ! 1221: } ! 1222: starasg(p); ! 1223: } ! 1224: else ! 1225: asgwrite(p); ! 1226: longjmp(back, 1); ! 1227: } ! 1228: pr("#\tmov%c\t%s,%s\n", type(p), str(x), str(t)); ! 1229: if(strcmp(str(x), str(dest)) == 0) { ! 1230: dest.flag |= CC; ! 1231: return(dest); ! 1232: } ! 1233: goto movexdest; ! 1234: } ! 1235: t = doit(p->in.left, USED, 0, regmask); ! 1236: regmask &= ~t.regmask; ! 1237: if(p->in.right->in.op == GENLAB) ! 1238: extracheck(p); /* slightly worse code in usual case */ ! 1239: s = doit(p->in.right, VALUE, t, regmask); ! 1240: if(s.flag & NOGOOD) { ! 1241: /* did we fail because of a dest, or was it us? */ ! 1242: if(s.flag & FAIL) { ! 1243: if(dest.ans || svmask != REGMASK) { ! 1244: s = doit(p->in.right, VALUE, t, svmask); ! 1245: if(s.flag & FAIL) { ! 1246: return(s); ! 1247: } ! 1248: } ! 1249: asgwrite(p); ! 1250: longjmp(back, 1); ! 1251: } ! 1252: else if((flag & USED) && !((flag & CC) && (s.flag & CC))) { ! 1253: /* presumably USED as in *p++=*q++ */ ! 1254: totemp(p, RIGHT); ! 1255: longjmp(back, 1); ! 1256: } ! 1257: } ! 1258: if(dest.ans) { ! 1259: x = s; ! 1260: goto movexdest; ! 1261: } ! 1262: else if(M32 && (flag & TOSTACK)) { ! 1263: pr("#\tpushw\t%s\n", str(s)); ! 1264: return(s); ! 1265: } ! 1266: else if(flag & ASADDR) { ! 1267: i = (s.flag & (ISREG|CANINDIR|SCRATCH)); ! 1268: j = s.regmask; ! 1269: buf = str(s); ! 1270: goto convbuf; ! 1271: } ! 1272: return(s); ! 1273: } ! 1274: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.