![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to local.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / pcc / pcc.tahoe|
Return to local.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / pcc / pcc.tahoe |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)local.c 1.5 (Berkeley) 1/9/87"; ! 3: #endif ! 4: ! 5: # include "pass1.h" ! 6: ! 7: /* this file contains code which is dependent on the target machine */ ! 8: ! 9: NODE * ! 10: clocal(p) register NODE *p; { ! 11: ! 12: /* this is called to do local transformations on ! 13: an expression tree preparitory to its being ! 14: written out in intermediate code. ! 15: */ ! 16: ! 17: /* the major essential job is rewriting the ! 18: automatic variables and arguments in terms of ! 19: REG and OREG nodes */ ! 20: /* conversion ops which are not necessary are also clobbered here */ ! 21: /* in addition, any special features (such as rewriting ! 22: exclusive or) are easily handled here as well */ ! 23: ! 24: register struct symtab *q; ! 25: register NODE *r; ! 26: register int o; ! 27: register int m, ml; ! 28: ! 29: switch( o = p->in.op ){ ! 30: ! 31: case NAME: ! 32: if( p->tn.rval < 0 ) { /* already processed; ignore... */ ! 33: return(p); ! 34: } ! 35: q = &stab[p->tn.rval]; ! 36: switch( q->sclass ){ ! 37: ! 38: case AUTO: ! 39: case PARAM: ! 40: /* fake up a structure reference */ ! 41: r = block( REG, NIL, NIL, PTR+STRTY, 0, 0 ); ! 42: r->tn.lval = 0; ! 43: r->tn.rval = STKREG; ! 44: p = stref( block( STREF, r, p, 0, 0, 0 ) ); ! 45: break; ! 46: ! 47: case ULABEL: ! 48: case LABEL: ! 49: case STATIC: ! 50: if( q->slevel == 0 ) break; ! 51: p->tn.lval = 0; ! 52: p->tn.rval = -q->offset; ! 53: break; ! 54: ! 55: case REGISTER: ! 56: p->in.op = REG; ! 57: p->tn.lval = 0; ! 58: p->tn.rval = q->offset; ! 59: #ifdef REG_CHAR ! 60: m = p->in.type; ! 61: if( m==CHAR || m==SHORT ) ! 62: p->in.type = INT; ! 63: else if( m==UCHAR || m==USHORT ) ! 64: p->in.type = UNSIGNED; ! 65: #endif ! 66: break; ! 67: ! 68: } ! 69: break; ! 70: ! 71: case LT: ! 72: case LE: ! 73: case GT: ! 74: case GE: ! 75: if( ISPTR( p->in.left->in.type ) || ISPTR( p->in.right->in.type ) ){ ! 76: p->in.op += (ULT-LT); ! 77: } ! 78: break; ! 79: ! 80: case PCONV: ! 81: /* do pointer conversions for char and longs */ ! 82: ml = p->in.left->in.type; ! 83: if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->in.left->in.op != ICON ) break; ! 84: ! 85: /* pointers all have the same representation; the type is inherited */ ! 86: ! 87: inherit: ! 88: p->in.left->in.type = p->in.type; ! 89: p->in.left->fn.cdim = p->fn.cdim; ! 90: p->in.left->fn.csiz = p->fn.csiz; ! 91: p->in.op = FREE; ! 92: return( p->in.left ); ! 93: ! 94: case SCONV: ! 95: m = p->in.type; ! 96: ml = p->in.left->in.type; ! 97: if(m == FLOAT || m == DOUBLE) { ! 98: if(p->in.left->in.op==SCONV && ! 99: ml == DOUBLE && ! 100: p->in.left->in.left->in.type==m) { ! 101: p->in.op = p->in.left->in.op = FREE; ! 102: return(p->in.left->in.left); ! 103: } ! 104: if(p->in.left->in.op==FCON) ! 105: goto inherit; ! 106: break; ! 107: } ! 108: if(ml == FLOAT || ml == DOUBLE){ ! 109: if (p->in.left->in.op == FCON){ ! 110: p->in.left->in.op = FREE; ! 111: p->in.op = ICON; ! 112: p->tn.lval = p->in.left->fpn.fval; ! 113: p->tn.rval = NONAME; ! 114: return(p); ! 115: } ! 116: break; ! 117: } ! 118: /* now, look for conversions downwards */ ! 119: ! 120: if( p->in.left->in.op == ICON ){ /* simulate the conversion here */ ! 121: CONSZ val; ! 122: val = p->in.left->tn.lval; ! 123: switch( m ){ ! 124: case CHAR: ! 125: p->in.left->tn.lval = (char) val; ! 126: break; ! 127: case UCHAR: ! 128: p->in.left->tn.lval = val & 0XFF; ! 129: break; ! 130: case USHORT: ! 131: p->in.left->tn.lval = val & 0XFFFFL; ! 132: break; ! 133: case SHORT: ! 134: p->in.left->tn.lval = (short)val; ! 135: break; ! 136: case UNSIGNED: ! 137: p->in.left->tn.lval = val & 0xFFFFFFFFL; ! 138: break; ! 139: case INT: ! 140: p->in.left->tn.lval = (int)val; ! 141: break; ! 142: } ! 143: p->in.left->in.type = m; ! 144: } else if (tlen(p) == tlen(p->in.left)) ! 145: goto inherit; ! 146: else ! 147: break; ! 148: /* clobber conversion */ ! 149: p->in.op = FREE; ! 150: return( p->in.left ); /* conversion gets clobbered */ ! 151: break; ! 152: ! 153: case QUEST: /* the right side should be COLON */ ! 154: if((r = p->in.right)->in.op == SCONV) { ! 155: p->in.right = r->in.left; ! 156: p->in.type = r->in.left->in.type; ! 157: r->in.left = p; ! 158: return(r); ! 159: } ! 160: return(p); ! 161: ! 162: case PVCONV: ! 163: case PMCONV: ! 164: if( p->in.right->in.op != ICON ) cerror( "bad conversion", 0); ! 165: p->in.op = FREE; ! 166: return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) ); ! 167: ! 168: case FLD: ! 169: /* make sure that the second pass does not make the ! 170: descendant of a FLD operator into a doubly indexed OREG */ ! 171: ! 172: if( p->in.left->in.op == UNARY MUL ! 173: && (r=p->in.left->in.left)->in.op == PCONV) ! 174: if( r->in.left->in.op == PLUS || r->in.left->in.op == MINUS ) ! 175: if( ISPTR(r->in.type) ) { ! 176: if( ISUNSIGNED(p->in.left->in.type) ) ! 177: p->in.left->in.type = UNSIGNED; ! 178: else ! 179: p->in.left->in.type = INT; ! 180: } ! 181: break; ! 182: case FORTCALL: /* arg must be FLOAT */ ! 183: if((r = p->in.right)->in.type != FLOAT) ! 184: p->in.right = clocal(makety(r, FLOAT, 0, FLOAT)); ! 185: return(p); ! 186: } ! 187: ! 188: /* if both sides are FLOAT, so is the op */ ! 189: if(optype(o)!=LTYPE && p->in.left->in.type==DOUBLE && ! 190: (o==UNARY MINUS || optype(o)==BITYPE && p->in.right->in.type==DOUBLE)) { ! 191: r = p->in.left; ! 192: if(r->in.op==SCONV && r->in.left->in.type==FLOAT) { ! 193: if(optype(o)==BITYPE) { ! 194: r = p->in.right; ! 195: if(r->in.op==SCONV && r->in.left->in.type==FLOAT) { ! 196: r->in.op = FREE; ! 197: p->in.right = r->in.left; ! 198: } else if(r->in.op==FCON) ! 199: r->in.type = FLOAT; ! 200: else ! 201: return(p); ! 202: } ! 203: r = p->in.left; ! 204: p->in.left = r->in.left; ! 205: } else if(optype(o)==BITYPE && r->in.op==FCON) { ! 206: r = p->in.right; ! 207: if(!(r->in.op==SCONV && r->in.left->in.type==FLOAT)) ! 208: return(p); ! 209: p->in.right = r->in.left; ! 210: p->in.left->in.type = FLOAT; ! 211: } else ! 212: return(p); ! 213: if(p->in.type==DOUBLE) { ! 214: p->in.type = FLOAT; ! 215: r->in.left = p; ! 216: return(r); ! 217: } else { /* usually logop */ ! 218: r->in.op = FREE; ! 219: return(p); ! 220: } ! 221: } ! 222: return(p); ! 223: } ! 224: ! 225: andable( p ) NODE *p; { ! 226: return(1); /* all names can have & taken on them */ ! 227: } ! 228: ! 229: cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */ ! 230: autooff = AUTOINIT; ! 231: } ! 232: ! 233: cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */ ! 234: ! 235: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* tbl */ ! 236: #ifdef REG_CHAR ! 237: || t==CHAR || t==UCHAR || t==SHORT || t==USHORT /* tbl */ ! 238: #endif ! 239: || ISPTR(t) || t == FLOAT) return (1); /* wnj */ ! 240: return(0); ! 241: } ! 242: ! 243: NODE * ! 244: offcon( off, t, d, s ) OFFSZ off; TWORD t; { ! 245: ! 246: /* return a node, for structure references, which is suitable for ! 247: being added to a pointer of type t, in order to be off bits offset ! 248: into a structure */ ! 249: ! 250: register NODE *p; ! 251: ! 252: /* t, d, and s are the type, dimension offset, and sizeoffset */ ! 253: /* in general they are necessary for offcon, but not on H'well */ ! 254: ! 255: p = bcon(0); ! 256: p->tn.lval = off/SZCHAR; ! 257: return(p); ! 258: ! 259: } ! 260: ! 261: ! 262: static inwd /* current bit offsed in word */; ! 263: static CONSZ word /* word being built from fields */; ! 264: ! 265: incode( p, sz ) register NODE *p; { ! 266: ! 267: /* generate initialization code for assigning a constant c ! 268: to a field of width sz */ ! 269: /* we assume that the proper alignment has been obtained */ ! 270: /* inoff is updated to have the proper final value */ ! 271: /* we also assume sz < SZINT */ ! 272: ! 273: inwd += sz; ! 274: if(inwd > SZINT) cerror("incode: field > int"); ! 275: word |= (p->tn.lval&((1L<<sz)-1)) << (SZINT-inwd); ! 276: inoff += sz; ! 277: if(inoff%SZINT == 0) { ! 278: printf( " .long 0x%X\n", word); ! 279: word = inwd = 0; ! 280: } ! 281: } ! 282: ! 283: fincode( d, sz ) double d; register int sz; { ! 284: /* ! 285: * output code to initialize space of size sz to the value d ! 286: * the proper alignment has been obtained ! 287: * inoff is updated to have the proper final value. ! 288: */ ! 289: ! 290: register struct sh4 { ! 291: unsigned short sh[4]; ! 292: } *x; ! 293: float f; ! 294: ! 295: if(sz == SZFLOAT) { /* force rounding */ ! 296: f = d; ! 297: d = f; ! 298: } ! 299: ! 300: x = (struct sh4 *)&d; ! 301: printf(" .long 0x%04x%04x", x->sh[0], x->sh[1]); ! 302: if(sz == SZDOUBLE) { ! 303: printf(", 0x%04x%04x", x->sh[2], x->sh[3]); ! 304: printf(" # .double %.17g\n", d); ! 305: } else ! 306: printf(" # .float %.8g\n", d); ! 307: inoff += sz; ! 308: } ! 309: ! 310: cinit( p, sz ) NODE *p; { ! 311: NODE *l; ! 312: ! 313: /* ! 314: * as a favor (?) to people who want to write ! 315: * int i = 9600/134.5; ! 316: * we will, under the proper circumstances, do ! 317: * a coersion here. ! 318: */ ! 319: switch (p->in.type) { ! 320: case INT: ! 321: case UNSIGNED: ! 322: l = p->in.left; ! 323: if (l->in.op != SCONV || ! 324: (l->in.left->tn.op != DCON && l->in.left->tn.op != FCON)) ! 325: break; ! 326: l->in.op = FREE; ! 327: l = l->in.left; ! 328: l->tn.lval = l->tn.op == DCON ? (long)(l->dpn.dval) : ! 329: (long)(l->fpn.fval); ! 330: l->tn.rval = NONAME; ! 331: l->tn.op = ICON; ! 332: l->tn.type = INT; ! 333: p->in.left = l; ! 334: break; ! 335: } ! 336: /* arrange for the initialization of p into a space of ! 337: size sz */ ! 338: /* the proper alignment has been opbtained */ ! 339: /* inoff is updated to have the proper final value */ ! 340: ecode( p ); ! 341: inoff += sz; ! 342: } ! 343: ! 344: vfdzero( n ){ /* define n bits of zeros in a vfd */ ! 345: ! 346: if( n <= 0 ) return; ! 347: ! 348: inwd += n; ! 349: inoff += n; ! 350: if( inoff%ALINT ==0 ) { ! 351: printf( " .long 0x%X\n", word ); ! 352: word = inwd = 0; ! 353: } ! 354: } ! 355: ! 356: char * ! 357: exname( p ) char *p; { ! 358: /* make a name look like an external name in the local machine */ ! 359: ! 360: #ifndef FLEXNAMES ! 361: static char text[NCHNAM+1]; ! 362: #else ! 363: static char text[BUFSIZ+1]; ! 364: #endif ! 365: ! 366: register int i; ! 367: ! 368: text[0] = '_'; ! 369: #ifndef FLEXNAMES ! 370: for( i=1; *p&&i<NCHNAM; ++i ) ! 371: #else ! 372: for( i=1; *p; ++i ) ! 373: #endif ! 374: text[i] = *p++; ! 375: ! 376: text[i] = '\0'; ! 377: #ifndef FLEXNAMES ! 378: text[NCHNAM] = '\0'; /* truncate */ ! 379: #endif ! 380: ! 381: return( text ); ! 382: } ! 383: ! 384: ctype( type )TWORD type;{ /* map types which are not defined on the local machine */ ! 385: switch( BTYPE(type) ){ ! 386: ! 387: case LONG: ! 388: MODTYPE(type,INT); ! 389: break; ! 390: ! 391: case ULONG: ! 392: MODTYPE(type,UNSIGNED); ! 393: } ! 394: return( type ); ! 395: } ! 396: ! 397: noinit() { /* curid is a variable which is defined but ! 398: is not initialized (and not a function ); ! 399: This routine returns the stroage class for an uninitialized declaration */ ! 400: ! 401: return(EXTERN); ! 402: ! 403: } ! 404: ! 405: commdec( id ){ /* make a common declaration for id, if reasonable */ ! 406: register struct symtab *q; ! 407: OFFSZ off, tsize(); ! 408: ! 409: q = &stab[id]; ! 410: printf( " .comm %s,", exname( q->sname ) ); ! 411: off = tsize( q->stype, q->dimoff, q->sizoff ); ! 412: printf( "%d\n" /*CONFMT*/, off/SZCHAR ); ! 413: } ! 414: ! 415: prtdcon(p) ! 416: register NODE *p; ! 417: { ! 418: register int o = p->in.op; ! 419: int i; ! 420: ! 421: if (o != DCON && o != FCON) ! 422: return; ! 423: /* ! 424: * Clobber constants of value zero so ! 425: * we can generate more efficient code. ! 426: */ ! 427: if ((o == DCON && p->dpn.dval == 0) || ! 428: (o == FCON && p->fpn.fval == 0)) { ! 429: p->in.op = ICON; ! 430: p->tn.rval = NONAME; ! 431: return; ! 432: } ! 433: locctr(DATA); ! 434: defalign(o == DCON ? ALDOUBLE : ALFLOAT); ! 435: deflab(i = getlab()); ! 436: if (o == FCON) ! 437: fincode(p->fpn.fval, SZFLOAT); ! 438: else ! 439: fincode(p->dpn.dval, SZDOUBLE); ! 440: p->tn.lval = 0; ! 441: p->tn.rval = -i; ! 442: p->in.type = (o == DCON ? DOUBLE : FLOAT); ! 443: p->in.op = NAME; ! 444: } ! 445: ! 446: isitfloat( s ) char *s; { ! 447: union cvt { ! 448: double d; ! 449: int n[2]; ! 450: } cvt; ! 451: double atof(); ! 452: ! 453: /* avoid floating point exception for double -> float conversions */ ! 454: dcon = cvt.d = atof(s); ! 455: if( cvt.n[1] == 0 ){ ! 456: fcon = dcon; ! 457: return( FCON ); ! 458: } ! 459: return( DCON ); ! 460: } ! 461: ! 462: ecode( p ) NODE *p; { ! 463: ! 464: /* walk the tree and write out the nodes.. */ ! 465: ! 466: if( nerrors ) return; ! 467: p2tree( p ); ! 468: p2compile( p ); ! 469: } ! 470: ! 471: #ifndef ONEPASS ! 472: tlen(p) NODE *p; ! 473: { ! 474: switch(p->in.type) { ! 475: case CHAR: ! 476: case UCHAR: ! 477: return(1); ! 478: ! 479: case SHORT: ! 480: case USHORT: ! 481: return(2); ! 482: ! 483: case DOUBLE: ! 484: return(8); ! 485: ! 486: default: ! 487: return(4); ! 488: } ! 489: } ! 490: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.