![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c10.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c|
Return to c10.c CVS log | Up to [Research Unix] / researchv10no / cmd / PDP11 / 11c |
1.1 ! root 1: # ! 2: /* ! 3: ! 4: C compiler, part 2 ! 5: ! 6: ! 7: */ ! 8: ! 9: #include "c1.h" ! 10: ! 11: #define dbprint(op) /* */ ! 12: #ifdef DEBUG ! 13: #define dbprint(op) printf(" / %s", opntab[op]) ! 14: #endif ! 15: ! 16: char maprel[] = { EQUAL, NEQUAL, GREATEQ, GREAT, LESSEQ, ! 17: LESS, GREATQP, GREATP, LESSEQP, LESSP ! 18: }; ! 19: ! 20: char notrel[] = { NEQUAL, EQUAL, GREAT, GREATEQ, LESS, ! 21: LESSEQ, GREATP, GREATQP, LESSP, LESSEQP ! 22: }; ! 23: ! 24: struct tconst czero = { CON, INT, 0}; ! 25: struct tconst cone = { CON, INT, 1}; ! 26: ! 27: struct tname sfuncr = { NAME, STRUCT, STATIC, 0, 0, 0 }; ! 28: ! 29: struct table *cregtab; ! 30: ! 31: int nreg = 3; ! 32: int isn = 10000; ! 33: ! 34: main(argc, argv) ! 35: char *argv[]; ! 36: { ! 37: ! 38: if (argc<4) { ! 39: error("Arg count"); ! 40: exit(1); ! 41: } ! 42: if (freopen(argv[1], "r", stdin)==NULL) { ! 43: error("Missing temp file"); ! 44: exit(1); ! 45: } ! 46: if ((freopen(argv[3], "w", stdout)) == NULL) { ! 47: error("Can't create %s", argv[3]); ! 48: exit(1); ! 49: } ! 50: funcbase = curbase = coremax = sbrk(0); ! 51: getree(); ! 52: /* ! 53: * If any floating-point instructions ! 54: * were used, generate a reference that ! 55: * pulls in the floating-point part of printf. ! 56: */ ! 57: if (nfloat) ! 58: printf(".globl fltused\n"); ! 59: /* ! 60: * tack on the string file. ! 61: */ ! 62: printf(".globl\n.data\n"); ! 63: if (*argv[2] != '-') { ! 64: if (freopen(argv[2], "r", stdin)==NULL) { ! 65: error("Missing temp file"); ! 66: exit(1); ! 67: } ! 68: getree(); ! 69: } ! 70: if (totspace >= (unsigned)56000) { ! 71: error("Warning: possibly too much data"); ! 72: nerror--; ! 73: } ! 74: exit(nerror!=0); ! 75: } ! 76: ! 77: /* ! 78: * Given a tree, a code table, and a ! 79: * count of available registers, find the code table ! 80: * for the appropriate operator such that the operands ! 81: * are of the right type and the number of registers ! 82: * required is not too large. ! 83: * Return a ptr to the table entry or 0 if none found. ! 84: */ ! 85: struct optab * ! 86: match(tree, table, nrleft, nocvt) ! 87: union tree *tree; ! 88: struct table *table; ! 89: { ! 90: #define NOCVL 1 ! 91: #define NOCVR 2 ! 92: int op, d1, d2, dope; ! 93: union tree *p2; ! 94: register union tree *p1; ! 95: register struct optab *opt; ! 96: ! 97: if (tree==NULL) ! 98: return(NULL); ! 99: if (table==lsptab) ! 100: table = sptab; ! 101: if ((op = tree->t.op)==0) ! 102: return(0); ! 103: dope = opdope[op]; ! 104: if ((dope&LEAF) == 0) ! 105: p1 = tree->t.tr1; ! 106: else ! 107: p1 = tree; ! 108: d1 = dcalc(p1, nrleft); ! 109: if ((dope&BINARY)!=0) { ! 110: p2 = tree->t.tr2; ! 111: /* ! 112: * If a subtree starts off with a conversion operator, ! 113: * try for a match with the conversion eliminated. ! 114: * E.g. int = double can be done without generating ! 115: * the converted int in a register by ! 116: * movf double,fr0; movfi fr0,int . ! 117: */ ! 118: if (opdope[p2->t.op]&CNVRT && (nocvt&NOCVR)==0 ! 119: && (opdope[p2->t.tr1->t.op]&CNVRT)==0) { ! 120: tree->t.tr2 = p2->t.tr1; ! 121: if (opt = match(tree, table, nrleft, NOCVL)) ! 122: return(opt); ! 123: tree->t.tr2 = p2; ! 124: } else if (opdope[p1->t.op]&CNVRT && (nocvt&NOCVL)==0 ! 125: && (opdope[p1->t.tr1->t.op]&CNVRT)==0) { ! 126: tree->t.tr1 = p1->t.tr1; ! 127: if (opt = match(tree, table, nrleft, NOCVR)) ! 128: return(opt); ! 129: tree->t.tr1 = p1; ! 130: } ! 131: d2 = dcalc(p2, nrleft); ! 132: } ! 133: for (; table->tabop!=op; table++) ! 134: if (table->tabop==0) ! 135: return(0); ! 136: for (opt = table->tabp; opt->tabdeg1!=0; opt++) { ! 137: if (d1 > (opt->tabdeg1&077) ! 138: || (opt->tabdeg1 >= 0100 && (p1->t.op != STAR))) ! 139: continue; ! 140: if (notcompat(p1, opt->tabtyp1, opt->tabdeg1, op)) ! 141: continue; ! 142: if ((opdope[op]&BINARY)!=0 && p2!=0) { ! 143: if (d2 > (opt->tabdeg2&077) ! 144: || (opt->tabdeg2 >= 0100) && (p2->t.op != STAR) ) ! 145: continue; ! 146: if (notcompat(p2,opt->tabtyp2, opt->tabdeg2, 0)) ! 147: continue; ! 148: if ((opt->tabdeg2&077)==20 && xdcalc(p2,nrleft)>20) ! 149: continue; ! 150: } ! 151: return(opt); ! 152: } ! 153: return(0); ! 154: } ! 155: ! 156: /* ! 157: * Given a tree, a code table, and a register, ! 158: * produce code to evaluate the tree with the appropriate table. ! 159: * Registers reg and upcan be used. ! 160: * If there is a value, it is desired that it appear in reg. ! 161: * The routine returns the register in which the value actually appears. ! 162: * This routine must work or there is an error. ! 163: * If the table called for is cctab, sptab, or efftab, ! 164: * and tree can't be done using the called-for table, ! 165: * another try is made. ! 166: * If the tree can't be compiled using cctab, regtab is ! 167: * used and a "tst" instruction is produced. ! 168: * If the tree can't be compiled using sptab, ! 169: * regtab is used and the register is pushed on the stack. ! 170: * If the tree can't be compiled using efftab, ! 171: * just use regtab. ! 172: * Regtab must succeed or an "op not found" error results. ! 173: * ! 174: * A number of special cases are recognized, and ! 175: * there is an interaction with the optimizer routines. ! 176: */ ! 177: rcexpr(atree, atable, reg) ! 178: union tree *atree; ! 179: struct table *atable; ! 180: { ! 181: register r; ! 182: int modf, nargs, recurf; ! 183: register union tree *tree; ! 184: register struct table *table; ! 185: ! 186: table = atable; ! 187: recurf = 0; ! 188: if (reg<0) { ! 189: recurf++; ! 190: reg = ~reg; ! 191: if (reg>=020) { ! 192: reg -= 020; ! 193: recurf++; ! 194: } ! 195: } ! 196: again: ! 197: if((tree=atree)==0) ! 198: return(0); ! 199: if (tree->t.type==VOID) { ! 200: if (table!=efftab) ! 201: error("Illegal use of void"); ! 202: tree->t.type = INT; ! 203: } ! 204: if (opdope[tree->t.op]&RELAT && tree->t.tr2->t.op==CON ! 205: && tree->t.tr2->c.value==0 ! 206: && table==cctab) ! 207: tree = atree = tree->t.tr1; ! 208: /* ! 209: * fieldselect(...) : in efftab mode, ! 210: * ignore the select, otherwise ! 211: * do the shift and mask. ! 212: */ ! 213: if (tree->t.op == FSELT) { ! 214: if (table==efftab) ! 215: atree = tree = tree->t.tr1; ! 216: else { ! 217: tree->t.op = FSEL; ! 218: atree = tree = optim(tree); ! 219: } ! 220: } ! 221: switch (tree->t.op) { ! 222: ! 223: /* ! 224: * Structure assignments ! 225: */ ! 226: case STRASG: ! 227: strasg(tree); ! 228: return(0); ! 229: ! 230: /* ! 231: * An initializing expression ! 232: */ ! 233: case INIT: ! 234: tree = optim(tree); ! 235: doinit(tree->t.type, tree->t.tr1); ! 236: return(0); ! 237: ! 238: /* ! 239: * Put the value of an expression in r0, ! 240: * for a switch or a return ! 241: */ ! 242: case RFORCE: ! 243: tree = tree->t.tr1; ! 244: if((r=rcexpr(tree, regtab, reg)) != 0) ! 245: movreg(r, 0, tree); ! 246: return(0); ! 247: ! 248: /* ! 249: * sequential execution ! 250: */ ! 251: case SEQNC: ! 252: r = nstack; ! 253: rcexpr(tree->t.tr1, efftab, reg); ! 254: nstack = r; ! 255: atree = tree = tree->t.tr2; ! 256: goto again; ! 257: ! 258: /* ! 259: * In the generated &~ operator, ! 260: * fiddle things so a PDP-11 "bit" ! 261: * instruction will be produced when cctab is used. ! 262: */ ! 263: case ANDN: ! 264: if (table==cctab) { ! 265: tree->t.op = TAND; ! 266: tree->t.tr2 = optim(tnode(COMPL, tree->t.type, tree->t.tr2, TNULL)); ! 267: } ! 268: break; ! 269: ! 270: /* ! 271: * Handle a subroutine call. It has to be done ! 272: * here because if cexpr got called twice, the ! 273: * arguments might be compiled twice. ! 274: * There is also some fiddling so the ! 275: * first argument, in favorable circumstances, ! 276: * goes to (sp) instead of -(sp), reducing ! 277: * the amount of stack-popping. ! 278: */ ! 279: case CALL: ! 280: r = 0; ! 281: nargs = 0; ! 282: modf = 0; ! 283: if (tree->t.tr1->t.op!=NAME || tree->t.tr1->n.class!=EXTERN) { ! 284: nargs++; ! 285: nstack++; ! 286: } ! 287: tree = tree->t.tr2; ! 288: if(tree->t.op) { ! 289: while (tree->t.op==COMMA) { ! 290: r += comarg(tree->t.tr2, &modf); ! 291: tree = tree->t.tr1; ! 292: nargs++; ! 293: } ! 294: r += comarg(tree, &modf); ! 295: nargs++; ! 296: } ! 297: tree = atree; ! 298: tree->t.op = CALL2; ! 299: if (modf && tree->t.tr1->t.op==NAME ! 300: && tree->t.tr1->n.class==EXTERN) ! 301: tree->t.op = CALL1; ! 302: if (cexpr(tree, regtab, reg)<0) ! 303: error("compiler botch: call"); ! 304: popstk(r); ! 305: nstack -= nargs; ! 306: if (table==efftab || table==regtab) ! 307: return(0); ! 308: r = 0; ! 309: goto fixup; ! 310: ! 311: /* ! 312: * Longs need special treatment. ! 313: */ ! 314: case ASLSH: ! 315: case LSHIFT: ! 316: if (tree->t.type==LONG) { ! 317: if (tree->t.tr2->t.op==ITOL) ! 318: tree->t.tr2 = tree->t.tr2->t.tr1; ! 319: else ! 320: tree->t.tr2 = optim(tnode(LTOI,INT,tree->t.tr2,TNULL)); ! 321: if (tree->t.op==ASLSH) ! 322: tree->t.op = ASLSHL; ! 323: else ! 324: tree->t.op = LLSHIFT; ! 325: } ! 326: break; ! 327: ! 328: /* ! 329: * Try to change * to shift. ! 330: */ ! 331: case TIMES: ! 332: case ASTIMES: ! 333: tree = pow2(tree); ! 334: } ! 335: /* ! 336: * Try to find postfix ++ and -- operators that can be ! 337: * pulled out and done after the rest of the expression ! 338: */ ! 339: if (table!=cctab && table!=cregtab && recurf<2 ! 340: && (opdope[tree->t.op]&LEAF)==0) { ! 341: if (r=delay(&atree, table, reg)) { ! 342: tree = atree; ! 343: table = efftab; ! 344: reg = r-1; ! 345: } ! 346: } ! 347: /* ! 348: * Basically, try to reorder the computation ! 349: * so reg = x+y is done as reg = x; reg += y ! 350: */ ! 351: if (recurf==0 && reorder(&atree, table, reg)) { ! 352: if (table==cctab && atree->t.op==NAME) ! 353: return(reg); ! 354: } ! 355: tree = atree; ! 356: if (table==efftab && tree->t.op==NAME) ! 357: return(reg); ! 358: if ((r=cexpr(tree, table, reg))>=0) { ! 359: if (table==cregtab && (tree->t.op==INCAFT ! 360: || tree->t.op==DECAFT || tree->t.op==TIMES)) ! 361: goto fixup; ! 362: return(r); ! 363: } ! 364: if (table!=regtab && (table!=cctab||(opdope[tree->t.op]&RELAT)==0)) { ! 365: if((r=cexpr(tree, regtab, reg))>=0) { ! 366: fixup: ! 367: modf = isfloat(tree); ! 368: dbprint(tree->t.op); ! 369: if (table==sptab || table==lsptab) { ! 370: if (tree->t.type==LONG) { ! 371: printf("mov\tr%d,-(sp)\n",r+1); ! 372: nstack++; ! 373: } ! 374: printf("mov%s r%d,%s(sp)\n", modf=='f'?"f":"", r, ! 375: table==sptab? "-":""); ! 376: nstack++; ! 377: } ! 378: if (table==cctab || table==cregtab) ! 379: printf("tst%s r%d\n", modf=='f'?"f":"", r); ! 380: return(r); ! 381: } ! 382: } ! 383: /* ! 384: * Special grace for unsigned chars as right operands ! 385: */ ! 386: if (opdope[tree->t.op]&BINARY && tree->t.tr2->t.type==UNCHAR) { ! 387: tree->t.tr2 = tnode(LOAD, UNSIGN, tree->t.tr2, TNULL); ! 388: return(rcexpr(tree, table, reg)); ! 389: } ! 390: /* ! 391: * There's a last chance for this operator ! 392: */ ! 393: if (tree->t.op==LTOI) { ! 394: r = rcexpr(tree->t.tr1, regtab, reg); ! 395: if (r >= 0) { ! 396: r++; ! 397: goto fixup; ! 398: } ! 399: } ! 400: if (tree->t.type == STRUCT) ! 401: error("Illegal operation on structure"); ! 402: else if (tree->t.op>0 && tree->t.op<RFORCE && opntab[tree->t.op]) ! 403: error("No code table for op: %s", opntab[tree->t.op]); ! 404: else ! 405: error("No code table for op %d", tree->t.op); ! 406: return(reg); ! 407: } ! 408: ! 409: /* ! 410: * Try to compile the tree with the code table using ! 411: * registers areg and up. If successful, ! 412: * return the register where the value actually ended up. ! 413: * If unsuccessful, return -1. ! 414: * ! 415: * Most of the work is the macro-expansion of the ! 416: * code table. ! 417: */ ! 418: cexpr(tree, table, areg) ! 419: register union tree *tree; ! 420: struct table *table; ! 421: { ! 422: int c, r; ! 423: register union tree *p, *p1; ! 424: struct table *ctable; ! 425: union tree *p2; ! 426: char *string; ! 427: int reg, reg1, rreg, flag, opd; ! 428: struct optab *opt; ! 429: ! 430: reg = areg; ! 431: p1 = tree->t.tr2; ! 432: c = tree->t.op; ! 433: opd = opdope[c]; ! 434: /* ! 435: * When the value of a relational or a logical expression is ! 436: * desired, more work must be done. ! 437: */ ! 438: if ((opd&RELAT||c==LOGAND||c==LOGOR||c==EXCLA) && table!=cctab) { ! 439: cbranch(tree, c=isn++, 1, reg); ! 440: rcexpr((union tree *)&czero, table, reg); ! 441: branch(isn, 0, 0); ! 442: label(c); ! 443: rcexpr((union tree *)&cone, table, reg); ! 444: label(isn++); ! 445: return(reg); ! 446: } ! 447: if(c==QUEST) { ! 448: if (table==cctab) ! 449: return(-1); ! 450: cbranch(tree->t.tr1, c=isn++, 0, reg); ! 451: flag = nstack; ! 452: rreg = rcexpr(p1->t.tr1, table, reg); ! 453: nstack = flag; ! 454: branch(r=isn++, 0, 0); ! 455: label(c); ! 456: reg = rcexpr(p1->t.tr2, table, rreg); ! 457: if (rreg!=reg) ! 458: movreg(reg, rreg, tree->t.tr2); ! 459: label(r); ! 460: return(rreg); ! 461: } ! 462: reg = oddreg(tree, reg); ! 463: reg1 = reg+1; ! 464: /* ! 465: * long values take 2 registers. ! 466: */ ! 467: if ((tree->t.type==LONG||opd&RELAT&&tree->t.tr1->t.type==LONG) ! 468: && tree->t.op!=ITOL) ! 469: reg1++; ! 470: /* ! 471: * Leaves of the expression tree ! 472: */ ! 473: if ((r = chkleaf(tree, table, reg)) >= 0) ! 474: return(r); ! 475: /* ! 476: * x + (-1) is better done as x-1. ! 477: */ ! 478: if (tree->t.op==PLUS||tree->t.op==ASPLUS) { ! 479: if ((p1=tree->t.tr2)->t.op==CON && p1->c.value==-1) { ! 480: p1->c.value = -p1->c.value; ! 481: tree->t.op += (MINUS-PLUS); ! 482: } ! 483: } ! 484: /* ! 485: * Because of a peculiarity of the PDP11 table ! 486: * char = *intreg++ and *--intreg cannot go through. ! 487: */ ! 488: if (tree->t.tr2 && (tree->t.tr2->t.op==AUTOI||tree->t.tr2->t.op==AUTOD) ! 489: && (tree->t.tr1->t.type==CHAR || tree->t.tr1->t.type==UNCHAR) ! 490: && tree->t.tr2->t.type!=CHAR && tree->t.tr2->t.type!=UNCHAR) ! 491: tree->t.tr2 = tnode(LOAD, tree->t.tr2->t.type, tree->t.tr2, TNULL); ! 492: if (table==cregtab) ! 493: table = regtab; ! 494: /* ! 495: * The following peculiar code depends on the fact that ! 496: * if you just want the codition codes set, efftab ! 497: * will generate the right code unless the operator is ! 498: * a shift or ! 499: * postfix ++ or --. Unravelled, if the table is ! 500: * cctab and the operator is not special, try first ! 501: * for efftab; if the table isn't, if the operator is, ! 502: * or the first match fails, try to match ! 503: * with the table actually asked for. ! 504: */ ! 505: /* ! 506: * Account for longs and oddregs; below is really ! 507: * r = nreg - reg - (reg-areg) - (reg1-reg-1); ! 508: */ ! 509: r = nreg - reg + areg - reg1 + 1; ! 510: if (table!=cctab || c==INCAFT || c==DECAFT || tree->t.type==LONG ! 511: || c==ASRSH || c==ASLSH || c==ASULSH || tree->t.tr1->t.type==UNCHAR ! 512: || (opt = match(tree, efftab, r, 0)) == 0) ! 513: if ((opt=match(tree, table, r, 0))==0) ! 514: return(-1); ! 515: string = opt->tabstring; ! 516: p1 = tree->t.tr1; ! 517: if (p1->t.op==FCON && p1->f.value>0) { ! 518: /* nonportable */ ! 519: printf(".data\nL%d:%o;%o;%o;%o\n.text\n", p1->f.value, ! 520: ((unsigned short *)&(p1->f.fvalue))[0], ! 521: ((unsigned short *)&(p1->f.fvalue))[1], ! 522: ((unsigned short *)&(p1->f.fvalue))[2], ! 523: ((unsigned short *)&(p1->f.fvalue))[3] ); ! 524: p1->c.value = -p1->c.value; ! 525: } ! 526: p2 = 0; ! 527: if (opdope[tree->t.op]&BINARY) { ! 528: p2 = tree->t.tr2; ! 529: if (p2->t.op==FCON && p2->f.value>0) { ! 530: /* nonportable */ ! 531: printf(".data\nL%d:%o;%o;%o;%o\n.text\n", p2->f.value, ! 532: ((unsigned short *)&(p2->f.fvalue))[0], ! 533: ((unsigned short *)&(p2->f.fvalue))[1], ! 534: ((unsigned short *)&(p2->f.fvalue))[2], ! 535: ((unsigned short *)&(p2->f.fvalue))[3] ); ! 536: p2->f.value = -p2->f.value; ! 537: } ! 538: } ! 539: loop: ! 540: /* ! 541: * The 0200 bit asks for a tab. ! 542: */ ! 543: if ((c = *string++) & 0200) { ! 544: c &= 0177; ! 545: putchar('\t'); ! 546: } ! 547: switch (c) { ! 548: ! 549: case '\n': ! 550: dbprint(tree->t.op); ! 551: break; ! 552: ! 553: case '\0': ! 554: if (!isfloat(tree)) ! 555: if (tree->t.op==DIVIDE||tree->t.op==ASDIV) ! 556: reg--; ! 557: if (table==regtab && (opdope[tree->t.op]&ASSGOP)) { ! 558: if (tree->t.tr1->t.type==CHAR) ! 559: printf("movb r%d,r%d\n", reg, reg); ! 560: } ! 561: return(reg); ! 562: ! 563: /* A1 */ ! 564: case 'A': ! 565: p = p1; ! 566: goto adr; ! 567: ! 568: /* A2 */ ! 569: case 'B': ! 570: p = p2; ! 571: goto adr; ! 572: ! 573: adr: ! 574: c = 0; ! 575: while (*string=='\'') { ! 576: c++; ! 577: string++; ! 578: } ! 579: if (*string=='+') { ! 580: c = 100; ! 581: string++; ! 582: } ! 583: pname(p, c); ! 584: goto loop; ! 585: ! 586: /* I */ ! 587: case 'M': ! 588: if ((c = *string)=='\'') ! 589: string++; ! 590: else ! 591: c = 0; ! 592: prins(tree->t.op, c, instab); ! 593: goto loop; ! 594: ! 595: /* B1 */ ! 596: case 'C': ! 597: if ((opd&LEAF) != 0) ! 598: p = tree; ! 599: else ! 600: p = p1; ! 601: goto pbyte; ! 602: ! 603: /* BF */ ! 604: case 'P': ! 605: p = tree; ! 606: goto pb1; ! 607: ! 608: /* B2 */ ! 609: case 'D': ! 610: p = p2; ! 611: pbyte: ! 612: if (p->t.type==CHAR || p->t.type==UNCHAR) ! 613: putchar('b'); ! 614: pb1: ! 615: if (isfloat(p)) ! 616: putchar('f'); ! 617: goto loop; ! 618: ! 619: /* BE */ ! 620: case 'L': ! 621: if (p1->t.type==CHAR || p2->t.type==CHAR ! 622: || p1->t.type==UNCHAR || p2->t.type==UNCHAR) ! 623: putchar('b'); ! 624: p = tree; ! 625: goto pb1; ! 626: ! 627: /* F */ ! 628: case 'G': ! 629: p = p1; ! 630: flag = 01; ! 631: goto subtre; ! 632: ! 633: /* S */ ! 634: case 'K': ! 635: p = p2; ! 636: flag = 02; ! 637: goto subtre; ! 638: ! 639: /* H */ ! 640: case 'H': ! 641: p = tree; ! 642: flag = 04; ! 643: ! 644: subtre: ! 645: ctable = regtab; ! 646: if (flag&04) ! 647: ctable = cregtab; ! 648: c = *string++ - 'A'; ! 649: if (*string=='!') { ! 650: string++; ! 651: c |= 020; /* force right register */ ! 652: } ! 653: if (*string=='?') { ! 654: string++; ! 655: c |= 040; /* force condition codes */ ! 656: } ! 657: if ((c&02)!=0) ! 658: ctable = sptab; ! 659: if ((c&04)!=0) ! 660: ctable = cctab; ! 661: if ((flag&01) && ctable==regtab && (c&01)==0 ! 662: && ((c&040)||tree->t.op==DIVIDE||tree->t.op==MOD ! 663: || tree->t.op==ASDIV||tree->t.op==ASMOD||tree->t.op==ITOL)) ! 664: ctable = cregtab; ! 665: if ((c&01)!=0) { ! 666: p = p->t.tr1; ! 667: if(collcon(p) && ctable!=sptab) { ! 668: if (p->t.op==STAR) ! 669: p = p->t.tr1; ! 670: p = p->t.tr1; ! 671: } ! 672: } ! 673: if (table==lsptab && ctable==sptab) ! 674: ctable = lsptab; ! 675: if (c&010) ! 676: r = reg1; ! 677: else ! 678: if (opdope[p->t.op]&LEAF || p->t.degree < 2) ! 679: r = reg; ! 680: else ! 681: r = areg; ! 682: rreg = rcexpr(p, ctable, r); ! 683: if (ctable!=regtab && ctable!=cregtab) ! 684: goto loop; ! 685: if (c&010) { ! 686: if (c&020 && rreg!=reg1) ! 687: movreg(rreg, reg1, p); ! 688: else ! 689: reg1 = rreg; ! 690: } else if (rreg!=reg) ! 691: if ((c&020)==0 && oddreg(tree, 0)==0 && tree->t.type!=LONG ! 692: && (flag&04 ! 693: || flag&01&&xdcalc(p2,nreg-rreg-1)<=(opt->tabdeg2&077) ! 694: || flag&02&&xdcalc(p1,nreg-rreg-1)<=(opt->tabdeg1&077))) { ! 695: reg = rreg; ! 696: reg1 = rreg+1; ! 697: } else ! 698: movreg(rreg, reg, p); ! 699: goto loop; ! 700: ! 701: /* R */ ! 702: case 'I': ! 703: r = reg; ! 704: if (*string=='-') { ! 705: string++; ! 706: r--; ! 707: } ! 708: goto preg; ! 709: ! 710: /* R1 */ ! 711: case 'J': ! 712: r = reg1; ! 713: preg: ! 714: if (*string=='+') { ! 715: string++; ! 716: r++; ! 717: } ! 718: if (r>nreg || r>=4 && tree->t.type==DOUBLE) { ! 719: if (regpanic) ! 720: error("Register overflow: simplify expression"); ! 721: else ! 722: longjmp(jmpbuf, 1); ! 723: } ! 724: printf("r%d", r); ! 725: goto loop; ! 726: ! 727: case '-': /* check -(sp) */ ! 728: if (*string=='(') { ! 729: nstack++; ! 730: if (table!=lsptab) ! 731: putchar('-'); ! 732: goto loop; ! 733: } ! 734: break; ! 735: ! 736: case ')': /* check (sp)+ */ ! 737: putchar(')'); ! 738: if (*string=='+') ! 739: nstack--; ! 740: goto loop; ! 741: ! 742: /* #1 */ ! 743: case '#': ! 744: p = p1->t.tr1; ! 745: goto nmbr; ! 746: ! 747: /* #2 */ ! 748: case '"': ! 749: p = p2->t.tr1; ! 750: ! 751: nmbr: ! 752: if(collcon(p)) { ! 753: if (p->t.op==STAR) { ! 754: printf("*"); ! 755: p = p->t.tr1; ! 756: } ! 757: if ((p = p->t.tr2)->t.op == CON) { ! 758: if (p->c.value) ! 759: psoct(p->c.value); ! 760: } else if (p->t.op==AMPER) ! 761: pname(p->t.tr1, 0); ! 762: } ! 763: goto loop; ! 764: ! 765: /* ! 766: * Certain adjustments for / % ! 767: */ ! 768: case 'T': ! 769: c = reg-1; ! 770: if (uns(p1) || uns(p2)) { ! 771: printf("clr r%d\n", c); ! 772: goto loop; ! 773: } ! 774: if (dcalc(p1, 5)>12 && !match(p1, cctab, 10, 0)) ! 775: printf("tst r%d\n", reg); ! 776: printf("sxt r%d\n", c); ! 777: goto loop; ! 778: ! 779: case 'V': /* adc sbc, clr, or sxt as required for longs */ ! 780: switch(tree->t.op) { ! 781: case PLUS: ! 782: case ASPLUS: ! 783: case INCBEF: ! 784: case INCAFT: ! 785: printf("adc"); ! 786: break; ! 787: ! 788: case MINUS: ! 789: case ASMINUS: ! 790: case NEG: ! 791: case DECBEF: ! 792: case DECAFT: ! 793: printf("sbc"); ! 794: break; ! 795: ! 796: case ASSIGN: ! 797: p = tree->t.tr2; ! 798: goto lcasev; ! 799: ! 800: case ASDIV: ! 801: case ASMOD: ! 802: case ASULSH: ! 803: p = tree->t.tr1; ! 804: lcasev: ! 805: if (p->t.type!=LONG) { ! 806: if (uns(p) || uns(tree->t.tr2)) ! 807: printf("clr"); ! 808: else ! 809: printf("sxt"); ! 810: goto loop; ! 811: } ! 812: default: ! 813: while ((c = *string++)!='\n' && c!='\0'); ! 814: break; ! 815: } ! 816: goto loop; ! 817: ! 818: /* ! 819: * Mask used in field assignments ! 820: */ ! 821: case 'Z': ! 822: printf("$%o", UNS(tree->F.mask)); ! 823: goto loop; ! 824: ! 825: /* ! 826: * Relational on long values. ! 827: * Might bug out early. E.g., ! 828: * (long<0) can be determined with only 1 test. ! 829: */ ! 830: case 'X': ! 831: if (xlongrel(*string++ - '0')) ! 832: return(reg); ! 833: goto loop; ! 834: } ! 835: putchar(c); ! 836: goto loop; ! 837: } ! 838: ! 839: /* ! 840: * This routine just calls sreorder (below) ! 841: * on the subtrees and then on the tree itself. ! 842: * It returns non-zero if anything changed. ! 843: */ ! 844: reorder(treep, table, reg) ! 845: union tree **treep; ! 846: struct table *table; ! 847: { ! 848: register r, o; ! 849: register union tree *p; ! 850: ! 851: p = *treep; ! 852: o = p->t.op; ! 853: if (opdope[o]&LEAF||o==LOGOR||o==LOGAND||o==SEQNC||o==QUEST||o==COLON) ! 854: return(0); ! 855: while(sreorder(&p->t.tr1, regtab, reg, 1)) ! 856: ; ! 857: if (opdope[o]&BINARY) ! 858: while(sreorder(&p->t.tr2, regtab, reg, 1)) ! 859: ; ! 860: r = 0; ! 861: if (table!=cctab) ! 862: while (sreorder(treep, table, reg, 0)) ! 863: r++; ! 864: *treep = optim(*treep); ! 865: return(r); ! 866: } ! 867: ! 868: /* ! 869: * Basically this routine carries out two kinds of optimization. ! 870: * First, it observes that "x + (reg = y)" where actually ! 871: * the = is any assignment op is better done as "reg=y; x+reg". ! 872: * In this case rcexpr is called to do the first part and the ! 873: * tree is modified so the name of the register ! 874: * replaces the assignment. ! 875: * Moreover, expressions like "reg = x+y" are best done as ! 876: * "reg = x; reg += y" (so long as "reg" and "y" are not the same!). ! 877: */ ! 878: sreorder(treep, table, reg, recurf) ! 879: union tree **treep; ! 880: struct table *table; ! 881: { ! 882: register union tree *p, *p1; ! 883: ! 884: p = *treep; ! 885: if (opdope[p->t.op]&LEAF) ! 886: return(0); ! 887: if (p->t.op==PLUS && recurf) ! 888: if (reorder(&p->t.tr2, table, reg)) ! 889: *treep = p = optim(p); ! 890: if ((p1 = p->t.tr1)==TNULL) ! 891: return(0); ! 892: if (p->t.op==STAR || p->t.op==PLUS) { ! 893: if (recurf && reorder(&p->t.tr1, table, reg)) { ! 894: *treep = p = optim(p); ! 895: if (opdope[p->t.op]&LEAF) ! 896: return(0); ! 897: } ! 898: p1 = p->t.tr1; ! 899: } ! 900: if (p1->t.op==NAME) switch(p->t.op) { ! 901: case ASLSH: ! 902: case ASRSH: ! 903: case ASSIGN: ! 904: if (p1->n.class != REG || p1->n.type==CHAR ! 905: || isfloat(p->t.tr2)) ! 906: return(0); ! 907: if (p->t.op==ASSIGN) switch (p->t.tr2->t.op) { ! 908: case RSHIFT: ! 909: if (p->t.type==UNSIGN) ! 910: return(0); ! 911: goto caseGEN; ! 912: case TIMES: ! 913: if (!ispow2(p->t.tr2)) ! 914: break; ! 915: p->t.tr2 = pow2(p->t.tr2); ! 916: case PLUS: ! 917: case MINUS: ! 918: case AND: ! 919: case ANDN: ! 920: case OR: ! 921: case EXOR: ! 922: case LSHIFT: ! 923: caseGEN: ! 924: p1 = p->t.tr2->t.tr2; ! 925: if (xdcalc(p1, 16) > 12 ! 926: || p1->t.op==NAME ! 927: &&(p1->n.nloc==p->t.tr1->n.nloc ! 928: || p1->n.regno==p->t.tr1->n.nloc)) ! 929: return(0); ! 930: p1 = p->t.tr2; ! 931: p->t.tr2 = p1->t.tr1; ! 932: if (p1->t.tr1->t.op!=NAME ! 933: || p1->t.tr1->n.class!=REG ! 934: || p1->t.tr1->n.nloc!=p->t.tr1->n.nloc) ! 935: rcexpr(p, efftab, reg); ! 936: p->t.tr2 = p1->t.tr2; ! 937: p->t.op = p1->t.op + ASPLUS - PLUS; ! 938: *treep = p; ! 939: return(1); ! 940: } ! 941: goto OK; ! 942: ! 943: case ASTIMES: ! 944: if (!ispow2(p)) ! 945: return(0); ! 946: case ASPLUS: ! 947: case ASMINUS: ! 948: case ASAND: ! 949: case ASANDN: ! 950: case ASOR: ! 951: case ASXOR: ! 952: case INCBEF: ! 953: case DECBEF: ! 954: OK: ! 955: if (table==cctab||table==cregtab) ! 956: reg += 020; ! 957: rcexpr(optim(p), efftab, ~reg); ! 958: *treep = p1; ! 959: return(1); ! 960: } ! 961: return(0); ! 962: } ! 963: ! 964: /* ! 965: * Delay handles postfix ++ and -- ! 966: * It observes that "x + y++" is better ! 967: * treated as "x + y; y++". ! 968: * If the operator is ++ or -- itself, ! 969: * it calls rcexpr to load the operand, letting ! 970: * the calling instance of rcexpr to do the ! 971: * ++ using efftab. ! 972: * Otherwise it uses sdelay to search for inc/dec ! 973: * among the operands. ! 974: */ ! 975: delay(treep, table, reg) ! 976: union tree **treep; ! 977: struct table *table; ! 978: { ! 979: register union tree *p, *p1; ! 980: register r; ! 981: ! 982: p = *treep; ! 983: if ((p->t.op==INCAFT||p->t.op==DECAFT) ! 984: && p->t.tr1->t.op==NAME) { ! 985: return(1+rcexpr(paint(p->t.tr1, p->t.type), table, reg)); ! 986: } ! 987: p1 = 0; ! 988: if (opdope[p->t.op]&BINARY) { ! 989: if (p->t.op==LOGAND || p->t.op==LOGOR ! 990: || p->t.op==QUEST || p->t.op==COLON || p->t.op==SEQNC) ! 991: return(0); ! 992: } ! 993: p1 = sdelay(&p->t.tr2); ! 994: if (p1==0) ! 995: p1 = sdelay(&p->t.tr1); ! 996: if (p1) { ! 997: r = rcexpr(optim(p), table, reg); ! 998: *treep = p1; ! 999: return(r+1); ! 1000: } ! 1001: return(0); ! 1002: } ! 1003: ! 1004: union tree * ! 1005: sdelay(ap) ! 1006: union tree **ap; ! 1007: { ! 1008: register union tree *p, *p1; ! 1009: ! 1010: if ((p = *ap)==TNULL) ! 1011: return(TNULL); ! 1012: if ((p->t.op==INCAFT||p->t.op==DECAFT) && p->t.tr1->t.op==NAME) { ! 1013: *ap = paint(ncopy(p->t.tr1), p->t.type); ! 1014: return(p); ! 1015: } ! 1016: if (p->t.op==STAR || p->t.op==PLUS) ! 1017: if (p1=sdelay(&p->t.tr1)) ! 1018: return(p1); ! 1019: if (p->t.op==PLUS) ! 1020: return(sdelay(&p->t.tr2)); ! 1021: return(0); ! 1022: } ! 1023: ! 1024: /* ! 1025: * Propagate possible implicit type-changing operation ! 1026: */ ! 1027: union tree * ! 1028: paint(tp, type) ! 1029: register union tree *tp; ! 1030: register type; ! 1031: { ! 1032: ! 1033: if (tp->t.type==type) ! 1034: return(tp); ! 1035: if (tp->t.type==CHAR && type==INT) ! 1036: return(tp); ! 1037: if (tp->t.type==CHAR || tp->t.type==UNCHAR) ! 1038: return(optim(tnode(LOAD, type, tp, TNULL))); ! 1039: tp->t.type = type; ! 1040: if (tp->t.op==AMPER && type&XTYPE) ! 1041: tp->t.tr1 = paint(tp->t.tr1, decref(type)); ! 1042: else if (tp->t.op==STAR) ! 1043: tp->t.tr1 = paint(tp->t.tr1, incref(type)); ! 1044: else if (tp->t.op==ASSIGN) { ! 1045: paint(tp->t.tr1, type); ! 1046: paint(tp->t.tr2, type); ! 1047: } ! 1048: return(tp); ! 1049: } ! 1050: ! 1051: /* ! 1052: * Copy a tree node for a register variable. ! 1053: * Used by sdelay because if *reg-- is turned ! 1054: * into *reg; reg-- the *reg will in turn ! 1055: * be changed to some offset class, accidentally ! 1056: * modifying the reg--. ! 1057: */ ! 1058: union tree * ! 1059: ncopy(p) ! 1060: register union tree *p; ! 1061: { ! 1062: register union tree *q; ! 1063: ! 1064: q = getblk(sizeof(struct xtname)); ! 1065: q->n.op = p->n.op; ! 1066: q->n.type = p->n.type; ! 1067: q->n.class = p->n.class; ! 1068: q->n.regno = p->n.regno; ! 1069: q->n.offset = p->n.offset; ! 1070: if (q->n.class==EXTERN || q->n.class==XOFFS) ! 1071: strncpy(q->x.name, p->x.name, NCPS); ! 1072: else ! 1073: q->n.nloc = p->n.nloc; ! 1074: return(q); ! 1075: } ! 1076: ! 1077: /* ! 1078: * If the tree can be immediately loaded into a register, ! 1079: * produce code to do so and return success. ! 1080: */ ! 1081: chkleaf(tree, table, reg) ! 1082: register union tree *tree; ! 1083: struct table *table; ! 1084: { ! 1085: struct tnode lbuf; ! 1086: ! 1087: if (tree->t.op!=STAR && dcalc(tree, nreg-reg) > 12) ! 1088: return(-1); ! 1089: lbuf.op = LOAD; ! 1090: lbuf.type = tree->t.type; ! 1091: lbuf.degree = tree->t.degree; ! 1092: lbuf.tr1 = tree; ! 1093: return(rcexpr((union tree *)&lbuf, table, reg)); ! 1094: } ! 1095: ! 1096: /* ! 1097: * Compile a function argument. ! 1098: * If the stack is currently empty, put it in (sp) ! 1099: * rather than -(sp); this will save a pop. ! 1100: * Return the number of bytes pushed, ! 1101: * for future popping. ! 1102: */ ! 1103: comarg(tree, flagp) ! 1104: register union tree *tree; ! 1105: int *flagp; ! 1106: { ! 1107: register retval; ! 1108: int i; ! 1109: int size; ! 1110: ! 1111: if (tree->t.op==STRASG) { ! 1112: size = tree->F.mask; ! 1113: tree = tree->t.tr1; ! 1114: tree = strfunc(tree); ! 1115: if (size <= sizeof(short)) { ! 1116: paint(tree, INT); ! 1117: goto normal; ! 1118: } ! 1119: if (size <= sizeof(long)) { ! 1120: paint(tree, LONG); ! 1121: goto normal; ! 1122: } ! 1123: if (tree->t.op!=NAME && tree->t.op!=STAR) { ! 1124: error("Unimplemented structure assignment"); ! 1125: return(0); ! 1126: } ! 1127: tree = tnode(AMPER, STRUCT+PTR, tree, TNULL); ! 1128: tree = tnode(PLUS, STRUCT+PTR, tree, tconst(size, INT)); ! 1129: tree = optim(tree); ! 1130: retval = rcexpr(tree, regtab, 0); ! 1131: size >>= 1; ! 1132: if (size <= 5) { ! 1133: for (i=0; i<size; i++) ! 1134: printf("mov -(r%d),-(sp)\n", retval); ! 1135: } else { ! 1136: if (retval!=0) ! 1137: printf("mov r%d,r0\n", retval); ! 1138: printf("mov $%o,r1\n", UNS(size)); ! 1139: printf("L%d:mov -(r0),-(sp)\ndec\tr1\njne\tL%d\n", isn, isn); ! 1140: isn++; ! 1141: } ! 1142: nstack++; ! 1143: return(size*2); ! 1144: } ! 1145: normal: ! 1146: if (nstack || isfloat(tree) || tree->t.type==LONG) { ! 1147: rcexpr(tree, sptab, 0); ! 1148: retval = arlength(tree->t.type); ! 1149: } else { ! 1150: (*flagp)++; ! 1151: rcexpr(tree, lsptab, 0); ! 1152: retval = 0; ! 1153: } ! 1154: return(retval); ! 1155: } ! 1156: ! 1157: union tree * ! 1158: strfunc(tp) ! 1159: register union tree *tp; ! 1160: { ! 1161: if (tp->t.op != CALL) ! 1162: return(tp); ! 1163: paint(tp, STRUCT+PTR); ! 1164: return(tnode(STAR, STRUCT, tp, TNULL)); ! 1165: } ! 1166: ! 1167: /* ! 1168: * Compile an initializing expression ! 1169: */ ! 1170: doinit(type, tree) ! 1171: register type; ! 1172: register union tree *tree; ! 1173: { ! 1174: float sfval; ! 1175: double fval; ! 1176: long lval; ! 1177: ! 1178: if (type==CHAR || type==UNCHAR) { ! 1179: printf(".byte "); ! 1180: if (tree->t.type&XTYPE) ! 1181: goto illinit; ! 1182: type = INT; ! 1183: } ! 1184: if (type&XTYPE) ! 1185: type = INT; ! 1186: switch (type) { ! 1187: case INT: ! 1188: case UNSIGN: ! 1189: if (tree->t.op==FTOI) { ! 1190: if (tree->t.tr1->t.op!=FCON && tree->t.tr1->t.op!=SFCON) ! 1191: goto illinit; ! 1192: tree = tree->t.tr1; ! 1193: tree->c.value = tree->f.fvalue; ! 1194: tree->t.op = CON; ! 1195: } else if (tree->t.op==LTOI) { ! 1196: if (tree->t.tr1->t.op!=LCON) ! 1197: goto illinit; ! 1198: tree = tree->t.tr1; ! 1199: lval = tree->l.lvalue; ! 1200: tree->t.op = CON; ! 1201: tree->c.value = lval; ! 1202: } ! 1203: if (tree->t.op == CON) ! 1204: printf("%o\n", UNS(tree->c.value)); ! 1205: else if (tree->t.op==AMPER) { ! 1206: pname(tree->t.tr1, 0); ! 1207: putchar('\n'); ! 1208: } else ! 1209: goto illinit; ! 1210: return; ! 1211: ! 1212: case DOUBLE: ! 1213: case FLOAT: ! 1214: if (tree->t.op==ITOF) { ! 1215: if (tree->t.tr1->t.op==CON) { ! 1216: fval = tree->t.tr1->c.value; ! 1217: } else ! 1218: goto illinit; ! 1219: } else if (tree->t.op==FCON || tree->t.op==SFCON) ! 1220: fval = tree->f.fvalue; ! 1221: else if (tree->t.op==LTOF) { ! 1222: if (tree->t.tr1->t.op!=LCON) ! 1223: goto illinit; ! 1224: fval = tree->t.tr1->l.lvalue; ! 1225: } else ! 1226: goto illinit; ! 1227: if (type==FLOAT) { ! 1228: sfval = fval; ! 1229: /* nonportable */ ! 1230: printf("%o; %o\n", ! 1231: ((unsigned short *)&sfval)[0], ! 1232: ((unsigned short *)&sfval)[1] ); ! 1233: } else ! 1234: printf("%o; %o; %o; %o\n", ! 1235: ((unsigned short *)&fval)[0], ! 1236: ((unsigned short *)&fval)[1], ! 1237: ((unsigned short *)&fval)[2], ! 1238: ((unsigned short *)&fval)[3] ); ! 1239: return; ! 1240: ! 1241: case LONG: ! 1242: if (tree->t.op==FTOL) { ! 1243: tree = tree->t.tr1; ! 1244: if (tree->t.op==SFCON) ! 1245: tree->t.op = FCON; ! 1246: if (tree->t.op!= FCON) ! 1247: goto illinit; ! 1248: lval = tree->f.fvalue; ! 1249: } else if (tree->t.op==ITOL) { ! 1250: if (tree->t.tr1->t.op != CON) ! 1251: goto illinit; ! 1252: if (uns(tree->t.tr1)) ! 1253: lval = (unsigned)tree->t.tr1->c.value; ! 1254: else ! 1255: lval = tree->t.tr1->c.value; ! 1256: } else if (tree->t.op==LCON) ! 1257: lval = tree->l.lvalue; ! 1258: else ! 1259: goto illinit; ! 1260: /* nonportable */ ! 1261: printf("%o; %o\n", UNS((lval>>16)), UNS(lval)); ! 1262: return; ! 1263: } ! 1264: illinit: ! 1265: error("Illegal initialization"); ! 1266: } ! 1267: ! 1268: movreg(r0, r1, tree) ! 1269: union tree *tree; ! 1270: { ! 1271: register char *s; ! 1272: char c; ! 1273: ! 1274: if (r0==r1) ! 1275: return; ! 1276: if (tree->t.type==LONG) { ! 1277: if (r0>=nreg || r1>=nreg) { ! 1278: error("register overflow: compiler error"); ! 1279: } ! 1280: s = "mov r%d,r%d\nmov r%d,r%d\n"; ! 1281: if (r0 < r1) ! 1282: printf(s, r0+1,r1+1,r0,r1); ! 1283: else ! 1284: printf(s, r0,r1,r0+1,r1+1); ! 1285: return; ! 1286: } ! 1287: c = isfloat(tree); ! 1288: printf("mov%.1s r%d,r%d\n", &c, r0, r1); ! 1289: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.