Index: lib/Analysis/CGSCCPassManager.cpp
===================================================================
--- lib/Analysis/CGSCCPassManager.cpp
+++ lib/Analysis/CGSCCPassManager.cpp
@@ -32,7 +32,7 @@
using namespace llvm;
-// Explicit template instantiations and specialization defininitions for core
+// Explicit template instantiations and specialization definitions for core
// template typedefs.
namespace llvm {
@@ -96,7 +96,7 @@
// ...getContext().yield();
}
- // Invaliadtion was handled after each pass in the above loop for the current
+ // Invalidation was handled after each pass in the above loop for the current
// SCC. Therefore, the remaining analysis results in the AnalysisManager are
// preserved. We mark this with a set so that we don't need to inspect each
// one individually.
@@ -372,7 +372,7 @@
// We need to propagate an invalidation call to all but the newly current SCC
// because the outer pass manager won't do that for us after splitting them.
// FIXME: We should accept a PreservedAnalysis from the CG updater so that if
- // there are preserved ananalyses we can avoid invalidating them here for
+ // there are preserved analysis we can avoid invalidating them here for
// split-off SCCs.
// We know however that this will preserve any FAM proxy so go ahead and mark
// that.
@@ -635,7 +635,7 @@
// If one of the invalidated SCCs had a cached proxy to a function
// analysis manager, we need to create a proxy in the new current SCC as
- // the invaliadted SCCs had their functions moved.
+ // the invalidated SCCs had their functions moved.
if (HasFunctionAnalysisProxy)
AM.getResult(*C, G);
Index: lib/Analysis/LoopAccessAnalysis.cpp
===================================================================
--- lib/Analysis/LoopAccessAnalysis.cpp
+++ lib/Analysis/LoopAccessAnalysis.cpp
@@ -1276,7 +1276,7 @@
// where Step is the absolute stride of the memory accesses in bytes,
// then there is no dependence.
//
- // Ratioanle:
+ // Rationale:
// We basically want to check if the absolute distance (|Dist/Step|)
// is >= the loop iteration count (or > BackedgeTakenCount).
// This is equivalent to the Strong SIV Test (Practical Dependence Testing,
Index: lib/Analysis/LoopAnalysisManager.cpp
===================================================================
--- lib/Analysis/LoopAnalysisManager.cpp
+++ lib/Analysis/LoopAnalysisManager.cpp
@@ -24,7 +24,7 @@
"enable-mssa-loop-dependency", cl::Hidden, cl::init(false),
cl::desc("Enable MemorySSA dependency for loop pass manager"));
-// Explicit template instantiations and specialization defininitions for core
+// Explicit template instantiations and specialization definitions for core
// template typedefs.
template class AllAnalysesOn;
template class AnalysisManager;
Index: lib/Analysis/ValueTracking.cpp
===================================================================
--- lib/Analysis/ValueTracking.cpp
+++ lib/Analysis/ValueTracking.cpp
@@ -530,7 +530,7 @@
if (Inv->getParent() != CxtI->getParent())
return false;
- // If we have a dom tree, then we now know that the assume doens't dominate
+ // If we have a dom tree, then we now know that the assume doesn't dominate
// the other instruction. If we don't have a dom tree then we can check if
// the assume is first in the BB.
if (!DT) {
@@ -574,7 +574,7 @@
if (Q.isExcluded(I))
continue;
- // Warning: This loop can end up being somewhat performance sensetive.
+ // Warning: This loop can end up being somewhat performance sensitive.
// We're running this loop for once for each value queried resulting in a
// runtime of ~O(#assumes * #values).
@@ -856,7 +856,7 @@
/// Compute known bits from a shift operator, including those with a
/// non-constant shift amount. Known is the output of this function. Known2 is a
/// pre-allocated temporary with the same bit width as Known. KZF and KOF are
-/// operator-specific functors that, given the known-zero or known-one bits
+/// operator-specific functions that, given the known-zero or known-one bits
/// respectively, and a shift amount, compute the implied known-zero or
/// known-one bits of the shift operator's result respectively for that shift
/// amount. The results from calling KZF and KOF are conservatively combined for
@@ -2192,7 +2192,7 @@
/// (itself), but other cases can give us information. For example, immediately
/// after an "ashr X, 2", we know that the top 3 bits are all equal to each
/// other, so we return 3. For vectors, return the number of sign bits for the
-/// vector element with the mininum number of known sign bits.
+/// vector element with the minimum number of known sign bits.
static unsigned ComputeNumSignBitsImpl(const Value *V, unsigned Depth,
const Query &Q) {
assert(Depth <= MaxDepth && "Limit Search Depth");
@@ -2979,7 +2979,7 @@
if (!V)
return nullptr;
- // Insert the value in the new (sub) aggregrate
+ // Insert the value in the new (sub) aggregate
return InsertValueInst::Create(To, V, makeArrayRef(Idxs).slice(IdxSkip),
"tmp", InsertBefore);
}
@@ -3008,9 +3008,9 @@
return BuildSubAggregate(From, To, IndexedType, Idxs, IdxSkip, InsertBefore);
}
-/// Given an aggregrate and an sequence of indices, see if
+/// Given an aggregate and an sequence of indices, see if
/// the scalar value indexed is already around as a register, for example if it
-/// were inserted directly into the aggregrate.
+/// were inserted directly into the aggregate.
///
/// If InsertBefore is not null, this function will duplicate (modified)
/// insertvalues when a part of a nested struct is extracted.
Index: lib/Analysis/VectorUtils.cpp
===================================================================
--- lib/Analysis/VectorUtils.cpp
+++ lib/Analysis/VectorUtils.cpp
@@ -163,7 +163,7 @@
return nullptr;
// Try to remove a gep instruction to make the pointer (actually index at this
- // point) easier analyzable. If OrigPtr is equal to Ptr we are analzying the
+ // point) easier analyzable. If OrigPtr is equal to Ptr we are analyzing the
// pointer, otherwise, we are analyzing the index.
Value *OrigPtr = Ptr;