/* * The idea is to remove redundant constants. * $c1->v1 * ($c1->v2 s/$c1/v1)* * set v1 return * The v1->v2 should be eliminated by copy propagation. */ void constprop(Adr *c1, Adr *v1, Reg *r) { Prog *p; if(debug['C']) print("constprop %D->%D\n", c1, v1); for(; r != R; r = r->s1) { p = r->prog; if(debug['C']) print("%P", p); if(uniqp(r) == R) { if(debug['C']) print("; merge; return\n"); return; } if(p->as == AMOVW && copyas(&p->from, c1)) { if(debug['C']) print("; sub%D/%D", &p->from, v1); p->from = *v1; } else if(copyu(p, v1, A) > 1) { if(debug['C']) print("; %Dset; return\n", v1); return; } if(debug['C']) print("\n"); if(r->s2) constprop(c1, v1, r->s2); } }
void optfunc() { #if !HTOD block *b; int iter; // iteration count clock_t starttime; cmes ("optfunc()\n"); dbg_optprint("optfunc\n"); #ifdef DEBUG if (debugb) { dbg_printf("................Before optimization.........\n"); WRfunc(); } #endif iter = 0; if (localgot) { // Initialize with: // localgot = OPgot; elem *e = el_long(TYnptr, 0); e->Eoper = OPgot; e = el_bin(OPeq, TYnptr, el_var(localgot), e); startblock->Belem = el_combine(e, startblock->Belem); } // Each pass through the loop can reduce only one level of comma expression. // The infinite loop check needs to take this into account. int iterationLimit = 0; for (b = startblock; b; b = b->Bnext) { if (!b->Belem) continue; int d = el_countCommas(b->Belem); if (d > iterationLimit) iterationLimit = d; } // Some functions can take enormous amounts of time to optimize. // We try to put a lid on it. starttime = clock(); do { //printf("iter = %d\n", iter); #if TX86 if (++iter > 200) { assert(iter < iterationLimit); // infinite loop check break; } #else L1: #endif #if MARS util_progress(); #else file_progress(); #endif //printf("optelem\n"); /* canonicalize the trees */ for (b = startblock; b; b = b->Bnext) if (b->Belem) { #if DEBUG if(debuge) { dbg_printf("before\n"); elem_print(b->Belem); //el_check(b->Belem); } #endif b->Belem = doptelem(b->Belem,bc_goal[b->BC] | GOALagain); #if DEBUG if(0 && debugf) { dbg_printf("after\n"); elem_print(b->Belem); } #endif } //printf("blockopt\n"); #if TX86 if (mfoptim & MFdc) blockopt(0); // do block optimization out_regcand(&globsym); // recompute register candidates changes = 0; /* no changes yet */ if (mfoptim & MFcnp) constprop(); /* make relationals unsigned */ if (mfoptim & (MFli | MFliv)) #else if (config.optimized && (mfoptim & MFdc)) blockopt(0); // do block optimization dbg_optprint("blockopt\n"); out_regcand(); // recompute register candidates changes = 0; /* no changes yet */ dbg_optprint("constprop\n"); if (config.optimized && (mfoptim & MFcnp)) constprop(); /* make relationals unsigned */ dbg_optprint("loopopt\n"); if (config.optimized && (mfoptim & (MFli | MFliv))) #endif loopopt(); /* remove loop invariants and */ /* induction vars */ /* do loop rotation */ else for (b = startblock; b; b = b->Bnext) b->Bweight = 1; dbg_optprint("boolopt\n"); #if TX86 if (mfoptim & MFcnp) boolopt(); // optimize boolean values if (changes && mfoptim & MFloop && (clock() - starttime) < 30 * CLOCKS_PER_SEC) continue; if (mfoptim & MFcnp) constprop(); /* constant propagation */ if (mfoptim & MFcp) copyprop(); /* do copy propagation */ /* Floating point constants and string literals need to be * replaced with loads from variables in read-only data. * This can result in localgot getting needed. */ symbol *localgotsave = localgot; for (b = startblock; b; b = b->Bnext) { if (b->Belem) { b->Belem = doptelem(b->Belem,bc_goal[b->BC] | GOALstruct); if (b->Belem) b->Belem = el_convert(b->Belem); } } if (localgot != localgotsave) { /* Looks like we did need localgot, initialize with: * localgot = OPgot; */ elem *e = el_long(TYnptr, 0); e->Eoper = OPgot; e = el_bin(OPeq, TYnptr, el_var(localgot), e); startblock->Belem = el_combine(e, startblock->Belem); } /* localize() is after localgot, otherwise we wind up with * more than one OPgot in a function, which mucks up OSX * code generation which assumes at most one (localgotoffset). */ if (mfoptim & MFlocal) localize(); // improve expression locality if (mfoptim & MFda) rmdeadass(); /* remove dead assignments */ cmes2 ("changes = %d\n", changes); if (!(changes && mfoptim & MFloop && (clock() - starttime) < 30 * CLOCKS_PER_SEC)) break; } while (1); cmes2("%d iterations\n",iter); if (mfoptim & MFdc) blockopt(1); // do block optimization #else if (config.optimized && (mfoptim & MFcnp)) boolopt(); // optimize boolean values util_progress(); if (changes) goto L1; dbg_optprint("constprop\n"); if (config.optimized && (mfoptim & MFcnp)) constprop(); /* constant propagation */ dbg_optprint("copyprop\n"); if (config.optimized && (mfoptim & MFcp)) copyprop(); /* do copy propagation */ dbg_optprint("localize\n"); if (config.optimized && (mfoptim & MFlocal)) localize(); // improve expression locality dbg_optprint("rmdeadass\n"); if (config.optimized && (mfoptim & MFda)) rmdeadass(); /* remove dead assignments */ cmes2 ("changes = %d\n", changes); iter++; assert (iter < 80); /* infinite loop check */ } while (changes && (config.optimized) && (mfoptim & MFloop));
void peep(Prog *firstp) { Flow *r; Graph *g; Prog *p; int t; g = flowstart(firstp, sizeof(Flow)); if(g == nil) return; for(r=g->start, t=0; r!=nil; r=r->link, t++) r->active = t; loop1: if(debug['P'] && debug['v']) dumpit("loop1", g->start, 0); t = 0; for(r=g->start; r!=nil; r=r->link) { p = r->prog; switch(p->as) { case ASLL: case ASRL: case ASRA: /* * elide shift into D_SHIFT operand of subsequent instruction */ // if(shiftprop(r)) { // excise(r); // t++; // break; // } break; case AMOVB: case AMOVH: case AMOVW: case AMOVF: case AMOVD: if(regtyp(&p->from)) if(p->from.type == p->to.type) if(p->scond == C_SCOND_NONE) { if(copyprop(g, r)) { excise(r); t++; break; } if(subprop(r) && copyprop(g, r)) { excise(r); t++; break; } } break; case AMOVHS: case AMOVHU: case AMOVBS: case AMOVBU: if(p->from.type == D_REG) { if(shortprop(r)) t++; } break; #ifdef NOTDEF if(p->scond == C_SCOND_NONE) if(regtyp(&p->to)) if(isdconst(&p->from)) { constprop(&p->from, &p->to, r->s1); } break; #endif } } if(t) goto loop1; for(r=g->start; r!=nil; r=r->link) { p = r->prog; switch(p->as) { case AEOR: /* * EOR -1,x,y => MVN x,y */ if(isdconst(&p->from) && p->from.offset == -1) { p->as = AMVN; p->from.type = D_REG; if(p->reg != NREG) p->from.reg = p->reg; else p->from.reg = p->to.reg; p->reg = NREG; } break; } } for(r=g->start; r!=nil; r=r->link) { p = r->prog; switch(p->as) { case AMOVW: case AMOVB: case AMOVBS: case AMOVBU: if(p->from.type == D_OREG && p->from.offset == 0) xtramodes(g, r, &p->from); else if(p->to.type == D_OREG && p->to.offset == 0) xtramodes(g, r, &p->to); else continue; break; // case ACMP: // /* // * elide CMP $0,x if calculation of x can set condition codes // */ // if(isdconst(&p->from) || p->from.offset != 0) // continue; // r2 = r->s1; // if(r2 == nil) // continue; // t = r2->prog->as; // switch(t) { // default: // continue; // case ABEQ: // case ABNE: // case ABMI: // case ABPL: // break; // case ABGE: // t = ABPL; // break; // case ABLT: // t = ABMI; // break; // case ABHI: // t = ABNE; // break; // case ABLS: // t = ABEQ; // break; // } // r1 = r; // do // r1 = uniqp(r1); // while (r1 != nil && r1->prog->as == ANOP); // if(r1 == nil) // continue; // p1 = r1->prog; // if(p1->to.type != D_REG) // continue; // if(p1->to.reg != p->reg) // if(!(p1->as == AMOVW && p1->from.type == D_REG && p1->from.reg == p->reg)) // continue; // // switch(p1->as) { // default: // continue; // case AMOVW: // if(p1->from.type != D_REG) // continue; // case AAND: // case AEOR: // case AORR: // case ABIC: // case AMVN: // case ASUB: // case ARSB: // case AADD: // case AADC: // case ASBC: // case ARSC: // break; // } // p1->scond |= C_SBIT; // r2->prog->as = t; // excise(r); // continue; } } // predicate(g); flowend(g); }
void peep(void) { Reg *r, *r1, *r2; Prog *p, *p1; int t; /* * complete R structure */ t = 0; for(r=firstr; r!=R; r=r1) { r1 = r->link; if(r1 == R) break; p = r->prog->link; while(p != r1->prog) switch(p->as) { default: r2 = rega(); r->link = r2; r2->link = r1; r2->prog = p; r2->p1 = r; r->s1 = r2; r2->s1 = r1; r1->p1 = r2; r = r2; t++; case ADATA: case AGLOBL: case ANAME: case ASIGNAME: p = p->link; } } loop1: t = 0; for(r=firstr; r!=R; r=r->link) { p = r->prog; if(p->as == ASLL || p->as == ASRL || p->as == ASRA) { /* * elide shift into D_SHIFT operand of subsequent instruction */ if(shiftprop(r)) { excise(r); t++; } } if(p->as == AMOVW || p->as == AMOVF || p->as == AMOVD) if(regtyp(&p->to)) { if(p->from.type == D_CONST) constprop(&p->from, &p->to, r->s1); else if(regtyp(&p->from)) if(p->from.type == p->to.type) { if(copyprop(r)) { excise(r); t++; } else if(subprop(r) && copyprop(r)) { excise(r); t++; } } } } if(t) goto loop1; /* * look for MOVB x,R; MOVB R,R */ for(r=firstr; r!=R; r=r->link) { p = r->prog; switch(p->as) { default: continue; case AEOR: /* * EOR -1,x,y => MVN x,y */ if(p->from.type == D_CONST && p->from.offset == -1) { p->as = AMVN; p->from.type = D_REG; if(p->reg != NREG) p->from.reg = p->reg; else p->from.reg = p->to.reg; p->reg = NREG; } continue; case AMOVH: case AMOVHU: case AMOVB: case AMOVBU: if(p->to.type != D_REG) continue; break; } r1 = r->link; if(r1 == R) continue; p1 = r1->prog; if(p1->as != p->as) continue; if(p1->from.type != D_REG || p1->from.reg != p->to.reg) continue; if(p1->to.type != D_REG || p1->to.reg != p->to.reg) continue; excise(r1); } for(r=firstr; r!=R; r=r->link) { p = r->prog; switch(p->as) { case AMOVW: case AMOVB: case AMOVBU: if(p->from.type == D_OREG && p->from.offset == 0) xtramodes(r, &p->from); else if(p->to.type == D_OREG && p->to.offset == 0) xtramodes(r, &p->to); else continue; break; case ACMP: /* * elide CMP $0,x if calculation of x can set condition codes */ if(p->from.type != D_CONST || p->from.offset != 0) continue; r2 = r->s1; if(r2 == R) continue; t = r2->prog->as; switch(t) { default: continue; case ABEQ: case ABNE: case ABMI: case ABPL: break; case ABGE: t = ABPL; break; case ABLT: t = ABMI; break; case ABHI: t = ABNE; break; case ABLS: t = ABEQ; break; } r1 = r; do r1 = uniqp(r1); while (r1 != R && r1->prog->as == ANOP); if(r1 == R) continue; p1 = r1->prog; if(p1->to.type != D_REG) continue; if(p1->to.reg != p->reg) if(!(p1->as == AMOVW && p1->from.type == D_REG && p1->from.reg == p->reg)) continue; switch(p1->as) { default: continue; case AMOVW: if(p1->from.type != D_REG) continue; case AAND: case AEOR: case AORR: case ABIC: case AMVN: case ASUB: case ARSB: case AADD: case AADC: case ASBC: case ARSC: break; } p1->scond |= C_SBIT; r2->prog->as = t; excise(r); continue; } } predicate(); }
void peep(void) { Reg *r, *r1, *r2; Prog *p, *p1; int t; p1 = nil; USED(p1); // ... in unreachable code... /* * complete R structure */ for(r=firstr; r!=R; r=r1) { r1 = r->link; if(r1 == R) break; p = r->prog->link; while(p != r1->prog) switch(p->as) { default: r2 = rega(); r->link = r2; r2->link = r1; r2->prog = p; r2->p1 = r; r->s1 = r2; r2->s1 = r1; r1->p1 = r2; r = r2; case ADATA: case AGLOBL: case ANAME: case ASIGNAME: p = p->link; } } //dumpit("begin", firstr); loop1: t = 0; for(r=firstr; r!=R; r=r->link) { p = r->prog; switch(p->as) { case ASLL: case ASRL: case ASRA: /* * elide shift into D_SHIFT operand of subsequent instruction */ // if(shiftprop(r)) { // excise(r); // t++; // break; // } break; case AMOVW: case AMOVF: case AMOVD: if(regtyp(&p->from)) if(p->from.type == p->to.type) if(p->scond == C_SCOND_NONE) { if(copyprop(r)) { excise(r); t++; break; } if(subprop(r) && copyprop(r)) { excise(r); t++; break; } } break; #ifdef NOTDEF if(p->scond == C_SCOND_NONE) if(regtyp(&p->to)) if(isdconst(&p->from)) { constprop(&p->from, &p->to, r->s1); } break; #endif } } if(t) goto loop1; return; #ifdef NOTDEF for(r=firstr; r!=R; r=r->link) { p = r->prog; switch(p->as) { // case AEOR: // /* // * EOR -1,x,y => MVN x,y // */ // if(isdconst(&p->from) && p->from.offset == -1) { // p->as = AMVN; // p->from.type = D_REG; // if(p->reg != NREG) // p->from.reg = p->reg; // else // p->from.reg = p->to.reg; // p->reg = NREG; // } // break; case AMOVH: case AMOVHU: case AMOVB: case AMOVBU: /* * look for MOVB x,R; MOVB R,R */ if(p->to.type != D_REG) break; if(r1 == R) break; p1 = r1->prog; if(p1->as != p->as) break; if(p1->from.type != D_REG || p1->from.reg != p->to.reg) break; if(p1->to.type != D_REG || p1->to.reg != p->to.reg) break; excise(r1); break; } r1 = r->link; } // for(r=firstr; r!=R; r=r->link) { // p = r->prog; // switch(p->as) { // case AMOVW: // case AMOVB: // case AMOVBU: // if(p->from.type == D_OREG && p->from.offset == 0) // xtramodes(r, &p->from); // else // if(p->to.type == D_OREG && p->to.offset == 0) // xtramodes(r, &p->to); // else // continue; // break; // case ACMP: // /* // * elide CMP $0,x if calculation of x can set condition codes // */ // if(isdconst(&p->from) || p->from.offset != 0) // continue; // r2 = r->s1; // if(r2 == R) // continue; // t = r2->prog->as; // switch(t) { // default: // continue; // case ABEQ: // case ABNE: // case ABMI: // case ABPL: // break; // case ABGE: // t = ABPL; // break; // case ABLT: // t = ABMI; // break; // case ABHI: // t = ABNE; // break; // case ABLS: // t = ABEQ; // break; // } // r1 = r; // do // r1 = uniqp(r1); // while (r1 != R && r1->prog->as == ANOP); // if(r1 == R) // continue; // p1 = r1->prog; // if(p1->to.type != D_REG) // continue; // if(p1->to.reg != p->reg) // if(!(p1->as == AMOVW && p1->from.type == D_REG && p1->from.reg == p->reg)) // continue; // // switch(p1->as) { // default: // continue; // case AMOVW: // if(p1->from.type != D_REG) // continue; // case AAND: // case AEOR: // case AORR: // case ABIC: // case AMVN: // case ASUB: // case ARSB: // case AADD: // case AADC: // case ASBC: // case ARSC: // break; // } // p1->scond |= C_SBIT; // r2->prog->as = t; // excise(r); // continue; // } // } predicate(); #endif }