Fixed some more spelling mistake in comments of LLVM Analysis passes

[reshabh]

Summary

Fixed spelling mistake in comments of LLVM Analysis passes

[vsk]

Thanks! Have you gotten commit access yet? If not, I can commit this for you.

[reshabh]

In D43939#1024718, @vsk wrote:

Thanks! Have you gotten commit access yet? If not, I can commit this for you.

Thanks for reviewing . No , I don't have commit access yet .

lib/Analysis/AliasAnalysisSummary.h

 //=====- CFLSummary.h - Abstract stratified sets implementation. --------=====//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 /// \file
 /// This file defines various utility types and functions useful to
 /// summary-based alias analysis.
 ///
 /// Summary-based analysis, also known as bottom-up analysis, is a style of
 /// interprocedrual static analysis that tries to analyze the callees before the
 /// callers get analyzed. The key idea of summary-based analysis is to first
-/// process each function indepedently, outline its behavior in a condensed
+/// process each function independently, outline its behavior in a condensed
 /// summary, and then instantiate the summary at the callsite when the said
 /// function is called elsewhere. This is often in contrast to another style
 /// called top-down analysis, in which callers are always analyzed first before
 /// the callees.
 ///
 /// In a summary-based analysis, functions must be examined independently and
 /// out-of-context. We have no information on the state of the memory, the
 /// arguments, the global values, and anything else external to the function. To

lib/Analysis/BranchProbabilityInfo.cpp

bool BranchProbabilityInfo::calcColdCallHeuristics(const BasicBlock *BB) {
   for (unsigned SuccIdx : ColdEdges)
     setEdgeProbability(BB, SuccIdx, ColdProb);
   for (unsigned SuccIdx : NormalEdges)
     setEdgeProbability(BB, SuccIdx, NormalProb);
 
   return true;
 }
 
-// Calculate Edge Weights using "Pointer Heuristics". Predict a comparsion
+// Calculate Edge Weights using "Pointer Heuristics". Predict a comparison
 // between two pointer or pointer and NULL will fail.
 bool BranchProbabilityInfo::calcPointerHeuristics(const BasicBlock *BB) {
   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
   if (!BI || !BI->isConditional())
     return false;
 
   Value *Cond = BI->getCondition();
   ICmpInst *CI = dyn_cast<ICmpInst>(Cond);

lib/Analysis/CFLAndersAliasAnalysis.cpp

 // than CFLSteensAliasAnalysis (the worst case complexity of
 // CFLAndersAliasAnalysis is cubic, while the worst case complexity of
 // CFLSteensAliasAnalysis is almost linear), but it is able to yield more
 // precise analysis result. The precision of this analysis is roughly the same
 // as that of an one level context-sensitive Andersen's algorithm.
 //
 // The algorithm used here is based on recursive state machine matching scheme
 // proposed in "Demand-driven alias analysis for C" by Xin Zheng and Radu
-// Rugina. The general idea is to extend the tranditional transitive closure
+// Rugina. The general idea is to extend the traditional transitive closure
 // algorithm to perform CFL matching along the way: instead of recording
 // "whether X is reachable from Y", we keep track of "whether X is reachable
 // from Y at state Z", where the "state" field indicates where we are in the CFL
 // matching process. To understand the matching better, it is advisable to have
 // the state machine shown in Figure 3 of the paper available when reading the
 // codes: all we do here is to selectively expand the transitive closure by
 // discarding edges that are not recognized by the state machine.
 //
static void processWorkListItem(const WorkListItem &Item, const CFLGraph &Graph,
   assert(NodeInfo != nullptr);
 
   // TODO: propagate field offsets
 
   // FIXME: Here is a neat trick we can do: since both ReachSet and MemSet holds
   // relations that are symmetric, we could actually cut the storage by half by
   // sorting FromNode and ToNode before insertion happens.
 
-  // The newly added value alias pair may pontentially generate more memory
+  // The newly added value alias pair may potentially generate more memory
   // alias pairs. Check for them here.
   auto FromNodeBelow = getNodeBelow(Graph, FromNode);
   auto ToNodeBelow = getNodeBelow(Graph, ToNode);
   if (FromNodeBelow && ToNodeBelow &&
       MemSet.insert(*FromNodeBelow, *ToNodeBelow)) {
     propagate(*FromNodeBelow, *ToNodeBelow,
               MatchState::FlowFromMemAliasNoReadWrite, ReachSet, WorkList);
     for (const auto &Mapping : ReachSet.reachableValueAliases(*FromNodeBelow)) {

lib/Analysis/LazyCallGraph.cpp

 /// - Updates the postorder sequence to correctly satisfy the postorder
 ///   constraint after the edge is inserted.
 /// - Only reorders SCCs in the closed postorder sequence from the source to
 ///   the target, so easy to bound how much has changed even in the ordering.
 /// - Big-O is the number of edges in the closed postorder range of SCCs from
 ///   source to target.
 ///
 /// This helper routine, in addition to updating the postorder sequence itself
-/// will also update a map from SCCs to indices within that sequecne.
+/// will also update a map from SCCs to indices within that sequence.
 ///
 /// The sequence and the map must operate on pointers to the SCC type.
 ///
 /// Two callbacks must be provided. The first computes the subset of SCCs in
 /// the postorder closed range from the source to the target which connect to
 /// the source SCC via some (transitive) set of edges. The second computes the
 /// subset of the same range which the target SCC connects to via some
 /// (transitive) set of edges. Both callbacks should populate the set argument
#endif
 
   // Otherwise we are removing a call edge from a single SCC. This may break
   // the cycle. In order to compute the new set of SCCs, we need to do a small
   // DFS over the nodes within the SCC to form any sub-cycles that remain as
   // distinct SCCs and compute a postorder over the resulting SCCs.
   //
   // However, we specially handle the target node. The target node is known to
   // reach all other nodes in the original SCC by definition. This means that
-  // we want the old SCC to be replaced with an SCC contaning that node as it
+  // we want the old SCC to be replaced with an SCC containing that node as it
   // will be the root of whatever SCC DAG results from the DFS. Assumptions
   // about an SCC such as the set of functions called will continue to hold,
   // etc.
 
   SCC &OldSCC = TargetSCC;
   SmallVector<std::pair<Node *, EdgeSequence::call_iterator>, 16> DFSStack;
   SmallVector<Node *, 16> PendingSCCStack;
   SmallVector<SCC *, 4> NewSCCs;
do {
 
         // Move to the next edge.
         ++I;
       }
       if (!N)
         // Cleared the DFS early, start another round.
         break;
 
-      // We've finished processing N and its descendents, put it on our pending
+      // We've finished processing N and its descendants, put it on our pending
       // SCC stack to eventually get merged into an SCC of nodes.
       PendingSCCStack.push_back(N);
 
       // If this node is linked to some lower entry, continue walking up the
       // stack.
       if (N->LowLink != N->DFSNumber)
         continue;
 
do {
         // Any child not on the stack will have a LowLink of -1.
         assert(ChildN.LowLink != 0 &&
                "Low-link must not be zero with a non-zero DFS number.");
         if (ChildN.LowLink >= 0 && ChildN.LowLink < N->LowLink)
           N->LowLink = ChildN.LowLink;
         ++I;
       }
 
-      // We've finished processing N and its descendents, put it on our pending
+      // We've finished processing N and its descendants, put it on our pending
       // stack to eventually get merged into a RefSCC.
       PendingRefSCCStack.push_back(N);
 
       // If this node is linked to some lower entry, continue walking up the
       // stack.
       if (N->LowLink != N->DFSNumber) {
         assert(!DFSStack.empty() &&
                "We never found a viable root for a RefSCC to pop off!");
do {
         assert(ChildN.LowLink > 0 && "Must have a positive low-link number!");
         if (ChildN.LowLink < N->LowLink)
           N->LowLink = ChildN.LowLink;
 
         // Move to the next edge.
         ++I;
       }
 
-      // We've finished processing N and its descendents, put it on our pending
+      // We've finished processing N and its descendants, put it on our pending
       // SCC stack to eventually get merged into an SCC of nodes.
       PendingSCCStack.push_back(N);
 
       // If this node is linked to some lower entry, continue walking up the
       // stack.
       if (N->LowLink != N->DFSNumber)
         continue;
 

lib/Analysis/MemoryBuiltins.cpp

 /// \brief Tests if a value is a call or invoke to a library function that
 /// allocates zero-filled memory (such as calloc).
 bool llvm::isCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
                           bool LookThroughBitCast) {
   return getAllocationData(V, CallocLike, TLI, LookThroughBitCast).hasValue();
 }
 
 /// \brief Tests if a value is a call or invoke to a library function that
-/// allocates memory similiar to malloc or calloc.
+/// allocates memory similar to malloc or calloc.
 bool llvm::isMallocOrCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI,
                                   bool LookThroughBitCast) {
   return getAllocationData(V, MallocOrCallocLike, TLI,
                            LookThroughBitCast).hasValue();
 }
 
 /// \brief Tests if a value is a call or invoke to a library function that
 /// allocates memory (either malloc, calloc, or strdup like).

lib/Analysis/ScalarEvolutionExpander.cpp

else {
     // or dominated by IVIncInsertPos.
     if (isa<Instruction>(Result) &&
         !SE.DT.dominates(cast<Instruction>(Result),
                          &*Builder.GetInsertPoint())) {
       // The induction variable's postinc expansion does not dominate this use.
       // IVUsers tries to prevent this case, so it is rare. However, it can
       // happen when an IVUser outside the loop is not dominated by the latch
       // block. Adjusting IVIncInsertPos before expansion begins cannot handle
-      // all cases. Consider a phi outide whose operand is replaced during
+      // all cases. Consider a phi outside whose operand is replaced during
       // expansion with the value of the postinc user. Without fundamentally
       // changing the way postinc users are tracked, the only remedy is
       // inserting an extra IV increment. StepV might fold into PostLoopOffset,
       // but hopefully expandCodeFor handles that.
       bool useSubtract =
         !ExpandTy->isPointerTy() && Step->isNonConstantNegative();
       if (useSubtract)
         Step = SE.getNegativeSCEV(Step);
       Value *StepV;
       {
         // Expand the step somewhere that dominates the loop header.
         SCEVInsertPointGuard Guard(Builder, this);
         StepV = expandCodeFor(Step, IntTy, &L->getHeader()->front());
       }
       Result = expandIVInc(PN, StepV, L, ExpandTy, IntTy, useSubtract);
     }
   }
 
   // We have decided to reuse an induction variable of a dominating loop. Apply
-  // truncation and/or invertion of the step.
+  // truncation and/or inversion of the step.
   if (TruncTy) {
     Type *ResTy = Result->getType();
     // Normalize the result type.
     if (ResTy != SE.getEffectiveSCEVType(ResTy))
       Result = InsertNoopCastOfTo(Result, SE.getEffectiveSCEVType(ResTy));
     // Truncate the result.
     if (TruncTy != Result->getType()) {
       Result = Builder.CreateTrunc(Result, TruncTy);
Value *EndCompareLT = Builder.CreateICmp(
       Signed ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT, Add, StartValue);
 
   // Select the answer based on the sign of Step.
   Value *EndCheck =
       Builder.CreateSelect(StepCompare, EndCompareGT, EndCompareLT);
 
   // If the backedge taken count type is larger than the AR type,
   // check that we don't drop any bits by truncating it. If we are
-  // droping bits, then we have overflow (unless the step is zero).
+  // dropping bits, then we have overflow (unless the step is zero).
   if (SE.getTypeSizeInBits(CountTy) > SE.getTypeSizeInBits(Ty)) {
     auto MaxVal = APInt::getMaxValue(DstBits).zext(SrcBits);
     auto *BackedgeCheck =
         Builder.CreateICmp(ICmpInst::ICMP_UGT, TripCountVal,
                            ConstantInt::get(Loc->getContext(), MaxVal));
     BackedgeCheck = Builder.CreateAnd(
         BackedgeCheck, Builder.CreateICmp(ICmpInst::ICMP_NE, StepValue, Zero));
 

lib/Analysis/TypeBasedAliasAnalysis.cpp

for (;;) {
 
     // Follow the edge with the correct offset. Offset will be adjusted to
     // be relative to the field type.
     BaseType = BaseType.getField(OffsetInBase);
   }
 
   // If the base object has a direct or indirect field of the subobject's type,
   // then this may be an access to that field. We need this to check now that
-  // we support aggreagtes as access types.
+  // we support aggregates as access types.
   if (NewFormat) {
     // TBAAStructTypeNode BaseAccessType(BaseTag.getAccessType());
     TBAAStructTypeNode FieldType(SubobjectTag.getBaseType());
     if (hasField(BaseType, FieldType)) {
       if (GenericTag)
         *GenericTag = createAccessTag(CommonType);
       MayAlias = true;
       return true;

lib/Analysis/ValueTracking.cpp

static SelectPatternResult matchSelectPattern(CmpInst::Predicate Pred,
 
   return matchFastFloatClamp(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS);
 }
 
 /// Helps to match a select pattern in case of a type mismatch.
 ///
 /// The function processes the case when type of true and false values of a
 /// select instruction differs from type of the cmp instruction operands because
-/// of a cast instructon. The function checks if it is legal to move the cast
+/// of a cast instruction. The function checks if it is legal to move the cast
 /// operation after "select". If yes, it returns the new second value of
 /// "select" (with the assumption that cast is moved):
 /// 1. As operand of cast instruction when both values of "select" are same cast
 /// instructions.
 /// 2. As restored constant (by applying reverse cast operation) when the first
 /// value of the "select" is a cast operation and the second value is a
 /// constant.
 /// NOTE: We return only the new second value because the first value could be