llvm.org GIT mirror llvm / 06a2673
Fixed spelling mistake in comments of LLVM Analysis passes Patch by Reshabh Sharma! Differential Revision: https://reviews.llvm.org/D43861 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@326352 91177308-0d34-0410-b5e6-96231b3b80d8 Vedant Kumar 2 years ago
4 changed file(s) with 14 addition(s) and 14 deletion(s). Raw diff Collapse all Expand all
3131
3232 using namespace llvm;
3333
34 // Explicit template instantiations and specialization defininitions for core
34 // Explicit template instantiations and specialization definitions for core
3535 // template typedefs.
3636 namespace llvm {
3737
9595 // ...getContext().yield();
9696 }
9797
98 // Invaliadtion was handled after each pass in the above loop for the current
98 // Invalidation was handled after each pass in the above loop for the current
9999 // SCC. Therefore, the remaining analysis results in the AnalysisManager are
100100 // preserved. We mark this with a set so that we don't need to inspect each
101101 // one individually.
371371 // We need to propagate an invalidation call to all but the newly current SCC
372372 // because the outer pass manager won't do that for us after splitting them.
373373 // FIXME: We should accept a PreservedAnalysis from the CG updater so that if
374 // there are preserved ananalyses we can avoid invalidating them here for
374 // there are preserved analysis we can avoid invalidating them here for
375375 // split-off SCCs.
376376 // We know however that this will preserve any FAM proxy so go ahead and mark
377377 // that.
634634
635635 // If one of the invalidated SCCs had a cached proxy to a function
636636 // analysis manager, we need to create a proxy in the new current SCC as
637 // the invaliadted SCCs had their functions moved.
637 // the invalidated SCCs had their functions moved.
638638 if (HasFunctionAnalysisProxy)
639639 AM.getResult(*C, G);
640640
2323 "enable-mssa-loop-dependency", cl::Hidden, cl::init(false),
2424 cl::desc("Enable MemorySSA dependency for loop pass manager"));
2525
26 // Explicit template instantiations and specialization defininitions for core
26 // Explicit template instantiations and specialization definitions for core
2727 // template typedefs.
2828 template class AllAnalysesOn;
2929 template class AnalysisManager;
529529 if (Inv->getParent() != CxtI->getParent())
530530 return false;
531531
532 // If we have a dom tree, then we now know that the assume doens't dominate
532 // If we have a dom tree, then we now know that the assume doesn't dominate
533533 // the other instruction. If we don't have a dom tree then we can check if
534534 // the assume is first in the BB.
535535 if (!DT) {
573573 if (Q.isExcluded(I))
574574 continue;
575575
576 // Warning: This loop can end up being somewhat performance sensetive.
576 // Warning: This loop can end up being somewhat performance sensitive.
577577 // We're running this loop for once for each value queried resulting in a
578578 // runtime of ~O(#assumes * #values).
579579
855855 /// Compute known bits from a shift operator, including those with a
856856 /// non-constant shift amount. Known is the output of this function. Known2 is a
857857 /// pre-allocated temporary with the same bit width as Known. KZF and KOF are
858 /// operator-specific functors that, given the known-zero or known-one bits
858 /// operator-specific functions that, given the known-zero or known-one bits
859859 /// respectively, and a shift amount, compute the implied known-zero or
860860 /// known-one bits of the shift operator's result respectively for that shift
861861 /// amount. The results from calling KZF and KOF are conservatively combined for
21912191 /// (itself), but other cases can give us information. For example, immediately
21922192 /// after an "ashr X, 2", we know that the top 3 bits are all equal to each
21932193 /// other, so we return 3. For vectors, return the number of sign bits for the
2194 /// vector element with the mininum number of known sign bits.
2194 /// vector element with the minimum number of known sign bits.
21952195 static unsigned ComputeNumSignBitsImpl(const Value *V, unsigned Depth,
21962196 const Query &Q) {
21972197 assert(Depth <= MaxDepth && "Limit Search Depth");
30023002 if (!V)
30033003 return nullptr;
30043004
3005 // Insert the value in the new (sub) aggregrate
3005 // Insert the value in the new (sub) aggregate
30063006 return InsertValueInst::Create(To, V, makeArrayRef(Idxs).slice(IdxSkip),
30073007 "tmp", InsertBefore);
30083008 }
30313031 return BuildSubAggregate(From, To, IndexedType, Idxs, IdxSkip, InsertBefore);
30323032 }
30333033
3034 /// Given an aggregrate and an sequence of indices, see if
3035 /// the scalar value indexed is already around as a register, for example if it
3036 /// were inserted directly into the aggregrate.
3034 /// Given an aggregate and a sequence of indices, see if the scalar value
3035 /// indexed is already around as a register, for example if it was inserted
3036 /// directly into the aggregate.
30373037 ///
30383038 /// If InsertBefore is not null, this function will duplicate (modified)
30393039 /// insertvalues when a part of a nested struct is extracted.
162162 return nullptr;
163163
164164 // Try to remove a gep instruction to make the pointer (actually index at this
165 // point) easier analyzable. If OrigPtr is equal to Ptr we are analzying the
165 // point) easier analyzable. If OrigPtr is equal to Ptr we are analyzing the
166166 // pointer, otherwise, we are analyzing the index.
167167 Value *OrigPtr = Ptr;
168168