[LICM][NFC] Fix typo

[Marcythm]

Summary

fix some typo in LICM.cpp

[Marcythm]

llvm/lib/Transforms/Scalar/LICM.cpp

560–561

I'm not sure if this is right, but I think it should be closer to what the author wants to express.

[asbirlea]

Thank you for the typo fixes.

llvm/lib/Transforms/Scalar/LICM.cpp

1352

Why is this removed?

[nikic]

llvm/lib/Transforms/Scalar/LICM.cpp

560–561

I don't think the new wording is right: What this is saying is that without this check, the instruction would be sunk, which is legal but pointless. Instead it is completely removed here.

[Marcythm]

llvm/lib/Transforms/Scalar/LICM.cpp

560–561

Oh sorry, I read it again and think you are right. Since I’m not a native English speaker, I have some misunderstandings about the comments. Sorry again.

1352

I think that the variable LI is used in the following assertion so there won't be an unused-variable warning.

[Marcythm]

Update comments on line 561.
I think describe it in this way is easier to understand.

[nikic]

llvm/lib/Transforms/Scalar/LICM.cpp

1352

asserts are not present in NDEBUG builds, which is why this void cast exists.

[Marcythm]

revoke the incorrect removal of void cast.

[Marcythm]

llvm/lib/Transforms/Scalar/LICM.cpp

1352

sorry I'm not aware of this, and it's fixed now.

[Marcythm]

add the missing comment back in the last diff.

[nikic]

LG

[Marcythm]

Thank you again for your patient explanations!

llvm/lib/Transforms/Scalar/LICM.cpp

for (DomTreeNode *DTN : reverse(Worklist)) {
     BasicBlock *BB = DTN->getBlock();
     // Only need to process the contents of this block if it is not part of a
     // subloop (which would already have been processed).
     if (inSubLoop(BB, CurLoop, LI))
       continue;
 
     for (BasicBlock::iterator II = BB->end(); II != BB->begin();) {
       Instruction &I = *--II;
 
-      // If the instruction is dead, we would try to sink it because it isn't
-      // used in the loop, instead, just delete it.
+      // The instruction is not used in the loop if it is dead.  In this case,
+      // we just delete it instead of sinking it.
       if (isInstructionTriviallyDead(&I, TLI)) {
         LLVM_DEBUG(dbgs() << "LICM deleting dead inst: " << I << '\n');
         salvageKnowledge(&I);
         salvageDebugInfo(I);
         ++II;
         eraseInstruction(I, *SafetyInfo, CurAST, MSSAU);
         Changed = true;
         continue;
return (isa<LoadInst>(I) || isa<StoreInst>(I) || isa<CallInst>(I) ||
           isa<FenceInst>(I) || isa<CastInst>(I) || isa<UnaryOperator>(I) ||
           isa<BinaryOperator>(I) || isa<SelectInst>(I) ||
           isa<GetElementPtrInst>(I) || isa<CmpInst>(I) ||
           isa<InsertElementInst>(I) || isa<ExtractElementInst>(I) ||
           isa<ShuffleVectorInst>(I) || isa<ExtractValueInst>(I) ||
           isa<InsertValueInst>(I) || isa<FreezeInst>(I));
 }
 /// Return true if all of the alias sets within this AST are known not to
-/// contain a Mod, or if MSSA knows thare are no MemoryDefs in the loop.
+/// contain a Mod, or if MSSA knows there are no MemoryDefs in the loop.
 bool isReadOnly(AliasSetTracker *CurAST, const MemorySSAUpdater *MSSAU,
                 const Loop *L) {
   if (CurAST) {
     for (AliasSet &AS : *CurAST) {
       if (!AS.isForwardingAliasSet() && AS.isMod()) {
         return false;
       }
     }
if (CurAST) {
               // Disable hoisting past potentially interfering loads. Optimized
               // Uses may point to an access outside the loop, as getClobbering
               // checks the previous iteration when walking the backedge.
               // FIXME: More precise: no Uses that alias SI.
               if (!Flags->getIsSink() && !MSSA->dominates(SIMD, MU))
                 return false;
             } else if (const auto *MD = dyn_cast<MemoryDef>(&MA)) {
               if (auto *LI = dyn_cast<LoadInst>(MD->getMemoryInst())) {
                 (void)LI; // Silence warning.
                 assert(!LI->isUnordered() && "Expected unordered load");
                 return false;
               }
               // Any call, while it may not be clobbering SI, it may be a use.
               if (auto *CI = dyn_cast<CallInst>(MD->getMemoryInst())) {
-                // Check if the call may read from the memory locattion written
+                // Check if the call may read from the memory location written
                 // to by SI. Check CI's attributes and arguments; the number of
                 // such checks performed is limited above by NoOfMemAccTooLarge.
                 ModRefInfo MRI = AA->getModRefInfo(CI, MemoryLocation::get(SI));
                 if (isModOrRefSet(MRI))
                   return false;
               }
             }
         }
for (User *U : ASIV->users()) {
         SawUnorderedAtomic |= Load->isAtomic();
         SawNotAtomic |= !Load->isAtomic();
 
         Align InstAlignment = Load->getAlign();
 
         // Note that proving a load safe to speculate requires proving
         // sufficient alignment at the target location.  Proving it guaranteed
         // to execute does as well.  Thus we can increase our guaranteed
-        // alignment as well. 
+        // alignment as well.
         if (!DereferenceableInPH || (InstAlignment > Alignment))
           if (isSafeToExecuteUnconditionally(*Load, DT, TLI, CurLoop,
                                              SafetyInfo, ORE,
                                              Preheader->getTerminator())) {
             DereferenceableInPH = true;
             Alignment = std::max(Alignment, InstAlignment);
           }
       } else if (const StoreInst *Store = dyn_cast<StoreInst>(UI)) {