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