Lines Matching full:instruction
11 // by a return instruction with a branch to the entry of the function, creating
40 // return instruction. It's possible that there could be a jump between
104 CallInst *FindTRECandidate(Instruction *I,
120 bool CanMoveAboveCall(Instruction *I, CallInst *CI);
121 Value *CanTransformAccumulatorRecursion(Instruction *I, CallInst *CI);
189 Instruction *I = cast<Instruction>(U->getUser());
192 case Instruction::Call:
193 case Instruction::Invoke: {
205 case Instruction::Load: {
210 case Instruction::Store: {
215 case Instruction::BitCast:
216 case Instruction::GetElementPtr:
217 case Instruction::PHI:
218 case Instruction::Select:
219 case Instruction::AddrSpaceCast:
243 SmallPtrSet<Instruction *, 32> AllocaUsers;
244 SmallPtrSet<Instruction *, 32> EscapePoints;
268 // contain the escaping instruction will be marked as being visited without an
436 /// instruction from after the call to before the call, assuming that all
437 /// instructions between the call and this instruction are movable.
439 Instruction *I, CallInst *CI) {
459 // Otherwise, if this is a side-effect free instruction, check to make sure
462 // the call, or movable instructions between the call and the instruction
532 /// If the specified instruction can be transformed using accumulator recursion
535 Value *TailCallElim::CanTransformAccumulatorRecursion(Instruction *I,
541 // Exactly one operand should be the result of the call instruction.
546 // The only user of this instruction we allow is a single return instruction.
556 static Instruction *FirstNonDbg(BasicBlock::iterator I) {
563 TailCallElim::FindTRECandidate(Instruction *TI,
620 // the call instruction that are both associative and commutative, the initial
623 // simple tail recursion elimination. If the operation is an LLVM instruction
625 // we are handling the case when the return instruction returns a constant C
630 Instruction *AccumulatorRecursionInstr = nullptr;
640 // If we can't move the instruction above the call, it might be because it
646 // Yes, this is accumulator recursion. Remember which instruction
663 // instruction returns a constant, and all other return instructions
666 return false; // Current return instruction does not return a constant.
704 Instruction *InsertPos = OldEntry->begin();
736 Instruction *AccRecInstr = AccumulatorRecursionInstr;
760 // our associative and commutative accumulator instruction.
763 // Next, rewrite the accumulator recursion instruction so that it does not
769 // constant returned by the current return instruction.
823 // because the ret instruction in there is still using a value which
