[Polly] Fix typo. NFC.

[grosser]

LGTM.

polly/trunk/include/polly/ScopBuilder.h

class ScopBuilder {
 
   /// Check for reductions in @p Stmt.
   ///
   /// Iterate over all store memory accesses and check for valid binary
   /// reduction like chains. For all candidates we check if they have the same
   /// base address and there are no other accesses which overlap with them. The
   /// base address check rules out impossible reductions candidates early. The
   /// overlap check, together with the "only one user" check in
-  /// collectCandiateReductionLoads, guarantees that none of the intermediate
+  /// collectCandidateReductionLoads, guarantees that none of the intermediate
   /// results will escape during execution of the loop nest. We basically check
   /// here that no other memory access can access the same memory as the
   /// potential reduction.
   void checkForReductions(ScopStmt &Stmt);
 
   /// Collect loads which might form a reduction chain with @p StoreMA.
   ///
   /// Check if the stored value for @p StoreMA is a binary operator with one or
   /// two loads as operands. If the binary operand is commutative & associative,
   /// used only once (by @p StoreMA) and its load operands are also used only
   /// once, we have found a possible reduction chain. It starts at an operand
   /// load and includes the binary operator and @p StoreMA.
   ///
   /// Note: We allow only one use to ensure the load and binary operator cannot
   ///       escape this block or into any other store except @p StoreMA.
-  void collectCandiateReductionLoads(MemoryAccess *StoreMA,
+  void collectCandidateReductionLoads(MemoryAccess *StoreMA,
                                       SmallVectorImpl<MemoryAccess *> &Loads);
 
   /// Build the access relation of all memory accesses of @p Stmt.
   void buildAccessRelations(ScopStmt &Stmt);
 
 public:
   explicit ScopBuilder(Region *R, AssumptionCache &AC, AliasAnalysis &AA,
                        const DataLayout &DL, DominatorTree &DT, LoopInfo &LI,
                        ScopDetection &SD, ScalarEvolution &SE,

polly/trunk/lib/Analysis/ScopBuilder.cpp

void ScopBuilder::checkForReductions(ScopStmt &Stmt) {
 
   // First collect candidate load-store reduction chains by iterating over all
   // stores and collecting possible reduction loads.
   for (MemoryAccess *StoreMA : Stmt) {
     if (StoreMA->isRead())
       continue;
 
     Loads.clear();
-    collectCandiateReductionLoads(StoreMA, Loads);
+    collectCandidateReductionLoads(StoreMA, Loads);
     for (MemoryAccess *LoadMA : Loads)
       Candidates.push_back(std::make_pair(LoadMA, StoreMA));
   }
 
   // Then check each possible candidate pair.
   for (const auto &CandidatePair : Candidates) {
     bool Valid = true;
     isl::map LoadAccs = CandidatePair.first->getAccessRelation();
for (const auto &CandidatePair : Candidates) {
 
     // If no overlapping access was found we mark the load and store as
     // reduction like.
     CandidatePair.first->markAsReductionLike(RT);
     CandidatePair.second->markAsReductionLike(RT);
   }
 }
 
-void ScopBuilder::collectCandiateReductionLoads(
+void ScopBuilder::collectCandidateReductionLoads(
     MemoryAccess *StoreMA, SmallVectorImpl<MemoryAccess *> &Loads) {
   ScopStmt *Stmt = StoreMA->getStatement();
 
   auto *Store = dyn_cast<StoreInst>(StoreMA->getAccessInstruction());
   if (!Store)
     return;
 
   // Skip if there is not one binary operator between the load and the store