Remove trailing whitespace

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

1 files changed, 25 insertions, 25 deletions

diff --git a/include/llvm/Analysis/IntervalIterator.h b/include/llvm/Analysis/IntervalIterator.h
index c6a87bdf94..3b1c6c9297 100644
--- a/include/llvm/Analysis/IntervalIterator.h
+++ b/include/llvm/Analysis/IntervalIterator.h
@@ -1,16 +1,16 @@
 //===- IntervalIterator.h - Interval Iterator Declaration -------*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file defines an iterator that enumerates the intervals in a control flow
 // graph of some sort.  This iterator is parametric, allowing iterator over the
 // following types of graphs:
-// 
+//
 //  1. A Function* object, composed of BasicBlock nodes.
 //  2. An IntervalPartition& object, composed of Interval nodes.
 //
@@ -18,9 +18,9 @@
 // in depth first order.  These intervals are completely filled in except for
 // the predecessor fields (the successor information is filled in however).
 //
-// By default, the intervals created by this iterator are deleted after they 
+// By default, the intervals created by this iterator are deleted after they
 // are no longer any use to the iterator.  This behavior can be changed by
-// passing a false value into the intervals_begin() function. This causes the 
+// passing a false value into the intervals_begin() function. This causes the
 // IOwnMem member to be set, and the intervals to not be deleted.
 //
 // It is only safe to use this if all of the intervals are deleted by the caller
@@ -42,27 +42,27 @@
 
 namespace llvm {
 
-// getNodeHeader - Given a source graph node and the source graph, return the 
+// getNodeHeader - Given a source graph node and the source graph, return the
 // BasicBlock that is the header node.  This is the opposite of
 // getSourceGraphNode.
 //
 inline BasicBlock *getNodeHeader(BasicBlock *BB) { return BB; }
 inline BasicBlock *getNodeHeader(Interval *I) { return I->getHeaderNode(); }
 
-// getSourceGraphNode - Given a BasicBlock and the source graph, return the 
+// getSourceGraphNode - Given a BasicBlock and the source graph, return the
 // source graph node that corresponds to the BasicBlock.  This is the opposite
 // of getNodeHeader.
 //
 inline BasicBlock *getSourceGraphNode(Function *, BasicBlock *BB) {
-  return BB; 
+  return BB;
 }
-inline Interval *getSourceGraphNode(IntervalPartition *IP, BasicBlock *BB) { 
+inline Interval *getSourceGraphNode(IntervalPartition *IP, BasicBlock *BB) {
   return IP->getBlockInterval(BB);
 }
 
 // addNodeToInterval - This method exists to assist the generic ProcessNode
-// with the task of adding a node to the new interval, depending on the 
-// type of the source node.  In the case of a CFG source graph (BasicBlock 
+// with the task of adding a node to the new interval, depending on the
+// type of the source node.  In the case of a CFG source graph (BasicBlock
 // case), the BasicBlock itself is added to the interval.
 //
 inline void addNodeToInterval(Interval *Int, BasicBlock *BB) {
@@ -70,8 +70,8 @@ inline void addNodeToInterval(Interval *Int, BasicBlock *BB) {
 }
 
 // addNodeToInterval - This method exists to assist the generic ProcessNode
-// with the task of adding a node to the new interval, depending on the 
-// type of the source node.  In the case of a CFG source graph (BasicBlock 
+// with the task of adding a node to the new interval, depending on the
+// type of the source node.  In the case of a CFG source graph (BasicBlock
 // case), the BasicBlock itself is added to the interval.  In the case of
 // an IntervalPartition source graph (Interval case), all of the member
 // BasicBlocks are added to the interval.
@@ -96,7 +96,7 @@ class IntervalIterator {
 public:
   typedef IntervalIterator<NodeTy, OrigContainer_t> _Self;
   typedef std::forward_iterator_tag iterator_category;
- 
+
   IntervalIterator() {} // End iterator, empty stack
   IntervalIterator(Function *M, bool OwnMemory) : IOwnMem(OwnMemory) {
     OrigContainer = M;
@@ -148,14 +148,14 @@ public:
       IntStack.pop();
     } while (!IntStack.empty());
 
-    return *this; 
+    return *this;
   }
   inline _Self operator++(int) { // Postincrement
-    _Self tmp = *this; ++*this; return tmp; 
+    _Self tmp = *this; ++*this; return tmp;
   }
 
 private:
-  // ProcessInterval - This method is used during the construction of the 
+  // ProcessInterval - This method is used during the construction of the
   // interval graph.  It walks through the source graph, recursively creating
   // an interval per invokation until the entire graph is covered.  This uses
   // the ProcessNode method to add all of the nodes to the interval.
@@ -178,7 +178,7 @@ private:
     IntStack.push(std::make_pair(Int, succ_begin(Int)));
     return true;
   }
-  
+
   // ProcessNode - This method is called by ProcessInterval to add nodes to the
   // interval being constructed, and it is also called recursively as it walks
   // the source graph.  A node is added to the current interval only if all of
@@ -191,7 +191,7 @@ private:
   void ProcessNode(Interval *Int, NodeTy *Node) {
     assert(Int && "Null interval == bad!");
     assert(Node && "Null Node == bad!");
-  
+
     BasicBlock *NodeHeader = getNodeHeader(Node);
 
     if (Visited.count(NodeHeader)) {     // Node already been visited?
@@ -202,7 +202,7 @@ private:
 	  Int->Successors.push_back(NodeHeader);
       }
     } else {                             // Otherwise, not in interval yet
-      for (typename IGT::ChildIteratorType I = IGT::child_begin(Node), 
+      for (typename IGT::ChildIteratorType I = IGT::child_begin(Node),
              E = IGT::child_end(Node); I != E; ++I) {
 	if (!Int->contains(*I)) {        // If pred not in interval, we can't be
 	  if (!Int->isSuccessor(NodeHeader)) // Add only if not already in set
@@ -215,14 +215,14 @@ private:
       // already.  In this case, we must add BB to the interval!
       addNodeToInterval(Int, Node);
       Visited.insert(NodeHeader);     // The node has now been visited!
-    
+
       if (Int->isSuccessor(NodeHeader)) {
 	// If we were in the successor list from before... remove from succ list
 	Int->Successors.erase(std::remove(Int->Successors.begin(),
-				          Int->Successors.end(), NodeHeader), 
+				          Int->Successors.end(), NodeHeader),
 			      Int->Successors.end());
       }
-    
+
       // Now that we have discovered that Node is in the interval, perhaps some
       // of its successors are as well?
       for (typename GT::ChildIteratorType It = GT::child_begin(Node),
@@ -236,7 +236,7 @@ typedef IntervalIterator<BasicBlock, Function> function_interval_iterator;
 typedef IntervalIterator<Interval, IntervalPartition> interval_part_interval_iterator;
 
 
-inline function_interval_iterator intervals_begin(Function *F, 
+inline function_interval_iterator intervals_begin(Function *F,
                                                   bool DeleteInts = true) {
   return function_interval_iterator(F, DeleteInts);
 }
@@ -244,7 +244,7 @@ inline function_interval_iterator intervals_end(Function *) {
   return function_interval_iterator();
 }
 
-inline interval_part_interval_iterator 
+inline interval_part_interval_iterator
    intervals_begin(IntervalPartition &IP, bool DeleteIntervals = true) {
   return interval_part_interval_iterator(IP, DeleteIntervals);
 }