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