![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 8.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to 8.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 ! root 1: /* gencode.c */ ! 2: extern struct _iobuf { ! 3: int _cnt; ! 4: unsigned char *_ptr; ! 5: unsigned char *_base; ! 6: short _flag; ! 7: char _file; ! 8: } _iob[20]; ! 9: struct _iobuf *fopen(); ! 10: struct _iobuf *fdopen(); ! 11: struct _iobuf *freopen(); ! 12: long ftell(); ! 13: char *fgets(); ! 14: char *hash(); ! 15: char *savestr(); ! 16: char *tstr(); ! 17: extern int tstrused; ! 18: extern char *tstrbuf[]; ! 19: extern char **curtstr; ! 20: extern int nerrors; ! 21: typedef union ndu NODE; ! 22: typedef unsigned int TWORD; ! 23: typedef long CONSZ; ! 24: extern int dope[]; ! 25: extern char *opst[]; ! 26: union ndu { ! 27: struct { ! 28: int op; ! 29: int goal; ! 30: TWORD type; ! 31: int cst[(6+4)]; ! 32: char * name; ! 33: char pad[8 -sizeof(char *)]; ! 34: NODE *left; ! 35: NODE *right; ! 36: }in; ! 37: ! 38: struct { ! 39: int op; ! 40: int goal; ! 41: TWORD type; ! 42: int cst[(6+4)]; ! 43: char * name; ! 44: char pad[8 -sizeof(char *)]; ! 45: CONSZ lval; ! 46: int rval; ! 47: }tn; ! 48: ! 49: struct { ! 50: int op; ! 51: int goal; ! 52: TWORD type; ! 53: int cst[(6+4)]; ! 54: int label; ! 55: int lop; ! 56: }bn; ! 57: struct { ! 58: int op; ! 59: int goal; ! 60: TWORD type; ! 61: int cst[(6+4)]; ! 62: int stsize; ! 63: short stalign; ! 64: short argsize; ! 65: }stn; ! 66: struct { ! 67: int op; ! 68: int goal; ! 69: TWORD type; ! 70: int cdim; ! 71: int csiz; ! 72: }fn; ! 73: ! 74: struct { ! 75: ! 76: int op; ! 77: int goal; ! 78: TWORD type; ! 79: int cdim; ! 80: int csiz; ! 81: double dval; ! 82: }fpn; ! 83: }; ! 84: extern int busy[]; ! 85: extern NODE node[]; ! 86: typedef struct shape SHAPE; ! 87: ! 88: extern struct shape { ! 89: int op; ! 90: SHAPE *sl; ! 91: SHAPE *sr; ! 92: int sh; ! 93: int sc; ! 94: } shapes[]; ! 95: extern SHAPE *pshape[]; ! 96: typedef struct optab OPTAB; ! 97: struct optab { ! 98: int op; ! 99: int tyop; ! 100: OPTAB *nextop; ! 101: SHAPE **lshape; ! 102: int ltype; ! 103: SHAPE **rshape; ! 104: int rtype; ! 105: int needs; ! 106: int rewrite; ! 107: char *cstring; ! 108: int cost; ! 109: int lcount; ! 110: int rcount; ! 111: int stinline; ! 112: }; ! 113: extern OPTAB ! 114: *match(), ! 115: *ophead[], ! 116: table[]; ! 117: extern NODE resc[]; ! 118: extern int tmpoff; ! 119: extern int maxboff; ! 120: extern int maxtemp; ! 121: extern int maxarg; ! 122: extern int ftnno; ! 123: extern int sideff; ! 124: extern NODE ! 125: *talloc(), ! 126: *ind2type(), ! 127: *tcopy(), ! 128: *getadr(), ! 129: *getlr(); ! 130: extern CONSZ rdin(); ! 131: extern char *rnames[]; ! 132: extern int lineno; ! 133: extern char ftitle[]; ! 134: extern int fldshf, fldsz; ! 135: extern int lflag, udebug, e2debug, odebug, rdebug, radebug, sdebug; ! 136: extern int fast; ! 137: typedef struct inst INST; ! 138: struct inst { ! 139: NODE *p; ! 140: OPTAB *q; ! 141: int goal; ! 142: }; ! 143: extern INST inst[300]; ! 144: extern nins; ! 145: typedef SHAPE *SHTABLE[2][20]; ! 146: extern SHTABLE sha; ! 147: typedef struct { ! 148: unsigned char ans; ! 149: unsigned char regmask; ! 150: unsigned short flag; ! 151: } ret; ! 152: ret doit(), allocreg(), reg0(), indir(), tostack(); ! 153: char *genjmp(); ! 154: char bufs[128][64]; ! 155: char *buf; ! 156: char prbuf[10240]; ! 157: char *prptr; ! 158: NODE *copytree(), *gimmenode(); ! 159: extern int ntree; ! 160: typedef int jmp_buf[10]; ! 161: jmp_buf back; ! 162: int acnt; ! 163: gencode(p) ! 164: NODE *p; ! 165: { NODE *q; ! 166: if(setjmp(back)) { ! 167: pr("#\treg\t%d\n", ++acnt); ! 168: if(acnt > 20) { ! 169: prtree(q); ! 170: outpr(); ! 171: return; ! 172: } ! 173: } ! 174: else ! 175: q = copytree(p); ! 176: buf = bufs[1]; ! 177: prptr = prbuf; ! 178: (void) doit(q, 0, 0, 0x3f); ! 179: acnt = ntree = 0; ! 180: outpr(); ! 181: } ! 182: ret ! 183: doit(p, flag, dest, regmask) ! 184: NODE *p; ! 185: ret dest; ! 186: { ret s, t, x; ! 187: char *pp; ! 188: NODE snode, *q; ! 189: int i, j; ! 190: switch(p->in.op) { ! 191: default: ! 192: pr("#\tweird??? %d\n", p->in.op); ! 193: return(dest); ! 194: case 1+ 14: ! 195: flag |= 256; ! 196: flag &= ~1; ! 197: case 14: ! 198: ! 199: t = doit(p->in.left, 2, 0, regmask); ! 200: regmask &= ~t.regmask; ! 201: s = doit(p->in.right, 2, 0, regmask); ! 202: if(s.flag & 1024) { ! 203: totemp(p, 0); ! 204: longjmp(back, 1); ! 205: } ! 206: regmask &= ~s.regmask; ! 207: if(flag & 1) { ! 208: pr("#\tbit%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[t.ans]); ! 209: dest.ans = 0; ! 210: dest.flag = 1; ! 211: dest.regmask = 0; ! 212: return(dest); ! 213: } ! 214: if(flag & 256) ! 215: dest = x = t; ! 216: if(dest.ans == 0) ! 217: if(s.flag & 16) ! 218: dest = x = s; ! 219: else if(t.flag & 16) ! 220: dest = x = t; ! 221: else ! 222: dest = x = allocreg(p, regmask); ! 223: else ! 224: x = allocreg(p, regmask); ! 225: if(p->in.right->in.op == 4) { ! 226: x = tostack(); ! 227: sprintf( bufs[x.ans], "$%d", -p->in.right->tn.lval - 1); ! 228: } ! 229: else ! 230: pr("#\tmcom%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[x.ans]); ! 231: if(strcmp( bufs[t.ans], bufs[dest.ans]) == 0) ! 232: pr("#\tbic%c2\t%s,%s\n", childtype(p), bufs[x.ans], bufs[dest.ans]); ! 233: else ! 234: pr("#\tbic%c3\t%s,%s,%s\n", childtype(p), bufs[x.ans], ! 235: bufs[t.ans], bufs[dest.ans]); ! 236: dest.flag |= 1; ! 237: return(dest); ! 238: case 70: ! 239: call: ! 240: funargs(p->in.right, regmask); ! 241: i = p->stn.argsize/32; ! 242: called: ! 243: s = doit(p->in.left, 2|8, 0, regmask & ~3); ! 244: pp = bufs[s.ans]; ! 245: aftercall: ! 246: if(regmask != 0x3f) { ! 247: s.flag = 1024; ! 248: return(s); ! 249: } ! 250: x = reg0(p, regmask); ! 251: pr("#\tcalls\t$%d,%s\n", i, pp); ! 252: if(p->in.op == 100 || p->in.op == 2+ 100 || (flag & 8)) { ! 253: strcat( bufs[x.ans], ")"); ! 254: strshift( bufs[x.ans], 1); ! 255: bufs[x.ans][0] = '('; ! 256: } ! 257: if(dest.ans == 0) ! 258: if(flag & 256) ! 259: dest = doit(p->in.left->in.op == 104? ! 260: p->in.left->in.left: ! 261: p->in.left, 0, 0, regmask & ~x.regmask); ! 262: else ! 263: return(x); ! 264: movexdest: ! 265: if(strcmp( bufs[x.ans], bufs[dest.ans]) == 0) ! 266: return(x); ! 267: if(flag & 4) ! 268: pr("#\tpush%c\t%s\n", type(p), bufs[x.ans]); ! 269: else ! 270: pr("#\tmov%c\t%s,%s\n", type(p), bufs[x.ans], bufs[dest.ans]); ! 271: dest.flag |= 1; ! 272: return(dest); ! 273: case 111: ! 274: s = doit(p->in.left, 2, 0, regmask); ! 275: regmask &= ~s.regmask; ! 276: t = doit(p->in.right, 2, 0, regmask); ! 277: if(t.flag & 1024) { ! 278: totemp(p, 0); ! 279: longjmp(back, 1); ! 280: } ! 281: pr("#\tcmp%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[t.ans]); ! 282: dest.ans = dest.regmask = 0; ! 283: dest.flag = 1; ! 284: return(dest); ! 285: case 59: ! 286: if(p->in.left->in.op == 108) { ! 287: if(dest.ans == 0) { ! 288: dest = allocreg(p, regmask); ! 289: } ! 290: (void) doit(p->in.left, 2, dest, regmask); ! 291: } ! 292: else ! 293: (void) doit(p->in.left, 0, 0, regmask); ! 294: s = doit(p->in.right, 2, dest, regmask); ! 295: if(flag & 8) { ! 296: dest.ans = 0; ! 297: i = (s.flag & (128|512|16)); ! 298: j = s.regmask; ! 299: buf = bufs[s.ans]; ! 300: goto convbuf; ! 301: } ! 302: return(s); ! 303: case 77: ! 304: s = doit(p->in.left, 2, 0, regmask); ! 305: if(dest.ans == 0) ! 306: if(s.flag & 16) ! 307: dest = s; ! 308: else ! 309: dest = allocreg(p, regmask & ~s.regmask); ! 310: pr("#\tmcom%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]); ! 311: dest.flag |= 1; ! 312: return(dest); ! 313: case 104: ! 314: if(p->in.left->in.op == 58 && p->in.left->in.left->in.op == (2+ 11)) { ! 315: if(dest.ans == 0) { ! 316: dest = allocreg(p, regmask); ! 317: s = doit(p->in.left, 2, dest, regmask); ! 318: } ! 319: else { ! 320: x = allocreg(p, regmask); ! 321: s = doit(p->in.left, 2, x, regmask & ~x.regmask); ! 322: } ! 323: } ! 324: else ! 325: s = doit(p->in.left, 2, 0, regmask); ! 326: regmask &= ~s.regmask; ! 327: if(childtype(p) == type(p)) ! 328: return(s); ! 329: if(dest.ans == 0) ! 330: if(s.flag & 16) ! 331: dest = s; ! 332: else ! 333: dest = allocreg(p, regmask); ! 334: if(isunsigned(p->in.left) && incrsize(p) > incrsize(p->in.left) ! 335: && type(p) != 'f' && type(p) != 'd') ! 336: pp = "movz"; ! 337: else ! 338: pp = "cvt"; ! 339: pr("#\t%s%c%c\t%s,%s\n", pp, childtype(p), type(p), bufs[s.ans], bufs[dest.ans]); ! 340: dest.flag |= 1; ! 341: return(dest); ! 342: case 79: ! 343: i = -1; ! 344: pp = "sub"; ! 345: incrop: ! 346: if(p->in.right->in.op != 4) ! 347: fflush((&_iob[1])), cerror("codegen! incrop not with ICON"); ! 348: s = doit(p->in.left, 0, 0, regmask); ! 349: t = doit(p->in.right, 0, 0, 0); ! 350: if(flag & 2) { ! 351: if(dest.ans == 0) ! 352: dest = allocreg(p, regmask & ~s.regmask); ! 353: pr("#\tmov%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]); ! 354: if(t.flag & 64) { ! 355: if(i == 1) ! 356: pp = "inc"; ! 357: else ! 358: pp = "dec"; ! 359: pr("#\t%s%c\t%s\n", pp, childtype(p), bufs[s.ans]); ! 360: } ! 361: else ! 362: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), ! 363: bufs[t.ans], bufs[s.ans]); ! 364: if(flag & 8) { ! 365: s = dest; ! 366: goto inreg; ! 367: } ! 368: dest.flag &= ~1; ! 369: return(dest); ! 370: } ! 371: if(t.flag & 64) { ! 372: if(i == 1) ! 373: pp = "inc"; ! 374: else ! 375: pp = "dec"; ! 376: pr("#\t%s%c\t%s\n", pp, childtype(p), bufs[s.ans]); ! 377: } ! 378: else ! 379: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), bufs[t.ans], bufs[s.ans]); ! 380: if(dest.ans) { ! 381: x = s; ! 382: goto movexdest; ! 383: } ! 384: s.flag |= 1; ! 385: return(s); ! 386: case 1+ 60: ! 387: flag |= 256; ! 388: case 60: ! 389: ! 390: if(!isunsigned(p->in.left)) { ! 391: if(p->in.left->in.op == 104 && type(p) == childtype(p->in.left)) { ! 392: p->in.left = p->in.left->in.left; ! 393: } ! 394: if(p->in.right->in.op == 104 && type(p) == childtype(p->in.right)) { ! 395: p->in.right = p->in.right->in.left; ! 396: } ! 397: pp = "div"; ! 398: goto binop; ! 399: } ! 400: pp = "udiv"; ! 401: unsdiv: ! 402: if(incrsize(p->in.right) != 4) { ! 403: snode.in.op = 104; ! 404: snode.in.left = p->in.right; ! 405: snode.in.type = 01000; ! 406: s = doit(&snode, 2|4, tostack(), regmask); ! 407: } ! 408: else ! 409: s = doit(p->in.right, 4, tostack(), regmask); ! 410: regmask &= ~s.regmask; ! 411: if(incrsize(p->in.left) != 4) { ! 412: snode.in.op = 104; ! 413: snode.in.left = p->in.left; ! 414: snode.in.type = 01000; ! 415: t = doit(&snode, 2|4, tostack(), regmask); ! 416: } ! 417: else ! 418: t = doit(p->in.left, 4, tostack(), regmask); ! 419: if(t.flag & 1024) { ! 420: totemp(p, 1); ! 421: longjmp(back, 1); ! 422: } ! 423: i = 2; ! 424: goto aftercall; ! 425: case 1+ 19: ! 426: flag |= 256; ! 427: case 19: ! 428: pp = "xor"; ! 429: binop: ! 430: t = doit(p->in.left, 2, 0, regmask); ! 431: regmask &= ~t.regmask; ! 432: s = doit(p->in.right, 2, 0, regmask); ! 433: if(s.flag & 1024) { ! 434: totemp(p, 0); ! 435: longjmp(back, 1); ! 436: } ! 437: regmask &= ~s.regmask; ! 438: if(type(p) != childtype(p)) { ! 439: x = allocreg(p, regmask); ! 440: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), bufs[s.ans], ! 441: bufs[t.ans], bufs[x.ans]); ! 442: if(dest.ans == 0) ! 443: dest = x; ! 444: pr("#\tcvt%c%c\t%s,%s\n", childtype(p), type(p), ! 445: bufs[x.ans], bufs[dest.ans]); ! 446: dest.flag |= 1; ! 447: return(dest); ! 448: } ! 449: if(dest.ans == 0) ! 450: if((t.flag & 16) || (flag & 256)) { ! 451: twoop: ! 452: dest = t; ! 453: if(*pp == 'a' && (s.flag & 64)) ! 454: pr("#\tinc%c\t%s\n", childtype(p), bufs[t.ans]); ! 455: else if(*pp == 's' && (s.flag & 64)) ! 456: pr("#\tdec%c\t%s\n", childtype(p), bufs[t.ans]); ! 457: else ! 458: pr("#\t%s%c2\t%s,%s\n", pp, childtype(p), ! 459: bufs[s.ans], bufs[t.ans]); ! 460: if(flag & 8) ! 461: goto binopaddr; ! 462: dest.flag |= 1; ! 463: return(dest); ! 464: } ! 465: else if(s.flag & 16) ! 466: dest = s; ! 467: else ! 468: dest = allocreg(p, regmask); ! 469: if((*pp == 'a' || *pp == 'm' || *pp == 'x' || *pp == 'b') ! 470: && strcmp( bufs[s.ans], bufs[dest.ans]) == 0) { ! 471: dest = s; ! 472: s = t; ! 473: t = dest; ! 474: goto twoop; ! 475: } ! 476: pr("#\t%s%c3\t%s,%s,%s\n", pp, childtype(p), bufs[s.ans], bufs[t.ans], bufs[dest.ans]); ! 477: binopaddr: ! 478: if(flag & 8) { ! 479: if(dest.flag & 128) { ! 480: strcat( bufs[dest.ans], ")"); ! 481: strshift( bufs[dest.ans], 1); ! 482: bufs[dest.ans][0] = '('; ! 483: return(dest); ! 484: } ! 485: if(dest.flag & 512) { ! 486: strshift( bufs[dest.ans], 1); ! 487: bufs[dest.ans][0] = '*'; ! 488: dest.flag &= ~512; ! 489: return(dest); ! 490: } ! 491: dest.flag = 1024; ! 492: return(dest); ! 493: } ! 494: dest.flag |= 1; ! 495: return(dest); ! 496: case 103: ! 497: ! 498: s = doit(p->in.left, 0, 0, regmask); ! 499: if(dest.ans == 0) ! 500: dest = allocreg(p, regmask & ~s.regmask); ! 501: pr("#\text%sv\t$%d,$%d,%s,%s\n", isunsigned(p->in.left)? "z": "", ! 502: p->tn.rval/64, p->tn.rval%64, bufs[s.ans], bufs[dest.ans]); ! 503: dest.flag |= 1; ! 504: return(dest); ! 505: case 110: ! 506: s = doit(p->in.left, 1|2, 0, regmask); ! 507: pp = genjmp(p->bn.lop); ! 508: if(s.flag & 1) ! 509: pr("#\t%s\tL%d\n", pp, p->bn.label); ! 510: else ! 511: pr("#\ttst%c\t%s\n#\t%s\tL%d\n", childtype(p), bufs[s.ans], ! 512: pp, p->bn.label); ! 513: s.flag |= 1; ! 514: return(s); ! 515: case 108: ! 516: s = doit(p->in.left, flag, dest, regmask); ! 517: pr("#L%d:\n", p->bn.label); ! 518: return(s); ! 519: case 112: ! 520: (void) doit(p->in.left, 0, dest, regmask); ! 521: pr("#\tjbr\tL%d\n", p->bn.label); ! 522: s.ans = s.regmask = s.flag = 0; ! 523: return(s); ! 524: case 4: ! 525: if(p->tn.name) ! 526: if(p->tn.lval) ! 527: sprintf(buf, "%s+%d", p->tn.name, p->tn.lval); ! 528: else ! 529: sprintf(buf, "%s", p->tn.name); ! 530: else ! 531: sprintf(buf, "%d", p->tn.lval); ! 532: if(!(flag & 8)) { ! 533: strshift(buf, 1);; ! 534: buf[0] = '$'; ! 535: } ! 536: i = 0; ! 537: if(p->tn.name == 0) ! 538: if(p->tn.lval == 0) ! 539: i = 32; ! 540: else if(p->tn.lval == 1) ! 541: i = 64; ! 542: j = 0; ! 543: convbuf: ! 544: if(dest.ans == 0) { ! 545: if(p->in.op == 4 || !(flag & 8)) { ! 546: s.ans = (buf - bufs[0])/64; buf += 64; s.flag = i; s.regmask = j; return(s); ! 547: } ! 548: if(i & 512) { ! 549: strshift(buf, 1); ! 550: buf[0] = '*'; ! 551: s.ans = (buf - bufs[0])/64; buf += 64; s.flag = i & ~512; s.regmask = j; return(s); ! 552: } ! 553: if(i & 128) { ! 554: strcat(buf, ")"); ! 555: strshift(buf, 1); ! 556: buf[0] = '('; ! 557: s.ans = (buf - bufs[0])/64; buf += 64; s.flag = i; s.regmask = j; return(s); ! 558: } ! 559: pp = buf; ! 560: buf += 64; ! 561: s = allocreg(p, regmask); ! 562: pr("#\tmov%c\t%s,%s\n", type(p), pp, bufs[s.ans]); ! 563: flag &= ~8; ! 564: goto inreg; ! 565: } ! 566: if(flag & 4) ! 567: if(p->in.type != 040) ! 568: pr("#\tpushl\t%s\n", buf); ! 569: else ! 570: pr("#\tmovd\t%s,%s\n", buf, bufs[dest.ans]); ! 571: else if(i & 32) ! 572: pr("#\tclr%c\t%s\n", type(p), bufs[dest.ans]); ! 573: else ! 574: pr("#\tmov%c\t%s,%s\n", type(p), buf, bufs[dest.ans]); ! 575: dest.flag |= 1; ! 576: return(dest); ! 577: case 78: ! 578: i = 1; ! 579: pp = "add"; ! 580: goto incrop; ! 581: case 113: ! 582: s = doit(p->in.left, 8, 0, 0); ! 583: pr("#\t.long\t%s\n", bufs[s.ans]); ! 584: return(dest); ! 585: case 1+ 64: ! 586: flag |= 256; ! 587: case 64: ! 588: s = doit(p->in.left, 2, 0, regmask); ! 589: regmask &= ~s.flag; ! 590: t = doit(p->in.right, 2, 0, regmask); ! 591: if(t.flag & 1024) { ! 592: totemp(p, 0); ! 593: longjmp(back, 1); ! 594: } ! 595: regmask &= ~t.regmask; ! 596: if(dest.ans == 0) ! 597: if((s.flag & 16) || (flag & 256)) ! 598: dest = s; ! 599: else ! 600: dest = allocreg(p, regmask); ! 601: pr("#\tashl\t%s,%s,%s\n", bufs[t.ans], bufs[s.ans], bufs[dest.ans]); ! 602: dest.flag |= 1; ! 603: return(dest); ! 604: case 1+ 8: ! 605: if(p->in.right->in.op == 4) { ! 606: i = -1; ! 607: pp = "sub"; ! 608: flag &= ~2; ! 609: goto incrop; ! 610: } ! 611: flag |= 256; ! 612: case 8: ! 613: pp = "sub"; ! 614: goto binop; ! 615: case 1+ 62: ! 616: flag |= 256; ! 617: if(p->in.left->in.op == 104 && !isunsigned(p)) { ! 618: snode = *p; ! 619: snode.in.left = p->in.left->in.left; ! 620: p = &snode; ! 621: } ! 622: case 62: ! 623: if(isunsigned(p)) { ! 624: pp = "urem"; ! 625: goto unsdiv; ! 626: } ! 627: s = doit(p->in.left, 2, 0, regmask); ! 628: regmask &= ~s.regmask; ! 629: t = doit(p->in.right, 2, 0, regmask); ! 630: regmask &= ~t.regmask; ! 631: x = allocreg(p, regmask); ! 632: pr("#\tdiv%c3\t%s,%s,%s\n", childtype(p), bufs[t.ans], bufs[s.ans], bufs[x.ans]); ! 633: pr("#\tmul%c2\t%s,%s\n", childtype(p), bufs[t.ans], bufs[x.ans]); ! 634: pr("#\tsub%c3\t%s,%s,%s\n", childtype(p), bufs[x.ans], bufs[s.ans], bufs[x.ans]); ! 635: if(dest.ans) ! 636: goto movexdest; ! 637: if(flag & 256) { ! 638: dest = s; ! 639: goto movexdest; ! 640: } ! 641: x.flag |= 1; ! 642: return(x); ! 643: case 1+ 11: ! 644: flag |= 256; ! 645: case 11: ! 646: pp = "mul"; ! 647: goto binop; ! 648: case 2: ! 649: if(p->tn.lval) ! 650: sprintf(buf, "%s+%d", p->tn.name, p->tn.lval); ! 651: else if(p->tn.name) ! 652: sprintf(buf, "%s", p->tn.name); ! 653: else ! 654: sprintf(buf, "0"); ! 655: j = 0; ! 656: i = 512; ! 657: goto convbuf; ! 658: case 1+ 17: ! 659: flag |= 256; ! 660: case 17: ! 661: pp = "bis"; ! 662: goto binop; ! 663: case 1+ 6: ! 664: if(p->in.right->in.op == 4) { ! 665: i = 1; ! 666: pp = "add"; ! 667: flag &= ~2; ! 668: goto incrop; ! 669: } ! 670: flag |= 256; ! 671: case 6: ! 672: pp = "add"; ! 673: goto binop; ! 674: case 94: ! 675: sprintf(buf, "r%d", p->tn.rval); ! 676: j = 0; ! 677: i = 128; ! 678: goto convbuf; ! 679: case 118: case 119: ! 680: x = reg0(p, 3); ! 681: x.regmask = 0; ! 682: if(dest.ans) ! 683: goto movexdest; ! 684: return(x); ! 685: case 120: ! 686: return(reg0(p, regmask)); ! 687: case 1+ 66: ! 688: flag |= 256; ! 689: case 66: ! 690: s = doit(p->in.left, 2, 0, regmask); ! 691: regmask &= ~s.regmask; ! 692: if(dest.ans == 0) ! 693: if((flag & 256) || (s.flag & 16)) ! 694: dest = s; ! 695: else ! 696: dest = allocreg(p, regmask); ! 697: dest.flag |= 1; ! 698: regmask &= ~dest.regmask; ! 699: if(p->in.right->in.op == 4 && (i = p->in.right->tn.lval) >= 0) { ! 700: pr("#\textv\t$%d,$%d,%s,%s\n", i, 32 - i, bufs[s.ans], bufs[dest.ans]); ! 701: return(dest); ! 702: } ! 703: t = doit(p->in.right, 2, 0, regmask); ! 704: regmask &= ~t.regmask; ! 705: x = allocreg(p, regmask); ! 706: pr("#\tmnegl\t%s,%s\n", bufs[t.ans], bufs[x.ans]); ! 707: pr("#\tashl\t%s,%s,%s\n", bufs[x.ans], bufs[s.ans], bufs[dest.ans]); ! 708: return(dest); ! 709: case (2+ 11): ! 710: switch(p->in.left->in.op) { ! 711: case 116: ! 712: case 117: ! 713: case 2: ! 714: s = doit(p->in.left, 2, 0, regmask); ! 715: sprintf(buf, "*%s", bufs[s.ans]); ! 716: j = i = 0; ! 717: goto convbuf; ! 718: case 94: ! 719: s = doit(p->in.left, 2, 0, regmask); ! 720: inreg: ! 721: if(s.flag & 128) { ! 722: sprintf(buf, "(%s)", bufs[s.ans]); ! 723: j = 0; ! 724: i = 512; ! 725: goto convbuf; ! 726: } ! 727: else if(s.flag & 512) { ! 728: sprintf(buf, "*%s", bufs[s.ans]); ! 729: j = 0; ! 730: i = 0; ! 731: goto convbuf; ! 732: } ! 733: else { ! 734: s.flag = 1024; ! 735: return(s); ! 736: } ! 737: } ! 738: q = p->in.left; ! 739: if(q->in.op == 78 ! 740: && q->in.right->in.op == 4 && q->in.left->in.op == 94 ! 741: && incrsize(p) == (int) q->in.right->tn.lval) { ! 742: s = doit(q->in.left, 2, 0, regmask); ! 743: sprintf(buf, "(%s)+", bufs[s.ans]); ! 744: i = 0; ! 745: j = s.regmask; ! 746: goto convbuf; ! 747: } ! 748: if(q->in.op == 6 && q->in.left->in.op == 64 ! 749: && q->in.left->in.right->in.op == 4 ! 750: && shiftsize(p) == (int) q->in.left->in.right->tn.lval) { ! 751: s = doit(q->in.left->in.left, 2, 0, regmask); ! 752: regmask &= ~s.regmask; ! 753: if(!(s.flag & 128)) { ! 754: x = allocreg(p, regmask); ! 755: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]); ! 756: regmask |= s.regmask; ! 757: regmask &= ~x.regmask; ! 758: s = x; ! 759: } ! 760: t = doit(q->in.right, 8, 0, regmask); ! 761: sprintf(buf, "%s[%s]", bufs[t.ans], bufs[s.ans]); ! 762: i = 0; ! 763: j = s.regmask; ! 764: goto convbuf; ! 765: } ! 766: if(q->in.op == 6 ! 767: && (q->in.right->in.op == 4 || q->in.right->in.op == 2)) { ! 768: s = doit(q->in.left, 2, 0, regmask); ! 769: regmask &= ~s.regmask; ! 770: if(!(s.flag & 128)) { ! 771: x = allocreg(p, regmask); ! 772: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]); ! 773: regmask |= s.regmask; ! 774: regmask &= ~x.regmask; ! 775: s = x; ! 776: } ! 777: t = doit(q->in.right, 8, 0, regmask); ! 778: sprintf(buf, "%s(%s)", bufs[t.ans], bufs[s.ans]); ! 779: i = 512; ! 780: j = s.regmask; ! 781: goto convbuf; ! 782: } ! 783: if(q->in.op == 8 && q->in.right->in.op == 4) { ! 784: s = doit(q->in.left, 2, 0, regmask); ! 785: regmask &= ~s.regmask; ! 786: if(!(s.flag & 128)) { ! 787: x = allocreg(p, regmask); ! 788: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]); ! 789: regmask |= s.regmask; ! 790: regmask &= ~x.regmask; ! 791: s = x; ! 792: if(!(s.flag & 128)) { ! 793: s.flag = 1024; ! 794: return(s); ! 795: } ! 796: } ! 797: sprintf(buf, "%d(%s)", -q->in.right->tn.lval, bufs[s.ans]); ! 798: i = 512; ! 799: j = s.regmask; ! 800: goto convbuf; ! 801: } ! 802: if(q->in.op == 1+ 8 ! 803: && q->in.right->in.op == 4 && q->in.left->in.op == 94 ! 804: && incrsize(p) == (int) q->in.right->tn.lval) { ! 805: s = doit(q->in.left, 2, 0, regmask); ! 806: sprintf(buf, "-(%s)", bufs[s.ans]); ! 807: i = 0; ! 808: j = s.regmask; ! 809: goto convbuf; ! 810: } ! 811: if(q->in.op == 6 && q->in.left->in.op == 94 ! 812: && q->in.right->in.op == 94) { ! 813: sprintf(buf, "(r%d)[r%d]", q->in.right->tn.rval, ! 814: q->in.left->tn.rval); ! 815: i = 0; ! 816: j = 0; ! 817: goto convbuf; ! 818: } ! 819: s = doit(p->in.left, 2, 0, regmask); ! 820: if(s.flag & 1024) ! 821: return(s); ! 822: regmask &= ~s.regmask; ! 823: if(s.flag & 512) { ! 824: sprintf(buf, "*%s", bufs[s.ans]); ! 825: i = 0; ! 826: j = s.regmask; ! 827: goto convbuf; ! 828: } ! 829: if(!(s.flag & 128)) { ! 830: x = allocreg(p, regmask); ! 831: pr("#\tmov%c\t%s,%s\n", childtype(q), bufs[s.ans], bufs[x.ans]); ! 832: regmask |= s.regmask; ! 833: regmask &= ~x.regmask; ! 834: s = x; ! 835: } ! 836: if(!(s.flag & 128)) { ! 837: s.flag = 1024; ! 838: return(s); ! 839: } ! 840: sprintf(buf, "(%s)", bufs[s.ans]); ! 841: i = 0; ! 842: j = s.regmask; ! 843: goto convbuf; ! 844: case 98: ! 845: if(p->stn.stsize/8 == 4) { ! 846: i = 'l'; ! 847: stasg: ! 848: s = doit(p->in.right, 2|8, 0, regmask); ! 849: regmask &= ~s.regmask; ! 850: t = doit(p->in.left, 2|8, 0, regmask); ! 851: pr("#\tmov%c\t%s,%s\n", i, bufs[s.ans], bufs[t.ans]); ! 852: s.regmask = s.flag = 0; ! 853: return(s); ! 854: } ! 855: else if(p->stn.stsize/8 == 8) { ! 856: i = 'q'; ! 857: goto stasg; ! 858: } ! 859: if(regmask != 0x3f) { ! 860: s.flag = 1024; ! 861: return(s); ! 862: } ! 863: s = doit(p->in.right, 2|8, 0, regmask); ! 864: regmask &= ~s.regmask; ! 865: t = doit(p->in.left, 2|8, 0, regmask); ! 866: pr("#\tmovc3\t$%d,%s,%s\n", p->stn.stsize/8, bufs[s.ans], bufs[t.ans]); ! 867: s.regmask = s.flag = 0; ! 868: return(s); ! 869: case 100: ! 870: goto call; ! 871: case 116: ! 872: sprintf(buf, "%d(fp)", p->tn.lval); ! 873: j = 0; ! 874: i = 512; ! 875: goto convbuf; ! 876: case 117: ! 877: sprintf(buf, "%d(ap)", p->tn.lval); ! 878: j = 0; ! 879: i = 512; ! 880: goto convbuf; ! 881: case 2+ 14: ! 882: s = doit(p->in.left, 0, 0, regmask); ! 883: regmask &= ~s.regmask; ! 884: if(dest.ans == 0) { ! 885: dest = allocreg(p, regmask); ! 886: } ! 887: if(flag & 4) ! 888: pr("#\tpushal\t%s\n", bufs[s.ans]); ! 889: else { ! 890: pr("#\tmova%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]); ! 891: } ! 892: if(flag & 8) { ! 893: if(dest.flag & 128) { ! 894: strcat( bufs[dest.ans], ")"); ! 895: strshift( bufs[dest.ans], 1); ! 896: bufs[dest.ans][0] = '('; ! 897: } ! 898: else { ! 899: strshift( bufs[dest.ans], 1); ! 900: bufs[dest.ans][0] = '*'; ! 901: } ! 902: } ! 903: return(dest); ! 904: case 2+ 70: ! 905: i = 0; ! 906: goto called; ! 907: case 2+ 8: ! 908: s = doit(p->in.left, 2, 0, regmask); ! 909: if(dest.ans == 0) ! 910: if(s.flag & 16) ! 911: dest = s; ! 912: else ! 913: dest = allocreg(p, regmask & ~s.regmask); ! 914: pr("#\tmneg%c\t%s,%s\n", childtype(p), bufs[s.ans], bufs[dest.ans]); ! 915: dest.flag |= 1; ! 916: return(dest); ! 917: case 2+ 100: ! 918: i = 0; ! 919: goto called; ! 920: case 58: ! 921: if(p->in.left->in.op == 120 && dest.ans) { ! 922: s = doit(p->in.right, 2, dest, regmask); ! 923: return(s); ! 924: } ! 925: if(p->in.left->in.op == 103) { ! 926: s = doit(p->in.left->in.left, 0, 0, regmask); ! 927: regmask &= ~s.regmask; ! 928: if(p->in.right->in.op == 58) { ! 929: x = allocreg(p->in.right, regmask); ! 930: t = doit(p->in.right, 2, x, regmask & ~x.regmask); ! 931: } ! 932: else ! 933: t = doit(p->in.right, 2, 0, regmask); ! 934: if(t.flag & 1024) { ! 935: totemp(p->in.left, 0); ! 936: longjmp(back, 1); ! 937: } ! 938: pr("#\tinsv\t%s,$%d,$%d,%s\n", bufs[t.ans], p->in.left->tn.rval/64, ! 939: p->in.left->tn.rval % 64, bufs[s.ans]); ! 940: t.flag |= 1; ! 941: return(t); ! 942: } ! 943: if(dest.ans && p->in.left->in.op == (2+ 11)) { ! 944: if(dest.flag & 16) ! 945: x = dest; ! 946: else ! 947: x = allocreg(p, regmask); ! 948: s = doit(p->in.right, 2, x, regmask); ! 949: regmask &= ~s.regmask; ! 950: assignit: ! 951: t = doit(p->in.left, 0, 0, regmask); ! 952: pr("#\tmov%c\t%s,%s\n", type(p), bufs[x.ans], bufs[t.ans]); ! 953: if(strcmp( bufs[x.ans], bufs[dest.ans]) == 0) { ! 954: dest.flag |= 1; ! 955: return(dest); ! 956: } ! 957: goto movexdest; ! 958: } ! 959: if(p->in.right->in.op == 119) ! 960: t = doit(p->in.left, 0, 0, regmask & ~3); ! 961: else ! 962: t = doit(p->in.left, 0, 0, regmask); ! 963: regmask &= ~t.regmask; ! 964: s = doit(p->in.right, 2, t, regmask); ! 965: if(s.flag & 1024) { ! 966: ! 967: if(dest.ans) { ! 968: regmask |= t.regmask; ! 969: s = doit(p->in.right, 2, t, regmask); ! 970: if(s.flag & 1024) ! 971: return(s); ! 972: } ! 973: asgwrite(p); ! 974: longjmp(back, 1); ! 975: } ! 976: if(dest.ans) { ! 977: x = s; ! 978: goto movexdest; ! 979: } ! 980: else if(flag & 8) { ! 981: i = (s.flag & (128|512|16)); ! 982: j = s.regmask; ! 983: buf = bufs[s.ans]; ! 984: goto convbuf; ! 985: } ! 986: s.flag |= 1; ! 987: return(s); ! 988: } ! 989: } ! 990: char * ! 991: genjmp(n) ! 992: { ! 993: switch(n) { ! 994: default: ! 995: return("jweird"); ! 996: case 80: ! 997: return("jeql"); ! 998: case 81: ! 999: return("jneq"); ! 1000: case 85: ! 1001: return("jgtr"); ! 1002: case 84: ! 1003: return("jgeq"); ! 1004: case 83: ! 1005: return("jlss"); ! 1006: case 82: ! 1007: return("jleq"); ! 1008: case 89: ! 1009: return("jgtru"); ! 1010: case 88: ! 1011: return("jgequ"); ! 1012: case 87: ! 1013: return("jlssu"); ! 1014: case 86: ! 1015: return("jlequ"); ! 1016: } ! 1017: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.