![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / lib / pcc|
Return to local2.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / pcc |
1.1 ! root 1: # ifndef lint ! 2: static char *sccsid ="@(#)local2.c 1.14 (Berkeley) 4/23/86"; ! 3: # endif ! 4: ! 5: # include "pass2.h" ! 6: # include "ctype.h" ! 7: # ifdef FORT ! 8: int ftlab1, ftlab2; ! 9: # endif ! 10: /* a lot of the machine dependent parts of the second pass */ ! 11: ! 12: # define putstr(s) fputs((s), stdout) ! 13: ! 14: # define BITMASK(n) ((1L<<n)-1) ! 15: ! 16: where(c){ ! 17: fprintf( stderr, "%s, line %d: ", filename, lineno ); ! 18: } ! 19: ! 20: lineid( l, fn ) char *fn; { ! 21: /* identify line l and file fn */ ! 22: printf( "# line %d, file %s\n", l, fn ); ! 23: } ! 24: ! 25: ! 26: eobl2(){ ! 27: OFFSZ spoff; /* offset from stack pointer */ ! 28: #ifdef FORT ! 29: spoff = maxoff; ! 30: if( spoff >= AUTOINIT ) spoff -= AUTOINIT; ! 31: spoff /= SZCHAR; ! 32: SETOFF(spoff,4); ! 33: #ifndef FLEXNAMES ! 34: printf( " .set .F%d,%ld\n", ftnno, spoff ); ! 35: #else ! 36: /* SHOULD BE L%d ... ftnno but must change pc/f77 */ ! 37: printf( " .set LF%d,%ld\n", ftnno, spoff ); ! 38: #endif ! 39: #else ! 40: extern int ftlab1, ftlab2; ! 41: ! 42: spoff = maxoff; ! 43: if( spoff >= AUTOINIT ) spoff -= AUTOINIT; ! 44: spoff /= SZCHAR; ! 45: SETOFF(spoff,4); ! 46: printf( "L%d:\n", ftlab1); ! 47: if( spoff!=0 ) ! 48: if( spoff < 64 ) ! 49: printf( " subl2 $%ld,sp\n", spoff); ! 50: else ! 51: printf( " movab -%ld(sp),sp\n", spoff); ! 52: printf( " jbr L%d\n", ftlab2); ! 53: #endif ! 54: maxargs = -1; ! 55: } ! 56: ! 57: struct hoptab { int opmask; char * opstring; } ioptab[] = { ! 58: ! 59: ASG PLUS, "add", ! 60: ASG MINUS, "sub", ! 61: ASG MUL, "mul", ! 62: ASG DIV, "div", ! 63: ASG OR, "bis", ! 64: ASG ER, "xor", ! 65: ASG AND, "bic", ! 66: PLUS, "add", ! 67: MINUS, "sub", ! 68: MUL, "mul", ! 69: DIV, "div", ! 70: OR, "bis", ! 71: ER, "xor", ! 72: AND, "bic", ! 73: -1, "" }; ! 74: ! 75: hopcode( f, o ){ ! 76: /* output the appropriate string from the above table */ ! 77: ! 78: register struct hoptab *q; ! 79: ! 80: for( q = ioptab; q->opmask>=0; ++q ){ ! 81: if( q->opmask == o ){ ! 82: putstr( q->opstring ); ! 83: /* tbl ! 84: if( f == 'F' ) putchar( 'e' ); ! 85: else if( f == 'D' ) putchar( 'd' ); ! 86: tbl */ ! 87: /* tbl */ ! 88: switch( f ) { ! 89: case 'L': ! 90: case 'W': ! 91: case 'B': ! 92: case 'D': ! 93: case 'F': ! 94: putchar(tolower(f)); ! 95: break; ! 96: ! 97: } ! 98: /* tbl */ ! 99: return; ! 100: } ! 101: } ! 102: cerror( "no hoptab for %s", opst[o] ); ! 103: } ! 104: ! 105: char * ! 106: rnames[] = { /* keyed to register number tokens */ ! 107: ! 108: "r0", "r1", ! 109: "r2", "r3", "r4", "r5", ! 110: "r6", "r7", "r8", "r9", "r10", "r11", ! 111: "ap", "fp", "sp", "pc", ! 112: ! 113: }; ! 114: ! 115: int rstatus[] = { ! 116: SAREG|STAREG, SAREG|STAREG, ! 117: SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, ! 118: SAREG, SAREG, SAREG, SAREG, SAREG, SAREG, ! 119: SAREG, SAREG, SAREG, SAREG, ! 120: ! 121: }; ! 122: ! 123: tlen(p) NODE *p; ! 124: { ! 125: switch(p->in.type) { ! 126: case CHAR: ! 127: case UCHAR: ! 128: return(1); ! 129: ! 130: case SHORT: ! 131: case USHORT: ! 132: return(2); ! 133: ! 134: case DOUBLE: ! 135: return(8); ! 136: ! 137: default: ! 138: return(4); ! 139: } ! 140: } ! 141: ! 142: mixtypes(p, q) NODE *p, *q; ! 143: { ! 144: register TWORD tp, tq; ! 145: ! 146: tp = p->in.type; ! 147: tq = q->in.type; ! 148: ! 149: return( (tp==FLOAT || tp==DOUBLE) != ! 150: (tq==FLOAT || tq==DOUBLE) ); ! 151: } ! 152: ! 153: prtype(n) NODE *n; ! 154: { ! 155: switch (n->in.type) ! 156: { ! 157: case DOUBLE: ! 158: putchar('d'); ! 159: return; ! 160: ! 161: case FLOAT: ! 162: putchar('f'); ! 163: return; ! 164: ! 165: case LONG: ! 166: case ULONG: ! 167: case INT: ! 168: case UNSIGNED: ! 169: putchar('l'); ! 170: return; ! 171: ! 172: case SHORT: ! 173: case USHORT: ! 174: putchar('w'); ! 175: return; ! 176: ! 177: case CHAR: ! 178: case UCHAR: ! 179: putchar('b'); ! 180: return; ! 181: ! 182: default: ! 183: if ( !ISPTR( n->in.type ) ) cerror("zzzcode- bad type"); ! 184: else { ! 185: putchar('l'); ! 186: return; ! 187: } ! 188: } ! 189: } ! 190: ! 191: zzzcode( p, c ) register NODE *p; { ! 192: register m; ! 193: CONSZ val; ! 194: switch( c ){ ! 195: ! 196: case 'N': /* logical ops, turned into 0-1 */ ! 197: /* use register given by register 1 */ ! 198: cbgen( 0, m=getlab(), 'I' ); ! 199: deflab( p->bn.label ); ! 200: printf( " clrl %s\n", rnames[getlr( p, '1' )->tn.rval] ); ! 201: deflab( m ); ! 202: return; ! 203: ! 204: case 'I': ! 205: case 'P': ! 206: cbgen( p->in.op, p->bn.label, c ); ! 207: return; ! 208: ! 209: case 'A': ! 210: { ! 211: register NODE *l, *r; ! 212: ! 213: if (xdebug) eprint(p, 0, &val, &val); ! 214: r = getlr(p, 'R'); ! 215: if (p->in.op == ASSIGN) ! 216: l = getlr(p, 'L'); ! 217: else if (p->in.op == SCONV) { ! 218: l = resc; ! 219: #if defined(FORT) || defined(SPRECC) ! 220: l->in.type = r->in.type; ! 221: #else ! 222: l->in.type = r->in.type==FLOAT ? DOUBLE : r->in.type; ! 223: #endif ! 224: r = getlr(p, 'L'); ! 225: } ! 226: else { /* OPLTYPE */ ! 227: l = resc; ! 228: #if defined(FORT) || defined(SPRECC) ! 229: l->in.type = (r->in.type==FLOAT || r->in.type==DOUBLE ? r->in.type : INT); ! 230: #else ! 231: l->in.type = (r->in.type==FLOAT || r->in.type==DOUBLE ? DOUBLE : INT); ! 232: #endif ! 233: } ! 234: if (r->in.op == ICON) ! 235: if (r->in.name[0] == '\0') { ! 236: if (r->tn.lval == 0) { ! 237: putstr("clr"); ! 238: prtype(l); ! 239: putchar('\t'); ! 240: adrput(l); ! 241: return; ! 242: } ! 243: if (r->tn.lval < 0 && r->tn.lval >= -63) { ! 244: putstr("mneg"); ! 245: prtype(l); ! 246: r->tn.lval = -r->tn.lval; ! 247: goto ops; ! 248: } ! 249: if (r->tn.lval < 0) ! 250: r->in.type = r->tn.lval >= -128 ? CHAR ! 251: : (r->tn.lval >= -32768 ? SHORT ! 252: : INT); ! 253: else if (l->in.type == FLOAT || ! 254: l->in.type == DOUBLE) ! 255: r->in.type = r->tn.lval <= 63 ? INT ! 256: : (r->tn.lval <= 127 ? CHAR ! 257: : (r->tn.lval <= 32767 ? SHORT ! 258: : INT)); ! 259: else ! 260: r->in.type = r->tn.lval <= 63 ? INT ! 261: : (r->tn.lval <= 127 ? CHAR ! 262: : (r->tn.lval <= 255 ? UCHAR ! 263: : (r->tn.lval <= 32767 ? SHORT ! 264: : (r->tn.lval <= 65535 ? USHORT ! 265: : INT)))); ! 266: } ! 267: else { ! 268: putstr("moval"); ! 269: putchar('\t'); ! 270: acon(r); ! 271: putchar(','); ! 272: adrput(l); ! 273: return; ! 274: } ! 275: ! 276: if (p->in.op == SCONV && ! 277: !(l->in.type == FLOAT || l->in.type == DOUBLE) && ! 278: !mixtypes(l, r)) { ! 279: /* ! 280: * Because registers must always contain objects ! 281: * of the same width as INTs, we may have to ! 282: * perform two conversions to get an INT. Can ! 283: * the conversions be collapsed into one? ! 284: */ ! 285: if (m = collapsible(l, r)) ! 286: r->in.type = m; ! 287: else { ! 288: /* ! 289: * Two steps are required. ! 290: */ ! 291: NODE *x = &resc[1]; ! 292: ! 293: *x = *l; ! 294: if (tlen(x) > tlen(r) && ISUNSIGNED(r->in.type)) ! 295: putstr("movz"); ! 296: else ! 297: putstr("cvt"); ! 298: prtype(r); ! 299: prtype(x); ! 300: putchar('\t'); ! 301: adrput(r); ! 302: putchar(','); ! 303: adrput(x); ! 304: putchar('\n'); ! 305: putchar('\t'); ! 306: r = x; ! 307: } ! 308: l->in.type = (ISUNSIGNED(l->in.type) ? UNSIGNED : INT); ! 309: } ! 310: ! 311: if ((r->in.type == UNSIGNED || r->in.type == ULONG) && ! 312: mixtypes(l, r)) { ! 313: int label1, label2; ! 314: ! 315: label1 = getlab(); ! 316: label2 = getlab(); ! 317: ! 318: putstr("movl\t"); ! 319: adrput(r); ! 320: putchar(','); ! 321: adrput(l); ! 322: putstr("\n\tjbsc\t$31,"); ! 323: adrput(l); ! 324: printf(",L%d\n\tcvtl", label1); ! 325: prtype(l); ! 326: putchar('\t'); ! 327: adrput(l); ! 328: putchar(','); ! 329: adrput(l); ! 330: printf("\n\tjbr\tL%d\nL%d:\n\tcvtl", label2, label1); ! 331: prtype(l); ! 332: putchar('\t'); ! 333: adrput(l); ! 334: putchar(','); ! 335: adrput(l); ! 336: putstr("\n\tadd"); ! 337: prtype(l); ! 338: putstr("2\t$0"); ! 339: prtype(l); ! 340: putstr("2.147483648e9,"); ! 341: adrput(l); ! 342: printf("\nL%d:", label2); ! 343: ! 344: return; ! 345: } ! 346: ! 347: if (!mixtypes(l,r)) { ! 348: if (tlen(l) == tlen(r)) { ! 349: putstr("mov"); ! 350: #ifdef FORT ! 351: if (Oflag) ! 352: prtype(l); ! 353: else { ! 354: if (l->in.type == DOUBLE) ! 355: putchar('q'); ! 356: else if(l->in.type == FLOAT) ! 357: putchar('l'); ! 358: else ! 359: prtype(l); ! 360: } ! 361: #else ! 362: prtype(l); ! 363: #endif FORT ! 364: goto ops; ! 365: } ! 366: else if (tlen(l) > tlen(r) && ISUNSIGNED(r->in.type)) ! 367: putstr("movz"); ! 368: else ! 369: putstr("cvt"); ! 370: } ! 371: else ! 372: putstr("cvt"); ! 373: prtype(r); ! 374: prtype(l); ! 375: ops: ! 376: putchar('\t'); ! 377: adrput(r); ! 378: putchar(','); ! 379: adrput(l); ! 380: return; ! 381: } ! 382: ! 383: case 'G': /* i *= f; asgops with int lhs and float rhs */ ! 384: { ! 385: register NODE *l, *r, *s; ! 386: int rt; ! 387: ! 388: l = p->in.left; ! 389: r = p->in.right; ! 390: s = talloc(); ! 391: rt = r->in.type; ! 392: ! 393: s->in.op = SCONV; ! 394: s->in.left = l; ! 395: s->in.type = rt; ! 396: zzzcode(s, 'A'); ! 397: putstr("\n\t"); ! 398: ! 399: hopcode(rt == FLOAT ? 'F' : 'D', p->in.op); ! 400: putstr("2\t"); ! 401: adrput(r); ! 402: putchar(','); ! 403: adrput(resc); ! 404: putstr("\n\t"); ! 405: ! 406: s->in.op = ASSIGN; ! 407: s->in.left = l; ! 408: s->in.right = resc; ! 409: s->in.type = l->in.type; ! 410: zzzcode(s, 'A'); ! 411: ! 412: s->in.op = FREE; ! 413: return; ! 414: } ! 415: ! 416: case 'B': /* get oreg value in temp register for left shift */ ! 417: { ! 418: register NODE *r; ! 419: if (xdebug) eprint(p, 0, &val, &val); ! 420: r = p->in.right; ! 421: if( tlen(r) == sizeof(int) && r->in.type != FLOAT ) ! 422: putstr("movl"); ! 423: else { ! 424: putstr("cvt"); ! 425: prtype(r); ! 426: putchar('l'); ! 427: } ! 428: return; ! 429: } ! 430: ! 431: case 'C': /* num words pushed on arg stack */ ! 432: { ! 433: extern int gc_numbytes; ! 434: extern int xdebug; ! 435: ! 436: if (xdebug) printf("->%d<-",gc_numbytes); ! 437: ! 438: printf("$%d", gc_numbytes/(SZLONG/SZCHAR) ); ! 439: return; ! 440: } ! 441: ! 442: case 'D': /* INCR and DECR */ ! 443: zzzcode(p->in.left, 'A'); ! 444: putchar('\n'); ! 445: putchar('\t'); ! 446: ! 447: case 'E': /* INCR and DECR, FOREFF */ ! 448: if (p->in.right->tn.lval == 1) ! 449: { ! 450: putstr( p->in.op == INCR ? "inc" : "dec" ); ! 451: prtype(p->in.left); ! 452: putchar('\t'); ! 453: adrput(p->in.left); ! 454: return; ! 455: } ! 456: putstr( p->in.op == INCR ? "add" : "sub" ); ! 457: prtype(p->in.left); ! 458: putchar('2'); ! 459: putchar('\t'); ! 460: adrput(p->in.right); ! 461: putchar(','); ! 462: adrput(p->in.left); ! 463: return; ! 464: ! 465: case 'F': /* register type of right operand */ ! 466: { ! 467: register NODE *n; ! 468: extern int xdebug; ! 469: register int ty; ! 470: ! 471: n = getlr( p, 'R' ); ! 472: ty = n->in.type; ! 473: ! 474: if (xdebug) printf("->%d<-", ty); ! 475: ! 476: if ( ty==DOUBLE) putchar('d'); ! 477: else if ( ty==FLOAT ) putchar('f'); ! 478: else putchar('l'); ! 479: return; ! 480: } ! 481: ! 482: case 'L': /* type of left operand */ ! 483: case 'R': /* type of right operand */ ! 484: { ! 485: register NODE *n; ! 486: extern int xdebug; ! 487: ! 488: n = getlr( p, c ); ! 489: if (xdebug) printf("->%d<-", n->in.type); ! 490: ! 491: prtype(n); ! 492: return; ! 493: } ! 494: ! 495: case 'Z': /* complement mask for bit instr */ ! 496: printf("$%ld", ~p->in.right->tn.lval); ! 497: return; ! 498: ! 499: case 'U': /* 32 - n, for unsigned right shifts */ ! 500: printf("$%d", 32 - p->in.right->tn.lval ); ! 501: return; ! 502: ! 503: case 'T': /* rounded structure length for arguments */ ! 504: { ! 505: int size; ! 506: ! 507: size = p->stn.stsize; ! 508: SETOFF( size, 4); ! 509: printf("$%d", size); ! 510: return; ! 511: } ! 512: ! 513: case 'S': /* structure assignment */ ! 514: { ! 515: register NODE *l, *r; ! 516: register size; ! 517: ! 518: if( p->in.op == STASG ){ ! 519: l = p->in.left; ! 520: r = p->in.right; ! 521: ! 522: } ! 523: else if( p->in.op == STARG ){ /* store an arg into a temporary */ ! 524: r = p->in.left; ! 525: } ! 526: else cerror( "STASG bad" ); ! 527: ! 528: if( r->in.op == ICON ) r->in.op = NAME; ! 529: else if( r->in.op == REG ) r->in.op = OREG; ! 530: else if( r->in.op != OREG ) cerror( "STASG-r" ); ! 531: ! 532: size = p->stn.stsize; ! 533: ! 534: if( size <= 0 || size > 65535 ) ! 535: cerror("structure size <0=0 or >65535"); ! 536: ! 537: switch(size) { ! 538: case 1: ! 539: putstr(" movb "); ! 540: break; ! 541: case 2: ! 542: putstr(" movw "); ! 543: break; ! 544: case 4: ! 545: putstr(" movl "); ! 546: break; ! 547: case 8: ! 548: putstr(" movq "); ! 549: break; ! 550: default: ! 551: printf(" movc3 $%d,", size); ! 552: break; ! 553: } ! 554: adrput(r); ! 555: if( p->in.op == STASG ){ ! 556: putchar(','); ! 557: adrput(l); ! 558: putchar('\n'); ! 559: } ! 560: else ! 561: putstr(",(sp)\n"); ! 562: ! 563: if( r->in.op == NAME ) r->in.op = ICON; ! 564: else if( r->in.op == OREG ) r->in.op = REG; ! 565: ! 566: } ! 567: break; ! 568: ! 569: default: ! 570: cerror( "illegal zzzcode" ); ! 571: } ! 572: } ! 573: ! 574: /* ! 575: * collapsible(dest, src) -- if a conversion with a register destination ! 576: * can be accomplished in one instruction, return the type of src ! 577: * that will do the job correctly; otherwise return 0. Note that ! 578: * a register must always end up having type INT or UNSIGNED. ! 579: */ ! 580: int ! 581: collapsible(dest, src) ! 582: NODE *dest, *src; ! 583: { ! 584: int st = src->in.type; ! 585: int dt = dest->in.type; ! 586: int newt = 0; ! 587: ! 588: /* ! 589: * Are there side effects of evaluating src? ! 590: * If the derived type will not be the same size as src, ! 591: * we may have to use two steps. ! 592: */ ! 593: if (tlen(src) > tlen(dest)) { ! 594: if (tshape(src, STARREG)) ! 595: return (0); ! 596: if (src->in.op == OREG && R2TEST(src->tn.rval)) ! 597: return (0); ! 598: } ! 599: ! 600: /* ! 601: * Can we get an object of dest's type by punning src? ! 602: * Praises be to great Cthulhu for little-endian machines... ! 603: */ ! 604: if (st == CHAR && dt == USHORT) ! 605: /* ! 606: * Special case -- we must sign-extend to 16 bits. ! 607: */ ! 608: return (0); ! 609: ! 610: if (tlen(src) < tlen(dest)) ! 611: newt = st; ! 612: else ! 613: newt = dt; ! 614: ! 615: return (newt); ! 616: } ! 617: ! 618: rmove( rt, rs, t ) TWORD t; { ! 619: printf( " %s %s,%s\n", ! 620: #ifdef FORT ! 621: !Oflag ? (t==DOUBLE ? "movq" : "movl") : ! 622: #endif ! 623: (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")), ! 624: rnames[rs], rnames[rt] ); ! 625: } ! 626: ! 627: struct respref ! 628: respref[] = { ! 629: INTAREG|INTBREG, INTAREG|INTBREG, ! 630: INAREG|INBREG, INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON, ! 631: INTEMP, INTEMP, ! 632: FORARG, FORARG, ! 633: INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM, ! 634: 0, 0 }; ! 635: ! 636: setregs(){ /* set up temporary registers */ ! 637: fregs = 6; /* tbl- 6 free regs on VAX (0-5) */ ! 638: ; ! 639: } ! 640: ! 641: rewfld( p ) NODE *p; { ! 642: return(1); ! 643: } ! 644: ! 645: callreg(p) NODE *p; { ! 646: return( R0 ); ! 647: } ! 648: ! 649: base( p ) register NODE *p; { ! 650: register int o = p->in.op; ! 651: ! 652: if( (o==ICON && p->in.name[0] != '\0')) return( 100 ); /* ie no base reg */ ! 653: if( o==REG ) return( p->tn.rval ); ! 654: if( (o==PLUS || o==MINUS) && p->in.left->in.op == REG && p->in.right->in.op==ICON) ! 655: return( p->in.left->tn.rval ); ! 656: if( o==OREG && !R2TEST(p->tn.rval) && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) ) ! 657: return( p->tn.rval + 0200*1 ); ! 658: if( o==INCR && p->in.left->in.op==REG ) return( p->in.left->tn.rval + 0200*2 ); ! 659: if( o==ASG MINUS && p->in.left->in.op==REG) return( p->in.left->tn.rval + 0200*4 ); ! 660: if( o==UNARY MUL && p->in.left->in.op==INCR && p->in.left->in.left->in.op==REG ! 661: && (p->in.type==INT || p->in.type==UNSIGNED || ISPTR(p->in.type)) ) ! 662: return( p->in.left->in.left->tn.rval + 0200*(1+2) ); ! 663: return( -1 ); ! 664: } ! 665: ! 666: offset( p, tyl ) register NODE *p; int tyl; { ! 667: ! 668: if( tyl==1 && ! 669: p->in.op==REG && ! 670: (p->in.type==INT || p->in.type==UNSIGNED) ) ! 671: return( p->tn.rval ); ! 672: if( p->in.op==LS && ! 673: p->in.left->in.op==REG && ! 674: (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) && ! 675: p->in.right->in.op==ICON && ! 676: p->in.right->in.name[0]=='\0' && ! 677: (1<<p->in.right->tn.lval)==tyl) ! 678: return( p->in.left->tn.rval ); ! 679: if( tyl==2 && ! 680: p->in.op==PLUS && ! 681: (p->in.left->in.type==INT || p->in.left->in.type==UNSIGNED) && ! 682: p->in.left->in.op==REG && ! 683: p->in.right->in.op==REG && ! 684: p->in.left->tn.rval==p->in.right->tn.rval ) ! 685: return( p->in.left->tn.rval ); ! 686: return( -1 ); ! 687: } ! 688: ! 689: makeor2( p, q, b, o) register NODE *p, *q; register int b, o; { ! 690: register NODE *t; ! 691: register int i; ! 692: NODE *f; ! 693: ! 694: p->in.op = OREG; ! 695: f = p->in.left; /* have to free this subtree later */ ! 696: ! 697: /* init base */ ! 698: switch (q->in.op) { ! 699: case ICON: ! 700: case REG: ! 701: case OREG: ! 702: t = q; ! 703: break; ! 704: ! 705: case MINUS: ! 706: q->in.right->tn.lval = -q->in.right->tn.lval; ! 707: case PLUS: ! 708: t = q->in.right; ! 709: break; ! 710: ! 711: case INCR: ! 712: case ASG MINUS: ! 713: t = q->in.left; ! 714: break; ! 715: ! 716: case UNARY MUL: ! 717: t = q->in.left->in.left; ! 718: break; ! 719: ! 720: default: ! 721: cerror("illegal makeor2"); ! 722: } ! 723: ! 724: p->tn.lval = t->tn.lval; ! 725: #ifndef FLEXNAMES ! 726: for(i=0; i<NCHNAM; ++i) ! 727: p->in.name[i] = t->in.name[i]; ! 728: #else ! 729: p->in.name = t->in.name; ! 730: #endif ! 731: ! 732: /* init offset */ ! 733: p->tn.rval = R2PACK( (b & 0177), o, (b>>7) ); ! 734: ! 735: tfree(f); ! 736: return; ! 737: } ! 738: ! 739: canaddr( p ) NODE *p; { ! 740: register int o = p->in.op; ! 741: ! 742: if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->in.left)) ) return(1); ! 743: return(0); ! 744: } ! 745: ! 746: flshape( p ) register NODE *p; { ! 747: return( p->in.op == REG || p->in.op == NAME || p->in.op == ICON || ! 748: (p->in.op == OREG && (!R2TEST(p->tn.rval) || tlen(p) == 1)) ); ! 749: } ! 750: ! 751: shtemp( p ) register NODE *p; { ! 752: if( p->in.op == STARG ) p = p->in.left; ! 753: return( p->in.op==NAME || p->in.op ==ICON || p->in.op == OREG || (p->in.op==UNARY MUL && shumul(p->in.left)) ); ! 754: } ! 755: ! 756: shumul( p ) register NODE *p; { ! 757: register o; ! 758: extern int xdebug; ! 759: ! 760: if (xdebug) { ! 761: printf("\nshumul:op=%d,lop=%d,rop=%d", p->in.op, p->in.left->in.op, p->in.right->in.op); ! 762: printf(" prname=%s,plty=%d, prlval=%D\n", p->in.right->in.name, p->in.left->in.type, p->in.right->tn.lval); ! 763: } ! 764: ! 765: ! 766: o = p->in.op; ! 767: if( o == NAME || (o == OREG && !R2TEST(p->tn.rval)) || o == ICON ) return( STARNM ); ! 768: ! 769: if( ( o == INCR || o == ASG MINUS ) && ! 770: ( p->in.left->in.op == REG && p->in.right->in.op == ICON ) && ! 771: p->in.right->in.name[0] == '\0' ) ! 772: { ! 773: switch (p->in.type) ! 774: { ! 775: case CHAR|PTR: ! 776: case UCHAR|PTR: ! 777: o = 1; ! 778: break; ! 779: ! 780: case SHORT|PTR: ! 781: case USHORT|PTR: ! 782: o = 2; ! 783: break; ! 784: ! 785: case INT|PTR: ! 786: case UNSIGNED|PTR: ! 787: case LONG|PTR: ! 788: case ULONG|PTR: ! 789: case FLOAT|PTR: ! 790: o = 4; ! 791: break; ! 792: ! 793: case DOUBLE|PTR: ! 794: o = 8; ! 795: break; ! 796: ! 797: default: ! 798: if ( ISPTR(p->in.type) && ! 799: ISPTR(DECREF(p->in.type)) ) { ! 800: o = 4; ! 801: break; ! 802: } ! 803: else return(0); ! 804: } ! 805: return( p->in.right->tn.lval == o ? STARREG : 0); ! 806: } ! 807: ! 808: return( 0 ); ! 809: } ! 810: ! 811: adrcon( val ) CONSZ val; { ! 812: putchar( '$' ); ! 813: printf( CONFMT, val ); ! 814: } ! 815: ! 816: conput( p ) register NODE *p; { ! 817: switch( p->in.op ){ ! 818: ! 819: case ICON: ! 820: acon( p ); ! 821: return; ! 822: ! 823: case REG: ! 824: putstr( rnames[p->tn.rval] ); ! 825: return; ! 826: ! 827: default: ! 828: cerror( "illegal conput" ); ! 829: } ! 830: } ! 831: ! 832: insput( p ) register NODE *p; { ! 833: cerror( "insput" ); ! 834: } ! 835: ! 836: upput( p ) register NODE *p; { ! 837: cerror( "upput" ); ! 838: } ! 839: ! 840: adrput( p ) register NODE *p; { ! 841: register int r; ! 842: /* output an address, with offsets, from p */ ! 843: ! 844: if( p->in.op == FLD ){ ! 845: p = p->in.left; ! 846: } ! 847: switch( p->in.op ){ ! 848: ! 849: case NAME: ! 850: acon( p ); ! 851: return; ! 852: ! 853: case ICON: ! 854: /* addressable value of the constant */ ! 855: putchar( '$' ); ! 856: acon( p ); ! 857: return; ! 858: ! 859: case REG: ! 860: putstr( rnames[p->tn.rval] ); ! 861: return; ! 862: ! 863: case OREG: ! 864: r = p->tn.rval; ! 865: if( R2TEST(r) ){ /* double indexing */ ! 866: register int flags; ! 867: ! 868: flags = R2UPK3(r); ! 869: if( flags & 1 ) putchar('*'); ! 870: if( flags & 4 ) putchar('-'); ! 871: if( p->tn.lval != 0 || p->in.name[0] != '\0' ) acon(p); ! 872: if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] ); ! 873: if( flags & 2 ) putchar('+'); ! 874: printf( "[%s]", rnames[R2UPK2(r)] ); ! 875: return; ! 876: } ! 877: if( r == AP ){ /* in the argument region */ ! 878: if( p->tn.lval <= 0 || p->in.name[0] != '\0' ) werror( "bad arg temp" ); ! 879: printf( CONFMT, p->tn.lval ); ! 880: putstr( "(ap)" ); ! 881: return; ! 882: } ! 883: if( p->tn.lval != 0 || p->in.name[0] != '\0') acon( p ); ! 884: printf( "(%s)", rnames[p->tn.rval] ); ! 885: return; ! 886: ! 887: case UNARY MUL: ! 888: /* STARNM or STARREG found */ ! 889: if( tshape(p, STARNM) ) { ! 890: putchar( '*' ); ! 891: adrput( p->in.left); ! 892: } ! 893: else { /* STARREG - really auto inc or dec */ ! 894: register NODE *q; ! 895: ! 896: /* tbl ! 897: p = p->in.left; ! 898: p->in.left->in.op = OREG; ! 899: if( p->in.op == INCR ) { ! 900: adrput( p->in.left ); ! 901: putchar( '+' ); ! 902: } ! 903: else { ! 904: putchar( '-' ); ! 905: adrput( p->in.left ); ! 906: } ! 907: tbl */ ! 908: q = p->in.left; ! 909: if( q->in.right->tn.lval != tlen(p) ) ! 910: cerror("adrput: bad auto-increment/decrement"); ! 911: printf("%s(%s)%s", (q->in.op==INCR ? "" : "-"), ! 912: rnames[q->in.left->tn.rval], ! 913: (q->in.op==INCR ? "+" : "") ); ! 914: p->in.op = OREG; ! 915: p->tn.rval = q->in.left->tn.rval; ! 916: p->tn.lval = (q->in.op == INCR ? -q->in.right->tn.lval : 0); ! 917: #ifndef FLEXNAMES ! 918: p->in.name[0] = '\0'; ! 919: #else ! 920: p->in.name = ""; ! 921: #endif ! 922: tfree(q); ! 923: } ! 924: return; ! 925: ! 926: default: ! 927: cerror( "illegal address" ); ! 928: return; ! 929: ! 930: } ! 931: ! 932: } ! 933: ! 934: acon( p ) register NODE *p; { /* print out a constant */ ! 935: ! 936: if( p->in.name[0] == '\0' ){ ! 937: printf( CONFMT, p->tn.lval); ! 938: } ! 939: else if( p->tn.lval == 0 ) { ! 940: #ifndef FLEXNAMES ! 941: printf( "%.8s", p->in.name ); ! 942: #else ! 943: putstr( p->in.name ); ! 944: #endif ! 945: } ! 946: else { ! 947: #ifndef FLEXNAMES ! 948: printf( "%.8s+", p->in.name ); ! 949: #else ! 950: printf( "%s+", p->in.name ); ! 951: #endif ! 952: printf( CONFMT, p->tn.lval ); ! 953: } ! 954: } ! 955: ! 956: /* ! 957: aacon( p ) register NODE *p; { /* print out a constant */ ! 958: /* ! 959: ! 960: if( p->in.name[0] == '\0' ){ ! 961: printf( CONFMT, p->tn.lval); ! 962: return( 0 ); ! 963: } ! 964: else if( p->tn.lval == 0 ) { ! 965: #ifndef FLEXNAMES ! 966: printf( "$%.8s", p->in.name ); ! 967: #else ! 968: printf( "$%s", p->in.name ); ! 969: #endif ! 970: return( 1 ); ! 971: } ! 972: else { ! 973: printf( "$(" ); ! 974: printf( CONFMT, p->tn.lval ); ! 975: printf( "+" ); ! 976: #ifndef FLEXNAMES ! 977: printf( "%.8s)", p->in.name ); ! 978: #else ! 979: printf( "%s)", p->in.name ); ! 980: #endif ! 981: return(1); ! 982: } ! 983: } ! 984: */ ! 985: ! 986: genscall( p, cookie ) register NODE *p; { ! 987: /* structure valued call */ ! 988: return( gencall( p, cookie ) ); ! 989: } ! 990: ! 991: /* tbl */ ! 992: int gc_numbytes; ! 993: /* tbl */ ! 994: ! 995: gencall( p, cookie ) register NODE *p; { ! 996: /* generate the call given by p */ ! 997: register NODE *p1; ! 998: register temp, temp1; ! 999: register m; ! 1000: ! 1001: if( p->in.right ) temp = argsize( p->in.right ); ! 1002: else temp = 0; ! 1003: ! 1004: if( p->in.op == STCALL || p->in.op == UNARY STCALL ){ ! 1005: /* set aside room for structure return */ ! 1006: ! 1007: if( p->stn.stsize > temp ) temp1 = p->stn.stsize; ! 1008: else temp1 = temp; ! 1009: } ! 1010: ! 1011: if( temp > maxargs ) maxargs = temp; ! 1012: SETOFF(temp1,4); ! 1013: ! 1014: if( p->in.right ){ /* make temp node, put offset in, and generate args */ ! 1015: genargs( p->in.right ); ! 1016: } ! 1017: ! 1018: p1 = p->in.left; ! 1019: if( p1->in.op != ICON ){ ! 1020: if( p1->in.op != REG ){ ! 1021: if( p1->in.op != OREG || R2TEST(p1->tn.rval) ){ ! 1022: if( p1->in.op != NAME ){ ! 1023: order( p1, INAREG ); ! 1024: } ! 1025: } ! 1026: } ! 1027: } ! 1028: ! 1029: /* ! 1030: if( p1->in.op == REG && p->tn.rval == R5 ){ ! 1031: cerror( "call register overwrite" ); ! 1032: } ! 1033: */ ! 1034: /* tbl ! 1035: setup gc_numbytes so reference to ZC works */ ! 1036: ! 1037: gc_numbytes = temp&(0x3ff); ! 1038: /* tbl */ ! 1039: ! 1040: p->in.op = UNARY CALL; ! 1041: m = match( p, INTAREG|INTBREG ); ! 1042: ! 1043: /* compensate for deficiency in 'ret' instruction ... wah,kre */ ! 1044: /* (plus in assignment to gc_numbytes above, for neatness only) */ ! 1045: if (temp >= 1024) ! 1046: printf(" addl2 $%d,sp\n", (temp&(~0x3ff))); ! 1047: ! 1048: /* tbl ! 1049: switch( temp ) { ! 1050: case 0: ! 1051: break; ! 1052: case 2: ! 1053: printf( " tst (sp)+\n" ); ! 1054: break; ! 1055: case 4: ! 1056: printf( " cmp (sp)+,(sp)+\n" ); ! 1057: break; ! 1058: default: ! 1059: printf( " add $%d,sp\n", temp); ! 1060: } ! 1061: tbl */ ! 1062: return(m != MDONE); ! 1063: } ! 1064: ! 1065: /* tbl */ ! 1066: char * ! 1067: ccbranches[] = { ! 1068: " jeql L%d\n", ! 1069: " jneq L%d\n", ! 1070: " jleq L%d\n", ! 1071: " jlss L%d\n", ! 1072: " jgeq L%d\n", ! 1073: " jgtr L%d\n", ! 1074: " jlequ L%d\n", ! 1075: " jlssu L%d\n", ! 1076: " jgequ L%d\n", ! 1077: " jgtru L%d\n", ! 1078: }; ! 1079: /* tbl */ ! 1080: ! 1081: cbgen( o, lab, mode ) { /* printf conditional and unconditional branches */ ! 1082: ! 1083: /* tbl */ ! 1084: if( o == 0 ) printf( " jbr L%d\n", lab ); ! 1085: /* tbl */ ! 1086: else { ! 1087: if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] ); ! 1088: printf( ccbranches[o-EQ], lab ); ! 1089: } ! 1090: } ! 1091: ! 1092: nextcook( p, cookie ) NODE *p; { ! 1093: /* we have failed to match p with cookie; try another */ ! 1094: if( cookie == FORREW ) return( 0 ); /* hopeless! */ ! 1095: if( !(cookie&(INTAREG|INTBREG)) ) return( INTAREG|INTBREG ); ! 1096: if( !(cookie&INTEMP) && asgop(p->in.op) ) return( INTEMP|INAREG|INTAREG|INTBREG|INBREG ); ! 1097: return( FORREW ); ! 1098: } ! 1099: ! 1100: lastchance( p, cook ) NODE *p; { ! 1101: /* forget it! */ ! 1102: return(0); ! 1103: } ! 1104: ! 1105: optim2( p ) register NODE *p; { ! 1106: /* do local tree transformations and optimizations */ ! 1107: ! 1108: register NODE *l, *r; ! 1109: int m, ml; ! 1110: ! 1111: switch( p->in.op ) { ! 1112: ! 1113: case AND: ! 1114: /* commute L and R to eliminate complements and constants */ ! 1115: if( (l = p->in.left)->in.op == ICON && l->in.name[0] == 0 || ! 1116: l->in.op == COMPL ) { ! 1117: p->in.left = p->in.right; ! 1118: p->in.right = l; ! 1119: } ! 1120: case ASG AND: ! 1121: /* change meaning of AND to ~R&L - bic on pdp11 */ ! 1122: r = p->in.right; ! 1123: if( r->in.op==ICON && r->in.name[0]==0 ) { /* complement constant */ ! 1124: r->tn.lval = ~r->tn.lval; ! 1125: } ! 1126: else if( r->in.op==COMPL ) { /* ~~A => A */ ! 1127: r->in.op = FREE; ! 1128: p->in.right = r->in.left; ! 1129: } ! 1130: else { /* insert complement node */ ! 1131: p->in.right = l = talloc(); ! 1132: l->in.op = COMPL; ! 1133: l->in.rall = NOPREF; ! 1134: l->in.type = r->in.type; ! 1135: l->in.left = r; ! 1136: l->in.right = NULL; ! 1137: } ! 1138: break; ! 1139: ! 1140: case SCONV: ! 1141: l = p->in.left; ! 1142: #if defined(FORT) || defined(SPRECC) ! 1143: if( p->in.type == FLOAT || p->in.type == DOUBLE || ! 1144: l->in.type == FLOAT || l->in.type == DOUBLE ) ! 1145: return; ! 1146: #else ! 1147: if( mixtypes(p, l) ) return; ! 1148: #endif ! 1149: if( l->in.op == PCONV ) ! 1150: return; ! 1151: ! 1152: /* Only trust it to get it right if the size is the same */ ! 1153: if( tlen(p) != tlen(l) ) ! 1154: return; ! 1155: ! 1156: /* clobber conversion */ ! 1157: if( l->in.op != FLD ) ! 1158: l->in.type = p->in.type; ! 1159: ncopy( p, l ); ! 1160: l->in.op = FREE; ! 1161: ! 1162: break; ! 1163: ! 1164: case ASSIGN: ! 1165: /* ! 1166: * Conversions are equivalent to assignments; ! 1167: * when the two operations are combined, ! 1168: * we can sometimes zap the conversion. ! 1169: */ ! 1170: r = p->in.right; ! 1171: l = p->in.left; ! 1172: if ( r->in.op == SCONV && ! 1173: !mixtypes(l, r) && ! 1174: tlen(l) == tlen(r) ) { ! 1175: p->in.right = r->in.left; ! 1176: r->in.op = FREE; ! 1177: } ! 1178: break; ! 1179: ! 1180: } ! 1181: } ! 1182: ! 1183: NODE * addroreg(l) NODE *l; ! 1184: /* OREG was built in clocal() ! 1185: * for an auto or formal parameter ! 1186: * now its address is being taken ! 1187: * local code must unwind it ! 1188: * back to PLUS/MINUS REG ICON ! 1189: * according to local conventions ! 1190: */ ! 1191: { ! 1192: cerror("address of OREG taken"); ! 1193: /*NOTREACHED*/ ! 1194: } ! 1195: ! 1196: ! 1197: ! 1198: # ifndef ONEPASS ! 1199: main( argc, argv ) char *argv[]; { ! 1200: return( mainp2( argc, argv ) ); ! 1201: } ! 1202: # endif ! 1203: ! 1204: ! 1205: /* added by jwf */ ! 1206: struct functbl { ! 1207: int fop; ! 1208: TWORD ftype; ! 1209: char *func; ! 1210: } opfunc[] = { ! 1211: DIV, TANY, "udiv", ! 1212: MOD, TANY, "urem", ! 1213: ASG DIV, TANY, "audiv", ! 1214: ASG MOD, TANY, "aurem", ! 1215: 0, 0, 0 }; ! 1216: ! 1217: hardops(p) register NODE *p; { ! 1218: /* change hard to do operators into function calls. */ ! 1219: register NODE *q; ! 1220: register struct functbl *f; ! 1221: register o; ! 1222: NODE *old,*temp; ! 1223: ! 1224: o = p->in.op; ! 1225: if( ! (optype(o)==BITYPE && ! 1226: (ISUNSIGNED(p->in.left->in.type) || ! 1227: ISUNSIGNED(p->in.right->in.type))) ) ! 1228: return; ! 1229: ! 1230: for( f=opfunc; f->fop; f++ ) { ! 1231: if( o==f->fop ) goto convert; ! 1232: } ! 1233: return; ! 1234: ! 1235: convert: ! 1236: if( asgop( o ) ) { ! 1237: old = NIL; ! 1238: switch( p->in.left->in.op ){ ! 1239: case FLD: ! 1240: q = p->in.left->in.left; ! 1241: /* ! 1242: * rewrite (lval.fld /= rval); as ! 1243: * ((*temp).fld = udiv((*(temp = &lval)).fld,rval)); ! 1244: * else the compiler will evaluate lval twice. ! 1245: */ ! 1246: if( q->in.op == UNARY MUL ){ ! 1247: /* first allocate a temp storage */ ! 1248: temp = talloc(); ! 1249: temp->in.op = OREG; ! 1250: temp->tn.rval = TMPREG; ! 1251: temp->tn.lval = BITOOR(freetemp(1)); ! 1252: temp->in.type = INCREF(p->in.type); ! 1253: #ifdef FLEXNAMES ! 1254: temp->in.name = ""; ! 1255: #else ! 1256: temp->in.name[0] = '\0'; ! 1257: #endif ! 1258: old = q->in.left; ! 1259: q->in.left = temp; ! 1260: } ! 1261: /* fall thru ... */ ! 1262: ! 1263: case REG: ! 1264: case NAME: ! 1265: case OREG: ! 1266: /* change ASG OP to a simple OP */ ! 1267: q = talloc(); ! 1268: q->in.op = NOASG p->in.op; ! 1269: q->in.rall = NOPREF; ! 1270: q->in.type = p->in.type; ! 1271: q->in.left = tcopy(p->in.left); ! 1272: q->in.right = p->in.right; ! 1273: p->in.op = ASSIGN; ! 1274: p->in.right = q; ! 1275: p = q; ! 1276: f -= 2; /* Note: this depends on the table order */ ! 1277: /* on the right side only - replace *temp with ! 1278: *(temp = &lval), build the assignment node */ ! 1279: if( old ){ ! 1280: temp = q->in.left->in.left; /* the "*" node */ ! 1281: q = talloc(); ! 1282: q->in.op = ASSIGN; ! 1283: q->in.left = temp->in.left; ! 1284: q->in.right = old; ! 1285: q->in.type = old->in.type; ! 1286: #ifdef FLEXNAMES ! 1287: q->in.name = ""; ! 1288: #else ! 1289: q->in.name[0] = '\0'; ! 1290: #endif ! 1291: temp->in.left = q; ! 1292: } ! 1293: break; ! 1294: ! 1295: case UNARY MUL: ! 1296: /* avoid doing side effects twice */ ! 1297: q = p->in.left; ! 1298: p->in.left = q->in.left; ! 1299: q->in.op = FREE; ! 1300: break; ! 1301: ! 1302: default: ! 1303: cerror( "hardops: can't compute & LHS" ); ! 1304: } ! 1305: } ! 1306: ! 1307: /* build comma op for args to function */ ! 1308: q = talloc(); ! 1309: q->in.op = CM; ! 1310: q->in.rall = NOPREF; ! 1311: q->in.type = INT; ! 1312: q->in.left = p->in.left; ! 1313: q->in.right = p->in.right; ! 1314: p->in.op = CALL; ! 1315: p->in.right = q; ! 1316: ! 1317: /* put function name in left node of call */ ! 1318: p->in.left = q = talloc(); ! 1319: q->in.op = ICON; ! 1320: q->in.rall = NOPREF; ! 1321: q->in.type = INCREF( FTN + p->in.type ); ! 1322: #ifndef FLEXNAMES ! 1323: strcpy( q->in.name, f->func ); ! 1324: #else ! 1325: q->in.name = f->func; ! 1326: #endif ! 1327: q->tn.lval = 0; ! 1328: q->tn.rval = 0; ! 1329: ! 1330: } ! 1331: ! 1332: zappost(p) NODE *p; { ! 1333: /* look for ++ and -- operators and remove them */ ! 1334: ! 1335: register o, ty; ! 1336: register NODE *q; ! 1337: o = p->in.op; ! 1338: ty = optype( o ); ! 1339: ! 1340: switch( o ){ ! 1341: ! 1342: case INCR: ! 1343: case DECR: ! 1344: q = p->in.left; ! 1345: p->in.right->in.op = FREE; /* zap constant */ ! 1346: ncopy( p, q ); ! 1347: q->in.op = FREE; ! 1348: return; ! 1349: ! 1350: } ! 1351: ! 1352: if( ty == BITYPE ) zappost( p->in.right ); ! 1353: if( ty != LTYPE ) zappost( p->in.left ); ! 1354: } ! 1355: ! 1356: fixpre(p) NODE *p; { ! 1357: ! 1358: register o, ty; ! 1359: o = p->in.op; ! 1360: ty = optype( o ); ! 1361: ! 1362: switch( o ){ ! 1363: ! 1364: case ASG PLUS: ! 1365: p->in.op = PLUS; ! 1366: break; ! 1367: case ASG MINUS: ! 1368: p->in.op = MINUS; ! 1369: break; ! 1370: } ! 1371: ! 1372: if( ty == BITYPE ) fixpre( p->in.right ); ! 1373: if( ty != LTYPE ) fixpre( p->in.left ); ! 1374: } ! 1375: ! 1376: strip(p) register NODE *p; { ! 1377: NODE *q; ! 1378: ! 1379: /* strip nodes off the top when no side effects occur */ ! 1380: for( ; ; ) { ! 1381: switch( p->in.op ) { ! 1382: case SCONV: /* remove lint tidbits */ ! 1383: q = p->in.left; ! 1384: ncopy( p, q ); ! 1385: q->in.op = FREE; ! 1386: break; ! 1387: /* could probably add a few more here */ ! 1388: default: ! 1389: return; ! 1390: } ! 1391: } ! 1392: } ! 1393: ! 1394: myreader(p) register NODE *p; { ! 1395: strip( p ); /* strip off operations with no side effects */ ! 1396: canon( p ); /* expands r-vals for fields */ ! 1397: walkf( p, hardops ); /* convert ops to function calls */ ! 1398: walkf( p, optim2 ); ! 1399: /* jwf toff = 0; /* stack offset swindle */ ! 1400: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.