Lines Matching full:instruction
104 /// DeleteDeadInstruction - Delete this instruction. Before we do, go through
105 /// and zero out all the operands of this instruction. If any of them become
110 static void DeleteDeadInstruction(Instruction *I,
114 SmallVector<Instruction*, 32> NowDeadInsts;
119 // Before we touch this instruction, remove it from memdep!
121 Instruction *DeadInst = NowDeadInsts.pop_back_val();
124 // This instruction is dead, zap it, in stages. Start by removing it from
136 if (Instruction *OpI = dyn_cast<Instruction>(Op))
148 /// hasMemoryWrite - Does this instruction write some memory? This only returns
150 static bool hasMemoryWrite(Instruction *I, const TargetLibraryInfo *TLI) {
188 /// getLocForWrite - Return a Location stored to by the specified instruction.
190 /// describe the memory operations for this instruction.
192 getLocForWrite(Instruction *Inst, AliasAnalysis &AA) {
229 /// instruction if any.
231 getLocForRead(Instruction *Inst, AliasAnalysis &AA) {
233 "Unknown instruction case");
243 /// isRemovable - If the value of this instruction and the memory it writes to
244 /// is unused, may we delete this instruction?
245 static bool isRemovable(Instruction *I) {
276 /// isShortenable - Returns true if this instruction can be safely shortened in
278 static bool isShortenable(Instruction *I) {
299 static Value *getStoredPointerOperand(Instruction *I) {
455 /// This function detects when it is unsafe to remove a dependent instruction
456 /// because the DSE inducing instruction may be a self-read.
457 static bool isPossibleSelfRead(Instruction *Inst,
459 Instruction *DepWrite, AliasAnalysis &AA) {
463 if (InstReadLoc.Ptr == 0) return false; // Not a reading instruction.
469 // DepWrite instruction if we can prove that it reads from the same location
496 Instruction *Inst = BBI++;
524 // DeleteDeadInstruction can delete the current instruction. Save BBI
530 if (NextInst == 0) // Next instruction deleted.
532 else if (BBI != BB.begin()) // Revisit this instruction if possible.
549 // Get the memory clobbered by the instruction we depend on. MemDep will
555 // Find out what memory location the dependent instruction stores.
556 Instruction *DepWrite = InstDep.getInst();
579 // DeleteDeadInstruction can delete the current instruction in loop
623 // Can't look past this instruction if it might read 'Loc'.
666 Instruction *InstPt = BB->getTerminator();
671 Instruction *Dependency = Dep.getInst();
682 Instruction *Next = llvm::next(BasicBlock::iterator(Dependency));
772 Instruction *Dead = BBI++;
794 Instruction *Inst = BBI++;
844 // Instruction doesn't read memory. Note that stores that weren't removed
