bool TailCallElim::runTRE(Function &F) { // If this function is a varargs function, we won't be able to PHI the args // right, so don't even try to convert it... if (F.getFunctionType()->isVarArg()) return false; TTI = &getAnalysis<TargetTransformInfo>(); BasicBlock *OldEntry = nullptr; bool TailCallsAreMarkedTail = false; SmallVector<PHINode*, 8> ArgumentPHIs; bool MadeChange = false; // CanTRETailMarkedCall - If false, we cannot perform TRE on tail calls // marked with the 'tail' attribute, because doing so would cause the stack // size to increase (real TRE would deallocate variable sized allocas, TRE // doesn't). bool CanTRETailMarkedCall = CanTRE(F); // Change any tail recursive calls to loops. // // FIXME: The code generator produces really bad code when an 'escaping // alloca' is changed from being a static alloca to being a dynamic alloca. // Until this is resolved, disable this transformation if that would ever // happen. This bug is PR962. for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB->getTerminator())) { bool Change = ProcessReturningBlock(Ret, OldEntry, TailCallsAreMarkedTail, ArgumentPHIs, !CanTRETailMarkedCall); if (!Change && BB->getFirstNonPHIOrDbg() == Ret) Change = FoldReturnAndProcessPred(BB, Ret, OldEntry, TailCallsAreMarkedTail, ArgumentPHIs, !CanTRETailMarkedCall); MadeChange |= Change; } } // If we eliminated any tail recursions, it's possible that we inserted some // silly PHI nodes which just merge an initial value (the incoming operand) // with themselves. Check to see if we did and clean up our mess if so. This // occurs when a function passes an argument straight through to its tail // call. for (unsigned i = 0, e = ArgumentPHIs.size(); i != e; ++i) { PHINode *PN = ArgumentPHIs[i]; // If the PHI Node is a dynamic constant, replace it with the value it is. if (Value *PNV = SimplifyInstruction(PN)) { PN->replaceAllUsesWith(PNV); PN->eraseFromParent(); } } return MadeChange; }
bool TailCallElim::runOnFunction(Function &F) { // If this function is a varargs function, we won't be able to PHI the args // right, so don't even try to convert it... if (F.getFunctionType()->isVarArg()) return false; TTI = &getAnalysis<TargetTransformInfo>(); BasicBlock *OldEntry = 0; bool TailCallsAreMarkedTail = false; SmallVector<PHINode*, 8> ArgumentPHIs; bool MadeChange = false; // CanTRETailMarkedCall - If false, we cannot perform TRE on tail calls // marked with the 'tail' attribute, because doing so would cause the stack // size to increase (real TRE would deallocate variable sized allocas, TRE // doesn't). bool CanTRETailMarkedCall = true; // Find calls that can be marked tail. AllocaCaptureTracker ACT; for (Function::iterator BB = F.begin(), EE = F.end(); BB != EE; ++BB) { for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) { CanTRETailMarkedCall &= CanTRE(AI); PointerMayBeCaptured(AI, &ACT); // If any allocas are captured, exit. if (ACT.Captured) return false; } } } // Second pass, change any tail recursive calls to loops. // // FIXME: The code generator produces really bad code when an 'escaping // alloca' is changed from being a static alloca to being a dynamic alloca. // Until this is resolved, disable this transformation if that would ever // happen. This bug is PR962. if (ACT.UsesAlloca.empty()) { for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB->getTerminator())) { bool Change = ProcessReturningBlock(Ret, OldEntry, TailCallsAreMarkedTail, ArgumentPHIs, !CanTRETailMarkedCall); if (!Change && BB->getFirstNonPHIOrDbg() == Ret) Change = FoldReturnAndProcessPred(BB, Ret, OldEntry, TailCallsAreMarkedTail, ArgumentPHIs, !CanTRETailMarkedCall); MadeChange |= Change; } } } // If we eliminated any tail recursions, it's possible that we inserted some // silly PHI nodes which just merge an initial value (the incoming operand) // with themselves. Check to see if we did and clean up our mess if so. This // occurs when a function passes an argument straight through to its tail // call. if (!ArgumentPHIs.empty()) { for (unsigned i = 0, e = ArgumentPHIs.size(); i != e; ++i) { PHINode *PN = ArgumentPHIs[i]; // If the PHI Node is a dynamic constant, replace it with the value it is. if (Value *PNV = SimplifyInstruction(PN)) { PN->replaceAllUsesWith(PNV); PN->eraseFromParent(); } } } // At this point, we know that the function does not have any captured // allocas. If additionally the function does not call setjmp, mark all calls // in the function that do not access stack memory with the tail keyword. This // implies ensuring that there does not exist any path from a call that takes // in an alloca but does not capture it and the call which we wish to mark // with "tail". if (!F.callsFunctionThatReturnsTwice()) { for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { if (CallInst *CI = dyn_cast<CallInst>(I)) { if (!ACT.UsesAlloca.count(CI)) { CI->setTailCall(); MadeChange = true; } } } } } return MadeChange; }
bool TailCallElim::runOnFunction(Function &F) { // If this function is a varargs function, we won't be able to PHI the args // right, so don't even try to convert it... if (F.getFunctionType()->isVarArg()) return false; BasicBlock *OldEntry = 0; bool TailCallsAreMarkedTail = false; SmallVector<PHINode*, 8> ArgumentPHIs; bool MadeChange = false; bool FunctionContainsEscapingAllocas = false; // CannotTCETailMarkedCall - If true, we cannot perform TCE on tail calls // marked with the 'tail' attribute, because doing so would cause the stack // size to increase (real TCE would deallocate variable sized allocas, TCE // doesn't). bool CannotTCETailMarkedCall = false; // Loop over the function, looking for any returning blocks, and keeping track // of whether this function has any non-trivially used allocas. for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { if (FunctionContainsEscapingAllocas && CannotTCETailMarkedCall) break; FunctionContainsEscapingAllocas |= CheckForEscapingAllocas(BB, CannotTCETailMarkedCall); } /// FIXME: The code generator produces really bad code when an 'escaping /// alloca' is changed from being a static alloca to being a dynamic alloca. /// Until this is resolved, disable this transformation if that would ever /// happen. This bug is PR962. if (FunctionContainsEscapingAllocas) return false; // Second pass, change any tail calls to loops. for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) { if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB->getTerminator())) { bool Change = ProcessReturningBlock(Ret, OldEntry, TailCallsAreMarkedTail, ArgumentPHIs,CannotTCETailMarkedCall); if (!Change && BB->getFirstNonPHIOrDbg() == Ret) Change = FoldReturnAndProcessPred(BB, Ret, OldEntry, TailCallsAreMarkedTail, ArgumentPHIs, CannotTCETailMarkedCall); MadeChange |= Change; } } // If we eliminated any tail recursions, it's possible that we inserted some // silly PHI nodes which just merge an initial value (the incoming operand) // with themselves. Check to see if we did and clean up our mess if so. This // occurs when a function passes an argument straight through to its tail // call. if (!ArgumentPHIs.empty()) { for (unsigned i = 0, e = ArgumentPHIs.size(); i != e; ++i) { PHINode *PN = ArgumentPHIs[i]; // If the PHI Node is a dynamic constant, replace it with the value it is. if (Value *PNV = SimplifyInstruction(PN)) { PN->replaceAllUsesWith(PNV); PN->eraseFromParent(); } } } // Finally, if this function contains no non-escaping allocas, or calls // setjmp, mark all calls in the function as eligible for tail calls //(there is no stack memory for them to access). if (!FunctionContainsEscapingAllocas && !F.callsFunctionThatReturnsTwice()) for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) if (CallInst *CI = dyn_cast<CallInst>(I)) { CI->setTailCall(); MadeChange = true; } return MadeChange; }
/// MoveExceptionValueCalls - Ensure that eh.exception is only ever called from /// landing pads by replacing calls outside of landing pads with direct use of /// a register holding the appropriate value; this requires adding calls inside /// all landing pads to initialize the register. Also, move eh.exception calls /// inside landing pads to the start of the landing pad (optional, but may make /// things simpler for later passes). bool DwarfEHPrepare::MoveExceptionValueCalls() { // If the eh.exception intrinsic is not declared in the module then there is // nothing to do. Speed up compilation by checking for this common case. if (!ExceptionValueIntrinsic && !F->getParent()->getFunction(Intrinsic::getName(Intrinsic::eh_exception))) return false; bool Changed = false; // Move calls to eh.exception that are inside a landing pad to the start of // the landing pad. for (BBSet::const_iterator LI = LandingPads.begin(), LE = LandingPads.end(); LI != LE; ++LI) { BasicBlock *LP = *LI; for (BasicBlock::iterator II = LP->getFirstNonPHIOrDbg(), IE = LP->end(); II != IE;) if (EHExceptionInst *EI = dyn_cast<EHExceptionInst>(II++)) { // Found a call to eh.exception. if (!EI->use_empty()) { // If there is already a call to eh.exception at the start of the // landing pad, then get hold of it; otherwise create such a call. Value *CallAtStart = CreateExceptionValueCall(LP); // If the call was at the start of a landing pad then leave it alone. if (EI == CallAtStart) continue; EI->replaceAllUsesWith(CallAtStart); } EI->eraseFromParent(); ++NumExceptionValuesMoved; Changed = true; } } // Look for calls to eh.exception that are not in a landing pad. If one is // found, then a register that holds the exception value will be created in // each landing pad, and the SSAUpdater will be used to compute the values // returned by eh.exception calls outside of landing pads. SSAUpdater SSA; // Remember where we found the eh.exception call, to avoid rescanning earlier // basic blocks which we already know contain no eh.exception calls. bool FoundCallOutsideLandingPad = false; Function::iterator BB = F->begin(); for (Function::iterator BE = F->end(); BB != BE; ++BB) { // Skip over landing pads. if (LandingPads.count(BB)) continue; for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(), IE = BB->end(); II != IE; ++II) if (isa<EHExceptionInst>(II)) { SSA.Initialize(II->getType(), II->getName()); FoundCallOutsideLandingPad = true; break; } if (FoundCallOutsideLandingPad) break; } // If all calls to eh.exception are in landing pads then we are done. if (!FoundCallOutsideLandingPad) return Changed; // Add a call to eh.exception at the start of each landing pad, and tell the // SSAUpdater that this is the value produced by the landing pad. for (BBSet::iterator LI = LandingPads.begin(), LE = LandingPads.end(); LI != LE; ++LI) SSA.AddAvailableValue(*LI, CreateExceptionValueCall(*LI)); // Now turn all calls to eh.exception that are not in a landing pad into a use // of the appropriate register. for (Function::iterator BE = F->end(); BB != BE; ++BB) { // Skip over landing pads. if (LandingPads.count(BB)) continue; for (BasicBlock::iterator II = BB->getFirstNonPHIOrDbg(), IE = BB->end(); II != IE;) if (EHExceptionInst *EI = dyn_cast<EHExceptionInst>(II++)) { // Found a call to eh.exception, replace it with the value from any // upstream landing pad(s). EI->replaceAllUsesWith(SSA.GetValueAtEndOfBlock(BB)); EI->eraseFromParent(); ++NumExceptionValuesMoved; } } return true; }