![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bind.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / c / n0 / i8086|
Return to bind.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / c / n0 / i8086 |
1.1 ! root 1: /* ! 2: * This file contains the machine-specific parts of the parser. ! 3: * It is used in both the SMALL and the LARGE models of segmentation. ! 4: */ ! 5: #ifdef vax ! 6: #include "INC$LIB:cc0.h" ! 7: #else ! 8: #include "cc0.h" ! 9: #endif ! 10: ! 11: typedef struct locals { ! 12: struct locals *l_lstp; ! 13: int l_lofs; ! 14: int l_mask; ! 15: } LOCALS; ! 16: ! 17: LOCALS *clstp; /* Local stack */ ! 18: int clofs; /* Current local offset */ ! 19: int cmask; /* Current mask */ ! 20: int llofs; /* Last local offset reported */ ! 21: int lmask; /* Last register mask reported */ ! 22: int lastword = T_PTR; /* Last 16 bit type */ ! 23: char inbtr[] = "identifier \"%s\" not bound to register"; ! 24: ! 25: /* ! 26: * This table is indexed by C type to obtain the size ! 27: * in bytes of a machine object. ! 28: * The T_PTR entry is 2; this is for ONLYSMALL. ! 29: * The entry is patched based on the model. ! 30: */ ! 31: int mysizes[] = { ! 32: 0, ! 33: 1, 1, ! 34: 2, 2, ! 35: 2, 2, ! 36: 2, ! 37: 4, 4, ! 38: 4, 8, ! 39: 0, ! 40: 0, 0, ! 41: 0, 0, ! 42: 0, 0 ! 43: }; ! 44: ! 45: /* ! 46: * This table is indexed by C type to obtain the machine type, ! 47: * as defined in 'mch.h'. ! 48: */ ! 49: char mytypes[] = { ! 50: 0, ! 51: S8, U8, ! 52: S16, U16, ! 53: S16, U16, ! 54: SPTR, ! 55: S32, U32, ! 56: F32, F64, ! 57: S16, ! 58: BLK, 0, ! 59: BLK, 0, ! 60: 0, 0 ! 61: }; ! 62: ! 63: /* ! 64: * main() calls this routine to perform machine-dependent setup. ! 65: * On the i8086, it changes the size of a pointer and some other things ! 66: * that alter the allocation of register variables. ! 67: */ ! 68: vinit() ! 69: { ! 70: #if !ONLYSMALL ! 71: lastword = T_PTR; ! 72: mysizes[T_PTR] = 2; ! 73: mytypes[T_PTR] = SPTR; ! 74: if (notvariant(VSMALL)) { ! 75: lastword = T_UINT; ! 76: mysizes[T_PTR] = 4; ! 77: mytypes[T_PTR] = LPTR; ! 78: } ! 79: #endif ! 80: } ! 81: ! 82: /* ! 83: * Empty the local binding stack and mark the registers usable ! 84: * for register variables (SI and DI) as available. ! 85: */ ! 86: initlocals() ! 87: { ! 88: clstp = NULL; ! 89: clofs = 0; ! 90: cmask = BCS|BSS|BSP|BBP; ! 91: llofs = 0; ! 92: lmask = BCS|BSS|BSP|BBP; ! 93: bput(AUTOS); ! 94: iput((ival_t)clofs); ! 95: iput((ival_t)cmask); ! 96: } ! 97: ! 98: /* ! 99: * Save the current state of the local bindings. ! 100: */ ! 101: savelocals() ! 102: { ! 103: register LOCALS *lstp; ! 104: ! 105: lstp = (LOCALS *) new(sizeof(LOCALS)); ! 106: lstp->l_lstp = clstp; ! 107: lstp->l_lofs = clofs; ! 108: lstp->l_mask = cmask; ! 109: clstp = lstp; ! 110: } ! 111: ! 112: /* ! 113: * Restore locals. Tell the code generator if it changes. ! 114: */ ! 115: restlocals() ! 116: { ! 117: register LOCALS *lstp; ! 118: ! 119: if ((lstp=clstp) == NULL) ! 120: cbotch("restlocals"); ! 121: clstp = lstp->l_lstp; ! 122: clofs = lstp->l_lofs; ! 123: cmask = lstp->l_mask; ! 124: putautos(); ! 125: free((char *) lstp); ! 126: } ! 127: ! 128: /* ! 129: * Bind locals to the correct place on the stack frame. ! 130: * Where things end up is a function of the model of compilation. ! 131: */ ! 132: bindlocal(sp) ! 133: register SYM *sp; ! 134: { ! 135: register int c, regno; ! 136: ! 137: if ((c=sp->s_class) == C_REG) { ! 138: if ((regno=grabreg(sp)) >= 0) { ! 139: sp->s_value = regno; ! 140: return; ! 141: } ! 142: sp->s_class = C_AUTO; ! 143: if (isvariant(VSNREG)) ! 144: cstrict(inbtr, sp->s_id); ! 145: } ! 146: if (c==C_AUTO || c==C_REG) { ! 147: clofs -= ssize(sp); ! 148: #if OMF286 ! 149: /* ! 150: * The 80287 does not function properly for arguments ! 151: * on odd boundaries. ! 152: * The OMF286 compiler therefore rounds up the offsets ! 153: * of autos to keep them on even boundaries; ! 154: * however, char and unsigned char autos are not word-aligned. ! 155: * The compiler driver must also setvariant(VALIGN) to keep ! 156: * the stack word-aligned. ! 157: * fieldalign() should also keep structure members ! 158: * on word boundaries within the struct, but it does not; ! 159: * this is a kludge to maintain compatability with PL/M-286, ! 160: * which does not word-align structure members. ! 161: * The UDI interface routines fail if structure members ! 162: * are forced to word boundaries. ! 163: */ ! 164: if (ssize(sp) != 1 && (clofs & 1) != 0) ! 165: --clofs; ! 166: #endif ! 167: sp->s_value = clofs; ! 168: if (clofs >= 0) ! 169: cerror("auto \"%s\" is not addressable", sp->s_id); ! 170: } ! 171: } ! 172: ! 173: /* ! 174: * Attempt to get a register for symbol 'sp'. ! 175: * Only word things go in registers; ! 176: * this includes pointers in SMALL model. ! 177: */ ! 178: grabreg(sp) ! 179: register SYM *sp; ! 180: { ! 181: register DIM *dp; ! 182: register int type; ! 183: ! 184: if ((dp=sp->s_dp) != NULL) { ! 185: #if !ONLYSMALL ! 186: if (isvariant(VSMALL)) { ! 187: #endif ! 188: if (dp->d_type == D_PTR) { ! 189: if ((cmask&BSI) == 0) { ! 190: cmask |= BSI; ! 191: return (SI); ! 192: } ! 193: if ((cmask&BDI) == 0) { ! 194: cmask |= BDI; ! 195: return (DI); ! 196: } ! 197: } ! 198: #if !ONLYSMALL ! 199: } ! 200: #endif ! 201: return (-1); ! 202: } ! 203: type = sp->s_type; ! 204: if (type>=T_SHORT && type<=lastword) { ! 205: if ((cmask&BSI) == 0) { ! 206: cmask |= BSI; ! 207: return (SI); ! 208: } ! 209: if ((cmask&BDI) == 0) { ! 210: cmask |= BDI; ! 211: return (DI); ! 212: } ! 213: } ! 214: return (-1); ! 215: } ! 216: ! 217: /* ! 218: * Bind arguments. ! 219: */ ! 220: bindargs() ! 221: { ! 222: register SYM *sp; ! 223: register int i; ! 224: register sizeof_t offset; ! 225: ! 226: #if !ONLYSMALL ! 227: if (isvariant(VSMALL)) ! 228: offset = 8; ! 229: else ! 230: offset = 10; ! 231: #else ! 232: offset = 8; ! 233: #endif ! 234: for (i=0; i<nargs; ++i) { ! 235: sp = args[i]; ! 236: if (sp->s_class != C_PREG) ! 237: sp->s_class = C_PAUTO; ! 238: sp->s_value = offset; ! 239: offset += ssize(sp); ! 240: if (isvariant(VALIGN) && (offset & 1) != 0) ! 241: ++offset; ! 242: if ((short)offset != offset) ! 243: cerror("parameter \"%s\" is not addressible", sp->s_id); ! 244: } ! 245: } ! 246: ! 247: /* ! 248: * Copy register arguments from the stack into the register. ! 249: * Change class of the argument to plain register. ! 250: * Note that bindargs() has put the stack displacement ! 251: * into the 's_value' field of the argument symbol. ! 252: */ ! 253: loadargs() ! 254: { ! 255: register SYM *sp; ! 256: register int i, r, v; ! 257: ! 258: for (i=0; i<nargs; ++i) { ! 259: sp = args[i]; ! 260: if (sp->s_class == C_PREG) { ! 261: if ((r=grabreg(sp)) >= 0) { ! 262: v = sp->s_value; ! 263: sp->s_class = C_REG; ! 264: sp->s_value = r; ! 265: loadreg(sp, v); ! 266: continue; ! 267: } ! 268: sp->s_class = C_PAUTO; ! 269: if (isvariant(VSNREG)) ! 270: cstrict(inbtr, sp->s_id); ! 271: } ! 272: } ! 273: } ! 274: ! 275: /* ! 276: * Load symbol 'sp' from offset 'offset' in the frame. ! 277: * Since register variables are always words, ! 278: * the type can always be setup to T_INT. ! 279: */ ! 280: loadreg(sp, offset) ! 281: SYM *sp; ! 282: { ! 283: register TREE *lp, *rp, *tp; ! 284: ! 285: newtree(sizeof(TREE)); ! 286: lp = talloc(); ! 287: lp->t_op = REG; ! 288: lp->t_type = T_INT; ! 289: lp->t_reg = sp->s_value; ! 290: rp = talloc(); ! 291: rp->t_op = PID; ! 292: rp->t_type = T_INT; ! 293: rp->t_offs = offset; ! 294: tp = build(ASSIGN, lp, rp); ! 295: putautos(); ! 296: tput(EEXPR, 0, tp); ! 297: } ! 298: ! 299: /* ! 300: * Inform the code generator (and perhaps the optimizer) ! 301: * about the current automatic variable allocation. ! 302: * Keep the stack word-aligned if isvariant(VALIGN). ! 303: */ ! 304: putautos() ! 305: { ! 306: if (clofs != llofs || cmask != lmask) { ! 307: if (isvariant(VALIGN) && (clofs & 1) != 0) ! 308: --clofs; ! 309: llofs = clofs; ! 310: lmask = cmask; ! 311: bput(AUTOS); ! 312: iput((ival_t)-clofs); ! 313: iput((ival_t)cmask); ! 314: } ! 315: } ! 316: ! 317: /* ! 318: * Look at type 't', DIM list 'dp' and field width 'w' (0 for non fields) ! 319: * and return the bit offset of the base of the structure member. ! 320: * The 'offset' argument is the current bit offset in the structure or union. ! 321: * Check for fields that are too wide, bad field base types, and arrange ! 322: * that the byte or word that spans the field can be grabbed in one grab. ! 323: * See comments in bindlocal() above concerning reals and bitfield alignment. ! 324: */ ! 325: long ! 326: fieldalign(t, dp, ip, w, offset) ! 327: register DIM *dp; ! 328: INFO *ip; ! 329: register int w; ! 330: long offset; ! 331: { ! 332: register int maxwidth; ! 333: ! 334: if (w != 0) { /* nonzero width */ ! 335: if (dp != 0) ! 336: cerror("non scalar field"); ! 337: if ((maxwidth=8*mysizes[t]) > 16) /* 8 for char, 16 for int */ ! 338: cerror("bad base type for field"); ! 339: if (w > maxwidth) ! 340: cerror("field too wide"); ! 341: if ((offset&7)+w > maxwidth) ! 342: offset = (offset+7) & ~7L; ! 343: } else { /* zero width */ ! 344: offset = (offset+7) & ~7L; ! 345: } ! 346: return (offset); ! 347: } ! 348: ! 349: /* ! 350: * Convert a tree into its low level form. ! 351: * Fill in the machine type byte looking at the C type ! 352: * and the segment information. ! 353: */ ! 354: TREE * ! 355: transform(tp, why, above) ! 356: register TREE *tp; ! 357: { ! 358: register TREE *lp; ! 359: register int t; ! 360: register int wd; ! 361: ! 362: /* ! 363: * The way that this code looks at the DIM lists to decide ! 364: * what type of conversion is inserted makes me sick. ! 365: * The correct type of conversion node (MUL, DIV, etc.) ! 366: * should really be inserted when the tree is constructed, ! 367: * guided by a table. ! 368: */ ! 369: if (tp->t_op == CONVERT) { ! 370: lp = tp->t_lp; ! 371: if (tp->t_dp!=NULL && lp->t_dp==NULL ! 372: && why!=REXPR) { ! 373: tp->t_op = MUL; ! 374: tp->t_dp = NULL; ! 375: if (lp->t_type != T_INT) ! 376: tp->t_lp = bconvert(lp, T_INT, NULL,NULL,NULL); ! 377: tp->t_type = T_INT; ! 378: } else if (tp->t_dp==NULL && lp->t_dp!=NULL && tp->t_rp!=NULL) { ! 379: tp->t_op = DIV; ! 380: lp->t_dp = NULL; ! 381: lp->t_type = T_INT; ! 382: } ! 383: } ! 384: /* Fixup any remaining ZCON's */ ! 385: if (tp->t_op == ZCON) { ! 386: tp->t_op = ICON; ! 387: if (tp->t_zval > 0xFFFFL) ! 388: cwarn("sizeof truncated to unsigned"); ! 389: if (tp->t_zval < 0x8000L) ! 390: tp->t_type = T_INT; ! 391: tp->t_ival = tp->t_zval; ! 392: } ! 393: if (tp->t_dp != NULL) ! 394: tp->t_type = mytypes[T_PTR]; ! 395: else if ((t=tp->t_type)==T_FSTRUCT || t==T_FUNION || t==T_FENUM) { ! 396: unksize(t, tp->t_ip); ! 397: tp->t_type = S16; ! 398: } else { ! 399: if (t == T_ENUM) ! 400: t = tp->t_ip->i_type; ! 401: tp->t_type = mytypes[t]; ! 402: } ! 403: if (tp->t_op >= MIOBASE) { ! 404: wd = why; ! 405: if (why == REXPR) ! 406: wd = EEXPR; ! 407: tp->t_lp = transform(tp->t_lp, wd, tp->t_op); ! 408: if (tp->t_op!=FIELD && tp->t_rp!=NULL) ! 409: tp->t_rp = transform(tp->t_rp, wd, -1); ! 410: if (tp->t_op==CONVERT && tp->t_rp==NULL) { ! 411: lp = tp->t_lp; ! 412: if (tp->t_type == lp->t_type) ! 413: tp = lp; ! 414: } ! 415: } ! 416: return (tp); ! 417: } ! 418: ! 419: /* ! 420: * Check if the operator 'op', when applied to C types 'lt' and 'rt' ! 421: * (which are outputs from tltype(), which means that all pointers ! 422: * have been converted to type T_PTR), involves no conversions. ! 423: * What this means is that the code generator ! 424: * has to be prepared to deal with the type mismatch. ! 425: * This code has been edited too many times; I am really ! 426: * quite ashamed of the number of bugs that have been ! 427: * tracked down to this code. It is no longer amusing. ! 428: */ ! 429: noconvert(op, lt, rt) ! 430: register int op; ! 431: register int lt; ! 432: register int rt; ! 433: { ! 434: if (op==ASSIGN || op==CAST || (op>=EQ && op<=ULT)) { ! 435: if ((lt>=T_CHAR && lt<=T_UCHAR) ! 436: && (rt>=T_CHAR && rt<=T_UCHAR)) ! 437: return(1); ! 438: if ((lt>=T_SHORT && lt<=T_UINT) ! 439: && (rt>=T_SHORT && rt<=T_UINT)) ! 440: return (1); ! 441: if ((lt>=T_LONG && lt<=T_ULONG) ! 442: && (rt>=T_LONG && rt<=T_ULONG)) ! 443: return (1); ! 444: if (lt==T_PTR && rt==T_PTR) ! 445: return (1); ! 446: #if !ONLYSMALL ! 447: if (notvariant(VSMALL) ! 448: && op != CAST) { ! 449: if ((lt>=T_SHORT && lt<=T_ULONG) ! 450: && (rt>=T_SHORT && rt<=T_ULONG) ! 451: && (lt==T_PTR || rt==T_PTR)) ! 452: return (1); ! 453: } else if (isvariant(VSMALL)) { ! 454: #endif ! 455: if ((lt>=T_SHORT && lt<=T_PTR) ! 456: && (rt>=T_SHORT && rt<=T_PTR)) ! 457: return (1); ! 458: #if !ONLYSMALL ! 459: } ! 460: #endif ! 461: if (op==CAST && lt==T_FLOAT && rt==T_DOUBLE) ! 462: return (1); ! 463: } ! 464: return (0); ! 465: } ! 466: ! 467: /* ! 468: * Put out an ALIGN object of the correct flavor to align ! 469: * the location counter well enough for the object to which 'sp' points. ! 470: * On the i8086 there is only one type of alignment, ! 471: * so the argument is unused. ! 472: */ ! 473: align(sp) ! 474: SYM *sp; ! 475: { ! 476: bput(ALIGN); ! 477: bput(0); ! 478: } ! 479: ! 480: /* ! 481: * Check object sizes for overflow. ! 482: */ ! 483: sizeof_t szcheck(n, a, s) sizeof_t n; int a; char *s; ! 484: { ! 485: if (n < 0x10000L) ! 486: return n; ! 487: if (a == 0 || (n & ~MAXUV) != 0) { ! 488: cerror("size of %s too large", s); ! 489: return(0); ! 490: } ! 491: if (isvariant(VSLCON)) ! 492: cstrict("size of %s overflows fsize_t", s); ! 493: return (n); ! 494: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.