/// RewriteUsesOfClonedInstructions - We just cloned the instructions from the /// old header into the preheader. If there were uses of the values produced by /// these instruction that were outside of the loop, we have to insert PHI nodes /// to merge the two values. Do this now. static void RewriteUsesOfClonedInstructions(BasicBlock *OrigHeader, BasicBlock *OrigPreheader, ValueToValueMapTy &ValueMap) { // Remove PHI node entries that are no longer live. BasicBlock::iterator I, E = OrigHeader->end(); for (I = OrigHeader->begin(); PHINode *PN = dyn_cast<PHINode>(I); ++I) PN->removeIncomingValue(PN->getBasicBlockIndex(OrigPreheader)); // Now fix up users of the instructions in OrigHeader, inserting PHI nodes // as necessary. SSAUpdater SSA; for (I = OrigHeader->begin(); I != E; ++I) { Value *OrigHeaderVal = I; // If there are no uses of the value (e.g. because it returns void), there // is nothing to rewrite. if (OrigHeaderVal->use_empty()) continue; Value *OrigPreHeaderVal = ValueMap[OrigHeaderVal]; // The value now exits in two versions: the initial value in the preheader // and the loop "next" value in the original header. SSA.Initialize(OrigHeaderVal->getType(), OrigHeaderVal->getName()); SSA.AddAvailableValue(OrigHeader, OrigHeaderVal); SSA.AddAvailableValue(OrigPreheader, OrigPreHeaderVal); // Visit each use of the OrigHeader instruction. for (Value::use_iterator UI = OrigHeaderVal->use_begin(), UE = OrigHeaderVal->use_end(); UI != UE; ) { // Grab the use before incrementing the iterator. Use &U = *UI; // Increment the iterator before removing the use from the list. ++UI; // SSAUpdater can't handle a non-PHI use in the same block as an // earlier def. We can easily handle those cases manually. Instruction *UserInst = cast<Instruction>(U.getUser()); if (!isa<PHINode>(UserInst)) { BasicBlock *UserBB = UserInst->getParent(); // The original users in the OrigHeader are already using the // original definitions. if (UserBB == OrigHeader) continue; // Users in the OrigPreHeader need to use the value to which the // original definitions are mapped. if (UserBB == OrigPreheader) { U = OrigPreHeaderVal; continue; } } // Anything else can be handled by SSAUpdater. SSA.RewriteUse(U); } } }
unsigned InlineCostAnalyzer::FunctionInfo::countCodeReductionForAlloca( const CodeMetrics &Metrics, Value *V) { if (!V->getType()->isPointerTy()) return 0; // Not a pointer unsigned Reduction = 0; unsigned SROAReduction = 0; bool CanSROAAlloca = true; SmallVector<Value *, 4> Worklist; Worklist.push_back(V); do { Value *V = Worklist.pop_back_val(); for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; ++UI){ Instruction *I = cast<Instruction>(*UI); if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) Reduction += countCodeReductionForAllocaICmp(Metrics, ICI); if (CanSROAAlloca) CanSROAAlloca = countCodeReductionForSROAInst(I, Worklist, SROAReduction); } } while (!Worklist.empty()); return Reduction + (CanSROAAlloca ? SROAReduction : 0); }
void GraphBuilder::visitPtrToIntInst(PtrToIntInst& I) { DSNode* N = getValueDest(I.getOperand(0)).getNode(); if(I.hasOneUse()) { if(isa<ICmpInst>(*(I.use_begin()))) { NumBoringIntToPtr++; return; } } if(I.hasOneUse()) { Value *V = dyn_cast<Value>(*(I.use_begin())); DenseSet<Value *> Seen; while(V && V->hasOneUse() && Seen.insert(V).second) { if(isa<LoadInst>(V)) break; if(isa<StoreInst>(V)) break; if(isa<CallInst>(V)) break; V = dyn_cast<Value>(*(V->use_begin())); } if(isa<BranchInst>(V)){ NumBoringIntToPtr++; return; } } if(N) N->setPtrToIntMarker(); }
// GetTransitiveRedefinitions // Returns the transitive closure of uses of the given variable that are // redefinable. The instructions must dominate BB. static void GetTransitiveRedefinitions(Value *V, BasicBlock *BB, DominatorTree *DT, set<Value*>& Redefinitions) { assert(IsRedefinable(V) && "Parameter must be redefinable"); queue<Value*> Uses; // Initialize the worklist with the given value. Uses.push(V); while (!Uses.empty()) { Value *U = Uses.front(); assert(IsRedefinable(U) && "Value must be redefinable"); Uses.pop(); // Skip the visited values. if (Redefinitions.count(U)) continue; // Only redefine if the definition dominates the redefinition site. if (Instruction *I = dyn_cast<Instruction>(U)) if (I->getParent() == BB || !DT->dominates(I->getParent(), BB)) continue; // Insert the value into the redefinition list. Redefinitions.insert(U); // Add all its redefinable uses to the worklist. for (auto UI = U->use_begin(), UE = U->use_end(); UI != UE; ++UI) if (IsRedefinable(*UI)) Uses.push(*UI); } }
unsigned InlineCostAnalyzer::FunctionInfo::countCodeReductionForConstant( const CodeMetrics &Metrics, Value *V) { unsigned Reduction = 0; SmallVector<Value *, 4> Worklist; Worklist.push_back(V); do { Value *V = Worklist.pop_back_val(); for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E;++UI){ User *U = *UI; if (isa<BranchInst>(U) || isa<SwitchInst>(U)) { // We will be able to eliminate all but one of the successors. const TerminatorInst &TI = cast<TerminatorInst>(*U); const unsigned NumSucc = TI.getNumSuccessors(); unsigned Instrs = 0; for (unsigned I = 0; I != NumSucc; ++I) Instrs += Metrics.NumBBInsts.lookup(TI.getSuccessor(I)); // We don't know which blocks will be eliminated, so use the average size. Reduction += InlineConstants::InstrCost*Instrs*(NumSucc-1)/NumSucc; continue; } // Figure out if this instruction will be removed due to simple constant // propagation. Instruction &Inst = cast<Instruction>(*U); // We can't constant propagate instructions which have effects or // read memory. // // FIXME: It would be nice to capture the fact that a load from a // pointer-to-constant-global is actually a *really* good thing to zap. // Unfortunately, we don't know the pointer that may get propagated here, // so we can't make this decision. if (Inst.mayReadFromMemory() || Inst.mayHaveSideEffects() || isa<AllocaInst>(Inst)) continue; bool AllOperandsConstant = true; for (unsigned i = 0, e = Inst.getNumOperands(); i != e; ++i) if (!isa<Constant>(Inst.getOperand(i)) && Inst.getOperand(i) != V) { AllOperandsConstant = false; break; } if (!AllOperandsConstant) continue; // We will get to remove this instruction... Reduction += InlineConstants::InstrCost; // And any other instructions that use it which become constants // themselves. Worklist.push_back(&Inst); } } while (!Worklist.empty()); return Reduction; }
// Check if it is ok to perform this promotion. bool SRETPromotion::isSafeToUpdateAllCallers(Function *F) { if (F->use_empty()) // No users. OK to modify signature. return true; for (Value::use_iterator FnUseI = F->use_begin(), FnUseE = F->use_end(); FnUseI != FnUseE; ++FnUseI) { // The function is passed in as an argument to (possibly) another function, // we can't change it! CallSite CS(*FnUseI); Instruction *Call = CS.getInstruction(); // The function is used by something else than a call or invoke instruction, // we can't change it! if (!Call || !CS.isCallee(FnUseI)) return false; CallSite::arg_iterator AI = CS.arg_begin(); Value *FirstArg = *AI; if (!isa<AllocaInst>(FirstArg)) return false; // Check FirstArg's users. for (Value::use_iterator ArgI = FirstArg->use_begin(), ArgE = FirstArg->use_end(); ArgI != ArgE; ++ArgI) { User *U = *ArgI; // If FirstArg user is a CallInst that does not correspond to current // call site then this function F is not suitable for sret promotion. if (CallInst *CI = dyn_cast<CallInst>(U)) { if (CI != Call) return false; } // If FirstArg user is a GEP whose all users are not LoadInst then // this function F is not suitable for sret promotion. else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(U)) { // TODO : Use dom info and insert PHINodes to collect get results // from multiple call sites for this GEP. if (GEP->getParent() != Call->getParent()) return false; for (Value::use_iterator GEPI = GEP->use_begin(), GEPE = GEP->use_end(); GEPI != GEPE; ++GEPI) if (!isa<LoadInst>(*GEPI)) return false; } // Any other FirstArg users make this function unsuitable for sret // promotion. else return false; } } return true; }
void OptimizeReturned::visitCallSite(CallSite CS) { for (unsigned i = 0, e = CS.getNumArgOperands(); i < e; ++i) if (CS.paramHasAttr(1 + i, Attribute::Returned)) { Instruction *Inst = CS.getInstruction(); Value *Arg = CS.getArgOperand(i); // Ignore constants, globals, undef, etc. if (isa<Constant>(Arg)) continue; // Like replaceDominatedUsesWith but using Instruction/Use dominance. for (auto UI = Arg->use_begin(), UE = Arg->use_end(); UI != UE;) { Use &U = *UI++; if (DT->dominates(Inst, U)) U.set(Inst); } } }
// Predict that a comparison in which a register is an operand, the register is // used before being defined in a successor block, and the successor block // does not post-dominate will reach the successor block. int BranchProbabilities::CheckGuardHeuristic() { BranchInst *BI = dyn_cast<BranchInst>(_TI); bool bUses[2] = {false, false}; // If we don't have a conditional branch, abandon if ((!BI) || (BI->isUnconditional())) return -1; // If the condition is not immediately dependent on a comparison, abandon CmpInst *cmp = dyn_cast<CmpInst>(BI->getCondition()); if (!cmp) return -1; for (int i = 0; i < 2; i++) { if (_bPostDoms[i]) continue; // Get the values being compared Value *v = cmp->getOperand(i); // For all uses of the first value check if the use post-dominates for (Value::use_iterator UI = v->use_begin(), UE = v->use_end(); UI != UE; ++UI) { // if the use is not an instruction, skip it Instruction *I = dyn_cast<Instruction>(*UI); if (!I) continue; BasicBlock *UsingBlock = I->getParent(); // Check if the use is in either successor for (int i = 0; i < 2; i++) if (UsingBlock == _Succ[i]) bUses[i] = true; } } if (bUses[0] == bUses[1]) return -1; if (bUses[0]) return 0; else return 1; }
bool LiveIRVariables::isLiveOut(Value &V, BasicBlock &BB) { BasicBlock &DefBB = getDefiningBlock(V); if (&DefBB == &BB) { // If the value is defined within this basic block, just look for any use // outside it. for (Value::use_iterator UI = V.use_begin(), UE = V.use_end(); UI != UE; ++UI) { if (isa<Instruction>(*UI) && cast<Instruction>(*UI)->getParent() != &BB) return true; } return false; } DominatorTree &DT = getAnalysis<DominatorTree>(); if (!DT.properlyDominates(&DefBB, &BB)) return false; unsigned BBID = DFSOrdering.idFor(&BB) - 1; BitVector &BackEdges = ReachableBackEdges[BBID]; bool BBIsBackEdgeTarget = isBackEdgeTarget(BB); for (int i = BackEdges.find_first(); i != -1; i = BackEdges.find_next(i)) { BasicBlock &ReachableBB = *DFSOrdering[i + 1]; // Ignore back edge targets that leave the dominance tree of def(V) and // reenter it. if (!DT.properlyDominates(&DefBB, &ReachableBB)) continue; BitVector &ReachableBlocks = ReducedReachability[i]; for (int j = ReachableBlocks.find_first(); j != -1; j = ReachableBlocks.find_next(j)) { if ((unsigned)j == BBID && j == i && !BBIsBackEdgeTarget) continue; // Skip trivial paths. // FIXME: Precompute this to speed this up. if (V.isUsedInBasicBlock(DFSOrdering[j + 1])) return true; } } return false; }
// For each instruction used by the value, remove() the function that contains // the instruction. This should happen right before a call to RAUW. void MergeFunctions::removeUsers(Value *V) { std::vector<Value *> Worklist; Worklist.push_back(V); while (!Worklist.empty()) { Value *V = Worklist.back(); Worklist.pop_back(); for (Value::use_iterator UI = V->use_begin(), UE = V->use_end(); UI != UE; ++UI) { Use &U = UI.getUse(); if (Instruction *I = dyn_cast<Instruction>(U.getUser())) { remove(I->getParent()->getParent()); } else if (isa<GlobalValue>(U.getUser())) { // do nothing } else if (Constant *C = dyn_cast<Constant>(U.getUser())) { for (Value::use_iterator CUI = C->use_begin(), CUE = C->use_end(); CUI != CUE; ++CUI) Worklist.push_back(*CUI); } } } }
bool ObjCARCContract::runOnFunction(Function &F) { if (!EnableARCOpts) return false; // If nothing in the Module uses ARC, don't do anything. if (!Run) return false; Changed = false; AA = &getAnalysis<AliasAnalysis>(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); PA.setAA(&getAnalysis<AliasAnalysis>()); DEBUG(llvm::dbgs() << "**** ObjCARC Contract ****\n"); // Track whether it's ok to mark objc_storeStrong calls with the "tail" // keyword. Be conservative if the function has variadic arguments. // It seems that functions which "return twice" are also unsafe for the // "tail" argument, because they are setjmp, which could need to // return to an earlier stack state. bool TailOkForStoreStrongs = !F.isVarArg() && !F.callsFunctionThatReturnsTwice(); // For ObjC library calls which return their argument, replace uses of the // argument with uses of the call return value, if it dominates the use. This // reduces register pressure. SmallPtrSet<Instruction *, 4> DependingInstructions; SmallPtrSet<const BasicBlock *, 4> Visited; for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E;) { Instruction *Inst = &*I++; DEBUG(dbgs() << "Visiting: " << *Inst << "\n"); // First try to peephole Inst. If there is nothing further we can do in // terms of undoing objc-arc-expand, process the next inst. if (tryToPeepholeInstruction(F, Inst, I, DependingInstructions, Visited, TailOkForStoreStrongs)) continue; // Otherwise, try to undo objc-arc-expand. // Don't use GetArgRCIdentityRoot because we don't want to look through bitcasts // and such; to do the replacement, the argument must have type i8*. Value *Arg = cast<CallInst>(Inst)->getArgOperand(0); // TODO: Change this to a do-while. for (;;) { // If we're compiling bugpointed code, don't get in trouble. if (!isa<Instruction>(Arg) && !isa<Argument>(Arg)) break; // Look through the uses of the pointer. for (Value::use_iterator UI = Arg->use_begin(), UE = Arg->use_end(); UI != UE; ) { // Increment UI now, because we may unlink its element. Use &U = *UI++; unsigned OperandNo = U.getOperandNo(); // If the call's return value dominates a use of the call's argument // value, rewrite the use to use the return value. We check for // reachability here because an unreachable call is considered to // trivially dominate itself, which would lead us to rewriting its // argument in terms of its return value, which would lead to // infinite loops in GetArgRCIdentityRoot. if (DT->isReachableFromEntry(U) && DT->dominates(Inst, U)) { Changed = true; Instruction *Replacement = Inst; Type *UseTy = U.get()->getType(); if (PHINode *PHI = dyn_cast<PHINode>(U.getUser())) { // For PHI nodes, insert the bitcast in the predecessor block. unsigned ValNo = PHINode::getIncomingValueNumForOperand(OperandNo); BasicBlock *BB = PHI->getIncomingBlock(ValNo); if (Replacement->getType() != UseTy) Replacement = new BitCastInst(Replacement, UseTy, "", &BB->back()); // While we're here, rewrite all edges for this PHI, rather // than just one use at a time, to minimize the number of // bitcasts we emit. for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i) if (PHI->getIncomingBlock(i) == BB) { // Keep the UI iterator valid. if (UI != UE && &PHI->getOperandUse( PHINode::getOperandNumForIncomingValue(i)) == &*UI) ++UI; PHI->setIncomingValue(i, Replacement); } } else { if (Replacement->getType() != UseTy) Replacement = new BitCastInst(Replacement, UseTy, "", cast<Instruction>(U.getUser())); U.set(Replacement); } } } // If Arg is a no-op casted pointer, strip one level of casts and iterate. if (const BitCastInst *BI = dyn_cast<BitCastInst>(Arg)) Arg = BI->getOperand(0); else if (isa<GEPOperator>(Arg) && cast<GEPOperator>(Arg)->hasAllZeroIndices()) Arg = cast<GEPOperator>(Arg)->getPointerOperand(); else if (isa<GlobalAlias>(Arg) && !cast<GlobalAlias>(Arg)->mayBeOverridden()) Arg = cast<GlobalAlias>(Arg)->getAliasee(); else break; } } // If this function has no escaping allocas or suspicious vararg usage, // objc_storeStrong calls can be marked with the "tail" keyword. if (TailOkForStoreStrongs) for (CallInst *CI : StoreStrongCalls) CI->setTailCall(); StoreStrongCalls.clear(); return Changed; }
Value *PHITransAddr::PHITranslateSubExpr(Value *V, BasicBlock *CurBB, BasicBlock *PredBB, const DominatorTree *DT) { // If this is a non-instruction value, it can't require PHI translation. Instruction *Inst = dyn_cast<Instruction>(V); if (Inst == 0) return V; // Determine whether 'Inst' is an input to our PHI translatable expression. bool isInput = std::count(InstInputs.begin(), InstInputs.end(), Inst); // Handle inputs instructions if needed. if (isInput) { if (Inst->getParent() != CurBB) { // If it is an input defined in a different block, then it remains an // input. return Inst; } // If 'Inst' is defined in this block and is an input that needs to be phi // translated, we need to incorporate the value into the expression or fail. // In either case, the instruction itself isn't an input any longer. InstInputs.erase(std::find(InstInputs.begin(), InstInputs.end(), Inst)); // If this is a PHI, go ahead and translate it. if (PHINode *PN = dyn_cast<PHINode>(Inst)) return AddAsInput(PN->getIncomingValueForBlock(PredBB)); // If this is a non-phi value, and it is analyzable, we can incorporate it // into the expression by making all instruction operands be inputs. if (!CanPHITrans(Inst)) return 0; // All instruction operands are now inputs (and of course, they may also be // defined in this block, so they may need to be phi translated themselves. for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i) if (Instruction *Op = dyn_cast<Instruction>(Inst->getOperand(i))) InstInputs.push_back(Op); } // Ok, it must be an intermediate result (either because it started that way // or because we just incorporated it into the expression). See if its // operands need to be phi translated, and if so, reconstruct it. if (CastInst *Cast = dyn_cast<CastInst>(Inst)) { if (!isSafeToSpeculativelyExecute(Cast)) return 0; Value *PHIIn = PHITranslateSubExpr(Cast->getOperand(0), CurBB, PredBB, DT); if (PHIIn == 0) return 0; if (PHIIn == Cast->getOperand(0)) return Cast; // Find an available version of this cast. // Constants are trivial to find. if (Constant *C = dyn_cast<Constant>(PHIIn)) return AddAsInput(ConstantExpr::getCast(Cast->getOpcode(), C, Cast->getType())); // Otherwise we have to see if a casted version of the incoming pointer // is available. If so, we can use it, otherwise we have to fail. for (Value::use_iterator UI = PHIIn->use_begin(), E = PHIIn->use_end(); UI != E; ++UI) { if (CastInst *CastI = dyn_cast<CastInst>(*UI)) if (CastI->getOpcode() == Cast->getOpcode() && CastI->getType() == Cast->getType() && (!DT || DT->dominates(CastI->getParent(), PredBB))) return CastI; } return 0; } // Handle getelementptr with at least one PHI translatable operand. if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Inst)) { SmallVector<Value*, 8> GEPOps; bool AnyChanged = false; for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) { Value *GEPOp = PHITranslateSubExpr(GEP->getOperand(i), CurBB, PredBB, DT); if (GEPOp == 0) return 0; AnyChanged |= GEPOp != GEP->getOperand(i); GEPOps.push_back(GEPOp); } if (!AnyChanged) return GEP; // Simplify the GEP to handle 'gep x, 0' -> x etc. if (Value *V = SimplifyGEPInst(GEPOps, TD, TLI, DT)) { for (unsigned i = 0, e = GEPOps.size(); i != e; ++i) RemoveInstInputs(GEPOps[i], InstInputs); return AddAsInput(V); } // Scan to see if we have this GEP available. Value *APHIOp = GEPOps[0]; for (Value::use_iterator UI = APHIOp->use_begin(), E = APHIOp->use_end(); UI != E; ++UI) { if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(*UI)) if (GEPI->getType() == GEP->getType() && GEPI->getNumOperands() == GEPOps.size() && GEPI->getParent()->getParent() == CurBB->getParent() && (!DT || DT->dominates(GEPI->getParent(), PredBB))) { bool Mismatch = false; for (unsigned i = 0, e = GEPOps.size(); i != e; ++i) if (GEPI->getOperand(i) != GEPOps[i]) { Mismatch = true; break; } if (!Mismatch) return GEPI; } } return 0; } // Handle add with a constant RHS. if (Inst->getOpcode() == Instruction::Add && isa<ConstantInt>(Inst->getOperand(1))) { // PHI translate the LHS. Constant *RHS = cast<ConstantInt>(Inst->getOperand(1)); bool isNSW = cast<BinaryOperator>(Inst)->hasNoSignedWrap(); bool isNUW = cast<BinaryOperator>(Inst)->hasNoUnsignedWrap(); Value *LHS = PHITranslateSubExpr(Inst->getOperand(0), CurBB, PredBB, DT); if (LHS == 0) return 0; // If the PHI translated LHS is an add of a constant, fold the immediates. if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(LHS)) if (BOp->getOpcode() == Instruction::Add) if (ConstantInt *CI = dyn_cast<ConstantInt>(BOp->getOperand(1))) { LHS = BOp->getOperand(0); RHS = ConstantExpr::getAdd(RHS, CI); isNSW = isNUW = false; // If the old 'LHS' was an input, add the new 'LHS' as an input. if (std::count(InstInputs.begin(), InstInputs.end(), BOp)) { RemoveInstInputs(BOp, InstInputs); AddAsInput(LHS); } } // See if the add simplifies away. if (Value *Res = SimplifyAddInst(LHS, RHS, isNSW, isNUW, TD, TLI, DT)) { // If we simplified the operands, the LHS is no longer an input, but Res // is. RemoveInstInputs(LHS, InstInputs); return AddAsInput(Res); } // If we didn't modify the add, just return it. if (LHS == Inst->getOperand(0) && RHS == Inst->getOperand(1)) return Inst; // Otherwise, see if we have this add available somewhere. for (Value::use_iterator UI = LHS->use_begin(), E = LHS->use_end(); UI != E; ++UI) { if (BinaryOperator *BO = dyn_cast<BinaryOperator>(*UI)) if (BO->getOpcode() == Instruction::Add && BO->getOperand(0) == LHS && BO->getOperand(1) == RHS && BO->getParent()->getParent() == CurBB->getParent() && (!DT || DT->dominates(BO->getParent(), PredBB))) return BO; } return 0; } // Otherwise, we failed. return 0; }
void* MCJITHelper::dynamicInlinerForOpenOSR(Function* F1, Instruction* OSRSrc, void* extra, void* profDataAddr) { DynamicInlinerInfo* inlineInfo = (DynamicInlinerInfo*) extra; MCJITHelper* TheHelper = inlineInfo->TheHelper; bool verbose = TheHelper->verbose; assert(OSRSrc->getParent()->getParent() == F1 && "MCJIT messed up the objects"); if (verbose) { std::cerr << "Value for F1 is " << F1 << std::endl; std::cerr << "Value for OSRSrc is " << OSRSrc << std::endl; std::cerr << "Value for extra is " << extra << std::endl; std::cerr << "Value for profDataAddr is " << profDataAddr << std::endl; } std::pair<Function*, StateMap*> identityPair = StateMap::generateIdentityMapping(F1); Function* F2 = identityPair.first; StateMap* M = identityPair.second; Value* valToInlineInF2 = M->getCorrespondingOneToOneValue(inlineInfo->valToInline); Instruction* OSRSrcInF2 = cast<Instruction>(M->getCorrespondingOneToOneValue(OSRSrc)); assert (OSRSrcInF2 != nullptr && "TODO cannot find corresponding OSRSrc in temporary F2"); if (OSRLibrary::removeOSRPoint(*OSRSrcInF2) && verbose) { std::cerr << "OSR point removed after cloning F1" << std::endl; } Instruction* LPad = M->getLandingPad(OSRSrc); StateMap* M_F2toOSRContFun; LivenessAnalysis LA(F1); std::vector<Value*>* valuesToPass = OSRLibrary::getLiveValsVecAtInstr(OSRSrc, LA); std::string OSRDestFunName = (F2->getName().str()).append("OSRCont"); Function* OSRContFun = OSRLibrary::genContinuationFunc(TheHelper->Context, *F1, *F2, *OSRSrc, *LPad, *valuesToPass, *M, &OSRDestFunName, verbose, &M_F2toOSRContFun); Value* valToInline = M_F2toOSRContFun->getCorrespondingOneToOneValue(valToInlineInF2); assert (valToInline != nullptr && "broken state map for continuation function"); delete valuesToPass; delete F2; delete M; delete M_F2toOSRContFun; // create a module for generated code std::string modForJITName = "OpenOSRDynInline"; modForJITName.append(OSRDestFunName); std::unique_ptr<Module> modForJIT = llvm::make_unique<Module>(modForJITName, TheHelper->Context); Module* modForJIT_ptr = modForJIT.get(); // determine which function is called uint64_t calledFun = (uint64_t)profDataAddr; std::cerr << "Address of invoked function: " << calledFun << std::endl; Function* funToInline = nullptr; for (AddrSymPair &pair: TheHelper->CompiledFunAddrTable) { if (pair.first == calledFun) { std::string &FunName = pair.second; funToInline = TheHelper->getFunction(FunName); break; } } Function* myFunToInline = nullptr; if (funToInline == nullptr) { std::cerr << "Sorry, I could not determine which function was called!" << std::endl; } else { std::cerr << "Function being inlined: " << funToInline->getName().str() << std::endl; ValueToValueMapTy VMap; myFunToInline = CloneFunction(funToInline, VMap, false, nullptr); myFunToInline->addFnAttr(Attribute::AlwaysInline); myFunToInline->setLinkage(Function::LinkageTypes::PrivateLinkage); modForJIT_ptr->getFunctionList().push_back(myFunToInline); OSRLibrary::fixUsesOfFunctionsAndGlobals(funToInline, myFunToInline); for (Value::use_iterator UI = valToInline->use_begin(), UE = valToInline->use_end(); UI != UE; ) { Use &U = *(UI++); if (CallInst* CI = dyn_cast<CallInst>(U.getUser())) { if (CI->getParent()->getParent() != OSRContFun) continue; if (verbose) { raw_os_ostream errStream(std::cerr); std::cerr << "Updating instruction "; CI->print(errStream); std::cerr << std::endl; } U.set(myFunToInline); } } } modForJIT_ptr->getFunctionList().push_back(OSRContFun); verifyFunction(*OSRContFun, &outs()); // remove dead code & inline when possible FunctionPassManager FPM(modForJIT_ptr); FPM.add(createCFGSimplificationPass()); FPM.doInitialization(); FPM.run(*OSRContFun); if (funToInline != nullptr) { PassManager PM; PM.add(llvm::createAlwaysInlinerPass()); PM.run(*modForJIT_ptr); } // compile code TheHelper->addModule(std::move(modForJIT)); return (void*)TheHelper->JIT->getFunctionAddress(OSRDestFunName); }
/// FindPromotableValuesInLoop - Check the current loop for stores to definite /// pointers, which are not loaded and stored through may aliases and are safe /// for promotion. If these are found, create an alloca for the value, add it /// to the PromotedValues list, and keep track of the mapping from value to /// alloca. void LICM::FindPromotableValuesInLoop( std::vector<std::pair<AllocaInst*, Value*> > &PromotedValues, std::map<Value*, AllocaInst*> &ValueToAllocaMap) { Instruction *FnStart = CurLoop->getHeader()->getParent()->begin()->begin(); // Loop over all of the alias sets in the tracker object. for (AliasSetTracker::iterator I = CurAST->begin(), E = CurAST->end(); I != E; ++I) { AliasSet &AS = *I; // We can promote this alias set if it has a store, if it is a "Must" alias // set, if the pointer is loop invariant, and if we are not eliminating any // volatile loads or stores. if (AS.isForwardingAliasSet() || !AS.isMod() || !AS.isMustAlias() || AS.isVolatile() || !CurLoop->isLoopInvariant(AS.begin()->getValue())) continue; assert(!AS.empty() && "Must alias set should have at least one pointer element in it!"); Value *V = AS.begin()->getValue(); // Check that all of the pointers in the alias set have the same type. We // cannot (yet) promote a memory location that is loaded and stored in // different sizes. { bool PointerOk = true; for (AliasSet::iterator I = AS.begin(), E = AS.end(); I != E; ++I) if (V->getType() != I->getValue()->getType()) { PointerOk = false; break; } if (!PointerOk) continue; } // It isn't safe to promote a load/store from the loop if the load/store is // conditional. For example, turning: // // for () { if (c) *P += 1; } // // into: // // tmp = *P; for () { if (c) tmp +=1; } *P = tmp; // // is not safe, because *P may only be valid to access if 'c' is true. // // It is safe to promote P if all uses are direct load/stores and if at // least one is guaranteed to be executed. bool GuaranteedToExecute = false; bool InvalidInst = false; for (Value::use_iterator UI = V->use_begin(), UE = V->use_end(); UI != UE; ++UI) { // Ignore instructions not in this loop. Instruction *Use = dyn_cast<Instruction>(*UI); if (!Use || !CurLoop->contains(Use->getParent())) continue; if (!isa<LoadInst>(Use) && !isa<StoreInst>(Use)) { InvalidInst = true; break; } if (!GuaranteedToExecute) GuaranteedToExecute = isSafeToExecuteUnconditionally(*Use); } // If there is an non-load/store instruction in the loop, we can't promote // it. If there isn't a guaranteed-to-execute instruction, we can't // promote. if (InvalidInst || !GuaranteedToExecute) continue; const Type *Ty = cast<PointerType>(V->getType())->getElementType(); AllocaInst *AI = new AllocaInst(Ty, 0, V->getName()+".tmp", FnStart); PromotedValues.push_back(std::make_pair(AI, V)); // Update the AST and alias analysis. CurAST->copyValue(V, AI); for (AliasSet::iterator I = AS.begin(), E = AS.end(); I != E; ++I) ValueToAllocaMap.insert(std::make_pair(I->getValue(), AI)); DEBUG(errs() << "LICM: Promoting value: " << *V << "\n"); } }
/// PromoteValuesInLoop - Try to promote memory values to scalars by sinking /// stores out of the loop and moving loads to before the loop. We do this by /// looping over the stores in the loop, looking for stores to Must pointers /// which are loop invariant. We promote these memory locations to use allocas /// instead. These allocas can easily be raised to register values by the /// PromoteMem2Reg functionality. /// void LICM::PromoteValuesInLoop() { // PromotedValues - List of values that are promoted out of the loop. Each // value has an alloca instruction for it, and a canonical version of the // pointer. std::vector<std::pair<AllocaInst*, Value*> > PromotedValues; std::map<Value*, AllocaInst*> ValueToAllocaMap; // Map of ptr to alloca FindPromotableValuesInLoop(PromotedValues, ValueToAllocaMap); if (ValueToAllocaMap.empty()) return; // If there are values to promote. Changed = true; NumPromoted += PromotedValues.size(); std::vector<Value*> PointerValueNumbers; // Emit a copy from the value into the alloca'd value in the loop preheader TerminatorInst *LoopPredInst = Preheader->getTerminator(); for (unsigned i = 0, e = PromotedValues.size(); i != e; ++i) { Value *Ptr = PromotedValues[i].second; // If we are promoting a pointer value, update alias information for the // inserted load. Value *LoadValue = 0; if (isa<PointerType>(cast<PointerType>(Ptr->getType())->getElementType())) { // Locate a load or store through the pointer, and assign the same value // to LI as we are loading or storing. Since we know that the value is // stored in this loop, this will always succeed. for (Value::use_iterator UI = Ptr->use_begin(), E = Ptr->use_end(); UI != E; ++UI) if (LoadInst *LI = dyn_cast<LoadInst>(*UI)) { LoadValue = LI; break; } else if (StoreInst *SI = dyn_cast<StoreInst>(*UI)) { if (SI->getOperand(1) == Ptr) { LoadValue = SI->getOperand(0); break; } } assert(LoadValue && "No store through the pointer found!"); PointerValueNumbers.push_back(LoadValue); // Remember this for later. } // Load from the memory we are promoting. LoadInst *LI = new LoadInst(Ptr, Ptr->getName()+".promoted", LoopPredInst); if (LoadValue) CurAST->copyValue(LoadValue, LI); // Store into the temporary alloca. new StoreInst(LI, PromotedValues[i].first, LoopPredInst); } // Scan the basic blocks in the loop, replacing uses of our pointers with // uses of the allocas in question. // for (Loop::block_iterator I = CurLoop->block_begin(), E = CurLoop->block_end(); I != E; ++I) { BasicBlock *BB = *I; // Rewrite all loads and stores in the block of the pointer... for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E; ++II) { if (LoadInst *L = dyn_cast<LoadInst>(II)) { std::map<Value*, AllocaInst*>::iterator I = ValueToAllocaMap.find(L->getOperand(0)); if (I != ValueToAllocaMap.end()) L->setOperand(0, I->second); // Rewrite load instruction... } else if (StoreInst *S = dyn_cast<StoreInst>(II)) { std::map<Value*, AllocaInst*>::iterator I = ValueToAllocaMap.find(S->getOperand(1)); if (I != ValueToAllocaMap.end()) S->setOperand(1, I->second); // Rewrite store instruction... } } } // Now that the body of the loop uses the allocas instead of the original // memory locations, insert code to copy the alloca value back into the // original memory location on all exits from the loop. Note that we only // want to insert one copy of the code in each exit block, though the loop may // exit to the same block more than once. // SmallPtrSet<BasicBlock*, 16> ProcessedBlocks; SmallVector<BasicBlock*, 8> ExitBlocks; CurLoop->getExitBlocks(ExitBlocks); for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) { if (!ProcessedBlocks.insert(ExitBlocks[i])) continue; // Copy all of the allocas into their memory locations. BasicBlock::iterator BI = ExitBlocks[i]->getFirstNonPHI(); Instruction *InsertPos = BI; unsigned PVN = 0; for (unsigned i = 0, e = PromotedValues.size(); i != e; ++i) { // Load from the alloca. LoadInst *LI = new LoadInst(PromotedValues[i].first, "", InsertPos); // If this is a pointer type, update alias info appropriately. if (isa<PointerType>(LI->getType())) CurAST->copyValue(PointerValueNumbers[PVN++], LI); // Store into the memory we promoted. new StoreInst(LI, PromotedValues[i].second, InsertPos); } } // Now that we have done the deed, use the mem2reg functionality to promote // all of the new allocas we just created into real SSA registers. // std::vector<AllocaInst*> PromotedAllocas; PromotedAllocas.reserve(PromotedValues.size()); for (unsigned i = 0, e = PromotedValues.size(); i != e; ++i) PromotedAllocas.push_back(PromotedValues[i].first); PromoteMemToReg(PromotedAllocas, *DT, *DF, CurAST); }
/// PromoteAliasSet - Try to promote memory values to scalars by sinking /// stores out of the loop and moving loads to before the loop. We do this by /// looping over the stores in the loop, looking for stores to Must pointers /// which are loop invariant. /// void LICM::PromoteAliasSet(AliasSet &AS) { // We can promote this alias set if it has a store, if it is a "Must" alias // set, if the pointer is loop invariant, and if we are not eliminating any // volatile loads or stores. if (AS.isForwardingAliasSet() || !AS.isMod() || !AS.isMustAlias() || AS.isVolatile() || !CurLoop->isLoopInvariant(AS.begin()->getValue())) return; assert(!AS.empty() && "Must alias set should have at least one pointer element in it!"); Value *SomePtr = AS.begin()->getValue(); // It isn't safe to promote a load/store from the loop if the load/store is // conditional. For example, turning: // // for () { if (c) *P += 1; } // // into: // // tmp = *P; for () { if (c) tmp +=1; } *P = tmp; // // is not safe, because *P may only be valid to access if 'c' is true. // // It is safe to promote P if all uses are direct load/stores and if at // least one is guaranteed to be executed. bool GuaranteedToExecute = false; SmallVector<Instruction*, 64> LoopUses; SmallPtrSet<Value*, 4> PointerMustAliases; // We start with an alignment of one and try to find instructions that allow // us to prove better alignment. unsigned Alignment = 1; // Check that all of the pointers in the alias set have the same type. We // cannot (yet) promote a memory location that is loaded and stored in // different sizes. for (AliasSet::iterator ASI = AS.begin(), E = AS.end(); ASI != E; ++ASI) { Value *ASIV = ASI->getValue(); PointerMustAliases.insert(ASIV); // Check that all of the pointers in the alias set have the same type. We // cannot (yet) promote a memory location that is loaded and stored in // different sizes. if (SomePtr->getType() != ASIV->getType()) return; for (Value::use_iterator UI = ASIV->use_begin(), UE = ASIV->use_end(); UI != UE; ++UI) { // Ignore instructions that are outside the loop. Instruction *Use = dyn_cast<Instruction>(*UI); if (!Use || !CurLoop->contains(Use)) continue; // If there is an non-load/store instruction in the loop, we can't promote // it. if (LoadInst *load = dyn_cast<LoadInst>(Use)) { assert(!load->isVolatile() && "AST broken"); if (!load->isSimple()) return; } else if (StoreInst *store = dyn_cast<StoreInst>(Use)) { // Stores *of* the pointer are not interesting, only stores *to* the // pointer. if (Use->getOperand(1) != ASIV) continue; assert(!store->isVolatile() && "AST broken"); if (!store->isSimple()) return; // Note that we only check GuaranteedToExecute inside the store case // so that we do not introduce stores where they did not exist before // (which would break the LLVM concurrency model). // If the alignment of this instruction allows us to specify a more // restrictive (and performant) alignment and if we are sure this // instruction will be executed, update the alignment. // Larger is better, with the exception of 0 being the best alignment. unsigned InstAlignment = store->getAlignment(); if ((InstAlignment > Alignment || InstAlignment == 0) && (Alignment != 0)) if (isGuaranteedToExecute(*Use)) { GuaranteedToExecute = true; Alignment = InstAlignment; } if (!GuaranteedToExecute) GuaranteedToExecute = isGuaranteedToExecute(*Use); } else return; // Not a load or store. LoopUses.push_back(Use); } } // If there isn't a guaranteed-to-execute instruction, we can't promote. if (!GuaranteedToExecute) return; // Otherwise, this is safe to promote, lets do it! DEBUG(dbgs() << "LICM: Promoting value stored to in loop: " <<*SomePtr<<'\n'); Changed = true; ++NumPromoted; // Grab a debug location for the inserted loads/stores; given that the // inserted loads/stores have little relation to the original loads/stores, // this code just arbitrarily picks a location from one, since any debug // location is better than none. DebugLoc DL = LoopUses[0]->getDebugLoc(); SmallVector<BasicBlock*, 8> ExitBlocks; CurLoop->getUniqueExitBlocks(ExitBlocks); // We use the SSAUpdater interface to insert phi nodes as required. SmallVector<PHINode*, 16> NewPHIs; SSAUpdater SSA(&NewPHIs); LoopPromoter Promoter(SomePtr, LoopUses, SSA, PointerMustAliases, ExitBlocks, *CurAST, DL, Alignment); // Set up the preheader to have a definition of the value. It is the live-out // value from the preheader that uses in the loop will use. LoadInst *PreheaderLoad = new LoadInst(SomePtr, SomePtr->getName()+".promoted", Preheader->getTerminator()); PreheaderLoad->setAlignment(Alignment); PreheaderLoad->setDebugLoc(DL); SSA.AddAvailableValue(Preheader, PreheaderLoad); // Rewrite all the loads in the loop and remember all the definitions from // stores in the loop. Promoter.run(LoopUses); // If the SSAUpdater didn't use the load in the preheader, just zap it now. if (PreheaderLoad->use_empty()) PreheaderLoad->eraseFromParent(); }
/* * Renaming uses of V to uses of vSSA_PHI * The rule of renaming is: * - All uses of V in the dominator tree of vSSA_PHI are renamed * - Uses of V in the same basicblock of vSSA_PHI are only renamed if they are not in PHI functions * - Uses of V in the dominance frontier follow the same rules of sigma renaming */ void vSSA::renameUsesToPhi(Value *V, PHINode *phi) { // This vector of Instruction* points to the uses of operand. // This auxiliary vector of pointers is used because the use_iterators are invalidated when we do the renaming SmallVector<Instruction*, 25> usepointers; unsigned i = 0, n = V->getNumUses(); usepointers.resize(n); // This vector contains pointers to all sigmas that have its operand renamed to vSSA_phi // For them, we need to try to create phi functions again SmallVector<PHINode*, 25> sigmasRenamed; BasicBlock *BB_next = phi->getParent(); // Get the dominance frontier of the successor DominanceFrontier::iterator DF_BB = DF_->find(BB_next); for (Value::use_iterator uit = V->use_begin(), uend = V->use_end(); uit != uend; ++uit, ++i) usepointers[i] = dyn_cast<Instruction>(*uit); BasicBlock *BB_parent = phi->getParent(); for (i = 0; i < n; ++i) { // Check if the use is in the dominator tree of vSSA_PHI if (DT_->dominates(BB_parent, usepointers[i]->getParent())) { if (BB_parent != usepointers[i]->getParent()) { usepointers[i]->replaceUsesOfWith(V, phi); // If this use is in a sigma, we need to check whether phis creation are needed again for this sigma if (PHINode *sigma = dyn_cast<PHINode>(usepointers[i])) { if (sigma->getName().startswith(vSSA_SIG)) { sigmasRenamed.push_back(sigma); } } } else if (!isa<PHINode>(usepointers[i])) usepointers[i]->replaceUsesOfWith(V, phi); } // Check if the use is in the dominance frontier of phi else if (DF_BB->second.find(usepointers[i]->getParent()) != DF_BB->second.end()) { // Check if the user is a PHI node (it has to be, but only for precaution) if (PHINode *phiuser = dyn_cast<PHINode>(usepointers[i])) { for (unsigned i = 0, e = phiuser->getNumIncomingValues(); i < e; ++i) { Value *operand = phiuser->getIncomingValue(i); if (operand != V) continue; if (DT_->dominates(BB_next, phiuser->getIncomingBlock(i))) { phiuser->setIncomingValue(i, phi); } } } } } for (unsigned k = 0, f = phi->getNumIncomingValues(); k < f; ++k) { PHINode *p = dyn_cast<PHINode>(phi->getIncomingValue(k)); if (!p || !p->getName().startswith(vSSA_SIG)) continue; Value *V = p->getIncomingValue(0); n = V->getNumUses(); usepointers.resize(n); unsigned i = 0; for (Value::use_iterator uit = V->use_begin(), uend = V->use_end(); uit != uend; ++uit, ++i) usepointers[i] = dyn_cast<Instruction>(*uit); for (i = 0; i < n; ++i) { // Check if the use is in the dominator tree of vSSA_PHI if (DT_->dominates(BB_parent, usepointers[i]->getParent())) { if (BB_parent != usepointers[i]->getParent()) { usepointers[i]->replaceUsesOfWith(V, phi); // If this use is in a sigma, we need to check whether phis creation are needed again for this sigma if (PHINode *sigma = dyn_cast<PHINode>(usepointers[i])) { if (sigma->getName().startswith(vSSA_SIG)) { sigmasRenamed.push_back(sigma); } } } else if (!isa<PHINode>(usepointers[i])) usepointers[i]->replaceUsesOfWith(V, phi); } // Check if the use is in the dominance frontier of phi else if (DF_BB->second.find(usepointers[i]->getParent()) != DF_BB->second.end()) { // Check if the user is a PHI node (it has to be, but only for precaution) if (PHINode *phiuser = dyn_cast<PHINode>(usepointers[i])) { for (unsigned i = 0, e = phiuser->getNumIncomingValues(); i < e; ++i) { Value *operand = phiuser->getIncomingValue(i); if (operand != V) continue; if (DT_->dominates(BB_next, phiuser->getIncomingBlock(i))) { phiuser->setIncomingValue(i, phi); } } } } } } // Try to create phis again for the sigmas whose operand was renamed to vSSA_phi // Also, renaming may need to be done again for (SmallVectorImpl<PHINode*>::iterator vit = sigmasRenamed.begin(), vend = sigmasRenamed.end(); vit != vend; ++vit) { renameUsesToSigma(phi, *vit); SmallVector<PHINode*, 25> vssaphis_created = insertPhisForSigma(phi, *vit); //insertSigmaAsOperandOfPhis(vssaphis_created, *vit); populatePhis(vssaphis_created, (*vit)->getIncomingValue(0)); } // Creation of phis may require the creation of sigmas that were not created previosly, so we do it now createSigmasIfNeeded(phi->getParent()); }
/// updateCallSites - Update all sites that call F to use NF. CallGraphNode *SRETPromotion::updateCallSites(Function *F, Function *NF) { CallGraph &CG = getAnalysis<CallGraph>(); SmallVector<Value*, 16> Args; // Attributes - Keep track of the parameter attributes for the arguments. SmallVector<AttributeWithIndex, 8> ArgAttrsVec; // Get a new callgraph node for NF. CallGraphNode *NF_CGN = CG.getOrInsertFunction(NF); while (!F->use_empty()) { CallSite CS(*F->use_begin()); Instruction *Call = CS.getInstruction(); const AttrListPtr &PAL = F->getAttributes(); // Add any return attributes. if (Attributes attrs = PAL.getRetAttributes()) ArgAttrsVec.push_back(AttributeWithIndex::get(0, attrs)); // Copy arguments, however skip first one. CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end(); Value *FirstCArg = *AI; ++AI; // 0th parameter attribute is reserved for return type. // 1th parameter attribute is for first 1st sret argument. unsigned ParamIndex = 2; while (AI != AE) { Args.push_back(*AI); if (Attributes Attrs = PAL.getParamAttributes(ParamIndex)) ArgAttrsVec.push_back(AttributeWithIndex::get(ParamIndex - 1, Attrs)); ++ParamIndex; ++AI; } // Add any function attributes. if (Attributes attrs = PAL.getFnAttributes()) ArgAttrsVec.push_back(AttributeWithIndex::get(~0, attrs)); AttrListPtr NewPAL = AttrListPtr::get(ArgAttrsVec.begin(), ArgAttrsVec.end()); // Build new call instruction. Instruction *New; if (InvokeInst *II = dyn_cast<InvokeInst>(Call)) { New = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(), Args.begin(), Args.end(), "", Call); cast<InvokeInst>(New)->setCallingConv(CS.getCallingConv()); cast<InvokeInst>(New)->setAttributes(NewPAL); } else { New = CallInst::Create(NF, Args.begin(), Args.end(), "", Call); cast<CallInst>(New)->setCallingConv(CS.getCallingConv()); cast<CallInst>(New)->setAttributes(NewPAL); if (cast<CallInst>(Call)->isTailCall()) cast<CallInst>(New)->setTailCall(); } Args.clear(); ArgAttrsVec.clear(); New->takeName(Call); // Update the callgraph to know that the callsite has been transformed. CallGraphNode *CalleeNode = CG[Call->getParent()->getParent()]; CalleeNode->removeCallEdgeFor(Call); CalleeNode->addCalledFunction(New, NF_CGN); // Update all users of sret parameter to extract value using extractvalue. for (Value::use_iterator UI = FirstCArg->use_begin(), UE = FirstCArg->use_end(); UI != UE; ) { User *U2 = *UI++; CallInst *C2 = dyn_cast<CallInst>(U2); if (C2 && (C2 == Call)) continue; GetElementPtrInst *UGEP = cast<GetElementPtrInst>(U2); ConstantInt *Idx = cast<ConstantInt>(UGEP->getOperand(2)); Value *GR = ExtractValueInst::Create(New, Idx->getZExtValue(), "evi", UGEP); while(!UGEP->use_empty()) { // isSafeToUpdateAllCallers has checked that all GEP uses are // LoadInsts LoadInst *L = cast<LoadInst>(*UGEP->use_begin()); L->replaceAllUsesWith(GR); L->eraseFromParent(); } UGEP->eraseFromParent(); continue; } Call->eraseFromParent(); } return NF_CGN; }
// // Method: registerAllocaInst() // // Description: // Register a single alloca instruction. // // Inputs: // AI - The alloca which requires registration. // // Return value: // NULL - The alloca was not registered. // Otherwise, the call to poolregister() is returned. // CallInst * RegisterStackObjPass::registerAllocaInst (AllocaInst *AI) { // // Determine if any use (direct or indirect) escapes this function. If // not, then none of the checks will consult the MetaPool, and we can // forego registering the alloca. // #if 0 bool MustRegisterAlloca = false; #else // // FIXME: For now, register all allocas. The reason is that this // optimization requires that other optimizations be executed, and those are // not integrated into LLVM yet. // bool MustRegisterAlloca = true; #endif std::vector<Value *> AllocaWorkList; AllocaWorkList.push_back (AI); while ((!MustRegisterAlloca) && (AllocaWorkList.size())) { Value * V = AllocaWorkList.back(); AllocaWorkList.pop_back(); Value::use_iterator UI = V->use_begin(); for (; UI != V->use_end(); ++UI) { // We cannot handle PHI nodes or Select instructions if (isa<PHINode>(*UI) || isa<SelectInst>(*UI)) { MustRegisterAlloca = true; continue; } // The pointer escapes if it's stored to memory somewhere. StoreInst * SI; if ((SI = dyn_cast<StoreInst>(*UI)) && (SI->getOperand(0) == V)) { MustRegisterAlloca = true; continue; } // GEP instructions are okay, but need to be added to the worklist if (isa<GetElementPtrInst>(*UI)) { AllocaWorkList.push_back (*UI); continue; } // Cast instructions are okay as long as they cast to another pointer // type if (CastInst * CI = dyn_cast<CastInst>(*UI)) { if (isa<PointerType>(CI->getType())) { AllocaWorkList.push_back (*UI); continue; } else { MustRegisterAlloca = true; continue; } } #if 0 if (ConstantExpr *cExpr = dyn_cast<ConstantExpr>(*UI)) { if (cExpr->getOpcode() == Instruction::Cast) { AllocaWorkList.push_back (*UI); continue; } else { MustRegisterAlloca = true; continue; } } #endif CallInst * CI1; if ((CI1 = dyn_cast<CallInst>(*UI))) { if (!(CI1->getCalledFunction())) { MustRegisterAlloca = true; continue; } std::string FuncName = CI1->getCalledFunction()->getName(); if (FuncName == "exactcheck3") { AllocaWorkList.push_back (*UI); continue; } else if ((FuncName == "llvm.memcpy.i32") || (FuncName == "llvm.memcpy.i64") || (FuncName == "llvm.memset.i32") || (FuncName == "llvm.memset.i64") || (FuncName == "llvm.memmove.i32") || (FuncName == "llvm.memmove.i64") || (FuncName == "llva_memcpy") || (FuncName == "llva_memset") || (FuncName == "llva_strncpy") || (FuncName == "llva_invokememcpy") || (FuncName == "llva_invokestrncpy") || (FuncName == "llva_invokememset") || (FuncName == "memcmp")) { continue; } else { MustRegisterAlloca = true; continue; } } } } if (!MustRegisterAlloca) { ++SavedRegAllocs; return 0; } // // Insert the alloca registration. // // // Create an LLVM Value for the allocation size. Insert a multiplication // instruction if the allocation allocates an array. // Type * Int32Type = IntegerType::getInt32Ty(AI->getContext()); unsigned allocsize = TD->getTypeAllocSize(AI->getAllocatedType()); Value *AllocSize = ConstantInt::get (AI->getOperand(0)->getType(), allocsize); if (AI->isArrayAllocation()) { Value * Operand = AI->getOperand(0); AllocSize = BinaryOperator::Create(Instruction::Mul, AllocSize, Operand, "sizetmp", AI); } AllocSize = castTo (AllocSize, Int32Type, "sizetmp", AI); // // Attempt to insert the call to register the alloca'ed object after all of // the alloca instructions in the basic block. // Instruction *iptI = AI; BasicBlock::iterator InsertPt = AI; iptI = ++InsertPt; if (AI->getParent() == (&(AI->getParent()->getParent()->getEntryBlock()))) { InsertPt = AI->getParent()->begin(); while (&(*(InsertPt)) != AI) ++InsertPt; while (isa<AllocaInst>(InsertPt)) ++InsertPt; iptI = InsertPt; } // // Insert a call to register the object. // PointerType * VoidPtrTy = getVoidPtrType(AI->getContext()); Instruction *Casted = castTo (AI, VoidPtrTy, AI->getName()+".casted", iptI); Value * CastedPH = ConstantPointerNull::get (VoidPtrTy); std::vector<Value *> args; args.push_back (CastedPH); args.push_back (Casted); args.push_back (AllocSize); // Update statistics ++StackRegisters; return CallInst::Create (PoolRegister, args, "", iptI); }
/// RewriteUsesOfClonedInstructions - We just cloned the instructions from the /// old header into the preheader. If there were uses of the values produced by /// these instruction that were outside of the loop, we have to insert PHI nodes /// to merge the two values. Do this now. static void RewriteUsesOfClonedInstructions(BasicBlock *OrigHeader, BasicBlock *OrigPreheader, ValueToValueMapTy &ValueMap, SmallVectorImpl<PHINode*> *InsertedPHIs) { // Remove PHI node entries that are no longer live. BasicBlock::iterator I, E = OrigHeader->end(); for (I = OrigHeader->begin(); PHINode *PN = dyn_cast<PHINode>(I); ++I) PN->removeIncomingValue(PN->getBasicBlockIndex(OrigPreheader)); // Now fix up users of the instructions in OrigHeader, inserting PHI nodes // as necessary. SSAUpdater SSA(InsertedPHIs); for (I = OrigHeader->begin(); I != E; ++I) { Value *OrigHeaderVal = &*I; // If there are no uses of the value (e.g. because it returns void), there // is nothing to rewrite. if (OrigHeaderVal->use_empty()) continue; Value *OrigPreHeaderVal = ValueMap.lookup(OrigHeaderVal); // The value now exits in two versions: the initial value in the preheader // and the loop "next" value in the original header. SSA.Initialize(OrigHeaderVal->getType(), OrigHeaderVal->getName()); SSA.AddAvailableValue(OrigHeader, OrigHeaderVal); SSA.AddAvailableValue(OrigPreheader, OrigPreHeaderVal); // Visit each use of the OrigHeader instruction. for (Value::use_iterator UI = OrigHeaderVal->use_begin(), UE = OrigHeaderVal->use_end(); UI != UE;) { // Grab the use before incrementing the iterator. Use &U = *UI; // Increment the iterator before removing the use from the list. ++UI; // SSAUpdater can't handle a non-PHI use in the same block as an // earlier def. We can easily handle those cases manually. Instruction *UserInst = cast<Instruction>(U.getUser()); if (!isa<PHINode>(UserInst)) { BasicBlock *UserBB = UserInst->getParent(); // The original users in the OrigHeader are already using the // original definitions. if (UserBB == OrigHeader) continue; // Users in the OrigPreHeader need to use the value to which the // original definitions are mapped. if (UserBB == OrigPreheader) { U = OrigPreHeaderVal; continue; } } // Anything else can be handled by SSAUpdater. SSA.RewriteUse(U); } // Replace MetadataAsValue(ValueAsMetadata(OrigHeaderVal)) uses in debug // intrinsics. SmallVector<DbgValueInst *, 1> DbgValues; llvm::findDbgValues(DbgValues, OrigHeaderVal); for (auto &DbgValue : DbgValues) { // The original users in the OrigHeader are already using the original // definitions. BasicBlock *UserBB = DbgValue->getParent(); if (UserBB == OrigHeader) continue; // Users in the OrigPreHeader need to use the value to which the // original definitions are mapped and anything else can be handled by // the SSAUpdater. To avoid adding PHINodes, check if the value is // available in UserBB, if not substitute undef. Value *NewVal; if (UserBB == OrigPreheader) NewVal = OrigPreHeaderVal; else if (SSA.HasValueForBlock(UserBB)) NewVal = SSA.GetValueInMiddleOfBlock(UserBB); else NewVal = UndefValue::get(OrigHeaderVal->getType()); DbgValue->setOperand(0, MetadataAsValue::get(OrigHeaderVal->getContext(), ValueAsMetadata::get(NewVal))); } } }
Value* LoopTripCount::insertTripCount(Loop* L, Instruction* InsertPos) { // inspired from Loop::getCanonicalInductionVariable BasicBlock *H = L->getHeader(); BasicBlock* LoopPred = L->getLoopPredecessor(); BasicBlock* startBB = NULL;//which basicblock stores start value int OneStep = 0;// the extra add or plus step for calc Assert(LoopPred, "Require Loop has a Pred"); DEBUG(errs()<<"loop depth:"<<L->getLoopDepth()<<"\n"); /** whats difference on use of predecessor and preheader??*/ //RET_ON_FAIL(self->getLoopLatch()&&self->getLoopPreheader()); //assert(self->getLoopLatch() && self->getLoopPreheader() && "need loop simplify form" ); ret_null_fail(L->getLoopLatch(), "need loop simplify form"); BasicBlock* TE = NULL;//True Exit SmallVector<BasicBlock*,4> Exits; L->getExitingBlocks(Exits); if(Exits.size()==1) TE = Exits.front(); else{ if(std::find(Exits.begin(),Exits.end(),L->getLoopLatch())!=Exits.end()) TE = L->getLoopLatch(); else{ SmallVector<llvm::Loop::Edge,4> ExitEdges; L->getExitEdges(ExitEdges); //stl 用法,先把所有满足条件的元素(出口的结束符是不可到达)移动到数组的末尾,再统一删除 ExitEdges.erase(std::remove_if(ExitEdges.begin(), ExitEdges.end(), [](llvm::Loop::Edge& I){ return isa<UnreachableInst>(I.second->getTerminator()); }), ExitEdges.end()); if(ExitEdges.size()==1) TE = const_cast<BasicBlock*>(ExitEdges.front().first); } } //process true exit ret_null_fail(TE, "need have a true exit"); Instruction* IndOrNext = NULL; Value* END = NULL; //终止块的终止指令:分情况讨论branchinst,switchinst; //跳转指令br bool a1,a2;condition<-->bool if(isa<BranchInst>(TE->getTerminator())){ const BranchInst* EBR = cast<BranchInst>(TE->getTerminator()); Assert(EBR->isConditional(), "end branch is not conditional"); ICmpInst* EC = dyn_cast<ICmpInst>(EBR->getCondition()); if(EC->getPredicate() == EC->ICMP_SGT){ Assert(!L->contains(EBR->getSuccessor(0)), *EBR<<":abnormal exit with great than");//终止块的终止指令---->跳出执行循环外的指令 OneStep += 1; } else if(EC->getPredicate() == EC->ICMP_EQ) Assert(!L->contains(EBR->getSuccessor(0)), *EBR<<":abnormal exit with great than"); else if(EC->getPredicate() == EC->ICMP_SLT) { ret_null_fail(!L->contains(EBR->getSuccessor(1)), *EBR<<":abnormal exit with less than"); } else { ret_null_fail(0, *EC<<" unknow combination of end condition"); } IndOrNext = dyn_cast<Instruction>(castoff(EC->getOperand(0)));//去掉类型转化 END = EC->getOperand(1); DEBUG(errs()<<"end value:"<<*EC<<"\n"); }else if(isa<SwitchInst>(TE->getTerminator())){ SwitchInst* ESW = const_cast<SwitchInst*>(cast<SwitchInst>(TE->getTerminator())); IndOrNext = dyn_cast<Instruction>(castoff(ESW->getCondition())); for(auto I = ESW->case_begin(),E = ESW->case_end();I!=E;++I){ if(!L->contains(I.getCaseSuccessor())){ ret_null_fail(!END,""); assert(!END && "shouldn't have two ends"); END = I.getCaseValue(); } } DEBUG(errs()<<"end value:"<<*ESW<<"\n"); }else{ assert(0 && "unknow terminator type"); } ret_null_fail(L->isLoopInvariant(END), "end value should be loop invariant");//至此得END值 Value* start = NULL; Value* ind = NULL; Instruction* next = NULL; bool addfirst = false;//add before icmp ed DISABLE(errs()<<*IndOrNext<<"\n"); if(isa<LoadInst>(IndOrNext)){ //memory depend analysis Value* PSi = IndOrNext->getOperand(0);//point type Step.i int SICount[2] = {0};//store in predecessor count,store in loop body count for( auto I = PSi->use_begin(),E = PSi->use_end();I!=E;++I){ DISABLE(errs()<<**I<<"\n"); StoreInst* SI = dyn_cast<StoreInst>(*I); if(!SI || SI->getOperand(1) != PSi) continue; if(!start&&L->isLoopInvariant(SI->getOperand(0))) { if(SI->getParent() != LoopPred) if(std::find(pred_begin(LoopPred),pred_end(LoopPred),SI->getParent()) == pred_end(LoopPred)) continue; start = SI->getOperand(0); startBB = SI->getParent(); ++SICount[0]; } Instruction* SI0 = dyn_cast<Instruction>(SI->getOperand(0)); if(L->contains(SI) && SI0 && SI0->getOpcode() == Instruction::Add){ next = SI0; ++SICount[1]; } } Assert(SICount[0]==1 && SICount[1]==1, ""); ind = IndOrNext; }else{ if(isa<PHINode>(IndOrNext)){ PHINode* PHI = cast<PHINode>(IndOrNext); ind = IndOrNext; if(castoff(PHI->getIncomingValue(0)) == castoff(PHI->getIncomingValue(1)) && PHI->getParent() != H) ind = castoff(PHI->getIncomingValue(0)); addfirst = false; }else if(IndOrNext->getOpcode() == Instruction::Add){ next = IndOrNext; addfirst = true; }else{ Assert(0 ,"unknow how to analysis"); } for(auto I = H->begin();isa<PHINode>(I);++I){ PHINode* P = cast<PHINode>(I); if(ind && P == ind){ //start = P->getIncomingValueForBlock(L->getLoopPredecessor()); start = tryFindStart(P, L, startBB); next = dyn_cast<Instruction>(P->getIncomingValueForBlock(L->getLoopLatch())); }else if(next && P->getIncomingValueForBlock(L->getLoopLatch()) == next){ //start = P->getIncomingValueForBlock(L->getLoopPredecessor()); start = tryFindStart(P, L, startBB); ind = P; } } } Assert(start ,"couldn't find a start value"); //process complex loops later //DEBUG(if(L->getLoopDepth()>1 || !L->getSubLoops().empty()) return NULL); DEBUG(errs()<<"start value:"<<*start<<"\n"); DEBUG(errs()<<"ind value:"<<*ind<<"\n"); DEBUG(errs()<<"next value:"<<*next<<"\n"); //process non add later unsigned next_phi_idx = 0; ConstantInt* Step = NULL,*PrevStep = NULL;/*only used if next is phi node*/ ret_null_fail(next, ""); PHINode* next_phi = dyn_cast<PHINode>(next); do{ if(next_phi) { next = dyn_cast<Instruction>(next_phi->getIncomingValue(next_phi_idx)); ret_null_fail(next, ""); DEBUG(errs()<<"next phi "<<next_phi_idx<<":"<<*next<<"\n"); if(Step&&PrevStep){ Assert(Step->getSExtValue() == PrevStep->getSExtValue(),""); } PrevStep = Step; } Assert(next->getOpcode() == Instruction::Add , "why induction increment is not Add"); Assert(next->getOperand(0) == ind ,"why induction increment is not add it self"); Step = dyn_cast<ConstantInt>(next->getOperand(1)); Assert(Step,""); }while(next_phi && ++next_phi_idx<next_phi->getNumIncomingValues()); //RET_ON_FAIL(Step->equalsInt(1)); //assert(VERBOSE(Step->equalsInt(1),Step) && "why induction increment number is not 1"); Value* RES = NULL; //if there are no predecessor, we can insert code into start value basicblock IRBuilder<> Builder(InsertPos); Assert(start->getType()->isIntegerTy() && END->getType()->isIntegerTy() , " why increment is not integer type"); if(start->getType() != END->getType()){ start = Builder.CreateCast(CastInst::getCastOpcode(start, false, END->getType(), false),start,END->getType()); } if(Step->getType() != END->getType()){ //Because Step is a Constant, so it casted is constant Step = dyn_cast<ConstantInt>(Builder.CreateCast(CastInst::getCastOpcode(Step, false, END->getType(), false),Step,END->getType())); AssertRuntime(Step); } if(Step->isMinusOne()) RES = Builder.CreateSub(start,END); else//Step Couldn't be zero RES = Builder.CreateSub(END, start); if(addfirst) OneStep -= 1; if(Step->isMinusOne()) OneStep*=-1; assert(OneStep<=1 && OneStep>=-1); RES = (OneStep==1)?Builder.CreateAdd(RES,Step):(OneStep==-1)?Builder.CreateSub(RES, Step):RES; if(!Step->isMinusOne()&&!Step->isOne()) RES = Builder.CreateSDiv(RES, Step); RES->setName(H->getName()+".tc"); return RES; }
/// PromoteAliasSet - Try to promote memory values to scalars by sinking /// stores out of the loop and moving loads to before the loop. We do this by /// looping over the stores in the loop, looking for stores to Must pointers /// which are loop invariant. /// void LICM::PromoteAliasSet(AliasSet &AS) { // We can promote this alias set if it has a store, if it is a "Must" alias // set, if the pointer is loop invariant, and if we are not eliminating any // volatile loads or stores. if (AS.isForwardingAliasSet() || !AS.isMod() || !AS.isMustAlias() || AS.isVolatile() || !CurLoop->isLoopInvariant(AS.begin()->getValue())) return; assert(!AS.empty() && "Must alias set should have at least one pointer element in it!"); Value *SomePtr = AS.begin()->getValue(); // It isn't safe to promote a load/store from the loop if the load/store is // conditional. For example, turning: // // for () { if (c) *P += 1; } // // into: // // tmp = *P; for () { if (c) tmp +=1; } *P = tmp; // // is not safe, because *P may only be valid to access if 'c' is true. // // It is safe to promote P if all uses are direct load/stores and if at // least one is guaranteed to be executed. bool GuaranteedToExecute = false; SmallVector<Instruction*, 64> LoopUses; SmallPtrSet<Value*, 4> PointerMustAliases; // Check that all of the pointers in the alias set have the same type. We // cannot (yet) promote a memory location that is loaded and stored in // different sizes. for (AliasSet::iterator ASI = AS.begin(), E = AS.end(); ASI != E; ++ASI) { Value *ASIV = ASI->getValue(); PointerMustAliases.insert(ASIV); // Check that all of the pointers in the alias set have the same type. We // cannot (yet) promote a memory location that is loaded and stored in // different sizes. if (SomePtr->getType() != ASIV->getType()) return; for (Value::use_iterator UI = ASIV->use_begin(), UE = ASIV->use_end(); UI != UE; ++UI) { // Ignore instructions that are outside the loop. Instruction *Use = dyn_cast<Instruction>(*UI); if (!Use || !CurLoop->contains(Use)) continue; // If there is an non-load/store instruction in the loop, we can't promote // it. if (isa<LoadInst>(Use)) assert(!cast<LoadInst>(Use)->isVolatile() && "AST broken"); else if (isa<StoreInst>(Use)) { assert(!cast<StoreInst>(Use)->isVolatile() && "AST broken"); if (Use->getOperand(0) == ASIV) return; } else return; // Not a load or store. if (!GuaranteedToExecute) GuaranteedToExecute = isSafeToExecuteUnconditionally(*Use); LoopUses.push_back(Use); } } // If there isn't a guaranteed-to-execute instruction, we can't promote. if (!GuaranteedToExecute) return; // Otherwise, this is safe to promote, lets do it! DEBUG(dbgs() << "LICM: Promoting value stored to in loop: " <<*SomePtr<<'\n'); Changed = true; ++NumPromoted; // We use the SSAUpdater interface to insert phi nodes as required. SmallVector<PHINode*, 16> NewPHIs; SSAUpdater SSA(&NewPHIs); // It wants to know some value of the same type as what we'll be inserting. Value *SomeValue; if (isa<LoadInst>(LoopUses[0])) SomeValue = LoopUses[0]; else SomeValue = cast<StoreInst>(LoopUses[0])->getOperand(0); SSA.Initialize(SomeValue->getType(), SomeValue->getName()); // First step: bucket up uses of the pointers by the block they occur in. // This is important because we have to handle multiple defs/uses in a block // ourselves: SSAUpdater is purely for cross-block references. // FIXME: Want a TinyVector<Instruction*> since there is usually 0/1 element. DenseMap<BasicBlock*, std::vector<Instruction*> > UsesByBlock; for (unsigned i = 0, e = LoopUses.size(); i != e; ++i) { Instruction *User = LoopUses[i]; UsesByBlock[User->getParent()].push_back(User); } // Okay, now we can iterate over all the blocks in the loop with uses, // processing them. Keep track of which loads are loading a live-in value. SmallVector<LoadInst*, 32> LiveInLoads; DenseMap<Value*, Value*> ReplacedLoads; for (unsigned LoopUse = 0, e = LoopUses.size(); LoopUse != e; ++LoopUse) { Instruction *User = LoopUses[LoopUse]; std::vector<Instruction*> &BlockUses = UsesByBlock[User->getParent()]; // If this block has already been processed, ignore this repeat use. if (BlockUses.empty()) continue; // Okay, this is the first use in the block. If this block just has a // single user in it, we can rewrite it trivially. if (BlockUses.size() == 1) { // If it is a store, it is a trivial def of the value in the block. if (isa<StoreInst>(User)) { SSA.AddAvailableValue(User->getParent(), cast<StoreInst>(User)->getOperand(0)); } else { // Otherwise it is a load, queue it to rewrite as a live-in load. LiveInLoads.push_back(cast<LoadInst>(User)); } BlockUses.clear(); continue; } // Otherwise, check to see if this block is all loads. If so, we can queue // them all as live in loads. bool HasStore = false; for (unsigned i = 0, e = BlockUses.size(); i != e; ++i) { if (isa<StoreInst>(BlockUses[i])) { HasStore = true; break; } } if (!HasStore) { for (unsigned i = 0, e = BlockUses.size(); i != e; ++i) LiveInLoads.push_back(cast<LoadInst>(BlockUses[i])); BlockUses.clear(); continue; } // Otherwise, we have mixed loads and stores (or just a bunch of stores). // Since SSAUpdater is purely for cross-block values, we need to determine // the order of these instructions in the block. If the first use in the // block is a load, then it uses the live in value. The last store defines // the live out value. We handle this by doing a linear scan of the block. BasicBlock *BB = User->getParent(); Value *StoredValue = 0; for (BasicBlock::iterator II = BB->begin(), E = BB->end(); II != E; ++II) { if (LoadInst *L = dyn_cast<LoadInst>(II)) { // If this is a load from an unrelated pointer, ignore it. if (!PointerMustAliases.count(L->getOperand(0))) continue; // If we haven't seen a store yet, this is a live in use, otherwise // use the stored value. if (StoredValue) { L->replaceAllUsesWith(StoredValue); ReplacedLoads[L] = StoredValue; } else { LiveInLoads.push_back(L); } continue; } if (StoreInst *S = dyn_cast<StoreInst>(II)) { // If this is a store to an unrelated pointer, ignore it. if (!PointerMustAliases.count(S->getOperand(1))) continue; // Remember that this is the active value in the block. StoredValue = S->getOperand(0); } } // The last stored value that happened is the live-out for the block. assert(StoredValue && "Already checked that there is a store in block"); SSA.AddAvailableValue(BB, StoredValue); BlockUses.clear(); } // Now that all the intra-loop values are classified, set up the preheader. // It gets a load of the pointer we're promoting, and it is the live-out value // from the preheader. LoadInst *PreheaderLoad = new LoadInst(SomePtr,SomePtr->getName()+".promoted", Preheader->getTerminator()); SSA.AddAvailableValue(Preheader, PreheaderLoad); // Now that the preheader is good to go, set up the exit blocks. Each exit // block gets a store of the live-out values that feed them. Since we've // already told the SSA updater about the defs in the loop and the preheader // definition, it is all set and we can start using it. SmallVector<BasicBlock*, 8> ExitBlocks; CurLoop->getUniqueExitBlocks(ExitBlocks); for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i) { BasicBlock *ExitBlock = ExitBlocks[i]; Value *LiveInValue = SSA.GetValueInMiddleOfBlock(ExitBlock); Instruction *InsertPos = ExitBlock->getFirstNonPHI(); new StoreInst(LiveInValue, SomePtr, InsertPos); } // Okay, now we rewrite all loads that use live-in values in the loop, // inserting PHI nodes as necessary. for (unsigned i = 0, e = LiveInLoads.size(); i != e; ++i) { LoadInst *ALoad = LiveInLoads[i]; Value *NewVal = SSA.GetValueInMiddleOfBlock(ALoad->getParent()); ALoad->replaceAllUsesWith(NewVal); CurAST->copyValue(ALoad, NewVal); ReplacedLoads[ALoad] = NewVal; } // If the preheader load is itself a pointer, we need to tell alias analysis // about the new pointer we created in the preheader block and about any PHI // nodes that just got inserted. if (PreheaderLoad->getType()->isPointerTy()) { // Copy any value stored to or loaded from a must-alias of the pointer. CurAST->copyValue(SomeValue, PreheaderLoad); for (unsigned i = 0, e = NewPHIs.size(); i != e; ++i) CurAST->copyValue(SomeValue, NewPHIs[i]); } // Now that everything is rewritten, delete the old instructions from the body // of the loop. They should all be dead now. for (unsigned i = 0, e = LoopUses.size(); i != e; ++i) { Instruction *User = LoopUses[i]; // If this is a load that still has uses, then the load must have been added // as a live value in the SSAUpdate data structure for a block (e.g. because // the loaded value was stored later). In this case, we need to recursively // propagate the updates until we get to the real value. if (!User->use_empty()) { Value *NewVal = ReplacedLoads[User]; assert(NewVal && "not a replaced load?"); // Propagate down to the ultimate replacee. The intermediately loads // could theoretically already have been deleted, so we don't want to // dereference the Value*'s. DenseMap<Value*, Value*>::iterator RLI = ReplacedLoads.find(NewVal); while (RLI != ReplacedLoads.end()) { NewVal = RLI->second; RLI = ReplacedLoads.find(NewVal); } User->replaceAllUsesWith(NewVal); CurAST->copyValue(User, NewVal); } CurAST->deleteValue(User); User->eraseFromParent(); } // fwew, we're done! }
bool InferAddressSpaces::rewriteWithNewAddressSpaces( ArrayRef<WeakTrackingVH> Postorder, const ValueToAddrSpaceMapTy &InferredAddrSpace, Function *F) const { // For each address expression to be modified, creates a clone of it with its // pointer operands converted to the new address space. Since the pointer // operands are converted, the clone is naturally in the new address space by // construction. ValueToValueMapTy ValueWithNewAddrSpace; SmallVector<const Use *, 32> UndefUsesToFix; for (Value* V : Postorder) { unsigned NewAddrSpace = InferredAddrSpace.lookup(V); if (V->getType()->getPointerAddressSpace() != NewAddrSpace) { ValueWithNewAddrSpace[V] = cloneValueWithNewAddressSpace( V, NewAddrSpace, ValueWithNewAddrSpace, &UndefUsesToFix); } } if (ValueWithNewAddrSpace.empty()) return false; // Fixes all the undef uses generated by cloneInstructionWithNewAddressSpace. for (const Use *UndefUse : UndefUsesToFix) { User *V = UndefUse->getUser(); User *NewV = cast<User>(ValueWithNewAddrSpace.lookup(V)); unsigned OperandNo = UndefUse->getOperandNo(); assert(isa<UndefValue>(NewV->getOperand(OperandNo))); NewV->setOperand(OperandNo, ValueWithNewAddrSpace.lookup(UndefUse->get())); } SmallVector<Instruction *, 16> DeadInstructions; // Replaces the uses of the old address expressions with the new ones. for (const WeakTrackingVH &WVH : Postorder) { assert(WVH && "value was unexpectedly deleted"); Value *V = WVH; Value *NewV = ValueWithNewAddrSpace.lookup(V); if (NewV == nullptr) continue; DEBUG(dbgs() << "Replacing the uses of " << *V << "\n with\n " << *NewV << '\n'); if (Constant *C = dyn_cast<Constant>(V)) { Constant *Replace = ConstantExpr::getAddrSpaceCast(cast<Constant>(NewV), C->getType()); if (C != Replace) { DEBUG(dbgs() << "Inserting replacement const cast: " << Replace << ": " << *Replace << '\n'); C->replaceAllUsesWith(Replace); V = Replace; } } Value::use_iterator I, E, Next; for (I = V->use_begin(), E = V->use_end(); I != E; ) { Use &U = *I; // Some users may see the same pointer operand in multiple operands. Skip // to the next instruction. I = skipToNextUser(I, E); if (isSimplePointerUseValidToReplace(U)) { // If V is used as the pointer operand of a compatible memory operation, // sets the pointer operand to NewV. This replacement does not change // the element type, so the resultant load/store is still valid. U.set(NewV); continue; } User *CurUser = U.getUser(); // Handle more complex cases like intrinsic that need to be remangled. if (auto *MI = dyn_cast<MemIntrinsic>(CurUser)) { if (!MI->isVolatile() && handleMemIntrinsicPtrUse(MI, V, NewV)) continue; } if (auto *II = dyn_cast<IntrinsicInst>(CurUser)) { if (rewriteIntrinsicOperands(II, V, NewV)) continue; } if (isa<Instruction>(CurUser)) { if (ICmpInst *Cmp = dyn_cast<ICmpInst>(CurUser)) { // If we can infer that both pointers are in the same addrspace, // transform e.g. // %cmp = icmp eq float* %p, %q // into // %cmp = icmp eq float addrspace(3)* %new_p, %new_q unsigned NewAS = NewV->getType()->getPointerAddressSpace(); int SrcIdx = U.getOperandNo(); int OtherIdx = (SrcIdx == 0) ? 1 : 0; Value *OtherSrc = Cmp->getOperand(OtherIdx); if (Value *OtherNewV = ValueWithNewAddrSpace.lookup(OtherSrc)) { if (OtherNewV->getType()->getPointerAddressSpace() == NewAS) { Cmp->setOperand(OtherIdx, OtherNewV); Cmp->setOperand(SrcIdx, NewV); continue; } } // Even if the type mismatches, we can cast the constant. if (auto *KOtherSrc = dyn_cast<Constant>(OtherSrc)) { if (isSafeToCastConstAddrSpace(KOtherSrc, NewAS)) { Cmp->setOperand(SrcIdx, NewV); Cmp->setOperand(OtherIdx, ConstantExpr::getAddrSpaceCast(KOtherSrc, NewV->getType())); continue; } } } if (AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(CurUser)) { unsigned NewAS = NewV->getType()->getPointerAddressSpace(); if (ASC->getDestAddressSpace() == NewAS) { ASC->replaceAllUsesWith(NewV); DeadInstructions.push_back(ASC); continue; } } // Otherwise, replaces the use with flat(NewV). if (Instruction *I = dyn_cast<Instruction>(V)) { BasicBlock::iterator InsertPos = std::next(I->getIterator()); while (isa<PHINode>(InsertPos)) ++InsertPos; U.set(new AddrSpaceCastInst(NewV, V->getType(), "", &*InsertPos)); } else { U.set(ConstantExpr::getAddrSpaceCast(cast<Constant>(NewV), V->getType())); } } } if (V->use_empty()) { if (Instruction *I = dyn_cast<Instruction>(V)) DeadInstructions.push_back(I); } } for (Instruction *I : DeadInstructions) RecursivelyDeleteTriviallyDeadInstructions(I); return true; }
// // Method: processFunction() // // Description: // This method searches for calls to a specified run-time check. For every // such call, it replaces the pointer that the call checks with the return // value of the call. // // This allows functions like boundscheck() to return a rewrite pointer; // this code changes the program to use the returned rewrite pointer instead // of the original pointer which was passed into boundscheck(). // // Inputs: // M - The module to modify. // Check - A reference to a structure describing the checking function to // process. // // Return value: // false - No modifications were made to the Module. // true - One or more modifications were made to the module. // bool RewriteOOB::processFunction (Module & M, const CheckInfo & Check) { // // Get a pointer to the checking function. If the checking function does // not exist within the program, then do nothing. // Function * F = M.getFunction (Check.name); if (!F) return false; // // Ensure the function has the right number of arguments and that its // result is a pointer type. // assert (isa<PointerType>(F->getReturnType())); // // To avoid recalculating the dominator information each time we process a // use of the specified function F, we will record the function containing // the call instruction to F and the corresponding dominator information; we // will then update this information only when the next use is a call // instruction belonging to a different function. We are helped by the fact // that iterating through uses often groups uses within the same function. // Function * CurrentFunction = 0; DominatorTree * domTree = 0; // // Iterate though all calls to the function and modify the use of the // operand to be the result of the function. // bool modified = false; for (Value::use_iterator FU = F->use_begin(); FU != F->use_end(); ++FU) { // // We are only concerned about call instructions; any other use is of // no interest to the organization. // if (CallInst * CI = dyn_cast<CallInst>(*FU)) { // // We're going to make a change. Mark that we will have done so. // modified = true; // // Get the operand that needs to be replaced as well as the operand // with all of the casts peeled away. Increment the operand index by // one because a call instruction's first operand is the function to // call. // Value * RealOperand = Check.getCheckedPointer (CI); Value * PeeledOperand = RealOperand->stripPointerCasts(); // // Cast the result of the call instruction to match that of the original // value. // BasicBlock::iterator i(CI); Instruction * CastCI = castTo (CI, PeeledOperand->getType(), PeeledOperand->getName(), ++i); // // Get dominator information for the function. // if ((CI->getParent()->getParent()) != CurrentFunction) { CurrentFunction = CI->getParent()->getParent(); domTree = &getAnalysis<DominatorTree>(*CurrentFunction); } // // For every use that the call instruction dominates, change the use to // use the result of the call instruction. We first collect the uses // that need to be modified before doing the modifications to avoid any // iterator invalidation errors. // std::vector<User *> Uses; Value::use_iterator UI = PeeledOperand->use_begin(); for (; UI != PeeledOperand->use_end(); ++UI) { if (Instruction * Use = dyn_cast<Instruction>(*UI)) if ((CI != Use) && (domTree->dominates (CI, Use))) { Uses.push_back (*UI); ++Changes; } } while (Uses.size()) { User * Use = Uses.back(); Uses.pop_back(); Use->replaceUsesOfWith (PeeledOperand, CastCI); } } } return modified; }
bool CodeGenPrepare::OptimizeExtUses(Instruction *I) { BasicBlock *DefBB = I->getParent(); // If the result of a {s|z}ext and its source are both live out, rewrite all // other uses of the source with result of extension. Value *Src = I->getOperand(0); if (Src->hasOneUse()) return false; // Only do this xform if truncating is free. if (TLI && !TLI->isTruncateFree(I->getType(), Src->getType())) return false; // Only safe to perform the optimization if the source is also defined in // this block. if (!isa<Instruction>(Src) || DefBB != cast<Instruction>(Src)->getParent()) return false; bool DefIsLiveOut = false; for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI != E; ++UI) { Instruction *User = cast<Instruction>(*UI); // Figure out which BB this ext is used in. BasicBlock *UserBB = User->getParent(); if (UserBB == DefBB) continue; DefIsLiveOut = true; break; } if (!DefIsLiveOut) return false; // Make sure non of the uses are PHI nodes. for (Value::use_iterator UI = Src->use_begin(), E = Src->use_end(); UI != E; ++UI) { Instruction *User = cast<Instruction>(*UI); BasicBlock *UserBB = User->getParent(); if (UserBB == DefBB) continue; // Be conservative. We don't want this xform to end up introducing // reloads just before load / store instructions. if (isa<PHINode>(User) || isa<LoadInst>(User) || isa<StoreInst>(User)) return false; } // InsertedTruncs - Only insert one trunc in each block once. DenseMap<BasicBlock*, Instruction*> InsertedTruncs; bool MadeChange = false; for (Value::use_iterator UI = Src->use_begin(), E = Src->use_end(); UI != E; ++UI) { Use &TheUse = UI.getUse(); Instruction *User = cast<Instruction>(*UI); // Figure out which BB this ext is used in. BasicBlock *UserBB = User->getParent(); if (UserBB == DefBB) continue; // Both src and def are live in this block. Rewrite the use. Instruction *&InsertedTrunc = InsertedTruncs[UserBB]; if (!InsertedTrunc) { BasicBlock::iterator InsertPt = UserBB->getFirstInsertionPt(); InsertedTrunc = new TruncInst(I, Src->getType(), "", InsertPt); } // Replace a use of the {s|z}ext source with a use of the result. TheUse = InsertedTrunc; ++NumExtUses; MadeChange = true; } return MadeChange; }
void InlineCostAnalyzer::FunctionInfo::countCodeReductionForPointerPair( const CodeMetrics &Metrics, DenseMap<Value *, unsigned> &PointerArgs, Value *V, unsigned ArgIdx) { SmallVector<Value *, 4> Worklist; Worklist.push_back(V); do { Value *V = Worklist.pop_back_val(); for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI != E; ++UI){ Instruction *I = cast<Instruction>(*UI); if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I)) { // If the GEP has variable indices, we won't be able to do much with it. if (!GEP->hasAllConstantIndices()) continue; // Unless the GEP is in-bounds, some comparisons will be non-constant. // Fortunately, the real-world cases where this occurs uses in-bounds // GEPs, and so we restrict the optimization to them here. if (!GEP->isInBounds()) continue; // Constant indices just change the constant offset. Add the resulting // value both to our worklist for this argument, and to the set of // viable paired values with future arguments. PointerArgs[GEP] = ArgIdx; Worklist.push_back(GEP); continue; } // Track pointer through casts. Even when the result is not a pointer, it // remains a constant relative to constants derived from other constant // pointers. if (CastInst *CI = dyn_cast<CastInst>(I)) { PointerArgs[CI] = ArgIdx; Worklist.push_back(CI); continue; } // There are two instructions which produce a strict constant value when // applied to two related pointer values. Ignore everything else. if (!isa<ICmpInst>(I) && I->getOpcode() != Instruction::Sub) continue; assert(I->getNumOperands() == 2); // Ensure that the two operands are in our set of potentially paired // pointers (or are derived from them). Value *OtherArg = I->getOperand(0); if (OtherArg == V) OtherArg = I->getOperand(1); DenseMap<Value *, unsigned>::const_iterator ArgIt = PointerArgs.find(OtherArg); if (ArgIt == PointerArgs.end()) continue; std::pair<unsigned, unsigned> ArgPair(ArgIt->second, ArgIdx); if (ArgPair.first > ArgPair.second) std::swap(ArgPair.first, ArgPair.second); PointerArgPairWeights[ArgPair] += countCodeReductionForConstant(Metrics, I); } } while (!Worklist.empty()); }