2.9BSD - /usr/src/cmd/mip/trees.c

   1: # include "mfile1"
   2: 
   3: /*	some special actions, used in finding the type of nodes */
   4: # define NCVT 01
   5: # define PUN 02
   6: # define TYPL 04
   7: # define TYPR 010
   8: # define TYMATCH 040
   9: # define LVAL 0100
  10: # define CVTO 0200
  11: # define CVTL 0400
  12: # define CVTR 01000
  13: # define PTMATCH 02000
  14: # define OTHER 04000
  15: # define NCVTR 010000
  16: 
  17: /* node conventions:
  18: 
  19: 	NAME:	rval>0 is stab index for external
  20: 		rval<0 is -inlabel number
  21: 		lval is offset in bits
  22: 	ICON:	lval has the value
  23: 		rval has the STAB index, or - label number,
  24: 			if a name whose address is in the constant
  25: 		rval = NONAME means no name
  26: 	REG:	rval is reg. identification cookie
  27: 
  28: 	*/
  29: 
  30: int bdebug = 0;
  31: 
  32: NODE *
  33: buildtree( o, l, r ) register NODE *l, *r; {
  34:     register NODE *p, *q;
  35:     register actions;
  36:     register opty;
  37:     register struct symtab *sp;
  38:     register NODE *lr, *ll;
  39:     int i;
  40:     extern int eprint();
  41: 
  42:     if( bdebug ) printf( "buildtree( %s, %o, %o )\n", opst[o], l, r );
  43:     opty = optype(o);
  44: 
  45:     /* check for constants */
  46: 
  47:     if( opty == UTYPE && l->op == ICON ){
  48: 
  49:         switch( o ){
  50: 
  51:         case NOT:
  52:             if( hflag ) werror( "constant argument to NOT" );
  53:         case UNARY MINUS:
  54:         case COMPL:
  55:             if( conval( l, o, l ) ) return(l);
  56:             break;
  57: 
  58:             }
  59:         }
  60: 
  61:     else if( o==UNARY MINUS && l->op==FCON ){
  62:         l->dval = -l->dval;
  63:         return(l);
  64:         }
  65: 
  66:     else if( o==QUEST && l->op==ICON ) {
  67:         l->op = FREE;
  68:         r->op = FREE;
  69:         if( l->lval ){
  70:             tfree( r->right );
  71:             return( r->left );
  72:             }
  73:         else {
  74:             tfree( r->left );
  75:             return( r->right );
  76:             }
  77:         }
  78: 
  79:     else if( (o==ANDAND || o==OROR) && (l->op==ICON||r->op==ICON) ) goto ccwarn;
  80: 
  81:     else if( opty == BITYPE && l->op == ICON && r->op == ICON ){
  82: 
  83:         switch( o ){
  84: 
  85:         case ULT:
  86:         case UGT:
  87:         case ULE:
  88:         case UGE:
  89:         case LT:
  90:         case GT:
  91:         case LE:
  92:         case GE:
  93:         case EQ:
  94:         case NE:
  95:         case ANDAND:
  96:         case OROR:
  97:         case CBRANCH:
  98: 
  99:         ccwarn:
 100:             if( hflag ) werror( "constant in conditional context" );
 101: 
 102:         case PLUS:
 103:         case MINUS:
 104:         case MUL:
 105:         case DIV:
 106:         case MOD:
 107:         case AND:
 108:         case OR:
 109:         case ER:
 110:         case LS:
 111:         case RS:
 112:             if( conval( l, o, r ) ) {
 113:                 r->op = FREE;
 114:                 return(l);
 115:                 }
 116:             break;
 117:             }
 118:         }
 119: 
 120:     else if( opty == BITYPE && (l->op==FCON||l->op==ICON) &&
 121:         (r->op==FCON||r->op==ICON) ){
 122:         switch(o){
 123:         case PLUS:
 124:         case MINUS:
 125:         case MUL:
 126:         case DIV:
 127:             if( l->op == ICON ){
 128:                 l->dval = l->lval;
 129:                 }
 130:             if( r->op == ICON ){
 131:                 r->dval = r->lval;
 132:                 }
 133:             l->op = FCON;
 134:             l->type = l->csiz = DOUBLE;
 135:             r->op = FREE;
 136:             switch(o){
 137:             case PLUS:
 138:                 l->dval += r->dval;
 139:                 return(l);
 140:             case MINUS:
 141:                 l->dval -= r->dval;
 142:                 return(l);
 143:             case MUL:
 144:                 l->dval *= r->dval;
 145:                 return(l);
 146:             case DIV:
 147:                 if( r->dval == 0 ) uerror( "division by 0." );
 148:                 else l->dval /= r->dval;
 149:                 return(l);
 150:                 }
 151:             }
 152:         }
 153: 
 154:     /* its real; we must make a new node */
 155: 
 156:     p = block( o, l, r, INT, 0, INT );
 157: 
 158:     actions = opact(p);
 159: 
 160:     if( actions&LVAL ){ /* check left descendent */
 161:         if( notlval(p->left) ) {
 162:             uerror( "lvalue required" );
 163:             }
 164:         }
 165: 
 166:     if( actions & NCVTR ){
 167:         p->left = pconvert( p->left );
 168:         }
 169:     else if( !(actions & NCVT ) ){
 170:         switch( opty ){
 171: 
 172:         case BITYPE:
 173:             p->right = pconvert( p->right );
 174:         case UTYPE:
 175:             p->left = pconvert( p->left );
 176: 
 177:             }
 178:         }
 179: 
 180:     if( (actions&PUN) && (o!=CAST||cflag) ){
 181:         chkpun(p);
 182:         }
 183: 
 184:     if( actions & (TYPL|TYPR) ){
 185: 
 186:         q = (actions&TYPL) ? p->left : p->right;
 187: 
 188:         p->type = q->type;
 189:         p->cdim = q->cdim;
 190:         p->csiz = q->csiz;
 191:         }
 192: 
 193:     if( actions & CVTL ) p = convert( p, CVTL );
 194:     if( actions & CVTR ) p = convert( p, CVTR );
 195:     if( actions & TYMATCH ) p = tymatch(p);
 196:     if( actions & PTMATCH ) p = ptmatch(p);
 197: 
 198:     if( actions & OTHER ){
 199:         l = p->left;
 200:         r = p->right;
 201: 
 202:         switch(o){
 203: 
 204:         case NAME:
 205:             sp = &stab[idname];
 206:             if( sp->stype == UNDEF ){
 207:                 uerror( "%.8s undefined", sp->sname );
 208:                 /* make p look reasonable */
 209:                 p->type = p->cdim = p->csiz = INT;
 210:                 p->rval = idname;
 211:                 p->lval = 0;
 212:                 defid( p, SNULL );
 213:                 break;
 214:                 }
 215:             p->type = sp->stype;
 216:             p->cdim = sp->dimoff;
 217:             p->csiz = sp->sizoff;
 218:             p->lval = 0;
 219:             p->rval = idname;
 220:             /* special case: MOETY is really an ICON... */
 221:             if( p->type == MOETY ){
 222:                 p->rval = NONAME;
 223:                 p->lval = sp->offset;
 224:                 p->cdim = 0;
 225:                 p->type = ENUMTY;
 226:                 p->op = ICON;
 227:                 }
 228:             break;
 229: 
 230:         case ICON:
 231:             p->type = INT;
 232:             p->cdim = 0;
 233:             p->csiz = INT;
 234:             break;
 235: 
 236:         case STRING:
 237:             p->op = NAME;
 238:             p->type = CHAR+ARY;
 239:             p->lval = 0;
 240:             p->rval = NOLAB;
 241:             p->cdim = curdim;
 242:             p->csiz = CHAR;
 243:             break;
 244: 
 245:         case FCON:
 246:             p->lval = 0;
 247:             p->rval = 0;
 248:             p->type = DOUBLE;
 249:             p->cdim = 0;
 250:             p->csiz = DOUBLE;
 251:             break;
 252: 
 253:         case STREF:
 254:             /* p->x turned into *(p+offset) */
 255:             /* rhs must be a name; check correctness */
 256: 
 257:             i = r->rval;
 258:             if( i<0 || ((sp= &stab[i])->sclass != MOS && sp->sclass != MOU && !(sp->sclass&FIELD)) ){
 259:                 uerror( "member of structure or union required" );
 260:                 }
 261:             else {
 262:                 register j;
 263:                 if( l->type != PTR+STRTY && l->type != PTR+UNIONTY ){
 264:                     werror( "struct/union or struct/union pointer required" );
 265:                     }
 266:                 else if( (j=l->csiz+1)<0 ) cerror( "undefined structure or union" );
 267:                 else if( !chkstr( i, dimtab[j], DECREF(l->type) ) ){
 268:                     werror( "illegal member use: %.8s", stab[i].sname );
 269:                     }
 270:                 }
 271: 
 272:             p = stref( p );
 273:             break;
 274: 
 275:         case UNARY MUL:
 276:             if( l->op == UNARY AND ){
 277:                 p->op = l->op = FREE;
 278:                 p = l->left;
 279:                 }
 280:             if( !ISPTR(l->type))uerror("illegal indirection");
 281:             p->type = DECREF(l->type);
 282:             p->cdim = l->cdim;
 283:             p->csiz = l->csiz;
 284:             break;
 285: 
 286:         case UNARY AND:
 287:             switch( l->op ){
 288: 
 289:             case UNARY MUL:
 290:                 p->op = l->op = FREE;
 291:                 p = l->left;
 292:             case NAME:
 293:                 p->type = INCREF( l->type );
 294:                 p->cdim = l->cdim;
 295:                 p->csiz = l->csiz;
 296:                 break;
 297: 
 298:             case COMOP:
 299:                 lr = buildtree( UNARY AND, l->right, NIL );
 300:                 p->op = l->op = FREE;
 301:                 p = buildtree( COMOP, l->left, lr );
 302:                 break;
 303: 
 304:             case QUEST:
 305:                 lr = buildtree( UNARY AND, l->right->right, NIL );
 306:                 ll = buildtree( UNARY AND, l->right->left, NIL );
 307:                 p->op = l->op = l->right->op = FREE;
 308:                 p = buildtree( QUEST, l->left, buildtree( COLON, ll, lr ) );
 309:                 break;
 310: 
 311:             default:
 312:                 uerror( "unacceptable operand of &" );
 313:                 break;
 314:                 }
 315:             break;
 316: 
 317:         case LS:
 318:         case RS:
 319:         case ASG LS:
 320:         case ASG RS:
 321:             if(tsize(p->right->type, p->right->cdim, p->right->csiz) > SZINT)
 322:                 p->right = makety(p->right, INT, 0, INT );
 323:             break;
 324: 
 325:         case RETURN:
 326:         case ASSIGN:
 327:         case CAST:
 328:             /* structure assignment */
 329:             /* take the addresses of the two sides; then make an
 330: 			/* operator using STASG and
 331: 			/* the addresses of left and right */
 332: 
 333:             {
 334:                 register TWORD t;
 335:                 register d, s;
 336: 
 337:                 if( l->csiz != r->csiz ) uerror( "assignment of different structures" );
 338: 
 339:                 r = buildtree( UNARY AND, r, NIL );
 340:                 t = r->type;
 341:                 d = r->cdim;
 342:                 s = r->csiz;
 343: 
 344:                 l = block( STASG, l, r, t, d, s );
 345: 
 346:                 if( o == RETURN ){
 347:                     p->op = FREE;
 348:                     p = l;
 349:                     break;
 350:                     }
 351: 
 352:                 p->op = UNARY MUL;
 353:                 p->left = l;
 354:                 p->right = NIL;
 355:                 break;
 356:                 }
 357:         case COLON:
 358:             /* structure colon */
 359: 
 360:             if( l->csiz != r->csiz ) uerror( "type clash in conditional" );
 361:             break;
 362: 
 363:         case CALL:
 364:             p->right = r = strargs( p->right );
 365:         case UNARY CALL:
 366:             if( !ISPTR(l->type)) uerror("illegal function");
 367:             p->type = DECREF(l->type);
 368:             if( !ISFTN(p->type)) uerror("illegal function");
 369:             p->type = DECREF( p->type );
 370:             p->cdim = l->cdim;
 371:             p->csiz = l->csiz;
 372:             if( l->op == UNARY AND && l->left->op == NAME &&
 373:                 l->left->rval >= 0 && l->left->rval != NONAME &&
 374:                 ( (i=stab[l->left->rval].sclass) == FORTRAN || i==UFORTRAN ) ){
 375:                 p->op += (FORTCALL-CALL);
 376:                 }
 377:             if( p->type == STRTY || p->type == UNIONTY ){
 378:                 /* function returning structure */
 379:                 /*  make function really return ptr to str., with * */
 380: 
 381:                 p->op += STCALL-CALL;
 382:                 p->type = INCREF( p->type );
 383:                 p = buildtree( UNARY MUL, p, NIL );
 384: 
 385:                 }
 386:             break;
 387: 
 388:         default:
 389:             cerror( "other code %d", o );
 390:             }
 391: 
 392:         }
 393: 
 394:     if( actions & CVTO ) p = oconvert(p);
 395:     p = clocal(p);
 396: 
 397:     if( bdebug ) fwalk( p, eprint, 0 );
 398: 
 399:     return(p);
 400: 
 401:     }
 402: 
 403: NODE *
 404: strargs( p ) register NODE *p;  { /* rewrite structure flavored arguments */
 405: 
 406:     if( p->op == CM ){
 407:         p->left = strargs( p->left );
 408:         p->right = strargs( p->right );
 409:         return( p );
 410:         }
 411: 
 412:     if( p->type == STRTY || p->type == UNIONTY ){
 413:         p = block( STARG, p, NIL, p->type, p->cdim, p->csiz );
 414:         p->left = buildtree( UNARY AND, p->left, NIL );
 415:         p = clocal(p);
 416:         }
 417:     return( p );
 418:     }
 419: 
 420: chkstr( i, j, type ) TWORD type; {
 421:     /* is the MOS or MOU at stab[i] OK for strict reference by a ptr */
 422:     /* i has been checked to contain a MOS or MOU */
 423:     /* j is the index in dimtab of the members... */
 424:     int k, kk;
 425: 
 426:     extern int ddebug;
 427: 
 428:     if( ddebug > 1 ) printf( "chkstr( %.8s(%d), %d )\n", stab[i].sname, i, j );
 429:     if( (k = j) < 0 ) uerror( "undefined structure or union" );
 430:     else {
 431:         for( ; (kk = dimtab[k] ) >= 0; ++k ){
 432:             if( kk >= SYMTSZ ){
 433:                 cerror( "gummy structure" );
 434:                 return(1);
 435:                 }
 436:             if( kk == i ) return( 1 );
 437:             switch( stab[kk].stype ){
 438: 
 439:             case STRTY:
 440:             case UNIONTY:
 441:                 if( type == STRTY ) continue;  /* no recursive looking for strs */
 442:                 if( chkstr( i, dimtab[stab[kk].sizoff+1], stab[kk].stype ) ) return(1);
 443:                 }
 444:             }
 445:         }
 446:     return( 0 );
 447:     }
 448: 
 449: conval( p, o, q ) register NODE *p, *q; {
 450:     /* apply the op o to the lval part of p; if binary, rhs is val */
 451:     int i, u;
 452:     CONSZ val;
 453: 
 454:     val = q->lval;
 455:     u = ISUNSIGNED(p->type) || ISUNSIGNED(q->type);
 456:     if( u && (o==LE||o==LT||o==GE||o==GT)) o += (UGE-GE);
 457: 
 458:     if( p->rval != NONAME && q->rval != NONAME ) return(0);
 459:     if( q->rval != NONAME && o!=PLUS ) return(0);
 460:     if( p->rval != NONAME && o!=PLUS && o!=MINUS ) return(0);
 461: 
 462:     switch( o ){
 463: 
 464:     case PLUS:
 465:         p->lval += val;
 466:         if( p->rval == NONAME ){
 467:             p->rval = q->rval;
 468:             p->type = q->type;
 469:             }
 470:         break;
 471:     case MINUS:
 472:         p->lval -= val;
 473:         break;
 474:     case MUL:
 475:         p->lval *= val;
 476:         break;
 477:     case DIV:
 478:         if( val == 0 ) uerror( "division by 0" );
 479:         else p->lval /= val;
 480:         break;
 481:     case MOD:
 482:         if( val == 0 ) uerror( "division by 0" );
 483:         else p->lval %= val;
 484:         break;
 485:     case AND:
 486:         p->lval &= val;
 487:         break;
 488:     case OR:
 489:         p->lval |= val;
 490:         break;
 491:     case ER:
 492:         p->lval ^=  val;
 493:         break;
 494:     case LS:
 495:         i = val;
 496:         p->lval = p->lval << i;
 497:         break;
 498:     case RS:
 499:         i = val;
 500:         p->lval = p->lval >> i;
 501:         break;
 502: 
 503:     case UNARY MINUS:
 504:         p->lval = - p->lval;
 505:         break;
 506:     case COMPL:
 507:         p->lval = ~p->lval;
 508:         break;
 509:     case NOT:
 510:         p->lval = !p->lval;
 511:         break;
 512:     case LT:
 513:         p->lval = p->lval < val;
 514:         break;
 515:     case LE:
 516:         p->lval = p->lval <= val;
 517:         break;
 518:     case GT:
 519:         p->lval = p->lval > val;
 520:         break;
 521:     case GE:
 522:         p->lval = p->lval >= val;
 523:         break;
 524:     case ULT:
 525:         p->lval = (p->lval-val)<0;
 526:         break;
 527:     case ULE:
 528:         p->lval = (p->lval-val)<=0;
 529:         break;
 530:     case UGE:
 531:         p->lval = (p->lval-val)>=0;
 532:         break;
 533:     case UGT:
 534:         p->lval = (p->lval-val)>0;
 535:         break;
 536:     case EQ:
 537:         p->lval = p->lval == val;
 538:         break;
 539:     case NE:
 540:         p->lval = p->lval != val;
 541:         break;
 542:     default:
 543:         return(0);
 544:         }
 545:     return(1);
 546:     }
 547: 
 548: chkpun(p) register NODE *p; {
 549: 
 550:     /* checks p for the existance of a pun */
 551: 
 552:     /* this is called when the op of p is ASSIGN, RETURN, CAST, COLON, or relational */
 553: 
 554:     /* one case is when enumerations are used: this applies only to lint */
 555:     /* in the other case, one operand is a pointer, the other integer type */
 556:     /* we check that this integer is in fact a constant zero... */
 557: 
 558:     /* in the case of ASSIGN, any assignment of pointer to integer is illegal */
 559:     /* this falls out, because the LHS is never 0 */
 560: 
 561:     register NODE *q;
 562:     register t1, t2;
 563:     register d1, d2;
 564: 
 565:     t1 = p->left->type;
 566:     t2 = p->right->type;
 567: 
 568:     if( t1==ENUMTY || t2==ENUMTY ) { /* check for enumerations */
 569:         if( logop( p->op ) && p->op != EQ && p->op != NE ) {
 570:             uerror( "illegal comparison of enums" );
 571:             return;
 572:             }
 573:         if( t1==ENUMTY && t2==ENUMTY && p->left->csiz==p->right->csiz ) return;
 574:         werror( "enumeration type clash, operator %s", opst[p->op] );
 575:         return;
 576:         }
 577: 
 578:     if( ISPTR(t1) || ISARY(t1) ) q = p->right;
 579:     else q = p->left;
 580: 
 581:     if( !ISPTR(q->type) && !ISARY(q->type) ){
 582:         if( q->op != ICON || q->lval != 0 ){
 583:             werror( "illegal combination of pointer and integer");
 584:             }
 585:         }
 586:     else {
 587:         d1 = p->left->cdim;
 588:         d2 = p->right->cdim;
 589:         for( ;; ){
 590:             if( t1 == t2 ) {;
 591:                 if( p->left->csiz != p->right->csiz ) {
 592:                     werror( "illegal structure pointer combination" );
 593:                     }
 594:                 return;
 595:                 }
 596:             if( ISARY(t1) || ISPTR(t1) ){
 597:                 if( !ISARY(t2) && !ISPTR(t2) ) break;
 598:                 if( ISARY(t1) && ISARY(t2) && dimtab[d1] != dimtab[d2] ){
 599:                     werror( "illegal array size combination" );
 600:                     return;
 601:                     }
 602:                 if( ISARY(t1) ) ++d1;
 603:                 if( ISARY(t2) ) ++d2;
 604:                 }
 605:             else break;
 606:             t1 = DECREF(t1);
 607:             t2 = DECREF(t2);
 608:             }
 609:         werror( "illegal pointer combination" );
 610:         }
 611: 
 612:     }
 613: 
 614: NODE *
 615: stref( p ) register NODE *p; {
 616: 
 617:     TWORD t;
 618:     int d, s, dsc;
 619:     OFFSZ off;
 620:     register struct symtab *q;
 621: 
 622:     /* make p->x */
 623:     /* this is also used to reference automatic variables */
 624: 
 625:     q = &stab[p->right->rval];
 626:     p->right->op = FREE;
 627:     p->op = FREE;
 628:     p = pconvert( p->left );
 629: 
 630:     /* make p look like ptr to x */
 631: 
 632:     if( !ISPTR(p->type)){
 633:         p->type = PTR+UNIONTY;
 634:         }
 635: 
 636:     t = INCREF( q->stype );
 637:     d = q->dimoff;
 638:     s = q->sizoff;
 639: 
 640:     p = makety( p, t, d, s );
 641: 
 642:     /* compute the offset to be added */
 643: 
 644:     off = q->offset;
 645:     dsc = q->sclass;
 646: 
 647:     if( dsc & FIELD ){ /* make fields look like ints */
 648:         off = (off/ALINT)*ALINT;
 649:         s = INT;
 650:         }
 651:     if( off != 0 ) p = clocal( block( PLUS, p, offcon( off, t, d, s ), t, d, s ) );
 652: 
 653:     p = buildtree( UNARY MUL, p, NIL );
 654: 
 655:     /* if field, build field info */
 656: 
 657:     if( dsc & FIELD ){
 658:         p = block( FLD, p, NIL, q->stype, 0, q->sizoff );
 659:         p->rval = PKFIELD( dsc&FLDSIZ, q->offset%ALINT );
 660:         }
 661: 
 662:     return( clocal(p) );
 663:     }
 664: 
 665: notlval(p) register NODE *p; {
 666: 
 667:     /* return 0 if p an lvalue, 1 otherwise */
 668: 
 669:     again:
 670: 
 671:     switch( p->op ){
 672: 
 673:     case FLD:
 674:         p = p->left;
 675:         goto again;
 676: 
 677:     case NAME:
 678:     case OREG:
 679:     case UNARY MUL:
 680:         if( ISARY(p->type) || ISFTN(p->type) ) return(1);
 681:     case REG:
 682:         return(0);
 683: 
 684:     default:
 685:         return(1);
 686: 
 687:         }
 688: 
 689:     }
 690: 
 691: NODE *
 692: bcon( i ){ /* make a constant node with value i */
 693:     register NODE *p;
 694: 
 695:     p = block( ICON, NIL, NIL, INT, 0, INT );
 696:     p->lval = i;
 697:     p->rval = NONAME;
 698:     return( clocal(p) );
 699:     }
 700: 
 701: NODE *
 702: bpsize(p) register NODE *p; {
 703:     return( offcon( psize(p), p->type, p->cdim, p->csiz ) );
 704:     }
 705: 
 706: OFFSZ
 707: psize( p ) NODE *p; {
 708:     /* p is a node of type pointer; psize returns the
 709: 	   size of the thing pointed to */
 710: 
 711:     if( !ISPTR(p->type) ){
 712:         uerror( "pointer required");
 713:         return( SZINT );
 714:         }
 715:     /* note: no pointers to fields */
 716:     return( tsize( DECREF(p->type), p->cdim, p->csiz ) );
 717:     }
 718: 
 719: NODE *
 720: convert( p, f )  register NODE *p; {
 721:     /*  convert an operand of p
 722: 	    f is either CVTL or CVTR
 723: 	    operand has type int, and is converted by the size of the other side
 724: 	    */
 725: 
 726:     register NODE *q, *r;
 727: 
 728:     q = (f==CVTL)?p->left:p->right;
 729: 
 730:     r = block( PMCONV,
 731:         q, bpsize(f==CVTL?p->right:p->left), INT, 0, INT );
 732:     r = clocal(r);
 733:     if( f == CVTL )
 734:         p->left = r;
 735:     else
 736:         p->right = r;
 737:     return(p);
 738: 
 739:     }
 740: 
 741: econvert( p ) register NODE *p; {
 742: 
 743:     /* change enums to ints, or appropriate types */
 744: 
 745:     register TWORD ty;
 746: 
 747:     if( (ty=BTYPE(p->type)) == ENUMTY || ty == MOETY ) {
 748:         if( dimtab[ p->csiz ] == SZCHAR ) ty = CHAR;
 749:         else if( dimtab[ p->csiz ] == SZINT ) ty = INT;
 750:         else if( dimtab[ p->csiz ] == SZSHORT ) ty = SHORT;
 751:         else ty = LONG;
 752:         ty = ctype( ty );
 753:         p->csiz = ty;
 754:         MODTYPE(p->type,ty);
 755:         if( p->op == ICON && ty != LONG ) p->type = p->csiz = INT;
 756:         }
 757:     }
 758: 
 759: NODE *
 760: pconvert( p ) register NODE *p; {
 761: 
 762:     /* if p should be changed into a pointer, do so */
 763: 
 764:     if( ISARY( p->type) ){
 765:         p->type = DECREF( p->type );
 766:         ++p->cdim;
 767:         return( buildtree( UNARY AND, p, NIL ) );
 768:         }
 769:     if( ISFTN( p->type) )
 770:         return( buildtree( UNARY AND, p, NIL ) );
 771: 
 772:     return( p );
 773:     }
 774: 
 775: NODE *
 776: oconvert(p) register NODE *p; {
 777:     /* convert the result itself: used for pointer and unsigned */
 778: 
 779:     switch(p->op) {
 780: 
 781:     case LE:
 782:     case LT:
 783:     case GE:
 784:     case GT:
 785:         if( ISUNSIGNED(p->left->type) || ISUNSIGNED(p->right->type) )  p->op += (ULE-LE);
 786:     case EQ:
 787:     case NE:
 788:         return( p );
 789: 
 790:     case MINUS:
 791:         return(  clocal( block( PVCONV,
 792:             p, bpsize(p->left), INT, 0, INT ) ) );
 793:         }
 794: 
 795:     cerror( "illegal oconvert: %d", p->op );
 796: 
 797:     return(p);
 798:     }
 799: 
 800: NODE *
 801: ptmatch(p)  register NODE *p; {
 802: 
 803:     /* makes the operands of p agree; they are
 804: 	   either pointers or integers, by this time */
 805:     /* with MINUS, the sizes must be the same */
 806:     /* with COLON, the types must be the same */
 807: 
 808:     TWORD t1, t2, t;
 809:     int o, d2, d, s2, s;
 810: 
 811:     o = p->op;
 812:     t = t1 = p->left->type;
 813:     t2 = p->right->type;
 814:     d = p->left->cdim;
 815:     d2 = p->right->cdim;
 816:     s = p->left->csiz;
 817:     s2 = p->right->csiz;
 818: 
 819:     switch( o ){
 820: 
 821:     case ASSIGN:
 822:     case RETURN:
 823:     case CAST:
 824:         {  break; }
 825: 
 826:     case MINUS:
 827:         {  if( psize(p->left) != psize(p->right) ){
 828:             uerror( "illegal pointer subtraction");
 829:             }
 830:            break;
 831:            }
 832:     case COLON:
 833:         {  if( t1 != t2 ) uerror( "illegal types in :");
 834:            break;
 835:            }
 836:     default:  /* must work harder: relationals or comparisons */
 837: 
 838:         if( !ISPTR(t1) ){
 839:             t = t2;
 840:             d = d2;
 841:             s = s2;
 842:             break;
 843:             }
 844:         if( !ISPTR(t2) ){
 845:             break;
 846:             }
 847: 
 848:         /* both are pointers */
 849:         if( talign(t2,s2) < talign(t,s) ){
 850:             t = t2;
 851:             s = s2;
 852:             }
 853:         break;
 854:         }
 855: 
 856:     p->left = makety( p->left, t, d, s );
 857:     p->right = makety( p->right, t, d, s );
 858:     if( o!=MINUS && !logop(o) ){
 859: 
 860:         p->type = t;
 861:         p->cdim = d;
 862:         p->csiz = s;
 863:         }
 864: 
 865:     return(clocal(p));
 866:     }
 867: 
 868: int tdebug = 0;
 869: 
 870: NODE *
 871: tymatch(p)  register NODE *p; {
 872: 
 873:     /* satisfy the types of various arithmetic binary ops */
 874: 
 875:     /* rules are:
 876: 		if assignment, op, type of LHS
 877: 		if any float or doubles, make double
 878: 		if any longs, make long
 879: 		otherwise, make int
 880: 		if either operand is unsigned, the result is...
 881: 	*/
 882: 
 883:     register TWORD t1, t2, t, tu;
 884:     register o, u;
 885: 
 886:     o = p->op;
 887: 
 888:     t1 = p->left->type;
 889:     t2 = p->right->type;
 890: 
 891:     u = 0;
 892:     if( ISUNSIGNED(t1) ){
 893:         u = 1;
 894:         t1 = DEUNSIGN(t1);
 895:         }
 896:     if( ISUNSIGNED(t2) ){
 897:         u = 1;
 898:         t2 = DEUNSIGN(t2);
 899:         }
 900: 
 901:     if( ( t1 == CHAR || t1 == SHORT ) && o!= RETURN ) t1 = INT;
 902:     if( t2 == CHAR || t2 == SHORT ) t2 = INT;
 903: 
 904:     if( t1==DOUBLE || t1==FLOAT || t2==DOUBLE || t2==FLOAT ) t = DOUBLE;
 905:     else if( t1==LONG || t2==LONG ) t = LONG;
 906:     else t = INT;
 907: 
 908:     if( asgop(o) ){
 909:         tu = p->left->type;
 910:         t = t1;
 911:         }
 912:     else {
 913:         tu = (u && UNSIGNABLE(t))?ENUNSIGN(t):t;
 914:         }
 915: 
 916:     /* because expressions have values that are at least as wide
 917: 	   as INT or UNSIGNED, the only conversions needed
 918: 	   are those involving FLOAT/DOUBLE, and those
 919: 	   from LONG to INT and ULONG to UNSIGNED */
 920: 
 921:     if( t != t1 ) p->left = makety( p->left, tu, 0, (int)tu );
 922: 
 923:     if( t != t2 || o==CAST ) p->right = makety( p->right, tu, 0, (int)tu );
 924: 
 925:     if( asgop(o) ){
 926:         p->type = p->left->type;
 927:         p->cdim = p->left->cdim;
 928:         p->csiz = p->left->csiz;
 929:         }
 930:     else if( !logop(o) ){
 931:         p->type = tu;
 932:         p->cdim = 0;
 933:         p->csiz = t;
 934:         }
 935: 
 936:     if( tdebug ) printf( "tymatch(%o): %o %s %o => %o\n",p,t1,opst[o],t2,tu );
 937: 
 938:     return(p);
 939:     }
 940: 
 941: NODE *
 942: makety( p, t, d, s ) register NODE *p; TWORD t; {
 943:     /* make p into type t by inserting a conversion */
 944: 
 945:     if( p->type == ENUMTY && p->op == ICON ) econvert(p);
 946:     if( t == p->type ){
 947:         p->cdim = d;
 948:         p->csiz = s;
 949:         return( p );
 950:         }
 951: 
 952:     if( t & TMASK ){
 953:         /* non-simple type */
 954:         return( block( PCONV, p, NIL, t, d, s ) );
 955:         }
 956: 
 957:     if( p->op == ICON ){
 958:         if( t==DOUBLE||t==FLOAT ){
 959:             p->op = FCON;
 960:             if( ISUNSIGNED(p->type) ){
 961:                 p->dval = /* (unsigned CONSZ) */ p->lval;
 962:                 }
 963:             else {
 964:                 p->dval = p->lval;
 965:                 }
 966: 
 967:             p->type = p->csiz = t;
 968:             return( clocal(p) );
 969:             }
 970:         }
 971: 
 972:     return( block( SCONV, p, NIL, t, d, s ) );
 973: 
 974:     }
 975: 
 976: NODE *
 977: block( o, l, r, t, d, s ) register NODE *l, *r; TWORD t; {
 978: 
 979:     register NODE *p;
 980: 
 981:     p = talloc();
 982:     p->op = o;
 983:     p->left = l;
 984:     p->right = r;
 985:     p->type = t;
 986:     p->cdim = d;
 987:     p->csiz = s;
 988:     return(p);
 989:     }
 990: 
 991: icons(p) register NODE *p; {
 992:     /* if p is an integer constant, return its value */
 993:     int val;
 994: 
 995:     if( p->op != ICON ){
 996:         uerror( "constant expected");
 997:         val = 1;
 998:         }
 999:     else {
1000:         val = p->lval;
1001:         if( val != p->lval ) uerror( "constant too big for cross-compiler" );
1002:         }
1003:     tfree( p );
1004:     return(val);
1005:     }
1006: 
1007: /* 	the intent of this table is to examine the
1008: 	operators, and to check them for
1009: 	correctness.
1010: 
1011: 	The table is searched for the op and the
1012: 	modified type (where this is one of the
1013: 	types INT (includes char and short), LONG,
1014: 	DOUBLE (includes FLOAT), and POINTER
1015: 
1016: 	The default action is to make the node type integer
1017: 
1018: 	The actions taken include:
1019: 		PUN	  check for puns
1020: 		CVTL	  convert the left operand
1021: 		CVTR	  convert the right operand
1022: 		TYPL	  the type is determined by the left operand
1023: 		TYPR	  the type is determined by the right operand
1024: 		TYMATCH	  force type of left and right to match, by inserting conversions
1025: 		PTMATCH	  like TYMATCH, but for pointers
1026: 		LVAL	  left operand must be lval
1027: 		CVTO	  convert the op
1028: 		NCVT	  do not convert the operands
1029: 		OTHER	  handled by code
1030: 		NCVTR	  convert the left operand, not the right...
1031: 
1032: 	*/
1033: 
1034: # define MINT 01  /* integer */
1035: # define MDBI 02   /* integer or double */
1036: # define MSTR 04  /* structure */
1037: # define MPTR 010  /* pointer */
1038: # define MPTI 020  /* pointer or integer */
1039: # define MENU 040 /* enumeration variable or member */
1040: 
1041: opact( p )  NODE *p; {
1042: 
1043:     register mt12, mt1, mt2, o;
1044: 
1045:     mt12 = 0;
1046: 
1047:     switch( optype(o=p->op) ){
1048: 
1049:     case BITYPE:
1050:         mt12=mt2 = moditype( p->right->type );
1051:     case UTYPE:
1052:         mt12 &= (mt1 = moditype( p->left->type ));
1053: 
1054:         }
1055: 
1056:     switch( o ){
1057: 
1058:     case NAME :
1059:     case STRING :
1060:     case ICON :
1061:     case FCON :
1062:     case CALL :
1063:     case UNARY CALL:
1064:     case UNARY MUL:
1065:         {  return( OTHER ); }
1066:     case UNARY MINUS:
1067:         if( mt1 & MDBI ) return( TYPL );
1068:         break;
1069: 
1070:     case COMPL:
1071:         if( mt1 & MINT ) return( TYPL );
1072:         break;
1073: 
1074:     case UNARY AND:
1075:         {  return( NCVT+OTHER ); }
1076:     case INIT:
1077:     case CM:
1078:     case NOT:
1079:     case CBRANCH:
1080:     case ANDAND:
1081:     case OROR:
1082:         return( 0 );
1083: 
1084:     case MUL:
1085:     case DIV:
1086:         if( mt12 & MDBI ) return( TYMATCH );
1087:         break;
1088: 
1089:     case MOD:
1090:     case AND:
1091:     case OR:
1092:     case ER:
1093:         if( mt12 & MINT ) return( TYMATCH );
1094:         break;
1095: 
1096:     case LS:
1097:     case RS:
1098:         if( mt12 & MINT ) return( TYPL+OTHER );
1099:         break;
1100: 
1101:     case EQ:
1102:     case NE:
1103:     case LT:
1104:     case LE:
1105:     case GT:
1106:     case GE:
1107:         if( (mt1&MENU)||(mt2&MENU) ) return( PTMATCH+PUN+NCVT );
1108:         if( mt12 & MDBI ) return( TYMATCH+CVTO );
1109:         else if( mt12 & MPTR ) return( PTMATCH+PUN );
1110:         else if( mt12 & MPTI ) return( PTMATCH+PUN );
1111:         else break;
1112: 
1113:     case QUEST:
1114:     case COMOP:
1115:         if( mt2&MENU ) return( TYPR+NCVTR );
1116:         return( TYPR );
1117: 
1118:     case STREF:
1119:         return( NCVT+OTHER );
1120: 
1121:     case FORCE:
1122:         return( TYPL );
1123: 
1124:     case COLON:
1125:         if( mt12 & MENU ) return( NCVT+PUN+PTMATCH );
1126:         else if( mt12 & MDBI ) return( TYMATCH );
1127:         else if( mt12 & MPTR ) return( TYPL+PTMATCH+PUN );
1128:         else if( (mt1&MINT) && (mt2&MPTR) ) return( TYPR+PUN );
1129:         else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+PUN );
1130:         else if( mt12 & MSTR ) return( NCVT+TYPL+OTHER );
1131:         break;
1132: 
1133:     case ASSIGN:
1134:     case RETURN:
1135:         if( mt12 & MSTR ) return( LVAL+NCVT+TYPL+OTHER );
1136:     case CAST:
1137:         if( mt12 & MDBI ) return( TYPL+LVAL+TYMATCH );
1138:         else if( (mt1&MENU)||(mt2&MENU) ) return( LVAL+NCVT+TYPL+PTMATCH+PUN );
1139:         else if( mt1 & MPTR ) return( LVAL+PTMATCH+PUN );
1140:         else if( mt12 & MPTI ) return( TYPL+LVAL+TYMATCH+PUN );
1141:         break;
1142: 
1143:     case ASG LS:
1144:     case ASG RS:
1145:         if( mt12 & MINT ) return( TYPL+LVAL+OTHER );
1146:         break;
1147: 
1148:     case ASG MUL:
1149:     case ASG DIV:
1150:         if( mt12 & MDBI ) return( LVAL+TYMATCH );
1151:         break;
1152: 
1153:     case ASG MOD:
1154:     case ASG AND:
1155:     case ASG OR:
1156:     case ASG ER:
1157:         if( mt12 & MINT ) return( LVAL+TYMATCH );
1158:         break;
1159: 
1160:     case ASG PLUS:
1161:     case ASG MINUS:
1162:     case INCR:
1163:     case DECR:
1164:         if( mt12 & MDBI ) return( TYMATCH+LVAL );
1165:         else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+LVAL+CVTR );
1166:         break;
1167: 
1168:     case MINUS:
1169:         if( mt12 & MPTR ) return( CVTO+PTMATCH+PUN );
1170:         if( mt2 & MPTR ) break;
1171:     case PLUS:
1172:         if( mt12 & MDBI ) return( TYMATCH );
1173:         else if( (mt1&MPTR) && (mt2&MINT) ) return( TYPL+CVTR );
1174:         else if( (mt1&MINT) && (mt2&MPTR) ) return( TYPR+CVTL );
1175: 
1176:         }
1177:     uerror( "operands of %s have incompatible types", opst[o] );
1178:     return( NCVT );
1179:     }
1180: 
1181: moditype( ty ) TWORD ty; {
1182: 
1183:     switch( ty ){
1184: 
1185:     case ENUMTY:
1186:     case MOETY:
1187:         return( MENU );
1188: 
1189:     case STRTY:
1190:     case UNIONTY:
1191:         return( MSTR );
1192: 
1193:     case CHAR:
1194:     case SHORT:
1195:     case UCHAR:
1196:     case USHORT:
1197:         return( MINT|MDBI );
1198:     case UNSIGNED:
1199:     case ULONG:
1200:     case INT:
1201:     case LONG:
1202:         return( MINT|MDBI|MPTI );
1203:     case FLOAT:
1204:     case DOUBLE:
1205:         return( MDBI );
1206:     default:
1207:         return( MPTR|MPTI );
1208: 
1209:         }
1210:     }
1211: 
1212: NODE *
1213: doszof( p )  register NODE *p; {
1214:     /* do sizeof p */
1215:     int i;
1216: 
1217:     /* whatever is the meaning of this if it is a bitfield? */
1218:     i = tsize( p->type, p->cdim, p->csiz )/SZCHAR;
1219: 
1220:     tfree(p);
1221:     if( i <= 0 ) werror( "sizeof returns 0" );
1222:     return( bcon( i ) );
1223:     }
1224: 
1225: eprint( p, down, a, b ) register NODE *p; int *a, *b; {
1226:     register ty;
1227: 
1228:     *a = *b = down+1;
1229:     while( down > 1 ){
1230:         printf( "\t" );
1231:         down -= 2;
1232:         }
1233:     if( down ) printf( "    " );
1234: 
1235:     ty = optype( p->op );
1236: 
1237:     printf("%o) %s, ", p, opst[p->op] );
1238:     if( ty == LTYPE ){
1239:         printf( CONFMT, p->lval );
1240:         printf( ", %d, ", p->rval );
1241:         }
1242:     tprint( p->type );
1243:     printf( ", %d, %d\n", p->cdim, p->csiz );
1244:     }
1245: 
1246: prtdcon( p ) register NODE *p; {
1247:     int i;
1248: 
1249:     if( p->op == FCON ){
1250:         locctr( DATA );
1251:         defalign( ALDOUBLE );
1252:         deflab( i = getlab() );
1253:         fincode( p->dval, SZDOUBLE );
1254:         p->lval = 0;
1255:         p->rval = -i;
1256:         p->type = DOUBLE;
1257:         p->op = NAME;
1258:         }
1259:     }
1260: 
1261: 
1262: int edebug = 0;
1263: ecomp( p ) register NODE *p; {
1264:     if( edebug ) fwalk( p, eprint, 0 );
1265:     if( !reached ){
1266:         werror( "statement not reached" );
1267:         reached = 1;
1268:         }
1269:     p = optim(p);
1270:     walkf( p, prtdcon );
1271:     locctr( PROG );
1272:     ecode( p );
1273:     tfree(p);
1274:     }
1275: 
1276: # ifdef STDPRTREE
1277: # ifndef ONEPASS
1278: 
1279: prtree(p) register NODE *p; {
1280: 
1281:     register struct symtab *q;
1282:     register ty;
1283: 
1284: # ifdef MYPRTREE
1285:     MYPRTREE(p);  /* local action can be taken here; then return... */
1286: #endif
1287: 
1288:     ty = optype(p->op);
1289: 
1290:     printf( "%d\t", p->op );
1291: 
1292:     if( ty == LTYPE ) {
1293:         printf( CONFMT, p->lval );
1294:         printf( "\t" );
1295:         }
1296:     if( ty != BITYPE ) {
1297:         if( p->op == NAME || p->op == ICON ) printf( "0\t" );
1298:         else printf( "%d\t", p->rval );
1299:         }
1300: 
1301:     printf( "%o\t", p->type );
1302: 
1303:     /* handle special cases */
1304: 
1305:     switch( p->op ){
1306: 
1307:     case NAME:
1308:     case ICON:
1309:         /* print external name */
1310:         if( p->rval == NONAME ) printf( "\n" );
1311:         else if( p->rval >= 0 ){
1312:             q = &stab[p->rval];
1313:             printf(  "%s\n", exname(q->sname) );
1314:             }
1315:         else { /* label */
1316:             printf( LABFMT, -p->rval );
1317:             }
1318:         break;
1319: 
1320:     case STARG:
1321:     case STASG:
1322:     case STCALL:
1323:     case UNARY STCALL:
1324:         /* print out size */
1325:         /* use lhs size, in order to avoid hassles with the structure `.' operator */
1326: 
1327:         /* note: p->left not a field... */
1328:         printf( CONFMT, (CONSZ) tsize( STRTY, p->left->cdim, p->left->csiz ) );
1329:         printf( "\t%d\t\n", talign( STRTY, p->left->csiz ) );
1330:         break;
1331: 
1332:     default:
1333:         printf(  "\n" );
1334:         }
1335: 
1336:     if( ty != LTYPE ) prtree( p->left );
1337:     if( ty == BITYPE ) prtree( p->right );
1338: 
1339:     }
1340: 
1341: # else
1342: 
1343: p2tree(p) register NODE *p; {
1344:     register ty;
1345: 
1346: # ifdef MYP2TREE
1347:     MYP2TREE(p);  /* local action can be taken here; then return... */
1348: # endif
1349: 
1350:     ty = optype(p->op);
1351: 
1352:     switch( p->op ){
1353: 
1354:     case NAME:
1355:     case ICON:
1356:         if( p->rval == NONAME ) p->name[0] = '\0';
1357:         else if( p->rval >= 0 ){ /* copy name from exname */
1358:             register char *cp;
1359:             register i;
1360:             cp = exname( stab[p->rval].sname );
1361:             for( i=0; i<NCHNAM; ++i ) p->name[i] = *cp++;
1362:             }
1363:         else sprintf( p->name, LABFMT, -p->rval );
1364:         break;
1365: 
1366:     case STARG:
1367:     case STASG:
1368:     case STCALL:
1369:     case UNARY STCALL:
1370:         /* set up size parameters */
1371:         p->stsize = (tsize(STRTY,p->left->cdim,p->left->csiz)+SZCHAR-1)/SZCHAR;
1372:         p->stalign = talign(STRTY,p->left->csiz)/SZCHAR;
1373:         break;
1374: 
1375:     case REG:
1376:         rbusy( p->rval, p->type );
1377:     default:
1378:         p->name[0] = '\0';
1379:         }
1380: 
1381:     p->rall = NOPREF;
1382: 
1383:     if( ty != LTYPE ) p2tree( p->left );
1384:     if( ty == BITYPE ) p2tree( p->right );
1385:     }
1386: 
1387: # endif
1388: # endif

Defined functions

Defined variables

Defined macros