![[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 / usr.bin / f77 / f77pass2|
Return to match.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / f77 / f77pass2 |
1.1 ! root 1: # include "pass2.h" ! 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 int 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: /* ! 196: case LONG: ! 197: return( tword & TLONG ); ! 198: */ ! 199: case FLOAT: ! 200: return( tword & TFLOAT ); ! 201: case DOUBLE: ! 202: return( tword & TDOUBLE ); ! 203: } ! 204: ! 205: return(0); ! 206: } ! 207: ! 208: struct optab *rwtable; ! 209: ! 210: struct optab *opptr[DSIZE]; ! 211: ! 212: setrew(){ ! 213: /* set rwtable to first value which allows rewrite */ ! 214: register struct optab *q; ! 215: register int i; ! 216: ! 217: # ifdef MULTILEVEL ! 218: /* also initialize multi-level tree links */ ! 219: mlinit(); ! 220: # endif ! 221: ! 222: for( q = table; q->op != FREE; ++q ){ ! 223: if( q->needs == REWRITE ){ ! 224: rwtable = q; ! 225: goto more; ! 226: } ! 227: } ! 228: cerror( "bad setrew" ); ! 229: ! 230: ! 231: more: ! 232: for( i=0; i<DSIZE; ++i ){ ! 233: if( dope[i] ){ /* there is an op... */ ! 234: for( q=table; q->op != FREE; ++q ){ ! 235: /* beware; things like LTYPE that match ! 236: multiple things in the tree must ! 237: not try to look at the NIL at this ! 238: stage of things! Put something else ! 239: first in table.c */ ! 240: /* at one point, the operator matching was 15% of the ! 241: total comile time; thus, the function ! 242: call that was here was removed... ! 243: */ ! 244: ! 245: if( q->op < OPSIMP ){ ! 246: if( q->op==i ) break; ! 247: } ! 248: else { ! 249: register int opmtemp; ! 250: if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){ ! 251: if( i==NAME || i==ICON || i==OREG ) break; ! 252: else if( shltype( i, NIL ) ) break; ! 253: } ! 254: else if( (dope[i]&(opmtemp|ASGFLG)) == opmtemp ) break; ! 255: } ! 256: } ! 257: opptr[i] = q; ! 258: } ! 259: } ! 260: } ! 261: ! 262: match( p, cookie ) NODE *p; { ! 263: /* called by: order, gencall ! 264: look for match in table and generate code if found unless ! 265: entry specified REWRITE. ! 266: returns MDONE, MNOPE, or rewrite specification from table */ ! 267: ! 268: register struct optab *q; ! 269: register NODE *r; ! 270: ! 271: rcount(); ! 272: if( cookie == FORREW ) q = rwtable; ! 273: else q = opptr[p->in.op]; ! 274: ! 275: for( ; q->op != FREE; ++q ){ ! 276: ! 277: /* at one point the call that was here was over 15% of the total time; ! 278: thus the function call was expanded inline */ ! 279: if( q->op < OPSIMP ){ ! 280: if( q->op!=p->in.op ) continue; ! 281: } ! 282: else { ! 283: register int opmtemp; ! 284: if((opmtemp=mamask[q->op - OPSIMP])&SPFLG){ ! 285: if( p->in.op!=NAME && p->in.op!=ICON && p->in.op!= OREG && ! 286: ! shltype( p->in.op, p ) ) continue; ! 287: } ! 288: else if( (dope[p->in.op]&(opmtemp|ASGFLG)) != opmtemp ) continue; ! 289: } ! 290: ! 291: if( !(q->visit & cookie ) ) continue; ! 292: r = getlr( p, 'L' ); /* see if left child matches */ ! 293: if( !tshape( r, q->lshape ) ) continue; ! 294: if( !ttype( r->in.type, q->ltype ) ) continue; ! 295: r = getlr( p, 'R' ); /* see if right child matches */ ! 296: if( !tshape( r, q->rshape ) ) continue; ! 297: if( !ttype( r->in.type, q->rtype ) ) continue; ! 298: ! 299: /* REWRITE means no code from this match but go ahead ! 300: and rewrite node to help future match */ ! 301: if( q->needs & REWRITE ) return( q->rewrite ); ! 302: if( !allo( p, q ) ) continue; /* if can't generate code, skip entry */ ! 303: ! 304: /* resources are available */ ! 305: ! 306: expand( p, cookie, q->cstring ); /* generate code */ ! 307: reclaim( p, q->rewrite, cookie ); ! 308: ! 309: return(MDONE); ! 310: ! 311: } ! 312: ! 313: return(MNOPE); ! 314: } ! 315: ! 316: int rtyflg = 0; ! 317: ! 318: expand( p, cookie, cp ) NODE *p; register char *cp; { ! 319: /* generate code by interpreting table entry */ ! 320: ! 321: register char c; ! 322: CONSZ val; ! 323: ! 324: rtyflg = 0; ! 325: ! 326: for( ; *cp; ++cp ){ ! 327: switch( *cp ){ ! 328: ! 329: default: ! 330: PUTCHAR( *cp ); ! 331: continue; /* this is the usual case... */ ! 332: ! 333: case 'T': ! 334: /* rewrite register type is suppressed */ ! 335: rtyflg = 1; ! 336: continue; ! 337: ! 338: case 'Z': /* special machine dependent operations */ ! 339: # ifdef NEWZZZ ! 340: switch( c = *++cp ) { ! 341: ! 342: case '1': ! 343: case '2': ! 344: case '3': ! 345: case 'R': ! 346: case 'L': /* get down first */ ! 347: zzzcode( getlr( p, c ), *++cp ); ! 348: break; ! 349: default: /* normal zzzcode processing otherwise */ ! 350: zzzcode( p, c ); ! 351: break; ! 352: } ! 353: # else ! 354: zzzcode( p, *++cp ); ! 355: # endif ! 356: continue; ! 357: ! 358: case 'F': /* this line deleted if FOREFF is active */ ! 359: if( cookie & FOREFF ) while( *++cp != '\n' ) ; /* VOID */ ! 360: continue; ! 361: ! 362: case 'S': /* field size */ ! 363: printf( "%d", fldsz ); ! 364: continue; ! 365: ! 366: case 'H': /* field shift */ ! 367: printf( "%d", fldshf ); ! 368: continue; ! 369: ! 370: case 'M': /* field mask */ ! 371: case 'N': /* complement of field mask */ ! 372: val = 1; ! 373: val <<= fldsz; ! 374: --val; ! 375: val <<= fldshf; ! 376: adrcon( *cp=='M' ? val : ~val ); ! 377: continue; ! 378: ! 379: case 'L': /* output special label field */ ! 380: printf( "%d", p->bn.label ); ! 381: continue; ! 382: ! 383: case 'O': /* opcode string */ ! 384: hopcode( *++cp, p->in.op ); ! 385: continue; ! 386: ! 387: case 'B': /* byte offset in word */ ! 388: val = getlr(p,*++cp)->tn.lval; ! 389: val = BYTEOFF(val); ! 390: printf( CONFMT, val ); ! 391: continue; ! 392: ! 393: case 'C': /* for constant value only */ ! 394: conput( getlr( p, *++cp ) ); ! 395: continue; ! 396: ! 397: case 'I': /* in instruction */ ! 398: insput( getlr( p, *++cp ) ); ! 399: continue; ! 400: ! 401: case 'A': /* address of */ ! 402: adrput( getlr( p, *++cp ) ); ! 403: continue; ! 404: ! 405: case 'U': /* for upper half of address, only */ ! 406: upput( getlr( p, *++cp ) ); ! 407: continue; ! 408: ! 409: } ! 410: ! 411: } ! 412: ! 413: } ! 414: ! 415: NODE * ! 416: getlr( p, c ) NODE *p; { ! 417: ! 418: /* return the pointer to the left or right side of p, or p itself, ! 419: depending on the optype of p */ ! 420: ! 421: switch( c ) { ! 422: ! 423: case '1': ! 424: case '2': ! 425: case '3': ! 426: return( &resc[c-'1'] ); ! 427: ! 428: case 'L': ! 429: return( optype( p->in.op ) == LTYPE ? p : p->in.left ); ! 430: ! 431: case 'R': ! 432: return( optype( p->in.op ) != BITYPE ? p : p->in.right ); ! 433: ! 434: } ! 435: cerror( "bad getlr: %c", c ); ! 436: /* NOTREACHED */ ! 437: } ! 438: # ifdef MULTILEVEL ! 439: ! 440: union mltemplate{ ! 441: struct ml_head{ ! 442: int tag; /* identifies class of tree */ ! 443: int subtag; /* subclass of tree */ ! 444: union mltemplate * nexthead; /* linked by mlinit() */ ! 445: } mlhead; ! 446: struct ml_node{ ! 447: int op; /* either an operator or op description */ ! 448: int nshape; /* shape of node */ ! 449: /* both op and nshape must match the node. ! 450: * where the work is to be done entirely by ! 451: * op, nshape can be SANY, visa versa, op can ! 452: * be OPANY. ! 453: */ ! 454: int ntype; /* type descriptor from mfile2 */ ! 455: } mlnode; ! 456: }; ! 457: ! 458: # define MLSZ 30 ! 459: ! 460: extern union mltemplate mltree[]; ! 461: int mlstack[MLSZ]; ! 462: int *mlsp; /* pointing into mlstack */ ! 463: NODE * ststack[MLSZ]; ! 464: NODE **stp; /* pointing into ststack */ ! 465: ! 466: mlinit(){ ! 467: union mltemplate **lastlink; ! 468: register int union mltemplate *n; ! 469: register int mlop; ! 470: ! 471: lastlink = &(mltree[0].nexthead); ! 472: n = &mltree[0]; ! 473: for( ; (n++)->mlhead.tag != 0; ! 474: *lastlink = ++n, lastlink = &(n->mlhead.nexthead) ){ ! 475: # ifndef BUG3 ! 476: if( vdebug )printf("mlinit: %d\n",(n-1)->mlhead.tag); ! 477: # endif ! 478: /* wander thru a tree with a stack finding ! 479: * its structure so the next header can be located. ! 480: */ ! 481: mlsp = mlstack; ! 482: ! 483: for( ;; ++n ){ ! 484: if( (mlop = n->mlnode.op) < OPSIMP ){ ! 485: switch( optype(mlop) ){ ! 486: ! 487: default: ! 488: cerror("(1)unknown opcode: %o",mlop); ! 489: case BITYPE: ! 490: goto binary; ! 491: case UTYPE: ! 492: break; ! 493: case LTYPE: ! 494: goto leaf; ! 495: } ! 496: } ! 497: else{ ! 498: if( mamask[mlop-OPSIMP] & ! 499: (SIMPFLG|COMMFLG|MULFLG|DIVFLG|LOGFLG|FLOFLG|SHFFLG) ){ ! 500: binary: ! 501: *mlsp++ = BITYPE; ! 502: } ! 503: else if( ! (mamask[mlop-OPSIMP] & UTYPE) ){/* includes OPANY */ ! 504: ! 505: leaf: ! 506: if( mlsp == mlstack ) ! 507: goto tree_end; ! 508: else if ( *--mlsp != BITYPE ) ! 509: cerror("(1)bad multi-level tree descriptor around mltree[%d]", ! 510: n-mltree); ! 511: } ! 512: } ! 513: } ! 514: tree_end: /* n points to final leaf */ ! 515: ; ! 516: } ! 517: # ifndef BUG3 ! 518: if( vdebug > 3 ){ ! 519: printf("mltree={\n"); ! 520: for( n= &(mltree[0]); n->mlhead.tag != 0; ++n) ! 521: printf("%o: %d, %d, %o,\n",n, ! 522: n->mlhead.tag,n->mlhead.subtag,n->mlhead.nexthead); ! 523: printf(" }\n"); ! 524: } ! 525: # endif ! 526: } ! 527: ! 528: mlmatch( subtree, target, subtarget ) NODE * subtree; int target,subtarget;{ ! 529: /* ! 530: * does subtree match a multi-level tree with ! 531: * tag "target"? Return zero on failure, ! 532: * non-zero subtag on success (or MDONE if ! 533: * there is a zero subtag field). ! 534: */ ! 535: union mltemplate *head; /* current template header */ ! 536: register union mltemplate *n; /* node being matched */ ! 537: NODE * st; /* subtree being matched */ ! 538: register int mlop; ! 539: ! 540: # ifndef BUG3 ! 541: if( vdebug ) printf("mlmatch(%o,%d)\n",subtree,target); ! 542: # endif ! 543: for( head = &(mltree[0]); head->mlhead.tag != 0; ! 544: head=head->mlhead.nexthead){ ! 545: # ifndef BUG3 ! 546: if( vdebug > 1 )printf("mlmatch head(%o) tag(%d)\n", ! 547: head->mlhead.tag); ! 548: # endif ! 549: if( head->mlhead.tag != target )continue; ! 550: if( subtarget && head->mlhead.subtag != subtarget)continue; ! 551: # ifndef BUG3 ! 552: if( vdebug ) printf("mlmatch for %d\n",target); ! 553: # endif ! 554: ! 555: /* potential for match */ ! 556: ! 557: n = head + 1; ! 558: st = subtree; ! 559: stp = ststack; ! 560: mlsp = mlstack; ! 561: /* compare n->op, ->nshape, ->ntype to ! 562: * the subtree node st ! 563: */ ! 564: for( ;; ++n ){ /* for each node in multi-level template */ ! 565: /* opmatch */ ! 566: if( n->op < OPSIMP ){ ! 567: if( st->op != n->op )break; ! 568: } ! 569: else { ! 570: register int opmtemp; ! 571: if((opmtemp=mamask[n->op-OPSIMP])&SPFLG){ ! 572: if(st->op!=NAME && st->op!=ICON && st->op!=OREG && ! 573: ! shltype(st->op,st)) break; ! 574: } ! 575: else if((dope[st->op]&(opmtemp|ASGFLG))!=opmtemp) break; ! 576: } ! 577: /* check shape and type */ ! 578: ! 579: if( ! tshape( st, n->mlnode.nshape ) ) break; ! 580: if( ! ttype( st->type, n->mlnode.ntype ) ) break; ! 581: ! 582: /* that node matched, let's try another */ ! 583: /* must advance both st and n and halt at right time */ ! 584: ! 585: if( (mlop = n->mlnode.op) < OPSIMP ){ ! 586: switch( optype(mlop) ){ ! 587: ! 588: default: ! 589: cerror("(2)unknown opcode: %o",mlop); ! 590: case BITYPE: ! 591: goto binary; ! 592: case UTYPE: ! 593: st = st->left; ! 594: break; ! 595: case LTYPE: ! 596: goto leaf; ! 597: } ! 598: } ! 599: else{ ! 600: if( mamask[mlop - OPSIMP] & ! 601: (SIMPFLG|COMMFLG|MULFLG|DIVFLG|LOGFLG|FLOFLG|SHFFLG) ){ ! 602: binary: ! 603: *mlsp++ = BITYPE; ! 604: *stp++ = st; ! 605: st = st->left; ! 606: } ! 607: else if( ! (mamask[mlop-OPSIMP] & UTYPE) ){/* includes OPANY */ ! 608: ! 609: leaf: ! 610: if( mlsp == mlstack ) ! 611: goto matched; ! 612: else if ( *--mlsp != BITYPE ) ! 613: cerror("(2)bad multi-level tree descriptor around mltree[%d]", ! 614: n-mltree); ! 615: st = (*--stp)->right; ! 616: } ! 617: else /* UNARY */ st = st->left; ! 618: } ! 619: continue; ! 620: ! 621: matched: ! 622: /* complete multi-level match successful */ ! 623: # ifndef BUG3 ! 624: if( vdebug ) printf("mlmatch() success\n"); ! 625: # endif ! 626: if( head->mlhead.subtag == 0 ) return( MDONE ); ! 627: else { ! 628: # ifndef BUG3 ! 629: if( vdebug )printf("\treturns %d\n", ! 630: head->mlhead.subtag ); ! 631: # endif ! 632: return( head->mlhead.subtag ); ! 633: } ! 634: } ! 635: } ! 636: return( 0 ); ! 637: } ! 638: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.