void LinearScan::allocRegs(Trace* trace) { if (RuntimeOption::EvalHHIREnableCoalescing) { // <coalesce> doesn't need instruction numbering. coalesce(trace); } numberInstructions(trace); collectNatives(trace); computePreColoringHint(); initFreeList(); allocRegsToTraceAux(trace); // Renumber instructions, because we added spills and reloads. numberInstructions(trace); if (RuntimeOption::EvalHHIREnableRematerialization && m_slots.size() > 0) { // Don't bother rematerializing the trace if it has no Spill/Reload. if (RuntimeOption::EvalDumpIR > 5) { std::cout << "--------- HHIR before rematerialization ---------\n"; trace->print(std::cout, false); std::cout << "-------------------------------------------------\n"; } rematerialize(trace); } // assignSpillLoc needs next natives in order to decide whether we // can use MMX registers. collectNatives(trace); // Make sure rsp is 16-aligned. uint32 numSpillLocs = assignSpillLoc(trace); if (numSpillLocs % 2) { ++numSpillLocs; } assert(NumPreAllocatedSpillLocs % 2 == 0); if (numSpillLocs > 0) { preAllocSpillLoc(trace, numSpillLocs); if (numSpillLocs > (uint32)NumPreAllocatedSpillLocs) { /* * We only insert AllocSpill and FreeSpill when the pre-allocated * spill locations are not enough. * * AllocSpill and FreeSpill take the number of extra spill locations * besides the pre-allocated ones. * * TODO(#2044051) AllocSpill/FreeSpill are currently disabled * due to bugs. */ PUNT(LinearScan_AllocSpill); insertAllocFreeSpill(trace, numSpillLocs - NumPreAllocatedSpillLocs); } } numberInstructions(trace); // record the live out register set at each instruction LinearScan::computeLiveOutRegs(trace); }
void LinearScan::rematerialize(Trace* trace) { rematerializeAux(trace, NULL, NULL, std::vector<SSATmp*>()); numberInstructions(trace); // We only replaced Reloads in <rematerializeAux>. // Here, we remove Spills that are never reloaded. removeUnusedSpills(trace); numberInstructions(trace); }
bool BoUpSLP::vectorizeStores(StoreList &Stores, int costThreshold) { ValueSet Heads, Tails; SmallDenseMap<Value*, Value*> ConsecutiveChain; bool Changed = false; // Do a quadratic search on all of the given stores and find // all of the pairs of loads that follow each other. for (unsigned i = 0, e = Stores.size(); i < e; ++i) for (unsigned j = 0; j < e; ++j) { if (i == j) continue; if (isConsecutiveAccess(Stores[i], Stores[j])) { Tails.insert(Stores[j]); Heads.insert(Stores[i]); ConsecutiveChain[Stores[i]] = Stores[j]; } } // For stores that start but don't end a link in the chain: for (ValueSet::iterator it = Heads.begin(), e = Heads.end();it != e; ++it) { if (Tails.count(*it)) continue; // We found a store instr that starts a chain. Now follow the chain and try // to vectorize it. ValueList Operands; Value *I = *it; int MinCost = 0, MinVF = 0; while (Tails.count(I) || Heads.count(I)) { Operands.push_back(I); unsigned VF = Operands.size(); if (isPowerOf2_32(VF) && VF > 1) { int cost = getTreeRollCost(Operands, 0); DEBUG(dbgs() << "Found cost=" << cost << " for VF=" << VF << "\n"); if (cost < MinCost) { MinCost = cost; MinVF = VF; } } // Move to the next value in the chain. I = ConsecutiveChain[I]; } if (MinCost <= costThreshold && MinVF > 1) { DEBUG(dbgs() << "Decided to vectorize cost=" << MinCost << "\n"); vectorizeTree(Operands, MinVF); Stores.clear(); // The current numbering is invalid because we added and removed instrs. numberInstructions(); Changed = true; } } return Changed; }
BoUpSLP::BoUpSLP(BasicBlock *Bb, ScalarEvolution *S, DataLayout *Dl, TargetTransformInfo *Tti, AliasAnalysis *Aa) : BB(Bb), SE(S), DL(Dl), TTI(Tti), AA(Aa) { numberInstructions(); }