![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to register.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / c2|
Return to register.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)register.c 1.1 86/02/03 Copyr 1985 Sun Micro"; ! 3: #endif ! 4: ! 5: /* ! 6: * Copyright (c) 1985 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: #include "as.h" ! 10: #include "c2.h" ! 11: ! 12: extern struct ins_bkt *sopcode(); ! 13: extern NODE *insert_label(); ! 14: extern struct oper *newoperand(); ! 15: extern unsigned short make_touchop(); ! 16: int fortranprog = 0; ! 17: static struct sym_bkt *skyname; ! 18: #if TRACKSP ! 19: extern int spoffset; /* track a6-a7 distance */ ! 20: #endif TRACKSP ! 21: ! 22: extern struct ins_bkt *moveq, *subql, *addql; ! 23: ! 24: #define NREG (FP7REG-D0REG+1) ! 25: #define CONSRC 0 ! 26: #define CONDST 1 ! 27: struct regcon { ! 28: struct oper con; ! 29: subop_t size; ! 30: } regcon[ NREG ][2]; ! 31: ! 32: #define NMEM 100 /* totally arbitrary number */ ! 33: static struct memcon { ! 34: struct oper addr; ! 35: subop_t size; ! 36: struct oper value; ! 37: } memcon[ NMEM ]; ! 38: int nmem = 0; /* max memcon slot taken */ ! 39: ! 40: int bytesize[] = { ! 41: 1, /* SUBOP_B */ ! 42: 2, /* SUBOP_W */ ! 43: 4, /* SUBOP_L */ ! 44: 4, /* SUBOP_S */ ! 45: 8, /* SUBOP_D */ ! 46: 12, /* SUBOP_X */ ! 47: 12 /* SUBOP_P */ ! 48: }; ! 49: ! 50: #define BYTESIZE( s ) (bytesize[ (int)(s)]) ! 51: ! 52: int ! 53: dead_areg( p ) ! 54: NODE *p; ! 55: { ! 56: register i; ! 57: regmask m; m = p->rlive; ! 58: for (i=A6REG-1; i>=A0REG; i--) ! 59: if (!inmask(i, m )) ! 60: return i; ! 61: return -1; ! 62: } ! 63: ! 64: int ! 65: dead_dreg( p ) ! 66: NODE *p; ! 67: { ! 68: register i; ! 69: regmask m; m = p->rlive; ! 70: for (i=A0REG-1; i>=D0REG; i--) ! 71: if (!inmask(i, m )) ! 72: return i; ! 73: return -1; ! 74: } ! 75: ! 76: ! 77: int ! 78: cancache( o ) register struct oper *o; ! 79: { ! 80: /* ! 81: * currently, the only memory references we can cache are stack ! 82: * bound variables (and FORTRAN locals) ! 83: */ ! 84: extern int Xperimental; ! 85: ! 86: if (Xperimental) ! 87: switch (o->type_o){ ! 88: case T_REG: ! 89: case T_IMMED: ! 90: case T_PREDEC: ! 91: case T_POSTINC: return 0; ! 92: default: return 1; /* slut */ ! 93: } ! 94: if (o->type_o == T_DEFER || o->type_o == T_DISPL) ! 95: if (o->reg_o == FPREG || fortranprog && (o->reg_o==A0REG+4 || o->reg_o==A0REG+5)) ! 96: return 1; ! 97: return 0; ! 98: } ! 99: ! 100: static int ! 101: istmp( o ) register struct oper *o; ! 102: { ! 103: if ((o->type_o==T_DEFER && o->reg_o==FPREG) ! 104: || (o->type_o==T_DISPL && o->reg_o==FPREG && o->value_o>=0)) ! 105: return 1; ! 106: return 0; ! 107: } ! 108: ! 109: static int ! 110: isindir( o ) struct oper *o; ! 111: { ! 112: switch (o->type_o){ ! 113: case T_DEFER : ! 114: if (o->value_o == A6REG) return 0; ! 115: else return 1; ! 116: case T_DISPL: ! 117: if (o->reg_o == A6REG) return 0; ! 118: else return 1; ! 119: case T_INDEX: ! 120: return 1; ! 121: default: ! 122: return 0; ! 123: } ! 124: } ! 125: ! 126: struct oper * ! 127: get_regcon( regno ) ! 128: int regno; ! 129: { ! 130: return ®con[regno][CONSRC].con; ! 131: } ! 132: ! 133: void ! 134: forgetall() ! 135: { ! 136: register regno; ! 137: for (regno=0; regno< NREG ; regno++){ ! 138: regcon[regno][CONSRC].con.type_o = T_NULL; ! 139: regcon[regno][CONDST].con.type_o = T_NULL; ! 140: } ! 141: nmem = 0; ! 142: } ! 143: ! 144: static void ! 145: forgetlocals(forgetsky) ! 146: { ! 147: register regno; ! 148: register struct sym_bkt *sk; ! 149: register struct oper *sp; ! 150: sk = (forgetsky) ? (struct sym_bkt *)-1 : skyname ; ! 151: for (regno=0; regno< NREG ; regno++){ ! 152: if ( (sp= ®con[regno][CONSRC].con)->type_o!=T_NULL ! 153: && sp->type_o!=T_IMMED && sp->sym_o != sk) ! 154: sp->type_o = T_NULL; ! 155: regcon[regno][CONDST].con.type_o = T_NULL; /* always */ ! 156: } ! 157: nmem = 0; ! 158: } ! 159: ! 160: static struct memcon * ! 161: memfind( o, l, inexact, startaddr, startn ) ! 162: register struct oper *o; ! 163: subop_t l; ! 164: int *inexact; ! 165: struct memcon *startaddr; ! 166: int *startn; ! 167: { ! 168: /* ! 169: * lookup this operand at this length in the memory/constant ! 170: * table. Return pointer to the slot where we find it. If ! 171: * the address-length correspondence is inexact, set *inexact. ! 172: * Assume cancache(o). ! 173: * Assume there is no aliasing problem in the memory table. ! 174: */ ! 175: register i; ! 176: register struct memcon *mo; ! 177: register operand_t t=o->type_o; ! 178: int membegin = 0, memend, conbegin, conend; ! 179: int r; ! 180: switch (t){ ! 181: case T_DISPL: ! 182: r = o->reg_o; ! 183: /* FALL THROUGH */ ! 184: case T_ABSS: ! 185: case T_ABSL: ! 186: case T_NORMAL: ! 187: membegin = o->value_o; ! 188: memend = membegin + BYTESIZE(l)-1; ! 189: break; ! 190: case T_DEFER: ! 191: r = o->value_o; ! 192: memend = membegin + BYTESIZE(l)-1; ! 193: } ! 194: for (i= *startn, mo = startaddr; --i >= 0; mo++ ) ! 195: if (mo->addr.type_o != T_NULL && t == mo->addr.type_o ){ ! 196: switch ( t ){ ! 197: case T_ABSS: ! 198: case T_ABSL: ! 199: case T_NORMAL: ! 200: if (o->sym_o != mo->addr.sym_o) continue; ! 201: conbegin = mo->addr.value_o; ! 202: goto compare; ! 203: case T_DISPL: ! 204: if (mo->addr.reg_o != r) continue; ! 205: conbegin = mo->addr.value_o; ! 206: goto compare; ! 207: case T_DEFER: ! 208: if (mo->addr.value_o != r) continue; ! 209: conbegin = 0; ! 210: compare: ! 211: conend = conbegin + BYTESIZE(mo->size)-1; ! 212: if ( membegin< conend && conbegin < memend ){ ! 213: *inexact = ! (membegin==conbegin && l==mo->size); ! 214: *startn = i; ! 215: return mo; ! 216: } ! 217: } ! 218: } ! 219: *startn = 0; ! 220: return NULL; ! 221: } ! 222: ! 223: struct oper * ! 224: memlookup( o, l ) ! 225: { ! 226: /* abstract away the "inexact" problem from memfind() */ ! 227: int inexact; ! 228: int ntable = nmem; ! 229: struct memcon *m = &memcon[-1]; ! 230: ! 231: while ( (m=memfind( o, l, &inexact, m+1, &ntable)) != NULL ) ! 232: if ( !inexact ) return (&m->value); ! 233: return NULL; ! 234: } ! 235: ! 236: int ! 237: regfind( o, l, inexact, firstreg, firstpart, part ) ! 238: register struct oper *o; ! 239: subop_t l; ! 240: int *inexact; ! 241: register firstpart; ! 242: int *part; ! 243: { ! 244: /* ! 245: * lookup this operand at this length in the register ! 246: * table. Return the register number that matched. If ! 247: * the address-length correspondence is inexact, set *inexact. ! 248: * Assume cancache(o) or o->type_o==T_IMMED. ! 249: */ ! 250: register i,j; ! 251: register struct regcon *mo; ! 252: register operand_t t=o->type_o; ! 253: int membegin , memend, conbegin, conend; ! 254: int r; ! 255: switch (t){ ! 256: case T_DISPL: ! 257: r = o->reg_o; ! 258: /* FALL THROUGH */ ! 259: case T_ABSS: ! 260: case T_ABSL: ! 261: case T_NORMAL: ! 262: membegin = o->value_o; ! 263: memend = membegin + BYTESIZE(l); ! 264: break; ! 265: case T_DEFER: ! 266: r = o->value_o; ! 267: membegin = 0; ! 268: memend = BYTESIZE(l); ! 269: } ! 270: for (i=firstreg ; i<NREG; i++ ){ ! 271: for (j=firstpart; j<=CONDST; j++){ ! 272: mo = & regcon[i][j]; ! 273: if (mo->con.type_o != T_NULL && t == mo->con.type_o ){ ! 274: switch ( t ){ ! 275: case T_IMMED: ! 276: if ((mo->con.flags_o & O_FLOAT) != (o->flags_o & O_FLOAT)){ ! 277: break; ! 278: } else if (mo->con.flags_o & O_FLOAT ){ ! 279: if (mo->con.fval_o == o->fval_o){ ! 280: *inexact = 0; ! 281: return i; ! 282: } ! 283: } else if (mo->con.value_o == o->value_o ! 284: && mo->con.sym_o == o->sym_o ){ ! 285: *inexact = 0; ! 286: return i; ! 287: } ! 288: break; ! 289: case T_ABSS: ! 290: case T_ABSL: ! 291: case T_NORMAL: ! 292: if (o->sym_o != mo->con.sym_o) continue; ! 293: conbegin = mo->con.value_o; ! 294: goto compare; ! 295: case T_DISPL: ! 296: conbegin = mo->con.value_o; ! 297: if (mo->con.reg_o != r) continue; ! 298: goto compare; ! 299: case T_DEFER: ! 300: conbegin = 0; ! 301: if (mo->con.value_o != r) continue; ! 302: compare: ! 303: conend = conbegin + BYTESIZE(mo->size); ! 304: if ( membegin< conend && conbegin < memend ){ ! 305: *inexact = ! (membegin==conbegin && l==mo->size); ! 306: *part = j; ! 307: return i; ! 308: } ! 309: } ! 310: } ! 311: } ! 312: firstpart = CONSRC; ! 313: } ! 314: return -1; ! 315: } ! 316: ! 317: int ! 318: reglookup( o, l ) ! 319: struct oper *o; ! 320: subop_t l; ! 321: { ! 322: /* abstract away the "inexact" problem from regfind() */ ! 323: int inexact, part; ! 324: int r; ! 325: r = regfind( o, l, &inexact, D0REG, CONSRC, &part ); ! 326: if ( inexact ) return -1; ! 327: else return r; ! 328: } ! 329: ! 330: static void ! 331: meminsert( o , v, l ) ! 332: struct oper *o; ! 333: struct oper *v; ! 334: subop_t l; ! 335: { ! 336: /* ! 337: * look for a free slot in the memcon table to insert an entry. ! 338: * try to add at the end, but if the table is complete, then look ! 339: * for holes. If we still cannot find anything, just forget it. ! 340: * Assume that our caller already tried for an address match ! 341: * and would have inserted by easier means if possible. ! 342: */ ! 343: struct memcon *m; ! 344: if (nmem < NMEM){ ! 345: /* regular case */ ! 346: m = &memcon[nmem++]; ! 347: } else { ! 348: /* have to search */ ! 349: for (m= &memcon[0]; m > &memcon[NMEM-1]; m++){ ! 350: if (m->addr.type_o == T_NULL) goto gotone; ! 351: } ! 352: return ; /* oh, just forget it */ ! 353: } ! 354: gotone: ! 355: m->addr = *o; ! 356: m->size = l; ! 357: m->value = *v; ! 358: } ! 359: ! 360: static void ! 361: put_in_mem_table( o, v, l) ! 362: struct oper *o; ! 363: struct oper *v; ! 364: subop_t l; ! 365: { ! 366: /* ! 367: * put this address/value in the memcon table ! 368: * deal with aliasing. This is tricky. ! 369: */ ! 370: int nalias = 0, nexact = 0; ! 371: int inexact, ntabl = nmem; ! 372: struct memcon * m; ! 373: int src, dest, nbytes ; ! 374: union stuff{ /* KNOWS ABOUT 68000 MEMORY LAYOUT !!! */ ! 375: char bytes[4]; ! 376: short words[2]; ! 377: long longword; ! 378: } mine, his; ! 379: int sympart = v->sym_o!=NULL; ! 380: ! 381: ! 382: /* initialize my equivalencing structure */ ! 383: mine.longword = 0L; ! 384: if (!sympart) ! 385: switch (l){ ! 386: case SUBOP_B: mine.bytes[0] = v->value_o; break; ! 387: case SUBOP_W: mine.words[0] = v->value_o; break; ! 388: default: mine.longword = v->value_o; break; ! 389: } ! 390: ! 391: m = &memcon[-1]; ! 392: while( (m=memfind( o, l, &inexact, m+1, &ntabl )) != NULL ){ ! 393: if (inexact) { ! 394: /* ! 395: * either the address or the length don't agree. ! 396: * fix up the current entry as appropriate, then continue. ! 397: */ ! 398: if (sympart || m->value.sym_o != NULL){ ! 399: /* ! 400: * had or will have symbolic part ! 401: * cannot deal with inexact matches ! 402: */ ! 403: m->addr.type_o = T_NULL; /* forget it */ ! 404: continue; ! 405: } ! 406: /* fill in his equivalencing structure */ ! 407: his.longword = 0L; ! 408: switch (m->size){ ! 409: case SUBOP_B: his.bytes[0] = m->value.value_o; break; ! 410: case SUBOP_W: his.words[0] = m->value.value_o; break; ! 411: default: his.longword = m->value.value_o; break; ! 412: } ! 413: if (o->value_o >= m->addr.value_o){ ! 414: /* new starts after old */ ! 415: src = 0; ! 416: dest = o->value_o - m->addr.value_o; ! 417: } else { ! 418: src = m->addr.value_o - o->value_o ; ! 419: dest = 0; ! 420: } ! 421: nbytes = BYTESIZE( l ); ! 422: if (nbytes > BYTESIZE( m->size )-dest ) ! 423: nbytes = BYTESIZE(m->size)-dest; ! 424: while (nbytes--){ ! 425: his.bytes[dest++] = mine.bytes[src++]; ! 426: } ! 427: /* shovel back */ ! 428: switch (m->size){ ! 429: case SUBOP_B: m->value.value_o = his.bytes[0]; break; ! 430: case SUBOP_W: m->value.value_o = his.words[0]; break; ! 431: default: m->value.value_o = his.longword; break; ! 432: } ! 433: nalias++; ! 434: } else { ! 435: m->value = *v; ! 436: nexact++; ! 437: } ! 438: } ! 439: if ((nalias && nexact) || (nalias>4)) ! 440: sys_error("Multiple aliasing in memory table\n"); ! 441: if (nalias==0 && nexact==0){ ! 442: /* new entry -- stick it in. */ ! 443: meminsert( o , v, l ); ! 444: } ! 445: } ! 446: ! 447: ! 448: static void ! 449: forgetop( o, l ) ! 450: struct oper *o; ! 451: subop_t l; ! 452: { ! 453: int r, inexact, part; ! 454: int ntable = nmem; ! 455: struct memcon *m = &memcon[-1]; ! 456: ! 457: r = D0REG; ! 458: part = CONSRC; ! 459: while( (r = regfind( o, l, &inexact, r, part, &part )) >= D0REG){ ! 460: regcon[ r ][ part ].con.type_o = T_NULL; ! 461: if ( ++part > CONDST ){ ! 462: r++; ! 463: part = CONSRC; ! 464: } ! 465: } ! 466: ! 467: while ( (m=memfind( o, l, &inexact, m+1, &ntable)) != NULL ) ! 468: m->addr.type_o = T_NULL; ! 469: } ! 470: ! 471: static void ! 472: substitute( p, op, new ) ! 473: NODE *p; ! 474: struct oper *op, *new; ! 475: { ! 476: /* ! 477: * p is an instruction. ! 478: * op points to an operand of that instruction. ! 479: * new points to a (register) operand structure that we want to ! 480: * substitute for the one op addresses. ! 481: * Do the substitution and calculate the new properties of p ! 482: */ ! 483: *op = *new; ! 484: installinstruct( p, p->instr ); ! 485: p->rlive = compute_normal( p, p->forw->rlive); ! 486: } ! 487: ! 488: static int ! 489: track_cc( n ) ! 490: NODE *n; ! 491: { ! 492: /* ! 493: * we just moved a constant into a register. ! 494: * look for subsequent compares/ tests of ! 495: * the register, followed by jumps, even after cc is kilt ! 496: */ ! 497: register struct oper *op2, *comperand; ! 498: struct oper *o; ! 499: register NODE *p; ! 500: NODE *target; ! 501: subop_t so; ! 502: long v, compval; ! 503: static struct oper conz = { T_IMMED, 0, 0, NULL, 0, 0, 0 }; ! 504: int didchange = 0; ! 505: ! 506: if (n->op==OP_MOVE){ ! 507: op2 = n->ref[1]; ! 508: comperand = n->ref[0]; ! 509: if (comperand->type_o != T_IMMED) return 0; ! 510: } else { ! 511: /* CLR */ ! 512: op2 = n->ref[0]; ! 513: comperand = &conz; ! 514: } ! 515: if (!deladdr(op2)) return 0; ! 516: so = n->subop; ! 517: v = comperand->value_o; ! 518: for (p = n->forw; p->op!=OP_FIRST ; p = p->forw){ ! 519: switch (p->op){ ! 520: case OP_LABEL: ! 521: continue; ! 522: case OP_JUMP: ! 523: if (p->subop==JALL){ ! 524: if (p->luse == p->back){ ! 525: /* selfloop */ ! 526: break; ! 527: } ! 528: /* follow! */ ! 529: p = p->luse->back; ! 530: continue; ! 531: } ! 532: break; ! 533: case OP_TST: ! 534: if ( sameops( p->ref[0], op2 ) && p->subop==so){ ! 535: if (comperand->sym_o!=NULL) break; ! 536: compval = 0; ! 537: goto regcmp; ! 538: } ! 539: break; ! 540: case OP_CMP: ! 541: if ( !sameops(p->ref[1], op2 ) ) break; ! 542: if ( (o=p->ref[0])->type_o != T_IMMED ) break; ! 543: if ( o->sym_o != comperand->sym_o ) break; ! 544: compval = o->value_o; ! 545: regcmp: ! 546: p=p->forw; ! 547: if (p->op==OP_JUMP){ ! 548: /* this is it */ ! 549: if (inmask( CCREG, p->luse->rlive ) || ! 550: (p->subop!=JALL && inmask( CCREG, p->forw->rlive))) ! 551: break; /* too hard -- must do the cmp */ ! 552: switch(p->subop){ ! 553: case JEQ: compval = v==compval; break; ! 554: case JNE: compval = v!=compval; break; ! 555: case JLE: compval = v<=compval; break; ! 556: case JGE: compval = v>=compval; break; ! 557: case JLT: compval = v< compval; break; ! 558: case JGT: compval = v> compval; break; ! 559: case JCC: compval = ((unsigned)v) >= ((unsigned)compval); break; ! 560: case JLS: compval = ((unsigned)v) <= ((unsigned)compval); break; ! 561: case JHI: compval = ((unsigned)v) > ((unsigned)compval); break; ! 562: case JCS: compval = ((unsigned)v) < ((unsigned)compval); break; ! 563: case JALL: compval = 1; break; ! 564: case JNONE: compval = 0; break; ! 565: default: goto nojmp; ! 566: } ! 567: if (compval) target = p->luse; ! 568: else{ ! 569: target = p->forw; ! 570: if (target->op!=OP_LABEL) ! 571: target = insert_label(target); ! 572: } ! 573: cannibalize( p=new(), "jra" ); ! 574: p->op = OP_JUMP; ! 575: newreference( target, p); ! 576: p->ruse = p->rset = regmask0; ! 577: p->rlive = target->rlive; ! 578: insert( p, n ); ! 579: didchange++; ! 580: meter.nxjump++; ! 581: /* ! 582: * we just created an unconditional jump. ! 583: * Follow it, just like jumps we find in code. ! 584: */ ! 585: p = p->luse->back; ! 586: continue; ! 587: } ! 588: } ! 589: nojmp: ! 590: break; ! 591: } ! 592: return didchange; ! 593: } ! 594: ! 595: static int ! 596: addrlookup( o ) ! 597: register struct oper *o; ! 598: { ! 599: struct oper q; ! 600: int regname; ! 601: /* ! 602: * assume that o points to an index mode, indirect address node. ! 603: * find the memory address through which we are indirecting ! 604: * and see if we already have it in an address register. If so, we ! 605: * can simplify the addressing mode in disindex(). ! 606: */ ! 607: if (o->flags_o&O_PREINDEX) return -1; ! 608: if (o->flags_o&O_BSUPRESS){ ! 609: q.type_o = T_NORMAL; ! 610: q.value_o = o->disp_o; ! 611: q.sym_o = o->sym_o; ! 612: q.flags_o = o->flags_o&O_COMPLEX; ! 613: } else { ! 614: q.type_o = T_DISPL; ! 615: q.reg_o = o->reg_o; ! 616: q.value_o = o->disp_o; ! 617: q.sym_o = o->sym_o; ! 618: q.flags_o = o->flags_o&O_COMPLEX; ! 619: if (q.value_o == 0 && q.sym_o == NULL) ! 620: q.type_o = T_DEFER; ! 621: } ! 622: if (!cancache( &q)) return -1; ! 623: regname = reglookup( &q, SUBOP_L ); ! 624: if (areg(regname)) return regname; ! 625: return -1; ! 626: } ! 627: ! 628: static void ! 629: disindex( o, regname ) ! 630: register struct oper *o; ! 631: int regname; ! 632: { ! 633: register flags; ! 634: /* ! 635: * o points to an operand of type T_INDEX with the O_INDIRECT flag set. ! 636: * o is not preindexed. The memory cell through which o indirects is ! 637: * also contained in the A register named by regname. o can be simplified ! 638: * because of this: secondary displacement becomes primary displacement, ! 639: * post indexing becomes pre indexing, and the operand is no longer indirect. ! 640: * it may be simplified to T_DEFER, T_DISPL, or T_INDEX. ! 641: */ ! 642: flags = o->flags_o & ~O_INDIRECT; ! 643: o->reg_o = regname; ! 644: o->disp_o = o->disp2_o; ! 645: o->sym_o = o->sym2_o; ! 646: if (flags&O_COMPLEX2) ! 647: flags = (flags & ~O_COMPLEX2) | O_COMPLEX; ! 648: if (flags&O_WDISP2) ! 649: flags = (flags & ~O_WDISP2)|O_WDISP; ! 650: else if (flags&O_LDISP2) ! 651: flags = (flags & ~O_LDISP2)|O_LDISP; ! 652: if ((flags & O_POSTINDEX) == 0){ ! 653: if (o->disp_o == 0 && o->sym_o == NULL){ ! 654: o->type_o = T_DEFER; ! 655: } else { ! 656: o->type_o = T_DISPL; ! 657: } ! 658: } else { ! 659: o->type_o = T_INDEX; ! 660: flags = (flags& ~O_POSTINDEX)|O_PREINDEX; ! 661: } ! 662: o->flags_o = flags; ! 663: } ! 664: ! 665: static void ! 666: kill_uses( regno ) ! 667: register int regno; ! 668: { ! 669: register struct regcon *r; ! 670: register struct memcon *m, *l; ! 671: for (r = ®con[0][CONSRC]; r <= ®con[NREG-1][CONDST]; r++) ! 672: if (r->con.type_o != T_NULL && operand_uses( &r->con, regno )){ ! 673: r->con.type_o = T_NULL; ! 674: } ! 675: for (m = &memcon[0], l = &memcon[nmem]; m < l; m++) ! 676: if (m->addr.type_o != T_NULL && operand_uses( &m->addr, regno)){ ! 677: m->addr.type_o = T_NULL; ! 678: } ! 679: } ! 680: ! 681: void ! 682: con_to_reg( regno, o, size ) ! 683: struct oper *o; ! 684: subop_t size; ! 685: { ! 686: struct regcon *r = ®con[regno][CONSRC]; ! 687: ! 688: regcon[regno][CONDST].con.type_o = T_NULL; ! 689: r->con = *o; ! 690: if (dreg(regno)) ! 691: r->size = size; ! 692: else if (areg(regno)) ! 693: r->size = SUBOP_L; ! 694: else ! 695: r->size = SUBOP_X; ! 696: if (Xperimental) ! 697: kill_uses( regno ); ! 698: } ! 699: ! 700: static int ! 701: use_moveq( n ) ! 702: register NODE *n; ! 703: { ! 704: NODE *p; ! 705: static struct oper reg = { T_REG, 0, 0, NULL, 0, 0, 0 }; ! 706: /* ! 707: * doing an immediate operation with a small constant. ! 708: * we can moveq the constant into a dead D register, ! 709: * then do operations from that register. As a bonus, ! 710: * we'll have the value around. ! 711: * Avoid the case of "movl #3,d3". This will get fixed ! 712: * in quicken() later on. ! 713: */ ! 714: ! 715: if (!long_immediate(n->op) ! 716: || n->subop != SUBOP_L ! 717: || (reg.value_o=dead_dreg(n))<0 ! 718: || !operand_ok(n->instr, ®, n->ref[1], 0) ! 719: || (n->op==OP_MOVE && dreg_addr( n->ref[1] ) )){ ! 720: return 0; ! 721: } ! 722: p = new(); ! 723: p->nref = 2; ! 724: p->ref[0] = newoperand( n->ref[0] ); ! 725: p->ref[1] = newoperand( ® ); ! 726: insert( p, n->back ); ! 727: con_to_reg( reg.value_o, n->ref[0], SUBOP_L ); ! 728: substitute( n, n->ref[0], ® ); ! 729: installinstruct( p, moveq ); ! 730: p->rlive = compute_normal( p, n->rlive ); ! 731: return 1; ! 732: } ! 733: ! 734: static void ! 735: kill_cached_mem( n, touchop ) ! 736: register NODE *n; ! 737: register touchop; ! 738: { ! 739: register i; ! 740: /* if a local is modified, invalidate our cached value */ ! 741: for (i=0;i<n->nref;i++){ ! 742: if (touchop&(BW|LW|WW)) ! 743: if (isindir(n->ref[i])) ! 744: forgetlocals(0); ! 745: else if ( cancache(n->ref[i])) ! 746: forgetop( n->ref[i], n->subop ); ! 747: touchop >>= TOUCHWIDTH; ! 748: } ! 749: } ! 750: ! 751: dumpmem(){ ! 752: int i,j; ! 753: extern char *rnames[]; ! 754: static char sizes[] = "bwlsdxp"; ! 755: for (i=0; i<NREG; i++){ ! 756: printf("%s : ", rnames[i]); ! 757: for (j=0; j <= 1; j++) ! 758: if (regcon[i][j].con.type_o == T_NULL) ! 759: printf("XXXX "); ! 760: else{ ! 761: printoperand( ®con[i][j].con ); ! 762: printf("{%c} ", sizes[(int)regcon[i][j].size]); ! 763: } ! 764: printf("\n"); ! 765: } ! 766: printf("\n"); ! 767: for (i=0; i<nmem; i++){ ! 768: if (memcon[i].addr.type_o != T_NULL){ ! 769: printoperand( &memcon[i].addr ); ! 770: printf("{%c}: ", sizes[(int)memcon[i].size]); ! 771: printoperand( &memcon[i].value ); ! 772: printf("\n"); ! 773: } ! 774: } ! 775: } ! 776: ! 777: static int ! 778: substitute_move( n, o, reg, saveop ) ! 779: register NODE *n; ! 780: struct oper *o, *reg, *saveop; ! 781: { ! 782: if (n->instr == moveq) ! 783: return 0; ! 784: substitute( n, o, reg ); ! 785: if (saveop->type_o==T_IMMED && cancache(n->ref[1])) ! 786: put_in_mem_table( n->ref[1], saveop, n->subop ); ! 787: meter.nsaddr++; ! 788: return 1; ! 789: } ! 790: ! 791: /* ! 792: * we really should be doing flow analysis here. ! 793: * lacking that, recognize special case SKY code: ! 794: * 1: tstw a1@(-4) ! 795: * bge 1b ! 796: */ ! 797: # define CHECK_LABEL(n) \ ! 798: if (n->op==OP_LABEL){ \ ! 799: if (!(n->nref==1 && n->luse==n->forw->forw && emptymask(n->forw->rset) && n->forw->forw->op==OP_JUMP)) forgetall(); \ ! 800: continue; } ! 801: ! 802: # define IMMED_OR_SKY( o ) \ ! 803: (o->type_o==T_IMMED || (o->type_o==T_NORMAL && o->value_o==0 && o->sym_o==skyname)) ! 804: ! 805: /* move to self: kill unless cc live */ ! 806: # define DELETE_SELFMOVES( n ) \ ! 807: if ( n->ref[1]->value_o==regno && (!inmask( CCREG, n->forw->rlive) || areg(regno))){ \ ! 808: n = deletenode( n ); meter.redunm++; didchange++; continue; } ! 809: ! 810: # define SMALL_IMMED( o ) \ ! 811: ((o)->type_o==T_IMMED && (o)->sym_o==NULL && !((o)->flags_o&O_FLOAT) && (v=(o)->value_o)>=-128 && v<=127) ! 812: ! 813: int ! 814: content() ! 815: { ! 816: /* ! 817: * Follow the flow of control (roughly). Look at loads into ! 818: * registers. When a constant is loaded we know: ! 819: * 1) how the CC is set. ! 820: * 2) a cheap source of that constant. ! 821: * Special case if the same register is reloaded with that constant. ! 822: * SPECIAL HACK: Assume that the contents of the global var named ! 823: * "__skybase" are constant!! ! 824: */ ! 825: register NODE *n; ! 826: register v, regno; ! 827: register struct oper *o; ! 828: struct oper *op2, *op3; ! 829: int didchange=0; ! 830: int local_read, dest_reg; ! 831: int i; ! 832: struct oper saveop; ! 833: ! 834: ! 835: static struct oper reg = { T_REG, 0, 0, NULL, 0, 0, 0 }; ! 836: ! 837: /* initialize constant table to empty. Find __skybase */ ! 838: forgetall(); ! 839: if (skyname==NULL) skyname = lookup("__skybase"); ! 840: #if TRACKSP ! 841: spoffset=0; ! 842: #endif TRACKSP ! 843: ! 844: for (n=first.forw; n!=&first; n=n->forw){ ! 845: CHECK_LABEL(n); ! 846: if (!ISINSTRUC(n->op)) continue; ! 847: dest_reg = -1; ! 848: if (n->nref){ ! 849: v = make_touchop( n, n->instr->touchop_i); ! 850: kill_cached_mem( n, v ); ! 851: o = n->ref[0]; ! 852: local_read = cancache(o) && (v&(BW|LW|WW))==0; ! 853: if (IMMED_OR_SKY( o ) || local_read ){ ! 854: /* do lookup -- do we already have it */ ! 855: regno = reglookup( o, n->subop ); ! 856: if (regno>=0 ){ ! 857: /* try to substitute */ ! 858: reg.value_o = regno; ! 859: saveop = *o; ! 860: if (operand_ok(n->instr, ®, n->ref[1], 0)){ ! 861: if (n->op==OP_MOVE){ ! 862: didchange += substitute_move( n, o, ®, &saveop ); ! 863: if ( datareg_addr( n->ref[1] ) ){ ! 864: DELETE_SELFMOVES( n ); ! 865: con_to_reg( n->ref[1]->value_o, &saveop, n->subop ); ! 866: didchange += track_cc(n); ! 867: dest_reg = n->ref[1]->value_o; ! 868: } ! 869: } else { ! 870: /* not a move -- don't think, just do it */ ! 871: substitute( n, o, ® ); ! 872: meter.nsaddr++; ! 873: didchange++; ! 874: } ! 875: } ! 876: } ! 877: if (n->nref==2 && SMALL_IMMED( o )){ ! 878: didchange+= use_moveq( n ); ! 879: } ! 880: if (local_read && (op2=memlookup(o, n->subop))!= NULL){ ! 881: /* ! 882: * this is a local that contains an immediate at this ! 883: * time. substitute the immediate value for the mem-op, ! 884: * if we may. ! 885: */ ! 886: if (operand_ok(n->instr, op2, n->ref[1], 0)){ ! 887: substitute( n, o, op2 ); ! 888: meter.nsaddr++; ! 889: didchange++; ! 890: } ! 891: } ! 892: if (n->op==OP_MOVE){ ! 893: op2 = n->ref[1]; ! 894: if (datareg_addr(op2)){ ! 895: /* move to a register */ ! 896: con_to_reg( op2->value_o, o, n->subop ); ! 897: } else if (cancache( op2)){ ! 898: if(o->type_o==T_IMMED ) ! 899: put_in_mem_table( op2, o, n->subop ); ! 900: else if (o->type_o==T_REG && datareg( regno=o->value_o ) ! 901: && (op3= ®con[regno][CONSRC].con)->type_o == T_IMMED) ! 902: put_in_mem_table( op2, op3, n->subop ); ! 903: } ! 904: /* ! 905: * we may have moved a constant into a register. ! 906: * look for subsequent compares/ tests of ! 907: * the register, followed by jumps, even after cc is kilt ! 908: */ ! 909: didchange += track_cc(n); ! 910: if (op2->type_o == T_REG) ! 911: dest_reg = op2->value_o; ! 912: } ! 913: } else if (n->op==OP_MOVE && n->ref[0]->type_o==T_REG ! 914: && cancache( n->ref[1] )){ ! 915: /* movl d0,a6@(4) ; movl a6@(4),d1 */ ! 916: regcon[v=n->ref[0]->value_o][CONDST].con = *(n->ref[1]); ! 917: regcon[v][CONDST].size = n->subop; ! 918: dest_reg = v; ! 919: } else if (n->op==OP_CALL){ ! 920: forgetlocals(1); ! 921: } else if (n->op==OP_CLR){ ! 922: didchange += track_cc(n); ! 923: if (n->ref[0]->type_o == T_REG) ! 924: dest_reg = n->ref[0]->value_o; ! 925: } ! 926: /* ! 927: * try to avoid indirecting through things ! 928: * of which we already know the value ! 929: */ ! 930: for (i=n->nref, v=0; v<i; v++){ ! 931: if ((o = n->ref[v])->type_o == T_INDEX && (o->flags_o&O_INDIRECT)) ! 932: if ((regno = addrlookup( o )) >= 0 ){ ! 933: disindex( o, regno ); ! 934: substitute( n, o, o ); ! 935: meter.nsaddr++; ! 936: } ! 937: } ! 938: } ! 939: if (!emptymask(n->rset) ){ ! 940: /* kill a constant value */ ! 941: register sets = n->rset.da; ! 942: while (sets){ ! 943: v = ffs(sets)-1; ! 944: sets ^= 1<<v; ! 945: if (v<24) ! 946: v /=3; ! 947: else ! 948: v -=(24-A0REG); ! 949: if ( v == dest_reg ) ! 950: continue; ! 951: regcon[v][CONSRC].con.type_o = T_NULL; ! 952: regcon[v][CONDST].con.type_o = T_NULL; ! 953: if (Xperimental) ! 954: kill_uses( v ); ! 955: #ifdef TRACKSP ! 956: if (v==SPREG){ ! 957: /* try to keep track of distance from a6 to a7 */ ! 958: track_sp( n ); ! 959: } ! 960: #endif TRACKSP ! 961: } ! 962: sets = n->rset.f & 0377; /* registers only, no cc */ ! 963: while (sets){ ! 964: v = ffs(sets)-1; ! 965: sets ^= 1<<v; ! 966: v += FP0REG; ! 967: if ( v == dest_reg ) ! 968: continue; ! 969: regcon[v][CONSRC].con.type_o = T_NULL; ! 970: regcon[v][CONDST].con.type_o = T_NULL; ! 971: } ! 972: } ! 973: } ! 974: return didchange; ! 975: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.