/// Delete this instruction. Before we do, go through and zero out all the /// operands of this instruction. If any of them become dead, delete them and /// the computation tree that feeds them. /// If ValueSet is non-null, remove any deleted instructions from it as well. static void deleteDeadInstruction(Instruction *I, BasicBlock::iterator *BBI, MemoryDependenceResults &MD, const TargetLibraryInfo &TLI, InstOverlapIntervalsTy &IOL, DenseMap<Instruction*, size_t> *InstrOrdering, SmallSetVector<Value *, 16> *ValueSet = nullptr) { SmallVector<Instruction*, 32> NowDeadInsts; NowDeadInsts.push_back(I); --NumFastOther; // Keeping the iterator straight is a pain, so we let this routine tell the // caller what the next instruction is after we're done mucking about. BasicBlock::iterator NewIter = *BBI; // Before we touch this instruction, remove it from memdep! do { Instruction *DeadInst = NowDeadInsts.pop_back_val(); ++NumFastOther; // This instruction is dead, zap it, in stages. Start by removing it from // MemDep, which needs to know the operands and needs it to be in the // function. MD.removeInstruction(DeadInst); for (unsigned op = 0, e = DeadInst->getNumOperands(); op != e; ++op) { Value *Op = DeadInst->getOperand(op); DeadInst->setOperand(op, nullptr); // If this operand just became dead, add it to the NowDeadInsts list. if (!Op->use_empty()) continue; if (Instruction *OpI = dyn_cast<Instruction>(Op)) if (isInstructionTriviallyDead(OpI, &TLI)) NowDeadInsts.push_back(OpI); } if (ValueSet) ValueSet->remove(DeadInst); InstrOrdering->erase(DeadInst); IOL.erase(DeadInst); if (NewIter == DeadInst->getIterator()) NewIter = DeadInst->eraseFromParent(); else DeadInst->eraseFromParent(); } while (!NowDeadInsts.empty()); *BBI = NewIter; }
/// Delete this instruction. Before we do, go through and zero out all the /// operands of this instruction. If any of them become dead, delete them and /// the computation tree that feeds them. /// If ValueSet is non-null, remove any deleted instructions from it as well. static void deleteDeadInstruction(Instruction *I, MemoryDependenceResults &MD, const TargetLibraryInfo &TLI, SmallSetVector<Value *, 16> *ValueSet = nullptr) { SmallVector<Instruction*, 32> NowDeadInsts; NowDeadInsts.push_back(I); --NumFastOther; // Before we touch this instruction, remove it from memdep! do { Instruction *DeadInst = NowDeadInsts.pop_back_val(); ++NumFastOther; // This instruction is dead, zap it, in stages. Start by removing it from // MemDep, which needs to know the operands and needs it to be in the // function. MD.removeInstruction(DeadInst); for (unsigned op = 0, e = DeadInst->getNumOperands(); op != e; ++op) { Value *Op = DeadInst->getOperand(op); DeadInst->setOperand(op, nullptr); // If this operand just became dead, add it to the NowDeadInsts list. if (!Op->use_empty()) continue; if (Instruction *OpI = dyn_cast<Instruction>(Op)) if (isInstructionTriviallyDead(OpI, &TLI)) NowDeadInsts.push_back(OpI); } DeadInst->eraseFromParent(); if (ValueSet) ValueSet->remove(DeadInst); } while (!NowDeadInsts.empty()); }