[llvm] r274480 - Reformat comment lines.

[NAKAMURA Takumi via llvm-commits]

Author: chapuni
Date: Sun Jul  3 20:26:27 2016
New Revision: 274480

URL: http://llvm.org/viewvc/llvm-project?rev=274480&view=rev
Log:
Reformat comment lines.

Modified:
    llvm/trunk/lib/Analysis/LazyValueInfo.cpp
    llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

Modified: llvm/trunk/lib/Analysis/LazyValueInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/LazyValueInfo.cpp?rev=274480&r1=274479&r2=274480&view=diff
==============================================================================
--- llvm/trunk/lib/Analysis/LazyValueInfo.cpp (original)
+++ llvm/trunk/lib/Analysis/LazyValueInfo.cpp Sun Jul  3 20:26:27 2016
@@ -67,7 +67,7 @@ class LVILatticeVal {
     /// This Value has no known value yet.  As a result, this implies the
     /// producing instruction is dead.  Caution: We use this as the starting
     /// state in our local meet rules.  In this usage, it's taken to mean
-    /// "nothing known yet".  
+    /// "nothing known yet".
     undefined,
 
     /// This Value has a specific constant value.  (For integers, constantrange
@@ -318,7 +318,7 @@ static bool hasSingleValue(const LVILatt
 /// * This method does not promise to return the most precise possible lattice
 ///   value implied by A and B.  It is allowed to return any lattice element
 ///   which is at least as strong as *either* A or B (unless our facts
-///   conflict, see below).  
+///   conflict, see below).
 /// * Due to unreachable code, the intersection of two lattice values could be
 ///   contradictory.  If this happens, we return some valid lattice value so as
 ///   not confuse the rest of LVI.  Ideally, we'd always return Undefined, but
@@ -354,7 +354,7 @@ static LVILatticeVal intersect(LVILattic
     A.getConstantRange().intersectWith(B.getConstantRange());
   // Note: An empty range is implicitly converted to overdefined internally.
   // TODO: We could instead use Undefined here since we've proven a conflict
-  // and thus know this path must be unreachable. 
+  // and thus know this path must be unreachable.
   return LVILatticeVal::getRange(std::move(Range));
 }
 
@@ -928,7 +928,7 @@ bool LazyValueInfoCache::solveBlockValue
       case SPF_SMAX:                   /// Signed maximum
         BBLV.markConstantRange(TrueCR.smax(FalseCR));
         return true;
-      case SPF_UMAX:                   /// Unsigned maximum        
+      case SPF_UMAX:                   /// Unsigned maximum
         BBLV.markConstantRange(TrueCR.umax(FalseCR));
         return true;
       };
@@ -960,7 +960,7 @@ bool LazyValueInfoCache::solveBlockValue
     //   %siv.next = select i1 %39, i32 16, i32 %40
     //   %siv.next = constantrange<0, 17> not <-1, 17>
     // In general, this can handle any clamp idiom which tests the edge
-    // condition via an equality or inequality.  
+    // condition via an equality or inequality.
     ICmpInst::Predicate Pred = ICI->getPredicate();
     Value *A = ICI->getOperand(0);
     if (ConstantInt *CIBase = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
@@ -1172,7 +1172,7 @@ bool getValueFromFromCondition(Value *Va
   if (isa<Constant>(ICI->getOperand(1))) {
     if (ICI->isEquality() && ICI->getOperand(0) == Val) {
       // We know that V has the RHS constant if this is a true SETEQ or
-      // false SETNE. 
+      // false SETNE.
       if (isTrueDest == (ICI->getPredicate() == ICmpInst::ICMP_EQ))
         Result = LVILatticeVal::get(cast<Constant>(ICI->getOperand(1)));
       else
@@ -1641,7 +1641,7 @@ LazyValueInfo::getPredicateAt(unsigned P
   // We limit the search to one step backwards from the current BB and value.
   // We could consider extending this to search further backwards through the
   // CFG and/or value graph, but there are non-obvious compile time vs quality
-  // tradeoffs.  
+  // tradeoffs.
   if (CxtI) {
     BasicBlock *BB = CxtI->getParent();
 
@@ -1661,7 +1661,7 @@ LazyValueInfo::getPredicateAt(unsigned P
         for (unsigned i = 0, e = PHI->getNumIncomingValues(); i < e; i++) {
           Value *Incoming = PHI->getIncomingValue(i);
           BasicBlock *PredBB = PHI->getIncomingBlock(i);
-          // Note that PredBB may be BB itself.        
+          // Note that PredBB may be BB itself.
           Tristate Result = getPredicateOnEdge(Pred, Incoming, C, PredBB, BB,
                                                CxtI);
           

Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp?rev=274480&r1=274479&r2=274480&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp Sun Jul  3 20:26:27 2016
@@ -358,7 +358,7 @@ static bool isRequiredForExecution(const
     const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
     // Avoid loading zero-sized COFF sections.
     // In PE files, VirtualSize gives the section size, and SizeOfRawData
-    // may be zero for sections with content. In Obj files, SizeOfRawData 
+    // may be zero for sections with content. In Obj files, SizeOfRawData
     // gives the section size, and VirtualSize is always zero. Hence
     // the need to check for both cases below.
     bool HasContent =