From 1bc147b892b4b881a020a3fb706c5415ef244730 Mon Sep 17 00:00:00 2001
From: Bill Wendling <isanbard@gmail.com>
Date: Fri, 17 Feb 2012 02:09:28 +0000
Subject: [PATCH] Fix some grammar-os and formatting.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@150779 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Transforms/Utils/DemoteRegToStack.cpp | 38 ++++++++++-------------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/lib/Transforms/Utils/DemoteRegToStack.cpp b/lib/Transforms/Utils/DemoteRegToStack.cpp
index 3ef6b018bf8..c2483ab43c9 100644
--- a/lib/Transforms/Utils/DemoteRegToStack.cpp
+++ b/lib/Transforms/Utils/DemoteRegToStack.cpp
@@ -28,7 +28,6 @@ using namespace llvm;
 /// alloca.  This allows the CFG to be changed around without fear of
 /// invalidating the SSA information for the value.  It returns the pointer to
 /// the alloca inserted to create a stack slot for I.
-///
 AllocaInst* llvm::DemoteRegToStack(Instruction &I, bool VolatileLoads,
                                    Instruction *AllocaPoint) {
   if (I.use_empty()) {
@@ -47,20 +46,19 @@ AllocaInst* llvm::DemoteRegToStack(Instruction &I, bool VolatileLoads,
                           F->getEntryBlock().begin());
   }
 
-  // Change all of the users of the instruction to read from the stack slot
-  // instead.
+  // Change all of the users of the instruction to read from the stack slot.
   while (!I.use_empty()) {
     Instruction *U = cast<Instruction>(I.use_back());
     if (PHINode *PN = dyn_cast<PHINode>(U)) {
       // If this is a PHI node, we can't insert a load of the value before the
-      // use.  Instead, insert the load in the predecessor block corresponding
+      // use.  Instead insert the load in the predecessor block corresponding
       // to the incoming value.
       //
       // Note that if there are multiple edges from a basic block to this PHI
-      // node that we cannot multiple loads.  The problem is that the resultant
-      // PHI node will have multiple values (from each load) coming in from the
-      // same block, which is illegal SSA form.  For this reason, we keep track
-      // and reuse loads we insert.
+      // node that we cannot have multiple loads. The problem is that the
+      // resulting PHI node will have multiple values (from each load) coming in
+      // from the same block, which is illegal SSA form. For this reason, we
+      // keep track of and reuse loads we insert.
       std::map<BasicBlock*, Value*> Loads;
       for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
         if (PN->getIncomingValue(i) == &I) {
@@ -81,9 +79,9 @@ AllocaInst* llvm::DemoteRegToStack(Instruction &I, bool VolatileLoads,
   }
 
 
-  // Insert stores of the computed value into the stack slot.  We have to be
-  // careful is I is an invoke instruction though, because we can't insert the
-  // store AFTER the terminator instruction.
+  // Insert stores of the computed value into the stack slot. We have to be
+  // careful if I is an invoke instruction, because we can't insert the store
+  // AFTER the terminator instruction.
   BasicBlock::iterator InsertPt;
   if (!isa<TerminatorInst>(I)) {
     InsertPt = &I;
@@ -98,16 +96,15 @@ AllocaInst* llvm::DemoteRegToStack(Instruction &I, bool VolatileLoads,
   }
 
   for (; isa<PHINode>(InsertPt) || isa<LandingPadInst>(InsertPt); ++InsertPt)
-  /* empty */;   // Don't insert before any PHI nodes or landingpad instrs.
-  new StoreInst(&I, Slot, InsertPt);
+    /* empty */;   // Don't insert before PHI nodes or landingpad instrs.
 
+  new StoreInst(&I, Slot, InsertPt);
   return Slot;
 }
 
-
-/// DemotePHIToStack - This function takes a virtual register computed by a phi
-/// node and replaces it with a slot in the stack frame, allocated via alloca.
-/// The phi node is deleted and it returns the pointer to the alloca inserted.
+/// DemotePHIToStack - This function takes a virtual register computed by a PHI
+/// node and replaces it with a slot in the stack frame allocated via alloca.
+/// The PHI node is deleted. It returns the pointer to the alloca inserted.
 AllocaInst* llvm::DemotePHIToStack(PHINode *P, Instruction *AllocaPoint) {
   if (P->use_empty()) {
     P->eraseFromParent();
@@ -125,7 +122,7 @@ AllocaInst* llvm::DemotePHIToStack(PHINode *P, Instruction *AllocaPoint) {
                           F->getEntryBlock().begin());
   }
 
-  // Iterate over each operand, insert store in each predecessor.
+  // Iterate over each operand inserting a store in each predecessor.
   for (unsigned i = 0, e = P->getNumIncomingValues(); i < e; ++i) {
     if (InvokeInst *II = dyn_cast<InvokeInst>(P->getIncomingValue(i))) {
       assert(II->getParent() != P->getIncomingBlock(i) &&
@@ -135,12 +132,11 @@ AllocaInst* llvm::DemotePHIToStack(PHINode *P, Instruction *AllocaPoint) {
                   P->getIncomingBlock(i)->getTerminator());
   }
 
-  // Insert load in place of the phi and replace all uses.
+  // Insert a load in place of the PHI and replace all uses.
   Value *V = new LoadInst(Slot, P->getName()+".reload", P);
   P->replaceAllUsesWith(V);
 
-  // Delete phi.
+  // Delete PHI.
   P->eraseFromParent();
-
   return Slot;
 }