CbC/CbC_llvm: lib/Transforms/Scalar/DeadStoreElimination.cpp comparison

comparison lib/Transforms/Scalar/DeadStoreElimination.cpp @ 134:3a76565eade5 LLVM5.0.1

update 5.0.1

author	mir3636
date	Sat, 17 Feb 2018 09:57:20 +0900
parents	803732b1fca8
children	c2174574ed3a

comparison

equal deleted inserted replaced

-:c60214abe0e8
+:3a76565eade5
 // Before we touch this instruction, remove it from memdep!
 do {
 Instruction *DeadInst = NowDeadInsts.pop_back_val();
 ++NumFastOther;
+// Try to preserve debug information attached to the dead instruction.
+salvageDebugInfo(*DeadInst);
 // 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);
 *BBI = NewIter;
 }
 /// Does this instruction write some memory?  This only returns true for things
 /// that we can analyze with other helpers below.
-static bool hasMemoryWrite(Instruction *I, const TargetLibraryInfo &TLI) {
+static bool hasAnalyzableMemoryWrite(Instruction *I,
+const TargetLibraryInfo &TLI) {
 if (isa<StoreInst>(I))
 return true;
 if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
 switch (II->getIntrinsicID()) {
 default:
 }
 /// Return a Location stored to by the specified instruction. If isRemovable
 /// returns true, this function and getLocForRead completely describe the memory
 /// operations for this instruction.
-static MemoryLocation getLocForWrite(Instruction *Inst, AliasAnalysis &AA) {
+static MemoryLocation getLocForWrite(Instruction *Inst) {
 if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
 return MemoryLocation::get(SI);
 if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(Inst)) {
 // memcpy/memmove/memset.
 MemoryLocation Loc = MemoryLocation::getForDest(MI);
 return Loc;
 }
-IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst);
+if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
-if (!II)
+switch (II->getIntrinsicID()) {
-return MemoryLocation();
+default:
+return MemoryLocation(); // Unhandled intrinsic.
-switch (II->getIntrinsicID()) {
+case Intrinsic::init_trampoline:
-default:
+return MemoryLocation(II->getArgOperand(0));
-return MemoryLocation(); // Unhandled intrinsic.
+case Intrinsic::lifetime_end: {
-case Intrinsic::init_trampoline:
+uint64_t Len = cast<ConstantInt>(II->getArgOperand(0))->getZExtValue();
-// FIXME: We don't know the size of the trampoline, so we can't really
+return MemoryLocation(II->getArgOperand(1), Len);
-// handle it here.
+}
-return MemoryLocation(II->getArgOperand(0));
+}
-case Intrinsic::lifetime_end: {
+}
-uint64_t Len = cast<ConstantInt>(II->getArgOperand(0))->getZExtValue();
+if (auto CS = CallSite(Inst))
-return MemoryLocation(II->getArgOperand(1), Len);
+// All the supported TLI functions so far happen to have dest as their
-}
+// first argument.
-}
+return MemoryLocation(CS.getArgument(0));
-}
+return MemoryLocation();
+}
-/// Return the location read by the specified "hasMemoryWrite" instruction if
-/// any.
+/// Return the location read by the specified "hasAnalyzableMemoryWrite"
+/// instruction if any.
 static MemoryLocation getLocForRead(Instruction *Inst,
 const TargetLibraryInfo &TLI) {
-assert(hasMemoryWrite(Inst, TLI) && "Unknown instruction case");
+assert(hasAnalyzableMemoryWrite(Inst, TLI) && "Unknown instruction case");
 // The only instructions that both read and write are the mem transfer
 // instructions (memcpy/memmove).
 if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(Inst))
 return MemoryLocation::getForSource(MTI);
 if (StoreInst *SI = dyn_cast<StoreInst>(I))
 return SI->isUnordered();
 if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
 switch (II->getIntrinsicID()) {
-default: llvm_unreachable("doesn't pass 'hasMemoryWrite' predicate");
+default: llvm_unreachable("doesn't pass 'hasAnalyzableMemoryWrite' predicate");
 case Intrinsic::lifetime_end:
 // Never remove dead lifetime_end's, e.g. because it is followed by a
 // free.
 return false;
 case Intrinsic::init_trampoline:
 // Don't remove volatile memory intrinsics.
 return !cast<MemIntrinsic>(II)->isVolatile();
 }
 }
+// note: only get here for calls with analyzable writes - i.e. libcalls
 if (auto CS = CallSite(I))
 return CS.getInstruction()->use_empty();
 return false;
 }
 return II && II->getIntrinsicID() == Intrinsic::memset;
 }
 /// Return the pointer that is being written to.
 static Value *getStoredPointerOperand(Instruction *I) {
-if (StoreInst *SI = dyn_cast<StoreInst>(I))
+//TODO: factor this to reuse getLocForWrite
-return SI->getPointerOperand();
+MemoryLocation Loc = getLocForWrite(I);
-if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I))
+assert(Loc.Ptr &&
-return MI->getDest();
+"unable to find pointer writen for analyzable instruction?");
+// TODO: most APIs don't expect const Value *
-if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
+return const_cast<Value*>(Loc.Ptr);
-switch (II->getIntrinsicID()) {
-default: llvm_unreachable("Unexpected intrinsic!");
-case Intrinsic::init_trampoline:
-return II->getArgOperand(0);
-}
-}
-CallSite CS(I);
-// All the supported functions so far happen to have dest as their first
-// argument.
-return CS.getArgument(0);
 }
 static uint64_t getPointerSize(const Value *V, const DataLayout &DL,
 const TargetLibraryInfo &TLI) {
 uint64_t Size;
 // In this case we also have to look at instructions after SI.
 EI = B->end();
 }
 for (; BI != EI; ++BI) {
 Instruction *I = &*BI;
-if (I->mayWriteToMemory() && I != SecondI) {
+if (I->mayWriteToMemory() && I != SecondI)
-auto Res = AA->getModRefInfo(I, MemLoc);
+if (isModSet(AA->getModRefInfo(I, MemLoc)))
-if (Res & MRI_Mod)
 return false;
-}
 }
 if (B != FirstBB) {
 assert(B != &FirstBB->getParent()->getEntryBlock() &&
 "Should not hit the entry block because SI must be dominated by LI");
 for (auto PredI = pred_begin(B), PE = pred_end(B); PredI != PE; ++PredI) {
 MemDepResult Dep =
 MD->getPointerDependencyFrom(Loc, false, InstPt->getIterator(), BB);
 while (Dep.isDef() || Dep.isClobber()) {
 Instruction *Dependency = Dep.getInst();
-if (!hasMemoryWrite(Dependency, *TLI) || !isRemovable(Dependency))
+if (!hasAnalyzableMemoryWrite(Dependency, *TLI) ||
+!isRemovable(Dependency))
 break;
 Value *DepPointer =
 GetUnderlyingObject(getStoredPointerOperand(Dependency), DL);
 // Scan the basic block backwards
 for (BasicBlock::iterator BBI = BB.end(); BBI != BB.begin(); ){
 --BBI;
 // If we find a store, check to see if it points into a dead stack value.
-if (hasMemoryWrite(&*BBI, *TLI) && isRemovable(&*BBI)) {
+if (hasAnalyzableMemoryWrite(&*BBI, *TLI) && isRemovable(&*BBI)) {
 // See through pointer-to-pointer bitcasts
 SmallVector<Value *, 4> Pointers;
 GetUnderlyingObjects(getStoredPointerOperand(&*BBI), Pointers, DL);
 // Stores to stack values are valid candidates for removal.
 // If the call might load from any of our allocas, then any store above
 // the call is live.
 DeadStackObjects.remove_if([&](Value *I) {
 // See if the call site touches the value.
-ModRefInfo A = AA->getModRefInfo(CS, I, getPointerSize(I, DL, *TLI));
+return isRefSet(AA->getModRefInfo(CS, I, getPointerSize(I, DL, *TLI)));
-return A == MRI_ModRef || A == MRI_Ref;
 });
 // If all of the allocas were clobbered by the call then we're not going
 // to find anything else to process.
 if (DeadStackObjects.empty())
 // a good idea to shorten it
 // Power of 2 vector writes are probably always a bad idea to optimize
 // as any store/memset/memcpy is likely using vector instructions so
 // shortening it to not vector size is likely to be slower
 MemIntrinsic *EarlierIntrinsic = cast<MemIntrinsic>(EarlierWrite);
-unsigned EarlierWriteAlign = EarlierIntrinsic->getAlignment();
+unsigned EarlierWriteAlign = EarlierIntrinsic->getDestAlignment();
 if (!IsOverwriteEnd)
 LaterOffset = int64_t(LaterOffset + LaterSize);
 if (!(isPowerOf2_64(LaterOffset) && EarlierWriteAlign <= LaterOffset) &&
 !((EarlierWriteAlign != 0) && LaterOffset % EarlierWriteAlign == 0))
 const DataLayout &DL,
 InstOverlapIntervalsTy &IOL) {
 bool Changed = false;
 for (auto OI : IOL) {
 Instruction *EarlierWrite = OI.first;
-MemoryLocation Loc = getLocForWrite(EarlierWrite, *AA);
+MemoryLocation Loc = getLocForWrite(EarlierWrite);
 assert(isRemovable(EarlierWrite) && "Expect only removable instruction");
 assert(Loc.Size != MemoryLocation::UnknownSize && "Unexpected mem loc");
 const Value *Ptr = Loc.Ptr->stripPointerCasts();
 int64_t EarlierStart = 0;
 LastThrowingInstIndex = CurInstNumber;
 continue;
 }
 // Check to see if Inst writes to memory.  If not, continue.
-if (!hasMemoryWrite(Inst, *TLI))
+if (!hasAnalyzableMemoryWrite(Inst, *TLI))
 continue;
 // eliminateNoopStore will update in iterator, if necessary.
 if (eliminateNoopStore(Inst, BBI, AA, MD, DL, TLI, IOL, &InstrOrdering)) {
 MadeChange = true;
 // FIXME: cross-block DSE would be fun. :)
 if (!InstDep.isDef() && !InstDep.isClobber())
 continue;
 // Figure out what location is being stored to.
-MemoryLocation Loc = getLocForWrite(Inst, *AA);
+MemoryLocation Loc = getLocForWrite(Inst);
 // If we didn't get a useful location, fail.
 if (!Loc.Ptr)
 continue;
 // away the store and we bail out.  However, if we depend on something
 // that overwrites the memory location we *can* potentially optimize it.
 //
 // Find out what memory location the dependent instruction stores.
 Instruction *DepWrite = InstDep.getInst();
-MemoryLocation DepLoc = getLocForWrite(DepWrite, *AA);
+if (!hasAnalyzableMemoryWrite(DepWrite, *TLI))
+break;
+MemoryLocation DepLoc = getLocForWrite(DepWrite);
 // If we didn't get a useful location, or if it isn't a size, bail out.
 if (!DepLoc.Ptr)
 break;
 // Make sure we don't look past a call which might throw. This is an
 } else if (EnablePartialStoreMerging &&
 OR == OW_PartialEarlierWithFullLater) {
 auto *Earlier = dyn_cast<StoreInst>(DepWrite);
 auto *Later = dyn_cast<StoreInst>(Inst);
 if (Earlier && isa<ConstantInt>(Earlier->getValueOperand()) &&
-Later && isa<ConstantInt>(Later->getValueOperand())) {
+Later && isa<ConstantInt>(Later->getValueOperand()) &&
+memoryIsNotModifiedBetween(Earlier, Later, AA)) {
 // If the store we find is:
 //   a) partially overwritten by the store to 'Loc'
 //   b) the later store is fully contained in the earlier one and
 //   c) they both have a constant value
 // Merge the two stores, replacing the earlier store's value with a
 // we can remove the first store to P even though we don't know if P and Q
 // alias.
 if (DepWrite == &BB.front()) break;
 // Can't look past this instruction if it might read 'Loc'.
-if (AA->getModRefInfo(DepWrite, Loc) & MRI_Ref)
+if (isRefSet(AA->getModRefInfo(DepWrite, Loc)))
 break;
 InstDep = MD->getPointerDependencyFrom(Loc, /*isLoad=*/ false,
 DepWrite->getIterator(), &BB,
 /*QueryInst=*/ nullptr, &Limit);

Mercurial > hg > CbC > CbC_llvm

comparison lib/Transforms/Scalar/DeadStoreElimination.cpp @ 134:3a76565eade5 LLVM5.0.1