Various comment fixes.

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

diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h
index 859cb330bc723f3a23edeaccc0bd0f85455a72e4..88002cb77530e8c0e05d042aab31506e277e3da6 100644 (file)
--- a/include/llvm/Analysis/ScalarEvolution.h
+++ b/include/llvm/Analysis/ScalarEvolution.h
@@ -35,8 +35,8 @@ namespace llvm {
   class ScalarEvolution;
   class TargetData;
 
-  /// SCEV - This class represent an analyzed expression in the program.  These
-  /// are reference counted opaque objects that the client is not allowed to
+  /// SCEV - This class represents an analyzed expression in the program.  These
+  /// are reference-counted opaque objects that the client is not allowed to
   /// do much with directly.
   ///
   class SCEV {

diff --git a/lib/Analysis/ScalarEvolution.cpp b/lib/Analysis/ScalarEvolution.cpp
index 6c970e7175d69cc8a97c2280bf85c3d5fb2b4958..b150db30c20adafc9418cae245f15b9c9214a3be 100644 (file)
--- a/lib/Analysis/ScalarEvolution.cpp
+++ b/lib/Analysis/ScalarEvolution.cpp
@@ -596,7 +596,7 @@ static void GroupByComplexity(std::vector<SCEVHandle> &Ops,
 //===----------------------------------------------------------------------===//
 
 /// BinomialCoefficient - Compute BC(It, K).  The result has width W.
-// Assume, K > 0.
+/// Assume, K > 0.
 static SCEVHandle BinomialCoefficient(SCEVHandle It, unsigned K,
                                       ScalarEvolution &SE,
                                       const Type* ResultTy) {
@@ -933,7 +933,8 @@ SCEVHandle ScalarEvolution::getSignExtendExpr(const SCEVHandle &Op,
   return Result;
 }
 
-// get - Get a canonical add expression, or something simpler if possible.
+/// getAddExpr - Get a canonical add expression, or something simpler if
+/// possible.
 SCEVHandle ScalarEvolution::getAddExpr(std::vector<SCEVHandle> &Ops) {
   assert(!Ops.empty() && "Cannot get empty add!");
   if (Ops.size() == 1) return Ops[0];
@@ -1225,6 +1226,8 @@ SCEVHandle ScalarEvolution::getAddExpr(std::vector<SCEVHandle> &Ops) {
 }
 
 
+/// getMulExpr - Get a canonical multiply expression, or something simpler if
+/// possible.
 SCEVHandle ScalarEvolution::getMulExpr(std::vector<SCEVHandle> &Ops) {
   assert(!Ops.empty() && "Cannot get empty mul!");
 #ifndef NDEBUG
@@ -1388,6 +1391,8 @@ SCEVHandle ScalarEvolution::getMulExpr(std::vector<SCEVHandle> &Ops) {
   return Result;
 }
 
+/// getUDivExpr - Get a canonical multiply expression, or something simpler if
+/// possible.
 SCEVHandle ScalarEvolution::getUDivExpr(const SCEVHandle &LHS,
                                         const SCEVHandle &RHS) {
   assert(getEffectiveSCEVType(LHS->getType()) ==
@@ -1476,8 +1481,8 @@ SCEVHandle ScalarEvolution::getUDivExpr(const SCEVHandle &LHS,
 }
 
 
-/// SCEVAddRecExpr::get - Get a add recurrence expression for the
-/// specified loop.  Simplify the expression as much as possible.
+/// getAddRecExpr - Get an add recurrence expression for the specified loop.
+/// Simplify the expression as much as possible.
 SCEVHandle ScalarEvolution::getAddRecExpr(const SCEVHandle &Start,
                                const SCEVHandle &Step, const Loop *L) {
   std::vector<SCEVHandle> Operands;
@@ -1493,8 +1498,8 @@ SCEVHandle ScalarEvolution::getAddRecExpr(const SCEVHandle &Start,
   return getAddRecExpr(Operands, L);
 }
 
-/// SCEVAddRecExpr::get - Get a add recurrence expression for the
-/// specified loop.  Simplify the expression as much as possible.
+/// getAddRecExpr - Get an add recurrence expression for the specified loop.
+/// Simplify the expression as much as possible.
 SCEVHandle ScalarEvolution::getAddRecExpr(std::vector<SCEVHandle> &Operands,
                                           const Loop *L) {
   if (Operands.size() == 1) return Operands[0];
@@ -3201,7 +3206,7 @@ SolveQuadraticEquation(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE) {
 }
 
 /// HowFarToZero - Return the number of times a backedge comparing the specified
-/// value to zero will execute.  If not computable, return UnknownValue
+/// value to zero will execute.  If not computable, return UnknownValue.
 SCEVHandle ScalarEvolution::HowFarToZero(const SCEV *V, const Loop *L) {
   // If the value is a constant
   if (const SCEVConstant *C = dyn_cast<SCEVConstant>(V)) {
@@ -3506,8 +3511,8 @@ HowManyLessThans(const SCEV *LHS, const SCEV *RHS,
 
     // If we know that the condition is true in order to enter the loop,
     // then we know that it will run exactly (m-n)/s times. Otherwise, we
-    // only know if will execute (max(m,n)-n)/s times. In both cases, the
-    // division must round up.
+    // only know that it will execute (max(m,n)-n)/s times. In both cases,
+    // the division must round up.
     SCEVHandle End = RHS;
     if (!isLoopGuardedByCond(L,
                              isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT,