Fixed some more spelling mistake in comments of LLVM Analysis passes

[reshabh]

Summary

Fixed spelling mistake in comments of LLVM Analysis passes

[davide]

lib/Analysis/InstructionSimplify.cpp

2033

comparisons, I assume.

lib/Analysis/LazyValueInfo.cpp

100

useable is actually correct as far as I can tell.

[reshabh]

Removed a false correction and updated a wrong spelling .

[reshabh]

Thanks @davide for pointing those mistakes , I've updated now .

[vsk]

Thanks! Let me know if it's ok to commit this on your behalf.

[reshabh]

Thanks! Since I don't have commit access it would be great if you could commit this.

lib/Analysis/BasicAliasAnalysis.cpp

ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS1,
   // Like assumes, guard intrinsics are also marked as arbitrarily writing so
   // that proper control dependencies are maintained but they never mod any
   // particular memory location.
   //
   // *Unlike* assumes, guard intrinsics are modeled as reading memory since the
   // heap state at the point the guard is issued needs to be consistent in case
   // the guard invokes the "deopt" continuation.
 
-  // NB! This function is *not* commutative, so we specical case two
+  // NB! This function is *not* commutative, so we special case two
   // possibilities for guard intrinsics.
 
   if (isIntrinsicCall(CS1, Intrinsic::experimental_guard))
     return isModSet(createModRefInfo(getModRefBehavior(CS2)))
                ? ModRefInfo::Ref
                : ModRefInfo::NoModRef;
 
   if (isIntrinsicCall(CS2, Intrinsic::experimental_guard))
if (EltsDontOverlap(V1Off, V1Size, V2Off, V2Size) ||
       EltsDontOverlap(V2Off, V2Size, V1Off, V1Size))
     return NoAlias;
 
   return MayAlias;
 }
 
 // If a we have (a) a GEP and (b) a pointer based on an alloca, and the
 // beginning of the object the GEP points would have a negative offset with
-// repsect to the alloca, that means the GEP can not alias pointer (b).
+// respect to the alloca, that means the GEP can not alias pointer (b).
 // Note that the pointer based on the alloca may not be a GEP. For
 // example, it may be the alloca itself.
 // The same applies if (b) is based on a GlobalVariable. Note that just being
 // based on isIdentifiedObject() is not enough - we need an identified object
 // that does not permit access to negative offsets. For example, a negative
 // offset from a noalias argument or call can be inbounds w.r.t the actual
 // underlying object.
 //
if (isIdentifiedObject(O1) && isIdentifiedObject(O2))
       return NoAlias;
 
     // Constant pointers can't alias with non-const isIdentifiedObject objects.
     if ((isa<Constant>(O1) && isIdentifiedObject(O2) && !isa<Constant>(O2)) ||
         (isa<Constant>(O2) && isIdentifiedObject(O1) && !isa<Constant>(O1)))
       return NoAlias;
 
     // Function arguments can't alias with things that are known to be
-    // unambigously identified at the function level.
+    // unambiguously identified at the function level.
     if ((isa<Argument>(O1) && isIdentifiedFunctionLocal(O2)) ||
         (isa<Argument>(O2) && isIdentifiedFunctionLocal(O1)))
       return NoAlias;
 
     // If one pointer is the result of a call/invoke or load and the other is a
     // non-escaping local object within the same function, then we know the
     // object couldn't escape to a point where the call could return it.
     //

lib/Analysis/GlobalsModRef.cpp

do {
     const Value *Input = Inputs.pop_back_val();
 
     if (auto *InputGV = dyn_cast<GlobalValue>(Input)) {
       // If one input is the very global we're querying against, then we can't
       // conclude no-alias.
       if (InputGV == GV)
         return false;
 
-      // Distinct GlobalVariables never alias, unless overriden or zero-sized.
+      // Distinct GlobalVariables never alias, unless overridden or zero-sized.
       // FIXME: The condition can be refined, but be conservative for now.
       auto *GVar = dyn_cast<GlobalVariable>(GV);
       auto *InputGVar = dyn_cast<GlobalVariable>(InputGV);
       if (GVar && InputGVar &&
           !GVar->isDeclaration() && !InputGVar->isDeclaration() &&
           !GVar->isInterposable() && !InputGVar->isInterposable()) {
         Type *GVType = GVar->getInitializer()->getType();
         Type *InputGVType = InputGVar->getInitializer()->getType();

lib/Analysis/InstructionSimplify.cpp

if (llvm::isKnownNonZero(LHS, DL) && isa<ConstantPointerNull>(RHS) &&
     return ConstantInt::get(GetCompareTy(LHS),
                             !CmpInst::isTrueWhenEqual(Pred));
 
   // We can only fold certain predicates on pointer comparisons.
   switch (Pred) {
   default:
     return nullptr;
 
-    // Equality comaprisons are easy to fold.
+    // Equality comprisons are easy to fold.
   case CmpInst::ICMP_EQ:
   case CmpInst::ICMP_NE:
     break;
 
     // We can only handle unsigned relational comparisons because 'inbounds' on
     // a GEP only protects against unsigned wrapping.
   case CmpInst::ICMP_UGT:
   case CmpInst::ICMP_UGE:

lib/Analysis/LazyValueInfo.cpp

static ValueLatticeElement intersect(const ValueLatticeElement &A,
                                      const ValueLatticeElement &B) {
   // Undefined is the strongest state.  It means the value is known to be along
   // an unreachable path.
   if (A.isUndefined())
     return A;
   if (B.isUndefined())
     return B;
 
-  // If we gave up for one, but got a useable fact from the other, use it.
+  // If we gave up for one, but got a usable fact from the other, use it.
   if (A.isOverdefined())
     return B;
   if (B.isOverdefined())
     return A;
 
   // Can't get any more precise than constants.
   if (hasSingleValue(A))
     return A;
if (auto *SI = dyn_cast<SelectInst>(BBI))
     return solveBlockValueSelect(Res, SI, BB);
 
   // If this value is a nonnull pointer, record it's range and bailout.  Note
   // that for all other pointer typed values, we terminate the search at the
   // definition.  We could easily extend this to look through geps, bitcasts,
   // and the like to prove non-nullness, but it's not clear that's worth it
   // compile time wise.  The context-insensitive value walk done inside
   // isKnownNonZero gets most of the profitable cases at much less expense.
-  // This does mean that we have a sensativity to where the defining
+  // This does mean that we have a sensitivity to where the defining
   // instruction is placed, even if it could legally be hoisted much higher.
   // That is unfortunate.
   PointerType *PT = dyn_cast<PointerType>(BBI->getType());
   if (PT && isKnownNonZero(BBI, DL)) {
     Res = ValueLatticeElement::getNot(ConstantPointerNull::get(PT));
     return true;
   }
   if (BBI->getType()->isIntegerTy()) {

lib/Analysis/ScalarEvolution.cpp

if (Offset != nullptr) {
       if (SetVector<ValueOffsetPair> *SV = getSCEVValues(Stripped))
         SV->remove({V, Offset});
     }
     ValueExprMap.erase(V);
   }
 }
 
 /// Check whether value has nuw/nsw/exact set but SCEV does not.
-/// TODO: In reality it is better to check the poison recursevely
+/// TODO: In reality it is better to check the poison recursively
 /// but this is better than nothing.
 static bool SCEVLostPoisonFlags(const SCEV *S, const Value *V) {
   if (auto *I = dyn_cast<Instruction>(V)) {
     if (isa<OverflowingBinaryOperator>(I)) {
       if (auto *NS = dyn_cast<SCEVNAryExpr>(S)) {
         if (I->hasNoSignedWrap() && !NS->hasNoSignedWrap())
           return true;
         if (I->hasNoUnsignedWrap() && !NS->hasNoUnsignedWrap())
bool ScalarEvolution::isAddRecNeverPoison(const Instruction *I, const Loop *L) {
   // does not contain any throws or exiting blocks other than the latch, we now
   // have the ability to "choose" whether the backedge is taken or not (by
   // choosing a sufficiently evil value for the poison feeding into the branch)
   // for every iteration including and after the one in which \p I first became
   // poison.  There are two possibilities (let's call the iteration in which \p
   // I first became poison as K):
   //
   //  1. In the set of iterations including and after K, the loop body executes
-  //     no side effects.  In this case executing the backege an infinte number
+  //     no side effects.  In this case executing the backege an infinite number
   //     of times will yield undefined behavior.
   //
   //  2. In the set of iterations including and after K, the loop body executes
   //     at least one side effect.  In this case, that specific instance of side
   //     effect is control dependent on poison, which also yields undefined
   //     behavior.
 
   auto *ExitingBB = L->getExitingBlock();