![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to match.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / mip|
Return to match.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / lib / mip |
1.1 ! root 1: # include "mfile2" ! 2: ! 3: # ifdef WCARD1 ! 4: # ifdef WCARD2 ! 5: # define NOINDIRECT ! 6: # endif ! 7: # endif ! 8: ! 9: extern vdebug; ! 10: ! 11: int fldsz, fldshf; ! 12: ! 13: static int mamask[] = { /* masks for matching dope with shapes */ ! 14: SIMPFLG, /* OPSIMP */ ! 15: SIMPFLG|ASGFLG, /* ASG OPSIMP */ ! 16: COMMFLG, /* OPCOMM */ ! 17: COMMFLG|ASGFLG, /* ASG OPCOMM */ ! 18: MULFLG, /* OPMUL */ ! 19: MULFLG|ASGFLG, /* ASG OPMUL */ ! 20: DIVFLG, /* OPDIV */ ! 21: DIVFLG|ASGFLG, /* ASG OPDIV */ ! 22: UTYPE, /* OPUNARY */ ! 23: TYFLG, /* ASG OPUNARY is senseless */ ! 24: LTYPE, /* OPLEAF */ ! 25: TYFLG, /* ASG OPLEAF is senseless */ ! 26: 0, /* OPANY */ ! 27: ASGOPFLG|ASGFLG, /* ASG OPANY */ ! 28: LOGFLG, /* OPLOG */ ! 29: TYFLG, /* ASG OPLOG is senseless */ ! 30: FLOFLG, /* OPFLOAT */ ! 31: FLOFLG|ASGFLG, /* ASG OPFLOAT */ ! 32: SHFFLG, /* OPSHFT */ ! 33: SHFFLG|ASGFLG, /* ASG OPSHIFT */ ! 34: SPFLG, /* OPLTYPE */ ! 35: TYFLG, /* ASG OPLTYPE is senseless */ ! 36: }; ! 37: ! 38: int sdebug = 0; ! 39: ! 40: tshape( p, shape ) NODE *p; { ! 41: /* return true if shape is appropriate for the node p ! 42: side effect for SFLD is to set up fldsz,etc */ ! 43: register o, mask; ! 44: ! 45: o = p->in.op; ! 46: ! 47: # ifndef BUG3 ! 48: if( sdebug ){ ! 49: printf( "tshape( %o, %o), op = %d\n", p, shape, o ); ! 50: } ! 51: # endif ! 52: ! 53: if( shape & SPECIAL ){ ! 54: ! 55: switch( shape ){ ! 56: ! 57: case SZERO: ! 58: case SONE: ! 59: case SMONE: ! 60: case SSCON: ! 61: case SCCON: ! 62: if( o != ICON || p->in.name[0] ) return(0); ! 63: if( p->tn.lval == 0 && shape == SZERO ) return(1); ! 64: else if( p->tn.lval == 1 && shape == SONE ) return(1); ! 65: else if( p->tn.lval == -1 && shape == SMONE ) return(1); ! 66: else if( p->tn.lval > -129 && p->tn.lval < 128 && shape == SCCON ) return(1); ! 67: else if( p->tn.lval > -32769 && p->tn.lval < 32768 && shape == SSCON ) return(1); ! 68: else return(0); ! 69: ! 70: case SSOREG: /* non-indexed OREG */ ! 71: if( o == OREG && !R2TEST(p->tn.rval) ) return(1); ! 72: else return(0); ! 73: ! 74: default: ! 75: # ifdef MULTILEVEL ! 76: if( shape & MULTILEVEL ) ! 77: return( mlmatch(p,shape,0) ); ! 78: else ! 79: # endif ! 80: return( special( p, shape ) ); ! 81: } ! 82: } ! 83: ! 84: if( shape & SANY ) return(1); ! 85: ! 86: if( (shape&INTEMP) && shtemp(p) ) return(1); ! 87: ! 88: if( (shape&SWADD) && (o==NAME||o==OREG) ){ ! 89: if( BYTEOFF(p->tn.lval) ) return(0); ! 90: } ! 91: ! 92: # ifdef WCARD1 ! 93: if( shape & WCARD1 ) ! 94: return( wcard1(p) & shape ); ! 95: # endif ! 96: ! 97: # ifdef WCARD2 ! 98: if( shape & WCARD2 ) ! 99: return( wcard2(p) & shape ); ! 100: # endif ! 101: switch( o ){ ! 102: ! 103: case NAME: ! 104: return( shape&SNAME ); ! 105: case ICON: ! 106: mask = SCON; ! 107: return( shape & mask ); ! 108: ! 109: case FLD: ! 110: if( shape & SFLD ){ ! 111: if( !flshape( p->in.left ) ) return(0); ! 112: /* it is a FIELD shape; make side-effects */ ! 113: o = p->tn.rval; ! 114: fldsz = UPKFSZ(o); ! 115: # ifdef RTOLBYTES ! 116: fldshf = UPKFOFF(o); ! 117: # else ! 118: fldshf = SZINT - fldsz - UPKFOFF(o); ! 119: # endif ! 120: return(1); ! 121: } ! 122: return(0); ! 123: ! 124: case CCODES: ! 125: return( shape&SCC ); ! 126: ! 127: case REG: ! 128: /* distinctions: ! 129: SAREG any scalar register ! 130: STAREG any temporary scalar register ! 131: SBREG any lvalue (index) register ! 132: STBREG any temporary lvalue register ! 133: */ ! 134: mask = isbreg( p->tn.rval ) ? SBREG : SAREG; ! 135: if( istreg( p->tn.rval ) && busy[p->tn.rval]<=1 ) mask |= mask==SAREG ? STAREG : STBREG; ! 136: return( shape & mask ); ! 137: ! 138: case OREG: ! 139: return( shape & SOREG ); ! 140: ! 141: # ifndef NOINDIRECT ! 142: case UNARY MUL: ! 143: /* return STARNM or STARREG or 0 */ ! 144: return( shumul(p->in.left) & shape ); ! 145: # endif ! 146: ! 147: } ! 148: ! 149: return(0); ! 150: } ! 151: ! 152: int tdebug = 0; ! 153: ! 154: ttype( t, tword ) TWORD t; { ! 155: /* does the type t match tword */ ! 156: ! 157: if( tword & TANY ) return(1); ! 158: ! 159: if( t == UNDEF ) t=INT; /* void functions eased thru tables */ ! 160: # ifndef BUG3 ! 161: if( tdebug ){ ! 162: printf( "ttype( %o, %o )\n", t, tword ); ! 163: } ! 164: # endif ! 165: if( ISPTR(t) && (tword&TPTRTO) ) { ! 166: do { ! 167: t = DECREF(t); ! 168: } while ( ISARY(t) ); ! 169: /* arrays that are left are usually only ! 170: in structure references... */ ! 171: return( ttype( t, tword&(~TPTRTO) ) ); ! 172: } ! 173: if( t != BTYPE(t) ) return( tword & TPOINT ); /* TPOINT means not simple! */ ! 174: if( tword & TPTRTO ) return(0); ! 175: ! 176: switch( t ){ ! 177: ! 178: case CHAR: ! 179: return( tword & TCHAR ); ! 180: case SHORT: ! 181: return( tword & TSHORT ); ! 182: case STRTY: ! 183: case UNIONTY: ! 184: return( tword & TSTRUCT ); ! 185: case INT: ! 186: return( tword & TINT ); ! 187: case UNSIGNED: ! 188: return( tword & TUNSIGNED ); ! 189: case USHORT: ! 190: return( tword & TUSHORT ); ! 191: case UCHAR: ! 192: return( tword & TUCHAR ); ! 193: case ULONG: ! 194: return( tword & TULONG ); ! 195: case LONG: ! 196: return( tword & TLONG ); ! 197: case FLOAT: ! 198: return( tword & TFLOAT ); ! 199: case DOUBLE: ! 200: return( tword & TDOUBLE ); ! 201: } ! 202: ! 203: return(0); ! 204: } ! 205: ! 206: struct optab *rwtable; ! 207: ! 208: struct optab *opptr[DSIZE]; ! 209: ! 210: setrew(){ ! 211: /* set rwtable to first value which allows rewrite */ ! 212: register struct optab *q; ! 213: register int i; ! 214: ! 215: # ifdef MULTILEVEL ! 216: /* also initialize multi-level tree links */ ! 217: mlinit(); ! 218: # endif ! 219: ! 220: for( q = table; q->op != FREE; ++q ){ ! 221: if( q->needs == REWRITE ){ ! 222: rwtable = q; ! 223: goto more; ! 224: } ! 225: } ! 226: cerror( "bad setrew" ); ! 227: ! 228: ! 229: more: ! 230: for( i=0; i<DSIZE; ++i ){ ! 231: if( dope[i] ){ /* there is an op... */ ! 232: for( q=table; q->op != FREE; ++q ){ ! 233: /* beware; things like LTYPE that match ! 234: multiple things in the tree must ! 235: not try to look at the NIL at this ! 236: stage of things! Put something else ! 237: first in table.c */ ! 238: /* at one point, the operator matching was 15% of the ! 239: total comile time; thus, the function ! 240: call that was here was removed... ! 241: */ ! 242: ! 243: if( q->op < OPSIMP ){ ! 244: if( q->op==i ) break; ! 245: } ! 246: else { ! 247: register opmtemp; ! 248: if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){ ! 249: if( i==NAME || i==ICON || i==OREG ) break; ! 250: else if( shltype( i, NIL ) ) break; ! 251: } ! 252: else if( (dope[i]&(opmtemp|ASGFLG)) == opmtemp ) break; ! 253: } ! 254: } ! 255: opptr[i] = q; ! 256: } ! 257: } ! 258: } ! 259: ! 260: match( p, cookie ) NODE *p; { ! 261: /* called by: order, gencall ! 262: look for match in table and generate code if found unless ! 263: entry specified REWRITE. ! 264: returns MDONE, MNOPE, or rewrite specification from table */ ! 265: ! 266: register struct optab *q; ! 267: register NODE *r; ! 268: ! 269: rcount(); ! 270: if( cookie == FORREW ) q = rwtable; ! 271: else q = opptr[p->in.op]; ! 272: ! 273: for( ; q->op != FREE; ++q ){ ! 274: ! 275: /* at one point the call that was here was over 15% of the total time; ! 276: thus the function call was expanded inline */ ! 277: if( q->op < OPSIMP ){ ! 278: if( q->op!=p->in.op ) continue; ! 279: } ! 280: else { ! 281: register opmtemp; ! 282: if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){ ! 283: if( p->in.op!=NAME && p->in.op!=ICON && p->in.op!= OREG && ! 284: ! shltype( p->in.op, p ) ) continue; ! 285: } ! 286: else if( (dope[p->in.op]&(opmtemp|ASGFLG)) != opmtemp ) continue; ! 287: } ! 288: ! 289: if( !(q->visit & cookie ) ) continue; ! 290: r = getlr( p, 'L' ); /* see if left child matches */ ! 291: if( !tshape( r, q->lshape ) ) continue; ! 292: if( !ttype( r->in.type, q->ltype ) ) continue; ! 293: r = getlr( p, 'R' ); /* see if right child matches */ ! 294: if( !tshape( r, q->rshape ) ) continue; ! 295: if( !ttype( r->in.type, q->rtype ) ) continue; ! 296: ! 297: /* REWRITE means no code from this match but go ahead ! 298: and rewrite node to help future match */ ! 299: if( q->needs & REWRITE ) return( q->rewrite ); ! 300: if( !allo( p, q ) ) continue; /* if can't generate code, skip entry */ ! 301: ! 302: /* resources are available */ ! 303: ! 304: expand( p, cookie, q->cstring ); /* generate code */ ! 305: reclaim( p, q->rewrite, cookie ); ! 306: ! 307: return(MDONE); ! 308: ! 309: } ! 310: ! 311: return(MNOPE); ! 312: } ! 313: ! 314: int rtyflg = 0; ! 315: ! 316: expand( p, cookie, cp ) NODE *p; register char *cp; { ! 317: /* generate code by interpreting table entry */ ! 318: ! 319: register char c; ! 320: CONSZ val; ! 321: ! 322: rtyflg = 0; ! 323: ! 324: for( ; *cp; ++cp ){ ! 325: switch( *cp ){ ! 326: ! 327: default: ! 328: PUTCHAR( *cp ); ! 329: continue; /* this is the usual case... */ ! 330: ! 331: case 'T': ! 332: /* rewrite register type is suppressed */ ! 333: rtyflg = 1; ! 334: continue; ! 335: ! 336: case 'Z': /* special machine dependent operations */ ! 337: # ifdef NEWZZZ ! 338: switch( c = *++cp ) { ! 339: ! 340: case '1': ! 341: case '2': ! 342: case '3': ! 343: case 'R': ! 344: case 'L': /* get down first */ ! 345: zzzcode( getlr( p, c ), *++cp ); ! 346: break; ! 347: default: /* normal zzzcode processing otherwise */ ! 348: zzzcode( p, c ); ! 349: break; ! 350: } ! 351: # else ! 352: zzzcode( p, *++cp ); ! 353: # endif ! 354: continue; ! 355: ! 356: case 'F': /* this line deleted if FOREFF is active */ ! 357: if( cookie & FOREFF ) while( *++cp != '\n' ) ; /* VOID */ ! 358: continue; ! 359: ! 360: case 'S': /* field size */ ! 361: printf( "%d", fldsz ); ! 362: continue; ! 363: ! 364: case 'H': /* field shift */ ! 365: printf( "%d", fldshf ); ! 366: continue; ! 367: ! 368: case 'M': /* field mask */ ! 369: case 'N': /* complement of field mask */ ! 370: val = 1; ! 371: val <<= fldsz; ! 372: --val; ! 373: val <<= fldshf; ! 374: adrcon( *cp=='M' ? val : ~val ); ! 375: continue; ! 376: ! 377: case 'L': /* output special label field */ ! 378: printf( "%d", p->bn.label ); ! 379: continue; ! 380: ! 381: case 'O': /* opcode string */ ! 382: hopcode( *++cp, p->in.op ); ! 383: continue; ! 384: ! 385: case 'B': /* byte offset in word */ ! 386: val = getlr(p,*++cp)->tn.lval; ! 387: val = BYTEOFF(val); ! 388: printf( CONFMT, val ); ! 389: continue; ! 390: ! 391: case 'C': /* for constant value only */ ! 392: conput( getlr( p, *++cp ) ); ! 393: continue; ! 394: ! 395: case 'I': /* in instruction */ ! 396: insput( getlr( p, *++cp ) ); ! 397: continue; ! 398: ! 399: case 'A': /* address of */ ! 400: adrput( getlr( p, *++cp ) ); ! 401: continue; ! 402: ! 403: case 'U': /* for upper half of address, only */ ! 404: upput( getlr( p, *++cp ) ); ! 405: continue; ! 406: ! 407: } ! 408: ! 409: } ! 410: ! 411: } ! 412: ! 413: NODE * ! 414: getlr( p, c ) NODE *p; { ! 415: ! 416: /* return the pointer to the left or right side of p, or p itself, ! 417: depending on the optype of p */ ! 418: ! 419: switch( c ) { ! 420: ! 421: case '1': ! 422: case '2': ! 423: case '3': ! 424: return( &resc[c-'1'] ); ! 425: ! 426: case 'L': ! 427: return( optype( p->in.op ) == LTYPE ? p : p->in.left ); ! 428: ! 429: case 'R': ! 430: return( optype( p->in.op ) != BITYPE ? p : p->in.right ); ! 431: ! 432: } ! 433: cerror( "bad getlr: %c", c ); ! 434: /* NOTREACHED */ ! 435: } ! 436: # ifdef MULTILEVEL ! 437: ! 438: union mltemplate{ ! 439: struct ml_head{ ! 440: int tag; /* identifies class of tree */ ! 441: int subtag; /* subclass of tree */ ! 442: union mltemplate * nexthead; /* linked by mlinit() */ ! 443: } mlhead; ! 444: struct ml_node{ ! 445: int op; /* either an operator or op description */ ! 446: int nshape; /* shape of node */ ! 447: /* both op and nshape must match the node. ! 448: * where the work is to be done entirely by ! 449: * op, nshape can be SANY, visa versa, op can ! 450: * be OPANY. ! 451: */ ! 452: int ntype; /* type descriptor from mfile2 */ ! 453: } mlnode; ! 454: }; ! 455: ! 456: # define MLSZ 30 ! 457: ! 458: extern union mltemplate mltree[]; ! 459: int mlstack[MLSZ]; ! 460: int *mlsp; /* pointing into mlstack */ ! 461: NODE * ststack[MLSZ]; ! 462: NODE **stp; /* pointing into ststack */ ! 463: ! 464: mlinit(){ ! 465: union mltemplate **lastlink; ! 466: register union mltemplate *n; ! 467: register mlop; ! 468: ! 469: lastlink = &(mltree[0].nexthead); ! 470: n = &mltree[0]; ! 471: for( ; (n++)->mlhead.tag != 0; ! 472: *lastlink = ++n, lastlink = &(n->mlhead.nexthead) ){ ! 473: # ifndef BUG3 ! 474: if( vdebug )printf("mlinit: %d\n",(n-1)->mlhead.tag); ! 475: # endif ! 476: /* wander thru a tree with a stack finding ! 477: * its structure so the next header can be located. ! 478: */ ! 479: mlsp = mlstack; ! 480: ! 481: for( ;; ++n ){ ! 482: if( (mlop = n->mlnode.op) < OPSIMP ){ ! 483: switch( optype(mlop) ){ ! 484: ! 485: default: ! 486: cerror("(1)unknown opcode: %o",mlop); ! 487: case BITYPE: ! 488: goto binary; ! 489: case UTYPE: ! 490: break; ! 491: case LTYPE: ! 492: goto leaf; ! 493: } ! 494: } ! 495: else{ ! 496: if( mamask[mlop-OPSIMP] & ! 497: (SIMPFLG|COMMFLG|MULFLG|DIVFLG|LOGFLG|FLOFLG|SHFFLG) ){ ! 498: binary: ! 499: *mlsp++ = BITYPE; ! 500: } ! 501: else if( ! (mamask[mlop-OPSIMP] & UTYPE) ){/* includes OPANY */ ! 502: ! 503: leaf: ! 504: if( mlsp == mlstack ) ! 505: goto tree_end; ! 506: else if ( *--mlsp != BITYPE ) ! 507: cerror("(1)bad multi-level tree descriptor around mltree[%d]", ! 508: n-mltree); ! 509: } ! 510: } ! 511: } ! 512: tree_end: /* n points to final leaf */ ! 513: ; ! 514: } ! 515: # ifndef BUG3 ! 516: if( vdebug > 3 ){ ! 517: printf("mltree={\n"); ! 518: for( n= &(mltree[0]); n->mlhead.tag != 0; ++n) ! 519: printf("%o: %d, %d, %o,\n",n, ! 520: n->mlhead.tag,n->mlhead.subtag,n->mlhead.nexthead); ! 521: printf(" }\n"); ! 522: } ! 523: # endif ! 524: } ! 525: ! 526: mlmatch( subtree, target, subtarget ) NODE * subtree; int target,subtarget;{ ! 527: /* ! 528: * does subtree match a multi-level tree with ! 529: * tag "target"? Return zero on failure, ! 530: * non-zero subtag on success (or MDONE if ! 531: * there is a zero subtag field). ! 532: */ ! 533: union mltemplate *head; /* current template header */ ! 534: register union mltemplate *n; /* node being matched */ ! 535: NODE * st; /* subtree being matched */ ! 536: register int mlop; ! 537: ! 538: # ifndef BUG3 ! 539: if( vdebug ) printf("mlmatch(%o,%d)\n",subtree,target); ! 540: # endif ! 541: for( head = &(mltree[0]); head->mlhead.tag != 0; ! 542: head=head->mlhead.nexthead){ ! 543: # ifndef BUG3 ! 544: if( vdebug > 1 )printf("mlmatch head(%o) tag(%d)\n", ! 545: head->mlhead.tag); ! 546: # endif ! 547: if( head->mlhead.tag != target )continue; ! 548: if( subtarget && head->mlhead.subtag != subtarget)continue; ! 549: # ifndef BUG3 ! 550: if( vdebug ) printf("mlmatch for %d\n",target); ! 551: # endif ! 552: ! 553: /* potential for match */ ! 554: ! 555: n = head + 1; ! 556: st = subtree; ! 557: stp = ststack; ! 558: mlsp = mlstack; ! 559: /* compare n->op, ->nshape, ->ntype to ! 560: * the subtree node st ! 561: */ ! 562: for( ;; ++n ){ /* for each node in multi-level template */ ! 563: /* opmatch */ ! 564: if( n->op < OPSIMP ){ ! 565: if( st->op != n->op )break; ! 566: } ! 567: else { ! 568: register opmtemp; ! 569: if((opmtemp=mamask[n->op-OPSIMP])&SPFLG){ ! 570: if(st->op!=NAME && st->op!=ICON && st->op!=OREG && ! 571: ! shltype(st->op,st)) break; ! 572: } ! 573: else if((dope[st->op]&(opmtemp|ASGFLG))!=opmtemp) break; ! 574: } ! 575: /* check shape and type */ ! 576: ! 577: if( ! tshape( st, n->mlnode.nshape ) ) break; ! 578: if( ! ttype( st->type, n->mlnode.ntype ) ) break; ! 579: ! 580: /* that node matched, let's try another */ ! 581: /* must advance both st and n and halt at right time */ ! 582: ! 583: if( (mlop = n->mlnode.op) < OPSIMP ){ ! 584: switch( optype(mlop) ){ ! 585: ! 586: default: ! 587: cerror("(2)unknown opcode: %o",mlop); ! 588: case BITYPE: ! 589: goto binary; ! 590: case UTYPE: ! 591: st = st->left; ! 592: break; ! 593: case LTYPE: ! 594: goto leaf; ! 595: } ! 596: } ! 597: else{ ! 598: if( mamask[mlop - OPSIMP] & ! 599: (SIMPFLG|COMMFLG|MULFLG|DIVFLG|LOGFLG|FLOFLG|SHFFLG) ){ ! 600: binary: ! 601: *mlsp++ = BITYPE; ! 602: *stp++ = st; ! 603: st = st->left; ! 604: } ! 605: else if( ! (mamask[mlop-OPSIMP] & UTYPE) ){/* includes OPANY */ ! 606: ! 607: leaf: ! 608: if( mlsp == mlstack ) ! 609: goto matched; ! 610: else if ( *--mlsp != BITYPE ) ! 611: cerror("(2)bad multi-level tree descriptor around mltree[%d]", ! 612: n-mltree); ! 613: st = (*--stp)->right; ! 614: } ! 615: else /* UNARY */ st = st->left; ! 616: } ! 617: continue; ! 618: ! 619: matched: ! 620: /* complete multi-level match successful */ ! 621: # ifndef BUG3 ! 622: if( vdebug ) printf("mlmatch() success\n"); ! 623: # endif ! 624: if( head->mlhead.subtag == 0 ) return( MDONE ); ! 625: else { ! 626: # ifndef BUG3 ! 627: if( vdebug )printf("\treturns %d\n", ! 628: head->mlhead.subtag ); ! 629: # endif ! 630: return( head->mlhead.subtag ); ! 631: } ! 632: } ! 633: } ! 634: return( 0 ); ! 635: } ! 636: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.