Fix spelling of `propagate'.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@4423 91177308-0d34-0410-b5e6-96231b3b80d8

5 files changed, 52 insertions, 52 deletions

diff --git a/lib/Transforms/Scalar/CorrelatedExprs.cpp b/lib/Transforms/Scalar/CorrelatedExprs.cpp
index f8934f3033..6ba60675fe 100644
--- a/lib/Transforms/Scalar/CorrelatedExprs.cpp
+++ b/lib/Transforms/Scalar/CorrelatedExprs.cpp
@@ -1,12 +1,12 @@
 //===- CorrelatedExprs.cpp - Pass to detect and eliminated c.e.'s ---------===//
 //
-// Correlated Expression Elimination propogates information from conditional
-// branches to blocks dominated by destinations of the branch.  It propogates
+// Correlated Expression Elimination propagates information from conditional
+// branches to blocks dominated by destinations of the branch.  It propagates
 // information from the condition check itself into the body of the branch,
 // allowing transformations like these for example:
 //
 //  if (i == 7)
-//    ... 4*i;  // constant propogation
+//    ... 4*i;  // constant propagation
 //
 //  M = i+1; N = j+1;
 //  if (i == j)
@@ -91,7 +91,7 @@ namespace {
     // kept sorted by the Val field.
     std::vector<Relation> Relationships;
 
-    // If information about this value is known or propogated from constant
+    // If information about this value is known or propagated from constant
     // expressions, this range contains the possible values this value may hold.
     ConstantRange Bounds;
 
@@ -254,9 +254,9 @@ namespace {
     void InsertRegionExitMerges(PHINode *NewPHI, Instruction *OldVal,
                              const std::vector<BasicBlock*> &RegionExitBlocks);
 
-    void PropogateBranchInfo(BranchInst *BI);
-    void PropogateEquality(Value *Op0, Value *Op1, RegionInfo &RI);
-    void PropogateRelation(Instruction::BinaryOps Opcode, Value *Op0,
+    void PropagateBranchInfo(BranchInst *BI);
+    void PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI);
+    void PropagateRelation(Instruction::BinaryOps Opcode, Value *Op0,
                            Value *Op1, RegionInfo &RI);
     void UpdateUsersOfValue(Value *V, RegionInfo &RI);
     void IncorporateInstruction(Instruction *Inst, RegionInfo &RI);
@@ -331,11 +331,11 @@ bool CEE::TransformRegion(BasicBlock *BB, std::set<BasicBlock*> &VisitedBlocks){
 
   // Loop over all of the blocks that this block is the immediate dominator for.
   // Because all information known in this region is also known in all of the
-  // blocks that are dominated by this one, we can safely propogate the
+  // blocks that are dominated by this one, we can safely propagate the
   // information down now.
   //
   DominatorTree::Node *BBN = (*DT)[BB];
-  if (!RI.empty())        // Time opt: only propogate if we can change something
+  if (!RI.empty())        // Time opt: only propagate if we can change something
     for (unsigned i = 0, e = BBN->getChildren().size(); i != e; ++i) {
       BasicBlock *Dominated = BBN->getChildren()[i]->getNode();
       assert(RegionInfoMap.find(Dominated) == RegionInfoMap.end() &&
@@ -344,11 +344,11 @@ bool CEE::TransformRegion(BasicBlock *BB, std::set<BasicBlock*> &VisitedBlocks){
     }
 
   // Now that all of our successors have information if they deserve it,
-  // propogate any information our terminator instruction finds to our
+  // propagate any information our terminator instruction finds to our
   // successors.
   if (BranchInst *BI = dyn_cast<BranchInst>(TI))
     if (BI->isConditional())
-      PropogateBranchInfo(BI);
+      PropagateBranchInfo(BI);
 
   // If this is a branch to a block outside our region that simply performs
   // another conditional branch, one whose outcome is known inside of this
@@ -453,11 +453,11 @@ bool CEE::ForwardCorrelatedEdgeDestination(TerminatorInst *TI, unsigned SuccNo,
     if (PHINode *PN = dyn_cast<PHINode>(&*I)) {
       int OpNum = PN->getBasicBlockIndex(BB);
       assert(OpNum != -1 && "PHI doesn't have incoming edge for predecessor!?");
-      PropogateEquality(PN, PN->getIncomingValue(OpNum), NewRI);      
+      PropagateEquality(PN, PN->getIncomingValue(OpNum), NewRI);      
     } else if (SetCondInst *SCI = dyn_cast<SetCondInst>(&*I)) {
       Relation::KnownResult Res = getSetCCResult(SCI, NewRI);
       if (Res == Relation::Unknown) return false;
-      PropogateEquality(SCI, ConstantBool::get(Res), NewRI);
+      PropagateEquality(SCI, ConstantBool::get(Res), NewRI);
     } else {
       assert(isa<BranchInst>(*I) && "Unexpected instruction type!");
     }
@@ -760,30 +760,30 @@ void CEE::BuildRankMap(Function &F) {
 }
 
 
-// PropogateBranchInfo - When this method is invoked, we need to propogate
+// PropagateBranchInfo - When this method is invoked, we need to propagate
 // information derived from the branch condition into the true and false
 // branches of BI.  Since we know that there aren't any critical edges in the
 // flow graph, this can proceed unconditionally.
 //
-void CEE::PropogateBranchInfo(BranchInst *BI) {
+void CEE::PropagateBranchInfo(BranchInst *BI) {
   assert(BI->isConditional() && "Must be a conditional branch!");
 
-  // Propogate information into the true block...
+  // Propagate information into the true block...
   //
-  PropogateEquality(BI->getCondition(), ConstantBool::True,
+  PropagateEquality(BI->getCondition(), ConstantBool::True,
                     getRegionInfo(BI->getSuccessor(0)));
   
-  // Propogate information into the false block...
+  // Propagate information into the false block...
   //
-  PropogateEquality(BI->getCondition(), ConstantBool::False,
+  PropagateEquality(BI->getCondition(), ConstantBool::False,
                     getRegionInfo(BI->getSuccessor(1)));
 }
 
 
-// PropogateEquality - If we discover that two values are equal to each other in
-// a specified region, propogate this knowledge recursively.
+// PropagateEquality - If we discover that two values are equal to each other in
+// a specified region, propagate this knowledge recursively.
 //
-void CEE::PropogateEquality(Value *Op0, Value *Op1, RegionInfo &RI) {
+void CEE::PropagateEquality(Value *Op0, Value *Op1, RegionInfo &RI) {
   if (Op0 == Op1) return;  // Gee whiz. Are these really equal each other?
 
   if (isa<Constant>(Op0))  // Make sure the constant is always Op1
@@ -811,8 +811,8 @@ void CEE::PropogateEquality(Value *Op0, Value *Op1, RegionInfo &RI) {
       // as well.
       //
       if (CB->getValue() && Inst->getOpcode() == Instruction::And) {
-        PropogateEquality(Inst->getOperand(0), CB, RI);
-        PropogateEquality(Inst->getOperand(1), CB, RI);
+        PropagateEquality(Inst->getOperand(0), CB, RI);
+        PropagateEquality(Inst->getOperand(1), CB, RI);
       }
       
       // If we know that this instruction is an OR instruction, and the result
@@ -820,8 +820,8 @@ void CEE::PropogateEquality(Value *Op0, Value *Op1, RegionInfo &RI) {
       // as well.
       //
       if (!CB->getValue() && Inst->getOpcode() == Instruction::Or) {
-        PropogateEquality(Inst->getOperand(0), CB, RI);
-        PropogateEquality(Inst->getOperand(1), CB, RI);
+        PropagateEquality(Inst->getOperand(0), CB, RI);
+        PropagateEquality(Inst->getOperand(1), CB, RI);
       }
       
       // If we know that this instruction is a NOT instruction, we know that the
@@ -829,48 +829,48 @@ void CEE::PropogateEquality(Value *Op0, Value *Op1, RegionInfo &RI) {
       //
       if (BinaryOperator *BOp = dyn_cast<BinaryOperator>(Inst))
         if (BinaryOperator::isNot(BOp))
-          PropogateEquality(BinaryOperator::getNotArgument(BOp),
+          PropagateEquality(BinaryOperator::getNotArgument(BOp),
                             ConstantBool::get(!CB->getValue()), RI);
 
-      // If we know the value of a SetCC instruction, propogate the information
+      // If we know the value of a SetCC instruction, propagate the information
       // about the relation into this region as well.
       //
       if (SetCondInst *SCI = dyn_cast<SetCondInst>(Inst)) {
         if (CB->getValue()) {  // If we know the condition is true...
-          // Propogate info about the LHS to the RHS & RHS to LHS
-          PropogateRelation(SCI->getOpcode(), SCI->getOperand(0),
+          // Propagate info about the LHS to the RHS & RHS to LHS
+          PropagateRelation(SCI->getOpcode(), SCI->getOperand(0),
                             SCI->getOperand(1), RI);
-          PropogateRelation(SCI->getSwappedCondition(),
+          PropagateRelation(SCI->getSwappedCondition(),
                             SCI->getOperand(1), SCI->getOperand(0), RI);
 
         } else {               // If we know the condition is false...
           // We know the opposite of the condition is true...
           Instruction::BinaryOps C = SCI->getInverseCondition();
           
-          PropogateRelation(C, SCI->getOperand(0), SCI->getOperand(1), RI);
-          PropogateRelation(SetCondInst::getSwappedCondition(C),
+          PropagateRelation(C, SCI->getOperand(0), SCI->getOperand(1), RI);
+          PropagateRelation(SetCondInst::getSwappedCondition(C),
                             SCI->getOperand(1), SCI->getOperand(0), RI);
         }
       }
     }
   }
 
-  // Propogate information about Op0 to Op1 & visa versa
-  PropogateRelation(Instruction::SetEQ, Op0, Op1, RI);
-  PropogateRelation(Instruction::SetEQ, Op1, Op0, RI);
+  // Propagate information about Op0 to Op1 & visa versa
+  PropagateRelation(Instruction::SetEQ, Op0, Op1, RI);
+  PropagateRelation(Instruction::SetEQ, Op1, Op0, RI);
 }
 
 
-// PropogateRelation - We know that the specified relation is true in all of the
-// blocks in the specified region.  Propogate the information about Op0 and
+// PropagateRelation - We know that the specified relation is true in all of the
+// blocks in the specified region.  Propagate the information about Op0 and
 // anything derived from it into this region.
 //
-void CEE::PropogateRelation(Instruction::BinaryOps Opcode, Value *Op0,
+void CEE::PropagateRelation(Instruction::BinaryOps Opcode, Value *Op0,
                             Value *Op1, RegionInfo &RI) {
   assert(Op0->getType() == Op1->getType() && "Equal types expected!");
 
   // Constants are already pretty well understood.  We will apply information
-  // about the constant to Op1 in another call to PropogateRelation.
+  // about the constant to Op1 in another call to PropagateRelation.
   //
   if (isa<Constant>(Op0)) return;
 
@@ -896,7 +896,7 @@ void CEE::PropogateRelation(Instruction::BinaryOps Opcode, Value *Op0,
   }
 
   // If the information propogted is new, then we want process the uses of this
-  // instruction to propogate the information down to them.
+  // instruction to propagate the information down to them.
   //
   if (Op1R.incorporate(Opcode, VI))
     UpdateUsersOfValue(Op0, RI);
@@ -904,16 +904,16 @@ void CEE::PropogateRelation(Instruction::BinaryOps Opcode, Value *Op0,
 
 
 // UpdateUsersOfValue - The information about V in this region has been updated.
-// Propogate this to all consumers of the value.
+// Propagate this to all consumers of the value.
 //
 void CEE::UpdateUsersOfValue(Value *V, RegionInfo &RI) {
   for (Value::use_iterator I = V->use_begin(), E = V->use_end();
        I != E; ++I)
     if (Instruction *Inst = dyn_cast<Instruction>(*I)) {
       // If this is an instruction using a value that we know something about,
-      // try to propogate information to the value produced by the
+      // try to propagate information to the value produced by the
       // instruction.  We can only do this if it is an instruction we can
-      // propogate information for (a setcc for example), and we only WANT to
+      // propagate information for (a setcc for example), and we only WANT to
       // do this if the instruction dominates this region.
       //
       // If the instruction doesn't dominate this region, then it cannot be
@@ -937,7 +937,7 @@ void CEE::IncorporateInstruction(Instruction *Inst, RegionInfo &RI) {
     // See if we can figure out a result for this instruction...
     Relation::KnownResult Result = getSetCCResult(SCI, RI);
     if (Result != Relation::Unknown) {
-      PropogateEquality(SCI, Result ? ConstantBool::True : ConstantBool::False,
+      PropagateEquality(SCI, Result ? ConstantBool::True : ConstantBool::False,
                         RI);
     }
   }
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index dab702dba0..be9f637523 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -726,7 +726,7 @@ bool InstCombiner::runOnFunction(Function &F) {
     Instruction *I = WorkList.back();  // Get an instruction from the worklist
     WorkList.pop_back();
 
-    // Check to see if we can DCE or ConstantPropogate the instruction...
+    // Check to see if we can DCE or ConstantPropagate the instruction...
     // Check to see if we can DIE the instruction...
     if (isInstructionTriviallyDead(I)) {
       // Add operands to the worklist...
@@ -742,7 +742,7 @@ bool InstCombiner::runOnFunction(Function &F) {
       }
     } 
 
-    // Instruction isn't dead, see if we can constant propogate it...
+    // Instruction isn't dead, see if we can constant propagate it...
     if (Constant *C = ConstantFoldInstruction(I)) {
       // Add operands to the worklist...
       for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
diff --git a/lib/Transforms/Scalar/SCCP.cpp b/lib/Transforms/Scalar/SCCP.cpp
index 5ae9f52263..293469758a 100644
--- a/lib/Transforms/Scalar/SCCP.cpp
+++ b/lib/Transforms/Scalar/SCCP.cpp
@@ -482,7 +482,7 @@ void SCCP::visitCastInst(CastInst &I) {
   InstVal &VState = getValueState(V);
   if (VState.isOverdefined()) {        // Inherit overdefinedness of operand
     markOverdefined(&I);
-  } else if (VState.isConstant()) {    // Propogate constant value
+  } else if (VState.isConstant()) {    // Propagate constant value
     Constant *Result =
       ConstantFoldCastInstruction(VState.getConstant(), I.getType());
 
diff --git a/lib/Transforms/Utils/BasicBlockUtils.cpp b/lib/Transforms/Utils/BasicBlockUtils.cpp
index 20a4714135..22377ba3ed 100644
--- a/lib/Transforms/Utils/BasicBlockUtils.cpp
+++ b/lib/Transforms/Utils/BasicBlockUtils.cpp
@@ -26,7 +26,7 @@ void ReplaceInstWithValue(BasicBlock::InstListType &BIL,
   // Delete the unneccesary instruction now...
   BI = BIL.erase(BI);
 
-  // Make sure to propogate a name if there is one already...
+  // Make sure to propagate a name if there is one already...
   if (OldName.size() && !V->hasName())
     V->setName(OldName, BIL.getParent()->getSymbolTable());
 }
diff --git a/lib/Transforms/Utils/SimplifyCFG.cpp b/lib/Transforms/Utils/SimplifyCFG.cpp
index 6b642360d6..08fe1c5638 100644
--- a/lib/Transforms/Utils/SimplifyCFG.cpp
+++ b/lib/Transforms/Utils/SimplifyCFG.cpp
@@ -11,7 +11,7 @@
 #include <algorithm>
 #include <functional>
 
-// PropogatePredecessors - This gets "Succ" ready to have the predecessors from
+// PropagatePredecessors - This gets "Succ" ready to have the predecessors from
 // "BB".  This is a little tricky because "Succ" has PHI nodes, which need to
 // have extra slots added to them to hold the merge edges from BB's
 // predecessors.  This function returns true (failure) if the Succ BB already
@@ -19,7 +19,7 @@
 //
 // Assumption: Succ is the single successor for BB.
 //
-static bool PropogatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
+static bool PropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ) {
   assert(*succ_begin(BB) == Succ && "Succ is not successor of BB!");
 
   if (!isa<PHINode>(Succ->front()))
@@ -112,7 +112,7 @@ bool SimplifyCFG(BasicBlock *BB) {
         // Be careful though, if this transformation fails (returns true) then
         // we cannot do this transformation!
         //
-	if (!PropogatePredecessorsForPHIs(BB, Succ)) {
+	if (!PropagatePredecessorsForPHIs(BB, Succ)) {
           //cerr << "Killing Trivial BB: \n" << BB;
           BB->replaceAllUsesWith(Succ);
           std::string OldName = BB->getName();