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