![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtree2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 / i8086|
Return to mtree2.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n1 / i8086 |
1.1 ! root 1: /* ! 2: * This file contains the machine dependent parts of the tree modifier. ! 3: * This version handles both the SMALL and the LARGE model iAPX86. ! 4: * A conditionalization handles machines that have an 8087. ! 5: */ ! 6: #ifdef vax ! 7: #include "INC$LIB:cc1.h" ! 8: #else ! 9: #include "cc1.h" ! 10: #endif ! 11: ! 12: int blkflab; ! 13: ! 14: static char modoptab[] = { ! 15: 'i', 'u', 'i', 'u', 'l', 'v', 'f', ! 16: 'd', 'b', 'i', 'i', 'p', 'p', 'p', 'p' ! 17: }; ! 18: ! 19: ! 20: #if SPLIT_CC1 ! 21: /* ! 22: * Function prolog. ! 23: * Clear "BLK function" label. ! 24: */ ! 25: doprolog() ! 26: { ! 27: blkflab = 0; ! 28: } ! 29: ! 30: /* ! 31: * Copy auto information. ! 32: */ ! 33: doautos() ! 34: { ! 35: iput(iget()); ! 36: iput(iget()); ! 37: } ! 38: #endif ! 39: ! 40: /* ! 41: * This function performs machine specific tree modifications. ! 42: * It is called from "modtree" after all of the machine ! 43: * independent transformations have been done. ! 44: * It returns either a pointer to the new tree ! 45: * (telling "modtree" to do another pass) ! 46: * or NULL (which implies that no changes were made). ! 47: */ ! 48: TREE * ! 49: modoper(tp, ac, ptp) ! 50: register TREE *tp; ! 51: TREE *ptp; ! 52: { ! 53: register TREE *lp; ! 54: register TREE *rp; ! 55: register TREE *tp1; ! 56: register TREE *tp2; ! 57: register TREE *tp3; ! 58: register int c; ! 59: register int o; ! 60: register int op; ! 61: register int tt; ! 62: register int nbase; ! 63: register int ntype; ! 64: register int lt; ! 65: register int rt; ! 66: register int seg; ! 67: register int lab; ! 68: register int makecall; ! 69: ! 70: c = ac; ! 71: if (c==MRETURN || c==MSWITCH || c==MINIT) ! 72: c = MRVALUE; ! 73: #if !ONLYSMALL&&!NDP ! 74: /* ! 75: * All fetches of float or double values are rewritten as ! 76: * routine calls in LARGE model. ! 77: * This makes the code a great deal smaller, ! 78: * and solves the problem of addressability on the _fpac_, ! 79: * which is not in the same segment as the data of the file. ! 80: */ ! 81: if (isvariant(VLARGE) ! 82: && (ac!=MINIT && ac!=MLADDR && ac!=MRADDR) ! 83: && (tp->t_flag&T_LEAF) != 0 ! 84: && isflt(tp->t_type)) { ! 85: tp1 = makenode(GID, LPTR); ! 86: if (tp->t_type == F32) ! 87: tp1->t_sp = gidpool("dfload"); ! 88: else ! 89: tp1->t_sp = gidpool("ddload"); ! 90: tp1->t_seg = SANY; ! 91: tp1 = leftnode(CALL, tp1, F64); ! 92: storedcon(tp); ! 93: if (tp->t_op == STAR) ! 94: tp1->t_rp = tp->t_lp; ! 95: else ! 96: tp1->t_rp = leftnode(ADDR, tp, LPTR); ! 97: return (tp1); ! 98: } ! 99: #endif ! 100: op = tp->t_op; ! 101: if (isleaf(op)) { ! 102: if (op==AID || op==PID) { ! 103: ntype = SPTR; ! 104: nbase = BP; ! 105: #if !ONLYSMALL ! 106: if (isvariant(VLARGE)) { ! 107: ntype = LPTR; ! 108: nbase = SSBP; ! 109: } ! 110: #endif ! 111: o = tp->t_offs; ! 112: tp->t_op = STAR; ! 113: tp->t_rp = NULL; ! 114: tp->t_lp = tp2 = makenode(ADD, ntype); ! 115: tp2->t_lp = tp3 = makenode(REG, ntype); ! 116: tp3->t_reg = nbase; ! 117: tp2->t_rp = ivalnode(o); ! 118: return (tp); ! 119: } ! 120: #if !ONLYSMALL ! 121: /* Generate links to double constants under LARGE RAM option. */ ! 122: if ((ac != MINIT) && (op == DCON) && isvariant(VRAM) && isvariant(VLARGE)) { ! 123: pool(tp); /* the dcon */ ! 124: tp->t_type = LPTR; ! 125: tp->t_size = 0; ! 126: pool(tp); /* the label */ ! 127: tp = leftnode(STAR, tp, F64, 0); ! 128: return (tp); ! 129: } ! 130: /* ! 131: * Build up indirect links to any LID or GID items ! 132: * that you cannot access in a direct fashon. ! 133: */ ! 134: if (ac != MINIT ! 135: && (op==LID || op==GID) ! 136: && (ptp==NULL || ptp->t_op!=CALL || tp!=ptp->t_lp) ! 137: && isvariant(VLARGE)) { ! 138: seg = tp->t_seg; ! 139: if (seg==SANY || seg==SDATA || seg==SBSS ! 140: || (seg==SPURE && isvariant(VRAM)) ! 141: || (seg==SSTRN && notvariant(VROM))) { ! 142: pool(tp); ! 143: tp1=leftnode(STAR, tp, tp->t_type, tp->t_size); ! 144: tp->t_type = LPTR; ! 145: tp->t_size = 0; ! 146: return (tp1); ! 147: } ! 148: } ! 149: #endif ! 150: goto done; ! 151: } ! 152: /* ! 153: * Beat on lvalue fields. ! 154: */ ! 155: if ((op==ASSIGN || (op>=AADD && op<=ASHR) ! 156: || (op>=INCBEF && op<=DECAFT)) ! 157: && tp->t_lp->t_op==FIELD && tp->t_lp->t_type<FLD8) ! 158: return (modlfld(tp, c)); ! 159: /* ! 160: * Non leaf. ! 161: * Gather up subtrees. ! 162: * Rewrite some things as calls to library routines. ! 163: */ ! 164: tt = tp->t_type; ! 165: lp = tp->t_lp; ! 166: if (lp != NULL) ! 167: lt = lp->t_type; ! 168: rp = NULL; ! 169: if (op != FIELD) { ! 170: rp = tp->t_rp; ! 171: if (rp != NULL) ! 172: rt = rp->t_type; ! 173: } ! 174: /* ! 175: * Long MUL, DIV and REM are always a function call. ! 176: * If there is no NDP in the machine, ! 177: * then floating point is a routine call. ! 178: * If there is, we rewrite conversions from bytes and unsigned things ! 179: * and all conversions from float to fixed ! 180: * (a mode switch may be necessary). ! 181: */ ! 182: makecall = 0; ! 183: if (islong(tt) && op>=MUL && op<=REM) { ! 184: ++makecall; ! 185: #if NDP ! 186: } else if (isflt(tt)) { ! 187: if (op==CONVERT || op==CAST) { ! 188: if ((lp->t_flag&T_REG) != 0 ! 189: || (lp->t_flag&T_LEAF) == 0 ! 190: || (lt!=S16 && lt!=S32 && lt!=F32)) ! 191: ++makecall; ! 192: } ! 193: } else if ((op>=GT && op<=LT) && isflt(lt)) { ! 194: tp->t_op += UGT-GT; ! 195: #else ! 196: } else if (isflt(tt)) { ! 197: if (op==CONVERT || op==CAST) { ! 198: if (!isflt(lt)) ! 199: ++makecall; ! 200: } else if ((op>=ADD && op<=REM) ! 201: #if !ONLYSMALL ! 202: || (isvariant(VLARGE) && op==NEG) ! 203: || (isvariant(VLARGE) && op==ASSIGN) ! 204: #endif ! 205: || (op>=AADD && op<=AREM)) ! 206: ++makecall; ! 207: } else if (isrelop(op) && isflt(lt)) { ! 208: ++makecall; ! 209: #endif ! 210: } else if ((op==CONVERT || op==CAST) && isflt(lt)) ! 211: ++makecall; ! 212: if (makecall != 0) ! 213: return (modxfun(tp)); ! 214: switch (op) { ! 215: ! 216: case FIELD: ! 217: if (c != MLADDR) ! 218: return (modefld(tp->t_lp, tp, c, 1)); ! 219: break; ! 220: ! 221: case ASSIGN: ! 222: if (tt == BLK) { ! 223: tp = modsasg(lp, rp, tp->t_size); ! 224: if (c != MEFFECT) ! 225: tp = leftnode(STAR, tp, BLK, tp->t_size); ! 226: return (tp); ! 227: } ! 228: break; ! 229: ! 230: case CONVERT: ! 231: case CAST: ! 232: if (modkind(tt) == modkind(lp->t_type)) { ! 233: lp->t_type = tt; ! 234: return (lp); ! 235: } ! 236: } ! 237: /* ! 238: * If this tree is the return value of a structure function, ! 239: * arrange to copy the value into a secret place ! 240: * and return the address of the place. ! 241: */ ! 242: done: ! 243: if (tp->t_type==BLK && ac==MRETURN) { ! 244: if (blkflab == 0) { ! 245: blkflab = newlab(); ! 246: o = newseg(SBSS); ! 247: genlab(blkflab); ! 248: bput(BLOCK); ! 249: iput((ival_t) tp->t_size); ! 250: newseg(o); ! 251: } ! 252: lp = makenode(LID, BLK, tp->t_size); ! 253: lp->t_label = blkflab; ! 254: lp->t_seg = SBSS; ! 255: return (modsasg(lp, tp, tp->t_size)); ! 256: } ! 257: return (NULL); ! 258: } ! 259: ! 260: /* ! 261: * Given a type, return a kind that is used to see ! 262: * if two objects are just different names for the same bits. ! 263: */ ! 264: modkind(t) ! 265: register t; ! 266: { ! 267: if (t == U16) ! 268: t = S16; ! 269: else if (t == U32) ! 270: t = S32; ! 271: return (t); ! 272: } ! 273: ! 274: /* ! 275: * Build a call node for the assignment of structure data. ! 276: * The rep and a copy operation are not used so that the ES need not be used. ! 277: * The type of the CALL is PTR. ! 278: * The size is valid. ! 279: */ ! 280: TREE * ! 281: modsasg(lp, rp, s) ! 282: register TREE *lp; ! 283: register TREE *rp; ! 284: { ! 285: register TREE *tp; ! 286: int nptdt; ! 287: ! 288: nptdt = SPTR; ! 289: #if !ONLYSMALL ! 290: if (isvariant(VLARGE)) ! 291: nptdt = LPTR; ! 292: #endif ! 293: rp = leftnode(ADDR, rp, nptdt); ! 294: rp = leftnode(ARGLST, rp, nptdt); ! 295: rp->t_rp = ivalnode(s); ! 296: lp = leftnode(ADDR, lp, nptdt); ! 297: lp = leftnode(ARGLST, lp, nptdt); ! 298: lp->t_rp = rp; ! 299: tp = makenode(GID, nptdt); ! 300: tp->t_sp = gidpool("blkmv"); ! 301: tp->t_seg = SANY; ! 302: tp = leftnode(CALL, tp, nptdt); ! 303: tp->t_size = s; ! 304: tp->t_rp = lp; ! 305: return (tp); ! 306: } ! 307: ! 308: /* ! 309: * Modify function calls. ! 310: * Handle functions that return objects of type "BLK" ! 311: * by adding a free indirection node. ! 312: */ ! 313: TREE * ! 314: modcall(tp, c) ! 315: register TREE *tp; ! 316: { ! 317: tp->t_lp = modtree(tp->t_lp, MLADDR, tp); ! 318: tp->t_rp = modargs(tp->t_rp, tp); ! 319: if (tp->t_type == BLK) { ! 320: #if !ONLYSMALL ! 321: if (isvariant(VLARGE)) ! 322: tp->t_type = LPTR; ! 323: else ! 324: tp->t_type = SPTR; ! 325: #else ! 326: tp->t_type = SPTR; ! 327: #endif ! 328: if (c != MEFFECT) ! 329: tp = leftnode(STAR, tp, BLK, tp->t_size); ! 330: } ! 331: return (tp); ! 332: } ! 333: ! 334: /* ! 335: * Modify argument lists. ! 336: */ ! 337: TREE * ! 338: modargs(tp, ptp) ! 339: register TREE *tp; ! 340: TREE *ptp; ! 341: { ! 342: if (tp == NULL) ! 343: return (NULL); ! 344: if (tp->t_op == ARGLST) { ! 345: tp->t_lp = modargs(tp->t_lp, tp); ! 346: tp->t_rp = modargs(tp->t_rp, tp); ! 347: return (tp); ! 348: } ! 349: if (tp->t_type == BLK) { ! 350: #if !ONLYSMALL ! 351: tp = leftnode(ADDR, tp, ! 352: (isvariant(VLARGE))?LPTB:SPTB, ! 353: tp->t_size); ! 354: #else ! 355: tp = leftnode(ADDR, tp, SPTB, tp->t_size); ! 356: #endif ! 357: return (modtree(tp, MRVALUE, ptp)); ! 358: } ! 359: return (modtree(tp, MFNARG, ptp)); ! 360: } ! 361: ! 362: /* ! 363: * Given a pointer to a TREE node that describes an operation ! 364: * that the machine cannot directly perform, ! 365: * rewrite the node as a CALL to a magic routine. ! 366: * On the iAPX-86 we rewrite floating point, long multiply and divide ! 367: * and unsigned long multiply and divide. ! 368: * This routine only has to handle the ASSIGN ! 369: * operation if IEEE format; when using DECVAX format ! 370: * the double=>float conversion is easy. ! 371: */ ! 372: TREE * ! 373: modxfun(tp) ! 374: TREE *tp; ! 375: { ! 376: register TREE *lp, *rp; ! 377: register char *p1, *p2; ! 378: register TREE *tp1; ! 379: register int tt, lt, op; ! 380: register int nptct, nptdt; ! 381: ! 382: static char *name[] = { ! 383: "add", ! 384: "sub", ! 385: "mul", ! 386: "div", ! 387: "rem" ! 388: }; ! 389: ! 390: nptdt = SPTR; ! 391: #if !ONLYSMALL ! 392: if (isvariant(VLARGE)) ! 393: nptdt = LPTR; ! 394: #endif ! 395: tp1 = makenode(GID, nptdt); ! 396: op = tp->t_op; ! 397: lp = tp->t_lp; ! 398: rp = tp->t_rp; ! 399: tt = tp->t_type; ! 400: if (lp != NULL) ! 401: lt = lp->t_type; ! 402: p1 = id; ! 403: if (op==CONVERT || op==CAST || op==NEG) { ! 404: p2 = "cvt"; ! 405: if (op == NEG) ! 406: p2 = "neg"; ! 407: *p1++ = modoptab[tt]; ! 408: if (lt==F32 && tt!=F64) ! 409: lt = F64; ! 410: *p1++ = modoptab[lt]; ! 411: } else { ! 412: walk(tp, amd); ! 413: *p1++ = modoptab[tt]; ! 414: if ((op==ADD || op==MUL || isrelop(op)) ! 415: && ((lp->t_flag&T_LEAF)!=0 && (rp->t_flag&T_LEAF)==0 ! 416: || lp->t_op==DCON && rp->t_op!=DCON)) { ! 417: lp = rp; ! 418: rp = tp->t_lp; ! 419: if (isrelop(op)) ! 420: op = fliprel[op-EQ]; ! 421: } ! 422: if (op==ASSIGN || (op>=AADD && op<=AREM)) { ! 423: *p1++ = modoptab[lt]; ! 424: if (lp->t_op != STAR) ! 425: lp = leftnode(ADDR, lp, nptdt); ! 426: else ! 427: lp = lp->t_lp; ! 428: if (op == ASSIGN) ! 429: p2 = "asg"; ! 430: else ! 431: p2 = name[op-AADD]; ! 432: } else if (isrelop(op)) ! 433: p2 = "cmp"; ! 434: else if (op>=ADD && op<=REM) ! 435: p2 = name[op-ADD]; ! 436: else ! 437: cbotch("modxfun"); ! 438: storedcon(rp); ! 439: if (uselvalueform(op, tt, rp)) { ! 440: *p1++ = 'l'; ! 441: if (rp->t_op != STAR) ! 442: rp = leftnode(ADDR, rp, nptdt); ! 443: else ! 444: rp = rp->t_lp; ! 445: } else ! 446: *p1++ = 'r'; ! 447: } ! 448: while (*p1++ = *p2++) ! 449: ; ! 450: *p1 = 0; ! 451: tp1->t_sp = gidpool(id); ! 452: tp1->t_seg = SANY; ! 453: lp = leftnode(ARGLST, lp, nptdt); ! 454: lp->t_rp = rp; ! 455: tp->t_op = CALL; ! 456: tp->t_lp = tp1; ! 457: tp->t_rp = lp; ! 458: fixtoptype(tp); ! 459: if (tp->t_type!=tt && tt!=F32) ! 460: tp = leftnode(CONVERT, tp, tt); ! 461: if (isrelop(op)) { ! 462: tp = leftnode(op, tp, TRUTH); ! 463: tp->t_rp = ivalnode(0); ! 464: } ! 465: return (tp); ! 466: } ! 467: ! 468: /* ! 469: * Zap a DCON into a block of memory with a double in it. ! 470: */ ! 471: storedcon(tp) ! 472: register TREE *tp; ! 473: { ! 474: if (tp->t_op != DCON) ! 475: return; ! 476: pool(tp); ! 477: tp->t_flag = T_DIR; ! 478: } ! 479: ! 480: /* ! 481: * This routine, used only by the "modxfun" routine, ! 482: * checks if an lvalue form of an operator routine can be used. ! 483: * True return if it can. ! 484: */ ! 485: uselvalueform(op, tt, rp) ! 486: register TREE *rp; ! 487: { ! 488: if (isrelop(op)) { ! 489: if (rp->t_type != F64) ! 490: return (0); ! 491: } else { ! 492: if (rp->t_type != tt) ! 493: return (0); ! 494: } ! 495: if (rp->t_op==STAR || (rp->t_flag&T_DIR)!=0) ! 496: return (1); ! 497: return (0); ! 498: } ! 499: ! 500: /* ! 501: * Test if 1) the tree pointed to by "tp" is a register ! 502: * and 2) the operation "op" can be computed in it. ! 503: */ ! 504: isokareg(tp, op) ! 505: register TREE *tp; ! 506: register op; ! 507: { ! 508: if (op==MUL || op==DIV || op==REM) ! 509: return (0); ! 510: if (tp->t_op!=REG || !isword(tp->t_type)) ! 511: return (0); ! 512: return (1); ! 513: } ! 514: ! 515: /* ! 516: * Modify bit fields in lvalue contexts. ! 517: * The "tp" argument is a pointer to the tree node ! 518: * with the FIELD operation on the left side. ! 519: * This routine has two tasks. ! 520: * First, it rewrites the type in the FIELD node to be the type used by ! 521: * select to match the tree; this is also used as a flag ! 522: * to prevent this routine from being called twice on a node. ! 523: * Second, it inserts explict shift nodes to ! 524: * the operands and results so that all of the optimizations ! 525: * applied to shifts work for fields. ! 526: * A pointer to the new top of the tree is returned. ! 527: */ ! 528: TREE * ! 529: modlfld(tp, c) ! 530: register TREE *tp; ! 531: { ! 532: register TREE *lp, *rp; ! 533: register lt, tt; ! 534: register op; ! 535: register bmop; ! 536: register MASK mask; ! 537: ! 538: op = tp->t_op; ! 539: tt = tp->t_type; ! 540: lp = tp->t_lp; ! 541: if (lp != NULL) ! 542: lt = lp->t_type; ! 543: if (op!=AMUL && op!=ADIV && op!=ASHL && op!=ASHR) { ! 544: rp = tp->t_rp; ! 545: rp = leftnode(SHL, rp, rp->t_type); ! 546: rp->t_rp = ivalnode(lp->t_base); ! 547: tp->t_rp = rp; ! 548: } ! 549: if (op==AAND || op==AOR || op==AXOR || op==ASSIGN) { ! 550: mask = ((MASK)01<<lp->t_width) - 1; ! 551: mask = mask << lp->t_base; ! 552: bmop = AND; ! 553: if (op == AAND) { ! 554: mask = ~mask; ! 555: bmop = OR; ! 556: } ! 557: /* rp set above */ ! 558: rp = leftnode(bmop, rp, rp->t_type); ! 559: rp->t_rp = ivalnode(mask); ! 560: tp->t_rp = rp; ! 561: } ! 562: if (c != MEFFECT) ! 563: tp = modefld(tp, lp, c, 0); ! 564: if (isbyte(lt)) ! 565: lp->t_type = FLD8; ! 566: else ! 567: lp->t_type = FLD16; ! 568: return (tp); ! 569: } ! 570: ! 571: /* ! 572: * This function rewrites any field extraction. ! 573: * The argument "tp" is the base of the field. ! 574: * The argument "fp" is a FIELD node that supplies the width and the base. ! 575: * The argument "flag" is true to enable the mask off in unsigned field extract. ! 576: */ ! 577: TREE * ! 578: modefld(tp, fp, c, flag) ! 579: register TREE *tp; ! 580: register TREE *fp; ! 581: { ! 582: register n; ! 583: register tt; ! 584: register mw; ! 585: register mask; ! 586: register ttold; ! 587: ! 588: mw = 16; ! 589: if (isbyte(ttold = tt = tp->t_type)) { ! 590: mw = 8; ! 591: tp = leftnode(CONVERT, tp, tt); ! 592: fixtoptype(tp); ! 593: tt = tp->t_type; ! 594: } ! 595: if (c == MFLOW) { ! 596: mask = (01<<fp->t_width) - 1; ! 597: if ((n=fp->t_base) != 0) ! 598: mask <<= n; ! 599: tp = leftnode(AND, tp, tt); ! 600: tp->t_rp = ivalnode((ival_t)mask); ! 601: return (tp); ! 602: } ! 603: if (isuns(tt)) { ! 604: if ((n=fp->t_base) != 0) { ! 605: tp = leftnode(SHR, tp, tt); ! 606: tp->t_rp = ivalnode(n); ! 607: } ! 608: if (flag && (n=fp->t_width)<mw) { ! 609: tp = leftnode(AND, tp, tt); ! 610: tp->t_rp = ivalnode(((ival_t)01<<n)-1); ! 611: } ! 612: return (tp); ! 613: } ! 614: if ((n=mw-(fp->t_base+fp->t_width)) != 0) { ! 615: tp = leftnode(SHL, tp, tt); ! 616: tp->t_rp = ivalnode(n); ! 617: } ! 618: if ((n=mw-fp->t_width) != 0) { ! 619: tp = leftnode(SHR, tp, tt); ! 620: tp->t_rp = ivalnode(n); ! 621: } ! 622: if (ttold != tt) ! 623: tp = leftnode(CONVERT, tp, ttold); ! 624: return (tp); ! 625: } ! 626: ! 627: /* ! 628: * Check if a tree should have its left and right subtrees swapped. ! 629: * Do it if it is required. ! 630: * Sometimes the relational operation must be adjusted. ! 631: */ ! 632: modswap(tp, ptp) ! 633: register TREE *tp; ! 634: TREE *ptp; ! 635: { ! 636: register TREE *lp, *rp; ! 637: FLAG lf, rf; ! 638: ! 639: switch (tp->t_op) { ! 640: ! 641: case ADD: ! 642: case MUL: ! 643: case AND: ! 644: case OR: ! 645: case XOR: ! 646: case EQ: ! 647: case NE: ! 648: case GT: ! 649: case GE: ! 650: case LT: ! 651: case LE: ! 652: case UGT: ! 653: case UGE: ! 654: case ULT: ! 655: case ULE: ! 656: lp = tp->t_lp; ! 657: rp = tp->t_rp; ! 658: lf = lp->t_flag; ! 659: rf = rp->t_flag; ! 660: if (lf!=0 || rf!=0) { ! 661: if ((lf&T_CON) != 0 ! 662: || (rf&T_REG) != 0 ! 663: || (lf!=0 && rf==0)) ! 664: swapit(tp); ! 665: } else if (lp->t_cost > rp->t_cost) ! 666: swapit(tp); ! 667: } ! 668: } ! 669: ! 670: /* ! 671: * Swap subtrees. ! 672: * Fix up relational ops. ! 673: */ ! 674: swapit(tp) ! 675: register TREE *tp; ! 676: { ! 677: register TREE *xp; ! 678: register op; ! 679: ! 680: xp = tp->t_lp; ! 681: tp->t_lp = tp->t_rp; ! 682: tp->t_rp = xp; ! 683: op = tp->t_op; ! 684: if (isrelop(op)) ! 685: tp->t_op = fliprel[op-EQ]; ! 686: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.