![[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] / 41BSD / cmd / pcc|
Return to local.c CVS log | Up to [CSRG BSD Unix] / 41BSD / cmd / pcc |
1.1 ! root 1: static char *sccsid ="%W% (Berkeley) %G%"; ! 2: # include "mfile1" ! 3: ! 4: /* this file contains code which is dependent on the target machine */ ! 5: ! 6: NODE * ! 7: cast( p, t ) register NODE *p; TWORD t; { ! 8: /* cast node p to type t */ ! 9: ! 10: p = buildtree( CAST, block( NAME, NIL, NIL, t, 0, (int)t ), p ); ! 11: p->in.left->in.op = FREE; ! 12: p->in.op = FREE; ! 13: return( p->in.right ); ! 14: } ! 15: ! 16: NODE * ! 17: clocal(p) NODE *p; { ! 18: ! 19: /* this is called to do local transformations on ! 20: an expression tree preparitory to its being ! 21: written out in intermediate code. ! 22: */ ! 23: ! 24: /* the major essential job is rewriting the ! 25: automatic variables and arguments in terms of ! 26: REG and OREG nodes */ ! 27: /* conversion ops which are not necessary are also clobbered here */ ! 28: /* in addition, any special features (such as rewriting ! 29: exclusive or) are easily handled here as well */ ! 30: ! 31: register struct symtab *q; ! 32: register NODE *r; ! 33: register o; ! 34: register m, ml; ! 35: ! 36: switch( o = p->in.op ){ ! 37: ! 38: case NAME: ! 39: if( p->tn.rval < 0 ) { /* already processed; ignore... */ ! 40: return(p); ! 41: } ! 42: q = &stab[p->tn.rval]; ! 43: switch( q->sclass ){ ! 44: ! 45: case AUTO: ! 46: case PARAM: ! 47: /* fake up a structure reference */ ! 48: r = block( REG, NIL, NIL, PTR+STRTY, 0, 0 ); ! 49: r->tn.lval = 0; ! 50: r->tn.rval = (q->sclass==AUTO?STKREG:ARGREG); ! 51: p = stref( block( STREF, r, p, 0, 0, 0 ) ); ! 52: break; ! 53: ! 54: case ULABEL: ! 55: case LABEL: ! 56: case STATIC: ! 57: if( q->slevel == 0 ) break; ! 58: p->tn.lval = 0; ! 59: p->tn.rval = -q->offset; ! 60: break; ! 61: ! 62: case REGISTER: ! 63: p->in.op = REG; ! 64: p->tn.lval = 0; ! 65: p->tn.rval = q->offset; ! 66: break; ! 67: ! 68: } ! 69: break; ! 70: ! 71: case PCONV: ! 72: /* do pointer conversions for char and longs */ ! 73: ml = p->in.left->in.type; ! 74: if( ( ml==CHAR || ml==UCHAR || ml==SHORT || ml==USHORT ) && p->in.left->in.op != ICON ) break; ! 75: ! 76: /* pointers all have the same representation; the type is inherited */ ! 77: ! 78: inherit: ! 79: p->in.left->in.type = p->in.type; ! 80: p->in.left->fn.cdim = p->fn.cdim; ! 81: p->in.left->fn.csiz = p->fn.csiz; ! 82: p->in.op = FREE; ! 83: return( p->in.left ); ! 84: ! 85: case SCONV: ! 86: m = (p->in.type == FLOAT || p->in.type == DOUBLE ); ! 87: ml = (p->in.left->in.type == FLOAT || p->in.left->in.type == DOUBLE ); ! 88: if( m != ml ) break; ! 89: ! 90: /* now, look for conversions downwards */ ! 91: ! 92: m = p->in.type; ! 93: ml = p->in.left->in.type; ! 94: if( p->in.left->in.op == ICON ){ /* simulate the conversion here */ ! 95: CONSZ val; ! 96: val = p->in.left->tn.lval; ! 97: switch( m ){ ! 98: case CHAR: ! 99: p->in.left->tn.lval = (char) val; ! 100: break; ! 101: case UCHAR: ! 102: p->in.left->tn.lval = val & 0XFF; ! 103: break; ! 104: case USHORT: ! 105: p->in.left->tn.lval = val & 0XFFFFL; ! 106: break; ! 107: case SHORT: ! 108: p->in.left->tn.lval = (short)val; ! 109: break; ! 110: case UNSIGNED: ! 111: p->in.left->tn.lval = val & 0xFFFFFFFFL; ! 112: break; ! 113: case INT: ! 114: p->in.left->tn.lval = (int)val; ! 115: break; ! 116: } ! 117: p->in.left->in.type = m; ! 118: } ! 119: else { ! 120: /* meaningful ones are conversion of int to char, int to short, ! 121: and short to char, and unsigned version of them */ ! 122: if( m==CHAR || m==UCHAR ){ ! 123: if( ml!=CHAR && ml!= UCHAR ) break; ! 124: } ! 125: else if( m==SHORT || m==USHORT ){ ! 126: if( ml!=CHAR && ml!=UCHAR && ml!=SHORT && ml!=USHORT ) break; ! 127: } ! 128: } ! 129: ! 130: /* clobber conversion */ ! 131: if( tlen(p) == tlen(p->in.left) ) goto inherit; ! 132: p->in.op = FREE; ! 133: return( p->in.left ); /* conversion gets clobbered */ ! 134: ! 135: case PVCONV: ! 136: case PMCONV: ! 137: if( p->in.right->in.op != ICON ) cerror( "bad conversion", 0); ! 138: p->in.op = FREE; ! 139: return( buildtree( o==PMCONV?MUL:DIV, p->in.left, p->in.right ) ); ! 140: ! 141: case RS: ! 142: case ASG RS: ! 143: /* convert >> to << with negative shift count */ ! 144: /* only if type of left operand is not unsigned */ ! 145: ! 146: if( ISUNSIGNED(p->in.left->in.type) ) break; ! 147: p->in.right = buildtree( UNARY MINUS, p->in.right, NIL ); ! 148: if( p->in.op == RS ) p->in.op = LS; ! 149: else p->in.op = ASG LS; ! 150: break; ! 151: ! 152: case FLD: ! 153: /* make sure that the second pass does not make the ! 154: descendant of a FLD operator into a doubly indexed OREG */ ! 155: ! 156: if( p->in.left->in.op == UNARY MUL ! 157: && (r=p->in.left->in.left)->in.op == PCONV) ! 158: if( r->in.left->in.op == PLUS || r->in.left->in.op == MINUS ) ! 159: if( ISPTR(r->in.type) ) { ! 160: if( ISUNSIGNED(p->in.left->in.type) ) ! 161: p->in.left->in.type = UCHAR; ! 162: else ! 163: p->in.left->in.type = CHAR; ! 164: } ! 165: break; ! 166: } ! 167: ! 168: return(p); ! 169: } ! 170: ! 171: andable( p ) NODE *p; { ! 172: return(1); /* all names can have & taken on them */ ! 173: } ! 174: ! 175: cendarg(){ /* at the end of the arguments of a ftn, set the automatic offset */ ! 176: autooff = AUTOINIT; ! 177: } ! 178: ! 179: cisreg( t ) TWORD t; { /* is an automatic variable of type t OK for a register variable */ ! 180: ! 181: #ifdef TRUST_REG_CHAR_AND_REG_SHORT ! 182: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* tbl */ ! 183: || t==CHAR || t==UCHAR || t==SHORT /* tbl */ ! 184: || t==USHORT || ISPTR(t)) return(1); /* tbl */ ! 185: #else ! 186: if( t==INT || t==UNSIGNED || t==LONG || t==ULONG /* wnj */ ! 187: || ISPTR(t)) return (1); /* wnj */ ! 188: #endif ! 189: return(0); ! 190: } ! 191: ! 192: NODE * ! 193: offcon( off, t, d, s ) OFFSZ off; TWORD t; { ! 194: ! 195: /* return a node, for structure references, which is suitable for ! 196: being added to a pointer of type t, in order to be off bits offset ! 197: into a structure */ ! 198: ! 199: register NODE *p; ! 200: ! 201: /* t, d, and s are the type, dimension offset, and sizeoffset */ ! 202: /* in general they are necessary for offcon, but not on H'well */ ! 203: ! 204: p = bcon(0); ! 205: p->tn.lval = off/SZCHAR; ! 206: return(p); ! 207: ! 208: } ! 209: ! 210: ! 211: static inwd /* current bit offsed in word */; ! 212: static word /* word being built from fields */; ! 213: ! 214: incode( p, sz ) register NODE *p; { ! 215: ! 216: /* generate initialization code for assigning a constant c ! 217: to a field of width sz */ ! 218: /* we assume that the proper alignment has been obtained */ ! 219: /* inoff is updated to have the proper final value */ ! 220: /* we also assume sz < SZINT */ ! 221: ! 222: if((sz+inwd) > SZINT) cerror("incode: field > int"); ! 223: word |= ((unsigned)(p->tn.lval<<(32-sz))) >> (32-sz-inwd); ! 224: inwd += sz; ! 225: inoff += sz; ! 226: if(inoff%SZINT == 0) { ! 227: printf( " .long 0x%x\n", word); ! 228: word = inwd = 0; ! 229: } ! 230: } ! 231: ! 232: fincode( d, sz ) double d; { ! 233: /* output code to initialize space of size sz to the value d */ ! 234: /* the proper alignment has been obtained */ ! 235: /* inoff is updated to have the proper final value */ ! 236: /* on the target machine, write it out in octal! */ ! 237: ! 238: ! 239: printf(" %s 0%c%.20e\n", sz == SZDOUBLE ? ".double" : ".float", ! 240: sz == SZDOUBLE ? 'd' : 'f', d); ! 241: inoff += sz; ! 242: } ! 243: ! 244: cinit( p, sz ) NODE *p; { ! 245: /* arrange for the initialization of p into a space of ! 246: size sz */ ! 247: /* the proper alignment has been opbtained */ ! 248: /* inoff is updated to have the proper final value */ ! 249: ecode( p ); ! 250: inoff += sz; ! 251: } ! 252: ! 253: vfdzero( n ){ /* define n bits of zeros in a vfd */ ! 254: ! 255: if( n <= 0 ) return; ! 256: ! 257: inwd += n; ! 258: inoff += n; ! 259: if( inoff%ALINT ==0 ) { ! 260: printf( " .long 0x%x\n", word ); ! 261: word = inwd = 0; ! 262: } ! 263: } ! 264: ! 265: char * ! 266: exname( p ) char *p; { ! 267: /* make a name look like an external name in the local machine */ ! 268: ! 269: #ifndef FLEXNAMES ! 270: static char text[NCHNAM+1]; ! 271: #else ! 272: static char text[BUFSIZ+1]; ! 273: #endif ! 274: ! 275: register i; ! 276: ! 277: text[0] = '_'; ! 278: #ifndef FLEXNAMES ! 279: for( i=1; *p&&i<NCHNAM; ++i ){ ! 280: #else ! 281: for( i=1; *p; ++i ){ ! 282: #endif ! 283: text[i] = *p++; ! 284: } ! 285: ! 286: text[i] = '\0'; ! 287: #ifndef FLEXNAMES ! 288: text[NCHNAM] = '\0'; /* truncate */ ! 289: #endif ! 290: ! 291: return( text ); ! 292: } ! 293: ! 294: ctype( type ){ /* map types which are not defined on the local machine */ ! 295: switch( BTYPE(type) ){ ! 296: ! 297: case LONG: ! 298: MODTYPE(type,INT); ! 299: break; ! 300: ! 301: case ULONG: ! 302: MODTYPE(type,UNSIGNED); ! 303: } ! 304: return( type ); ! 305: } ! 306: ! 307: noinit( t ) { /* curid is a variable which is defined but ! 308: is not initialized (and not a function ); ! 309: This routine returns the stroage class for an uninitialized declaration */ ! 310: ! 311: return(EXTERN); ! 312: ! 313: } ! 314: ! 315: commdec( id ){ /* make a common declaration for id, if reasonable */ ! 316: register struct symtab *q; ! 317: OFFSZ off, tsize(); ! 318: ! 319: q = &stab[id]; ! 320: printf( " .comm %s,", exname( q->sname ) ); ! 321: off = tsize( q->stype, q->dimoff, q->sizoff ); ! 322: printf( CONFMT, off/SZCHAR ); ! 323: printf( "\n" ); ! 324: } ! 325: ! 326: isitlong( cb, ce ){ /* is lastcon to be long or short */ ! 327: /* cb is the first character of the representation, ce the last */ ! 328: ! 329: if( ce == 'l' || ce == 'L' || ! 330: lastcon >= (1L << (SZINT-1) ) ) return (1); ! 331: return(0); ! 332: } ! 333: ! 334: ! 335: isitfloat( s ) char *s; { ! 336: double atof(); ! 337: dcon = atof(s); ! 338: return( FCON ); ! 339: } ! 340: ! 341: ecode( p ) NODE *p; { ! 342: ! 343: /* walk the tree and write out the nodes.. */ ! 344: ! 345: if( nerrors ) return; ! 346: p2tree( p ); ! 347: p2compile( p ); ! 348: } ! 349: ! 350: #include <sys/types.h> ! 351: #include <a.out.h> ! 352: #include <stab.h> ! 353: extern int ddebug; ! 354: extern int gdebug; ! 355: ! 356: fixarg(p) ! 357: struct symtab *p; { ! 358: pstab(p->sname, N_PSYM); ! 359: if (gdebug) printf("0,%d,%d\n", p->stype, argoff/SZCHAR); ! 360: poffs(p); ! 361: } ! 362: int stabLCSYM; ! 363: ! 364: outstab(p) ! 365: struct symtab *p; { ! 366: register TWORD ptype; ! 367: register char *pname; ! 368: register char pclass; ! 369: register int poffset; ! 370: ! 371: if (!gdebug) return; ! 372: ! 373: ptype = p->stype; ! 374: pname = p->sname; ! 375: pclass = p->sclass; ! 376: poffset = p->offset; ! 377: ! 378: if (ISFTN(ptype)) { ! 379: return; ! 380: } ! 381: ! 382: switch (pclass) { ! 383: ! 384: case AUTO: ! 385: pstab(pname, N_LSYM); ! 386: printf("0,%d,%d\n", ptype, (-poffset)/SZCHAR); ! 387: poffs(p); ! 388: return; ! 389: ! 390: case EXTDEF: ! 391: case EXTERN: ! 392: pstab(pname, N_GSYM); ! 393: printf("0,%d,0\n", ptype); ! 394: poffs(p); ! 395: return; ! 396: ! 397: case STATIC: ! 398: #ifdef LCOMM ! 399: /* stabLCSYM is 1 during nidcl so we can get stab type right */ ! 400: pstab(pname, stabLCSYM ? N_LCSYM : N_STSYM); ! 401: #else ! 402: pstab(pname, N_STSYM); ! 403: #endif ! 404: if (p->slevel > 1) { ! 405: printf("0,%d,L%d\n", ptype, poffset); ! 406: } else { ! 407: printf("0,%d,%s\n", ptype, exname(pname)); ! 408: } ! 409: poffs(p); ! 410: return; ! 411: ! 412: case REGISTER: ! 413: pstab(pname, N_RSYM); ! 414: printf("0,%d,%d\n", ptype, poffset); ! 415: poffs(p); ! 416: return; ! 417: ! 418: case MOS: ! 419: case MOU: ! 420: pstab(pname, N_SSYM); ! 421: printf("0,%d,%d\n", ptype, poffset/SZCHAR); ! 422: poffs(p); ! 423: return; ! 424: ! 425: case PARAM: ! 426: /* parameter stab entries are processed in dclargs() */ ! 427: return; ! 428: ! 429: default: ! 430: #ifndef FLEXNAMES ! 431: if (ddebug) printf(" No .stab for %.8s\n", pname); ! 432: #else ! 433: if (ddebug) printf(" No .stab for %s\n", pname); ! 434: #endif ! 435: ! 436: } ! 437: } ! 438: ! 439: pstab(name, type) ! 440: char *name; ! 441: int type; { ! 442: register int i; ! 443: register char c; ! 444: if (!gdebug) return; ! 445: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 446: #ifdef ASSTRINGS ! 447: if ( name[0] == '\0') ! 448: printf("\t.stabn\t"); ! 449: else ! 450: #ifndef FLEXNAMES ! 451: printf("\t.stabs\t\"%.8s\", ", name); ! 452: #else ! 453: printf("\t.stabs\t\"%s\", ", name); ! 454: #endif ! 455: #else ! 456: printf(" .stab "); ! 457: for(i=0; i<8; i++) ! 458: if (c = name[i]) printf("'%c,", c); ! 459: else printf("0,"); ! 460: #endif ! 461: printf("0%o,", type); ! 462: } ! 463: ! 464: #ifdef STABDOT ! 465: pstabdot(type, value) ! 466: int type; ! 467: int value; ! 468: { ! 469: if ( ! gdebug) return; ! 470: /* locctr(PROG); /* .stabs must appear in .text for c2 */ ! 471: printf("\t.stabd\t"); ! 472: printf("0%o,0,0%o\n",type, value); ! 473: } ! 474: #endif ! 475: ! 476: poffs(p) ! 477: register struct symtab *p; { ! 478: int s; ! 479: if (!gdebug) return; ! 480: if ((s = dimtab[p->sizoff]/SZCHAR) > 1) { ! 481: pstab(p->sname, N_LENG); ! 482: printf("1,0,%d\n", s); ! 483: } ! 484: } ! 485: ! 486: extern char NULLNAME[8]; ! 487: extern int labelno; ! 488: extern int fdefflag; ! 489: ! 490: psline() { ! 491: static int lastlineno; ! 492: register char *cp, *cq; ! 493: register int i; ! 494: ! 495: if (!gdebug) return; ! 496: ! 497: cq = ititle; ! 498: cp = ftitle; ! 499: ! 500: while ( *cq ) if ( *cp++ != *cq++ ) goto neq; ! 501: if ( *cp == '\0' ) goto eq; ! 502: ! 503: neq: for (i=0; i<100; i++) ! 504: ititle[i] = '\0'; ! 505: cp = ftitle; ! 506: cq = ititle; ! 507: while ( *cp ) ! 508: *cq++ = *cp++; ! 509: *cq = '\0'; ! 510: *--cq = '\0'; ! 511: #ifndef FLEXNAMES ! 512: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 513: pstab(cp, N_SOL); ! 514: if (gdebug) printf("0,0,LL%d\n", labelno); ! 515: } ! 516: #else ! 517: pstab(ititle+1, N_SOL); ! 518: if (gdebug) printf("0,0,LL%d\n", labelno); ! 519: #endif ! 520: *cq = '"'; ! 521: printf("LL%d:\n", labelno++); ! 522: ! 523: eq: if (lineno == lastlineno) return; ! 524: lastlineno = lineno; ! 525: ! 526: if (fdefflag) { ! 527: #ifdef STABDOT ! 528: pstabdot(N_SLINE, lineno); ! 529: #else ! 530: pstab(NULLNAME, N_SLINE); ! 531: printf("0,%d,LL%d\n", lineno, labelno); ! 532: printf("LL%d:\n", labelno++); ! 533: #endif ! 534: } ! 535: } ! 536: ! 537: plcstab(level) { ! 538: if (!gdebug) return; ! 539: #ifdef STABDOT ! 540: pstabdot(N_LBRAC, level); ! 541: #else ! 542: pstab(NULLNAME, N_LBRAC); ! 543: printf("0,%d,LL%d\n", level, labelno); ! 544: printf("LL%d:\n", labelno++); ! 545: #endif ! 546: } ! 547: ! 548: prcstab(level) { ! 549: if (!gdebug) return; ! 550: #ifdef STABDOT ! 551: pstabdot(N_RBRAC, level); ! 552: #else ! 553: pstab(NULLNAME, N_RBRAC); ! 554: printf("0,%d,LL%d\n", level, labelno); ! 555: printf("LL%d:\n", labelno++); ! 556: #endif ! 557: } ! 558: ! 559: pfstab(sname) ! 560: char *sname; { ! 561: if (!gdebug) return; ! 562: pstab(sname, N_FUN); ! 563: #ifndef FLEXNAMES ! 564: printf("0,%d,_%.7s\n", lineno, sname); ! 565: #else ! 566: printf("0,%d,_%s\n", lineno, sname); ! 567: #endif ! 568: } ! 569: ! 570: #ifndef ONEPASS ! 571: tlen(p) NODE *p; ! 572: { ! 573: switch(p->in.type) { ! 574: case CHAR: ! 575: case UCHAR: ! 576: return(1); ! 577: ! 578: case SHORT: ! 579: case USHORT: ! 580: return(2); ! 581: ! 582: case DOUBLE: ! 583: return(8); ! 584: ! 585: default: ! 586: return(4); ! 587: } ! 588: } ! 589: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.