![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to code.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / pcc / save|
Return to code.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / pcc / save |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)code.c 1.1 86/02/03 SMI"; ! 3: #endif ! 4: ! 5: ! 6: # include "cpass1.h" ! 7: # include <sys/types.h> ! 8: ! 9: # include <a.out.h> ! 10: # include <stab.h> ! 11: ! 12: #ifndef VAX ! 13: extern char *rnames[]; ! 14: #endif ! 15: ! 16: #ifndef ONEPASS ! 17: int usedregs; ! 18: int usedfpregs; ! 19: #endif !ONEPASS ! 20: ! 21: int proflg = 0; /* are we generating profiling code? */ ! 22: int strftn = 0; /* is the current function one which returns a value */ ! 23: int fltfun = 0; /* is function float or double? */ ! 24: int optimize = 0; /* is optimization enabled? If so, no SLINEs for you */ ! 25: #ifdef STACKPROBE ! 26: int noprobe= 1; /* are we not generating 68000 stack probes? */ ! 27: #endif ! 28: int gdebug; ! 29: extern int oldway; ! 30: int fdefflag; /* are we within a function definition ? */ ! 31: char NULLNAME[8]; ! 32: int labelno; ! 33: ! 34: branch( n ) ! 35: { ! 36: /* output a branch to label n */ ! 37: /* exception is an ordinary function branching to retlab: then, return */ ! 38: if( n == retlab && !strftn ){ ! 39: #ifdef VAX ! 40: printf( " ret\n" ); ! 41: #else ! 42: printf( " jra LE%d\n", ftnno ); ! 43: #endif ! 44: } ! 45: else ! 46: #ifdef VAX ! 47: printf( " jbr L%d\n", n ); ! 48: #else ! 49: printf(" jra L%d\n", n ); ! 50: #endif ! 51: } ! 52: ! 53: int lastloc = { -1 }; ! 54: ! 55: #ifdef VAX ! 56: short log2tab[] = {0, 0, 1, 2, 2, 3, 3, 3, 3}; ! 57: #define LOG2SZ 9 ! 58: #endif ! 59: ! 60: defalign(n) ! 61: { ! 62: /* cause the alignment to become a multiple of n */ ! 63: #ifdef VAX ! 64: n /= SZCHAR; ! 65: if( lastloc != PROG && n > 1 ) printf( " .align %d\n", n >= 0 && n < LOG2SZ ? log2tab[n] : 0 ); ! 66: #else ! 67: if ( lastloc != PROG && n > 1 ) printf(" .even\n"); ! 68: #endif ! 69: } ! 70: ! 71: locctr( l ) ! 72: { ! 73: register temp; ! 74: /* l is PROG, ADATA, DATA, STRNG, ISTRNG, or STAB */ ! 75: ! 76: if( l == lastloc ) return(l); ! 77: temp = lastloc; ! 78: lastloc = l; ! 79: switch( l ){ ! 80: ! 81: case PROG: ! 82: printf( " .text\n" ); ! 83: if (gdebug && !oldway) ! 84: psline(lineno); ! 85: break; ! 86: ! 87: case DATA: ! 88: case ADATA: ! 89: if (temp != DATA && temp != ADATA) ! 90: printf( " .data\n" ); ! 91: break; ! 92: ! 93: /* The following levels of .data statements will be problems if ! 94: there is ever any relocation required. */ ! 95: case STRNG: ! 96: #ifdef VAX ! 97: printf( " .data 1\n" ); ! 98: #else ! 99: printf( " .data1\n" ); ! 100: #endif ! 101: break; ! 102: ! 103: case ISTRNG: ! 104: #ifdef VAX ! 105: printf( " .data 2\n" ); ! 106: #else ! 107: printf( " .data2\n" ); ! 108: #endif ! 109: break; ! 110: ! 111: case STAB: ! 112: printf( " .stab\n" ); ! 113: break; ! 114: ! 115: default: ! 116: cerror( "illegal location counter" ); ! 117: } ! 118: ! 119: return( temp ); ! 120: } ! 121: ! 122: deflab( n ) ! 123: { ! 124: /* output something to define the current position as label n */ ! 125: printf( "L%d:\n", n ); ! 126: } ! 127: ! 128: int crslab = 10; ! 129: ! 130: getlab() ! 131: { ! 132: /* return a number usable for a label */ ! 133: return( ++crslab ); ! 134: } ! 135: ! 136: ! 137: #ifdef VAX ! 138: int ent_mask[] = { ! 139: 0,0,0,0,0, 0xfc0, 0xf80, 0xf00, 0xe00, 0xc00, 0x800, 0}; ! 140: ! 141: int reg_use = 11; ! 142: #else ! 143: extern int regsused; ! 144: #endif ! 145: ! 146: efcode() ! 147: { ! 148: /* code for the end of a function */ ! 149: ! 150: #ifdef VAX ! 151: if( strftn ){ /* copy output (in R2) to caller */ ! 152: register NODE *l, *r; ! 153: register struct symtab *p; ! 154: register TWORD t; ! 155: register int j; ! 156: int i; ! 157: ! 158: p = STP(curftn); ! 159: t = p->stype; ! 160: t = DECREF(t); ! 161: ! 162: deflab( retlab ); ! 163: ! 164: i = getlab(); /* label for return area */ ! 165: #ifndef LCOMM ! 166: printf(" .data\n" ); ! 167: printf(" .align 2\n" ); ! 168: printf("L%d: .space %d\n", i, tsize(t, p->dimoff, p->sizoff)/SZCHAR ); ! 169: printf(" .text\n" ); ! 170: #else ! 171: { int sz = tsize(t, p->dimoff, p->sizoff) / SZCHAR; ! 172: if (sz % sizeof (int)) ! 173: sz += sizeof (int) - (sz % sizeof (int)); ! 174: printf(" .lcomm L%d,%d\n", i, sz); ! 175: } ! 176: #endif ! 177: psline(lineno); ! 178: printf(" movab L%d,r1\n", i); ! 179: ! 180: reached = 1; ! 181: l = block( REG, NIL, NIL, PTR|t, p->dimoff, p->sizoff ); ! 182: l->tn.rval = 1; /* R1 */ ! 183: l->tn.lval = 0; /* no offset */ ! 184: r = block( REG, NIL, NIL, PTR|t, p->dimoff, p->sizoff ); ! 185: r->tn.rval = 0; /* R0 */ ! 186: r->tn.lval = 0; ! 187: l = buildtree( UNARY MUL, l, NIL ); ! 188: r = buildtree( UNARY MUL, r, NIL ); ! 189: l = buildtree( ASSIGN, l, r ); ! 190: l->in.op = FREE; ! 191: ecomp( l->in.left ); ! 192: printf( " movab L%d,r0\n", i ); ! 193: /* turn off strftn flag, so return sequence will be generated */ ! 194: strftn = 0; ! 195: } ! 196: branch( retlab ); ! 197: #ifndef VMS ! 198: printf( " .set L%d,0x%x\n", ftnno, ent_mask[reg_use] ); ! 199: #else ! 200: printf( " .set L%d,%d # Hex = 0x%x\n", ftnno, 0x3c| ent_mask[reg_use], ent_mask[reg_use] ); ! 201: /* KLS kludge, under VMS if you use regs 2-5, you must save them. */ ! 202: #endif ! 203: reg_use = 11; ! 204: p2bend(); ! 205: fdefflag = 0; ! 206: #else ! 207: /* 68k code */ ! 208: /* NOTE: We still have to add FTN and stab support here */ ! 209: if( strftn ){ /* copy output (in r0) to caller */ ! 210: register struct symtab *p; ! 211: register int stlab; ! 212: register int count; ! 213: int size; ! 214: ! 215: p = STP(curftn); ! 216: ! 217: deflab( retlab ); ! 218: ! 219: stlab = getlab(); ! 220: printf( " movl d0,a0\n" ); ! 221: printf( " movl #L%d,a1\n", stlab ); ! 222: size = tsize( DECREF(p->stype), p->dimoff, p->sizoff ) / SZCHAR; ! 223: printf( " .bss\nL%d: .=.+%d\n .text\n", ! 224: stlab, size ); ! 225: if (size <= 20) { ! 226: count = size/2; ! 227: while( size ){ /* simple load/store loop */ ! 228: count = (size > 2) ? 4 : 2; ! 229: printf(" mov%c a0@+,a1@+\n", ! 230: count==2 ? 'w' : 'l'); ! 231: size -= count; ! 232: } ! 233: } else { ! 234: int residue; ! 235: ! 236: count = size / sizeof(long); ! 237: residue = size % sizeof(long); ! 238: if (count > 0x7fff) { ! 239: printf(" movl #%d,d0\n", count-1); ! 240: printf("1: movl a0@+,a1@+\n"); ! 241: printf(" dbra d0,1b\n"); ! 242: printf(" subql #1,d0\n"); ! 243: printf(" jcc 1b\n"); ! 244: } else { ! 245: printf(" movw #%d,d0\n", count-1); ! 246: printf("1: movl a0@+,a1@+\n"); ! 247: printf(" dbra d0,1b\n"); ! 248: } ! 249: switch(residue) { ! 250: case 1: ! 251: printf(" movb a0@+,a1@+\n"); ! 252: break; ! 253: case 2: ! 254: printf(" movw a0@+,a1@+\n"); ! 255: break; ! 256: case 3: ! 257: printf(" movw a0@+,a1@+\n"); ! 258: printf(" movb a0@+,a1@+\n"); ! 259: break; ! 260: default: ! 261: break; ! 262: } ! 263: } ! 264: printf( " movl #L%d,d0\n", stlab ); ! 265: /* turn off strftn flag, so return sequence will be generated */ ! 266: strftn = 0; ! 267: } ! 268: /* branch( retlab ); */ ! 269: p2bend(); ! 270: if (gdebug && oldway) ! 271: dbfunend(labelno++); ! 272: fdefflag = 0; ! 273: #endif ! 274: } ! 275: ! 276: int ftlab1, ftlab2; ! 277: ! 278: bfcode( a, n ) int a[]; ! 279: { ! 280: /* code for the beginning of a function; a is an array of ! 281: indices in stab for the arguments; n is the number */ ! 282: register i; ! 283: register temp; ! 284: register struct symtab *p; ! 285: int off; ! 286: char *toreg(); ! 287: ! 288: locctr( PROG ); ! 289: p = STP(curftn); ! 290: if (p == NULL) return; ! 291: temp = p->stype; ! 292: temp = DECREF(temp); ! 293: #ifdef VAX ! 294: printf( " .align 1\n"); ! 295: #else ! 296: /* magic cookie for c2 */ ! 297: /* uses old (pre-TERROR) type format */ ! 298: printf( "|#PROC# %#o\n", (temp&BTMASK) | ((temp&~BTMASK)>>2) ); ! 299: #endif ! 300: defnam( p ); ! 301: strftn = (temp==STRTY) || (temp==UNIONTY); ! 302: fltfun = (temp==FLOAT) || (temp==DOUBLE); ! 303: ! 304: retlab = getlab(); ! 305: ! 306: /* routine prolog */ ! 307: ! 308: #ifdef VAX ! 309: printf( " .word L%d\n", ftnno); ! 310: #else !VAX ! 311: printf(" link a6,#0\n"); ! 312: printf(" addl #-LF%d,sp\n", ftnno); ! 313: #ifdef STACKPROBE ! 314: if (noprobe!=1){ ! 315: printf(" tstb sp@(-LP%d)\n",ftnno); ! 316: } ! 317: #endif ! 318: printf(" moveml #LS%d,sp@\n",ftnno); ! 319: if (use68881) { ! 320: /* ! 321: * save floating registers used for variables ! 322: */ ! 323: if (use68020) { ! 324: printf(" fmovem #LSS%d,a6@(-LFF%d:l)\n", ! 325: ftnno, ftnno); ! 326: } else { ! 327: /* 68881 without 68020; unlikely combination */ ! 328: printf(" movl #-LFF%d,a0\n", ftnno); ! 329: printf(" fmovem #LSS%d,a6@(0,a0:l)\n", ftnno); ! 330: } ! 331: } ! 332: #endif !VAX ! 333: ! 334: #ifdef VAX ! 335: ftlab1 = getlab(); ! 336: ftlab2 = getlab(); ! 337: printf( " jbr L%d\n", ftlab1); ! 338: printf( "L%d:\n", ftlab2); ! 339: #endif ! 340: if( proflg ) { /* profile code */ ! 341: i = getlab(); ! 342: #ifdef VAX ! 343: printf(" movab L%d,r0\n", i); ! 344: printf(" jsb mcount\n"); ! 345: printf(" .data\n"); ! 346: printf(" .align 2\n"); ! 347: printf("L%d: .long 0\n", i); ! 348: printf(" .text\n"); ! 349: #else ! 350: printf(" movl #L%d,a0\n",i); ! 351: printf(" jsr mcount\n"); ! 352: printf(" .bss\n .even\n"); ! 353: printf("L%d: .skip 4\n .text\n",i); ! 354: #endif ! 355: psline(lineno); ! 356: } ! 357: ! 358: off = ARGINIT; ! 359: ! 360: for( i=0; i<n; ++i ){ ! 361: #ifndef VAX ! 362: char type; ! 363: #endif ! 364: ! 365: p = STP(a[i]); ! 366: if( p->sclass == REGISTER ){ ! 367: temp = p->offset; /* save register number */ ! 368: p->sclass = PARAM; /* forget that it is a register */ ! 369: p->offset = NOOFFSET; ! 370: oalloc( p, &off ); ! 371: #ifdef VAX ! 372: /*tbl*/ printf( " %s %d(ap),r%d\n", ! 373: toreg(p->stype), p->offset/SZCHAR, temp ); ! 374: #else ! 375: printf( " %s a6@(%d),%s\n", ! 376: toreg(p->stype), p->offset/SZCHAR, ! 377: rnames[temp]); ! 378: markused(temp); ! 379: #endif ! 380: p->offset = temp; /* remember register number */ ! 381: p->sclass = REGISTER; /* remember that it is a register */ ! 382: } ! 383: /* The 68k doesn't have this code. I'll try it for a while */ ! 384: #ifdef VAX ! 385: else if( p->stype == STRTY || p->stype == UNIONTY ) { ! 386: p->offset = NOOFFSET; ! 387: if( oalloc( p, &off ) ) cerror( "bad argument" ); ! 388: SETOFF( off, ALSTACK ); ! 389: } ! 390: #endif ! 391: else { ! 392: if( oalloc( p, &off ) ) cerror( "bad argument" ); ! 393: } ! 394: ! 395: } ! 396: if (gdebug && !oldway) ! 397: psline(lineno); ! 398: fdefflag = 1; ! 399: } ! 400: ! 401: bccode() ! 402: { /* called just before the first executable statment */ ! 403: /* by now, the automatics and register variables are allocated */ ! 404: SETOFF( autooff, SZINT ); ! 405: /* set aside store area offset */ ! 406: p2bbeg( autooff, regvar ); ! 407: #ifdef VAX ! 408: reg_use = (reg_use > regvar ? regvar : reg_use); ! 409: #endif ! 410: } ! 411: ! 412: ejobcode( flag ) ! 413: { ! 414: /* called just before final exit */ ! 415: /* flag is 1 if errors, 0 if none */ ! 416: if (gdebug) { ! 417: printf("\t.text\n"); ! 418: pstab(NULLNAME, N_ESO); ! 419: printf("0,0,LL%d\n", labelno); ! 420: printf("LL%d:\n", labelno++); ! 421: } ! 422: } ! 423: ! 424: aobeg() ! 425: { ! 426: /* called before removing automatics from stab */ ! 427: } ! 428: ! 429: aocode(p) struct symtab *p; ! 430: { ! 431: /* called when automatic p removed from stab */ ! 432: } ! 433: ! 434: aoend() ! 435: { ! 436: /* called after removing all automatics from stab */ ! 437: } ! 438: ! 439: defnam( p ) register struct symtab *p; ! 440: { ! 441: /* define the current location as the name p->sname */ ! 442: ! 443: if( p->sclass == EXTDEF ){ ! 444: printf( " .globl %s\n", exname( p->sname ) ); ! 445: } ! 446: if( p->sclass == STATIC && p->slevel>1 ) deflab( p->offset ); ! 447: else printf( "%s:\n", exname( p->sname ) ); ! 448: ! 449: } ! 450: ! 451: bycode( t, i ) ! 452: { ! 453: #ifdef ASSTRINGS ! 454: static int lastoctal = 0; ! 455: #endif ! 456: ! 457: /* put byte i+1 in a string */ ! 458: ! 459: #ifdef ASSTRINGS ! 460: ! 461: i &= 077; ! 462: if ( t < 0 ){ ! 463: if ( i != 0 ) printf( "\"\n" ); ! 464: } else { ! 465: if ( i == 0 ) printf("\t.ascii\t\""); ! 466: if ( t == '\\' || t == '"'){ ! 467: lastoctal = 0; ! 468: printf("\\%c", t); ! 469: } ! 470: /* ! 471: * We escape the colon in strings so that ! 472: * c2 will, in its infinite wisdom, interpret ! 473: * the characters preceding the colon as a label. ! 474: * If we didn't escape the colon, c2 would ! 475: * throw away any trailing blanks or tabs after ! 476: * the colon, but reconstruct a assembly ! 477: * language semantically correct program. ! 478: * C2 hasn't been taught about strings. ! 479: */ ! 480: else if ( t == ':' || t < 040 || t >= 0177 || t == '|' || t == ';' ){ ! 481: lastoctal++; ! 482: printf("\\%o",t); ! 483: } ! 484: else if ( lastoctal && '0' <= t && t <= '9' ){ ! 485: lastoctal = 0; ! 486: printf("\"\n\t.ascii\t\"%c", t ); ! 487: } ! 488: else ! 489: { ! 490: lastoctal = 0; ! 491: putchar(t); ! 492: } ! 493: if ( i == 077 ) printf("\"\n"); ! 494: } ! 495: #else ! 496: ! 497: i &= 07; ! 498: if( t < 0 ){ /* end of the string */ ! 499: if( i != 0 ) printf( "\n" ); ! 500: } ! 501: ! 502: else { /* stash byte t into string */ ! 503: if( i == 0 ) printf( " .byte " ); ! 504: else printf( "," ); ! 505: #ifdef VAX ! 506: printf( "0x%x", t ); ! 507: #else ! 508: printf( "0x%x", t ); ! 509: #endif ! 510: if( i == 07 ) printf( "\n" ); ! 511: } ! 512: #endif ! 513: } ! 514: ! 515: zecode( n ) ! 516: { ! 517: /* n integer words of zeros */ ! 518: OFFSZ temp; ! 519: #ifndef VAX ! 520: register i; ! 521: #endif ! 522: ! 523: if( n <= 0 ) return; ! 524: #ifdef VAX ! 525: printf( " .space %d\n", (SZINT/SZCHAR)*n ); ! 526: #else ! 527: printf( " .skip %d\n", (SZINT/SZCHAR)*n ); ! 528: #endif ! 529: temp = n; ! 530: inoff += temp*SZINT; ! 531: } ! 532: ! 533: fldal( t ) unsigned t; ! 534: { /* return the alignment of field of type t */ ! 535: uerror( "illegal field type" ); ! 536: return( ALINT ); ! 537: } ! 538: ! 539: fldty( p ) struct symtab *p; ! 540: { /* fix up type of field p */ ! 541: ; ! 542: } ! 543: ! 544: ! 545: where(c) ! 546: { /* print location of error */ ! 547: /* c is either 'u', 'c', or 'w' */ ! 548: /* GCOS version */ ! 549: fprintf( stderr, "%s, line %d: ", ftitle, lineno ); ! 550: } ! 551: ! 552: ! 553: /* tbl - toreg() returns a pointer to a char string ! 554: which is the correct "register move" for the passed type ! 555: */ ! 556: struct type_move ! 557: {TWORD fromtype; char tostrng[8];} toreg_strs[] = ! 558: { ! 559: #ifdef VAX ! 560: CHAR, "cvtbl", ! 561: SHORT, "cvtwl", ! 562: INT, "movl", ! 563: LONG, "movl", ! 564: FLOAT, "movf", ! 565: DOUBLE, "movd", ! 566: UCHAR, "movzbl", ! 567: USHORT, "movzwl", ! 568: UNSIGNED, "movl", ! 569: ULONG, "movl", ! 570: #else ! 571: CHAR, "movb", ! 572: UCHAR, "movb", ! 573: SHORT, "movw", ! 574: USHORT, "movw", ! 575: #endif ! 576: -1, "" ! 577: }; ! 578: ! 579: char ! 580: *toreg(type) ! 581: TWORD type; ! 582: { ! 583: struct type_move *p; ! 584: ! 585: for ( p=toreg_strs; p->fromtype > 0; p++) ! 586: if (p->fromtype == type) ! 587: return(p->tostrng); ! 588: ! 589: /* type not found, must be a pointer type */ ! 590: if (use68881 && type == FLOAT) { ! 591: return("fmoves"); ! 592: } ! 593: if (use68881 && type == DOUBLE) { ! 594: return("fmoved"); ! 595: } ! 596: return("movl"); ! 597: } ! 598: /* tbl */ ! 599: ! 600: ! 601: main( argc, argv ) char *argv[]; ! 602: { ! 603: int v; ! 604: #ifdef BUFSTDERR ! 605: char errbuf[BUFSIZ]; ! 606: setbuf(stderr, errbuf); ! 607: #endif ! 608: /* ffloat_(); /* HACK -- avoid sky board even if present */ ! 609: v = mainp1( argc, argv ); ! 610: floatnote(); ! 611: exit( v ); ! 612: } ! 613: ! 614: struct sw heapsw[SWITSZ]; /* heap for switches */ ! 615: ! 616: genswitch(p,n) register struct sw *p; ! 617: { ! 618: /* p points to an array of structures, each consisting ! 619: of a constant value and a label. ! 620: The first is >=0 if there is a default label; ! 621: its value is the label number ! 622: The entries p[1] to p[n] are the nontrivial cases ! 623: */ ! 624: register i; ! 625: register CONSZ j, range; ! 626: register dlab, swlab; ! 627: ! 628: range = p[n].sval-p[1].sval; ! 629: ! 630: if( range>0 && range <= 3*n && n>=4 ){ /* implement a direct switch */ ! 631: ! 632: dlab = p->slab >= 0 ? p->slab : getlab(); ! 633: #ifdef VAX ! 634: swlab = getlab(); ! 635: ! 636: /* already in r0 */ ! 637: printf(" casel r0,$%ld,$%ld\n", p[1].sval, range); ! 638: printf("L%d:\n", swlab); ! 639: for( i=1,j=p[1].sval; i<=n; j++) { ! 640: printf(" .word L%d-L%d\n", (j == p[i].sval ? ((j=p[i++].sval), p[i-1].slab) : dlab), ! 641: swlab); ! 642: } ! 643: ! 644: if( p->slab >= 0 ) branch( dlab ); ! 645: else printf("L%d:\n", dlab); ! 646: #else ! 647: if( p[1].sval ){ ! 648: printf( " subl #" ); ! 649: printf( CONFMT, p[1].sval ); ! 650: printf( ",d0\n" ); ! 651: } ! 652: ! 653: /* note that this is a cl; it thus checks ! 654: for numbers below range as well as out of range. ! 655: */ ! 656: printf( " cmpl #%ld,d0\n", range ); ! 657: printf( " jhi L%d\n", dlab ); ! 658: ! 659: if (use68020) { ! 660: printf( " movw pc@(6,d0:w:2),d0\n" ); ! 661: } else { ! 662: printf( " addw d0,d0\n" ); ! 663: printf( " movw pc@(6,d0:w),d0\n" ); ! 664: } ! 665: printf( " jmp pc@(2,d0:w)\n" ); ! 666: ! 667: /* output table */ ! 668: ! 669: /* printf( "L%d = \n", swlab=getlab() ); */ ! 670: printf( "L%d: \n", swlab=getlab() ); ! 671: for( i=1,j=p[1].sval; i<=n; ++j ) ! 672: printf( " .word L%d-L%d\n", ( j == p[i].sval ) ? ! 673: p[i++].slab : dlab, swlab ); ! 674: if( p->slab< 0 ) deflab( dlab ); ! 675: #endif ! 676: return; ! 677: ! 678: } ! 679: ! 680: if( n>8 ) { /* heap switch */ ! 681: #ifdef VAX ! 682: heapsw[0].slab = dlab = p->slab >= 0 ? p->slab : getlab(); ! 683: makeheap(p, n, 1); /* build heap */ ! 684: ! 685: walkheap(1, n); /* produce code */ ! 686: ! 687: if( p->slab >= 0 ) ! 688: branch( dlab ); ! 689: else ! 690: printf("L%d:\n", dlab); ! 691: return; ! 692: #else ! 693: /* drop comparison loop, then switch table, then comparison table */ ! 694: int tbllab, llab; ! 695: int biggest, smallest, range; ! 696: char sizechar; ! 697: char *sizeword; ! 698: int unsgned = 1; ! 699: tbllab = getlab(); ! 700: dlab = p->slab>=0 ? p->slab : getlab(); ! 701: biggest = p[n].sval; ! 702: smallest = p[1].sval; ! 703: range = biggest-smallest; ! 704: if (biggest<=0377 && smallest>=0){ ! 705: sizechar = 'b';sizeword = ".byte"; ! 706: smallest = 0; ! 707: }else if ( range<=0377 && range > 0 ){ ! 708: sizechar = 'b';sizeword = ".byte"; ! 709: }else if (biggest<=0177777 && smallest>=0){ ! 710: sizechar = 'w';sizeword = ".word"; ! 711: smallest = 0; ! 712: }else if ( range<=0177777 && range > 0 ){ ! 713: sizechar = 'w';sizeword = ".word"; ! 714: }else{ ! 715: sizechar = 'l';sizeword = ".long"; smallest = 0; unsgned = 0; ! 716: } ! 717: ! 718: if( smallest ){ ! 719: printf( " %sl #%d,d0\n", smallest<0?"add":"sub", ! 720: abs(smallest) ); ! 721: printf( " cmpl #%d,d0\n", range ); ! 722: printf( " jhi L%d\n", dlab ); ! 723: } else if (sizechar != 'l' ){ ! 724: printf( " cmpl #%d,d0\n", biggest ); ! 725: printf( " jhi L%d\n", dlab ); ! 726: } ! 727: printf( " lea L%d,a0\n mov%s #%d,d1\n", ! 728: tbllab, (n<=128)?"eq":"w",n-1); ! 729: llab = getlab(); ! 730: printf( "L%d: cmp%c a0@+,d0\n db%s d1,L%d\n", ! 731: llab, sizechar, unsgned?"cc":"ge", llab); ! 732: printf( " jne L%d\n", dlab ); ! 733: if (use68020) { ! 734: printf( " movw pc@(6,d1:w:2),d0\n" ); ! 735: } else { ! 736: printf( " addw d1,d1\n" ); ! 737: printf( " movw pc@(6,d1:w),d0\n" ); ! 738: } ! 739: printf( " jmp pc@(2,d0:w)\n" ); ! 740: /* put out statement list forwards, comparison table backwards*/ ! 741: printf( "L%d: \n", swlab=getlab() ); ! 742: for( i=1; i<=n; i++ ) ! 743: printf( " .word L%d-L%d\n", p[i].slab, swlab ); ! 744: printf( "L%d: \n", tbllab ); ! 745: for( i=n; i>=1; i-- ) ! 746: printf( " %s %d\n", sizeword, p[i].sval-smallest ); ! 747: if (sizechar == 'b') ! 748: printf(" .even\n"); ! 749: if( p->slab< 0 ) deflab( dlab ); ! 750: return; ! 751: #endif ! 752: } ! 753: ! 754: /* debugging code */ ! 755: ! 756: /* out for the moment ! 757: if( n >= 4 ) werror( "inefficient switch: %d, %d", n, (int) (range/n) ); ! 758: */ ! 759: ! 760: /* simple switch code */ ! 761: ! 762: for( i=1; i<=n; ++i ){ ! 763: /* already in r0 */ ! 764: ! 765: #ifdef VAX ! 766: printf( " cmpl r0,$" ); ! 767: #else ! 768: printf( " cmpl #" ); ! 769: #endif ! 770: printf( CONFMT, p[i].sval ); ! 771: #ifdef VAX ! 772: printf( "\n jeql L%d\n", p[i].slab ); ! 773: #else ! 774: printf( ",d0\n jeq L%d\n", p[i].slab ); ! 775: #endif ! 776: } ! 777: ! 778: if( p->slab>=0 ) branch( p->slab ); ! 779: } ! 780: ! 781: #ifdef VAX ! 782: ! 783: makeheap(p, m, n) ! 784: register struct sw *p; ! 785: { ! 786: register int q; ! 787: ! 788: q = select(m); ! 789: heapsw[n] = p[q]; ! 790: if( q>1 ) makeheap(p, q-1, 2*n); ! 791: if( q<m ) makeheap(p+q, m-q, 2*n+1); ! 792: } ! 793: ! 794: select(m) ! 795: { ! 796: register int l,i,k; ! 797: ! 798: for(i=1; ; i*=2) ! 799: if( (i-1) > m ) break; ! 800: l = ((k = i/2 - 1) + 1)/2; ! 801: return( l + (m-k < l ? m-k : l)); ! 802: } ! 803: ! 804: walkheap(start, limit) ! 805: { ! 806: int label; ! 807: ! 808: ! 809: if( start > limit ) return; ! 810: #ifdef VAX ! 811: printf( " cmpl r0,$" ); ! 812: #else ! 813: printf( " cmpl #" ); ! 814: #endif ! 815: printf( CONFMT, heapsw[start].sval ); ! 816: #ifdef VAX ! 817: printf( "\n jeql L%d\n", heapsw[start].slab ); ! 818: #else ! 819: printf( ",d0\n beq L%d\n", heapsw[start].slab ); ! 820: #endif ! 821: if( (2*start) > limit ) { ! 822: #ifdef VAX ! 823: printf(" jbr L%d\n", heapsw[0].slab); ! 824: #else ! 825: printf(" bra L%d\n", heapsw[0].slab); ! 826: #endif ! 827: return; ! 828: } ! 829: if( (2*start+1) <= limit ) { ! 830: label = getlab(); ! 831: #ifdef VAX ! 832: printf(" jgtr L%d\n", label); ! 833: #else ! 834: printf(" bgt L%d\n", label); ! 835: #endif ! 836: } else ! 837: #ifdef VAX ! 838: printf(" jgtr L%d\n", heapsw[0].slab); ! 839: #else ! 840: printf(" bgt L%d\n", heapsw[0].slab); ! 841: #endif ! 842: walkheap( 2*start, limit); ! 843: if( (2*start+1) <= limit ) { ! 844: printf("L%d:\n", label); ! 845: walkheap( 2*start+1, limit); ! 846: } ! 847: } ! 848: #endif VAX heap code
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.