Remove trailing whitespace

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

lib/Target/SparcV9/InstrSched/SchedPriorities.cpp

@@ -1,12 +1,12 @@
 //===-- SchedPriorities.h - Encapsulate scheduling heuristics -------------===//
-// 
+//
 //                     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.
-// 
+//
 //===----------------------------------------------------------------------===//
-// 
+//
 // Strategy:
 //    Priority ordering rules:
 //    (1) Max delay, which is the order of the heap S.candsAsHeap.
@@ -76,23 +76,23 @@ void
 SchedPriorities::initializeReadyHeap(const SchedGraph* graph) {
   const SchedGraphNode* graphRoot = (const SchedGraphNode*)graph->getRoot();
   assert(graphRoot->getMachineInstr() == NULL && "Expect dummy root");
-  
+
   // Insert immediate successors of dummy root, which are the actual roots
   sg_succ_const_iterator SEnd = succ_end(graphRoot);
   for (sg_succ_const_iterator S = succ_begin(graphRoot); S != SEnd; ++S)
     this->insertReady(*S);
-  
+
 #undef TEST_HEAP_CONVERSION
 #ifdef TEST_HEAP_CONVERSION
   std::cerr << "Before heap conversion:\n";
   copy(candsAsHeap.begin(), candsAsHeap.end(),
        ostream_iterator<NodeDelayPair*>(std::cerr,"\n"));
 #endif
-  
+
   candsAsHeap.makeHeap();
-  
+
   nextToTry = candsAsHeap.begin();
-  
+
 #ifdef TEST_HEAP_CONVERSION
   std::cerr << "After heap conversion:\n";
   copy(candsAsHeap.begin(), candsAsHeap.end(),
@@ -107,7 +107,7 @@ SchedPriorities::insertReady(const SchedGraphNode* node) {
   mcands.clear(); // ensure reset choices is called before any more choices
   earliestReadyTime = std::min(earliestReadyTime,
                        getEarliestReadyTimeForNode(node));
-  
+
   if (SchedDebugLevel >= Sched_PrintSchedTrace) {
     std::cerr << " Node " << node->getNodeId() << " will be ready in Cycle "
               << getEarliestReadyTimeForNode(node) << "; "
@@ -122,26 +122,26 @@ SchedPriorities::issuedReadyNodeAt(CycleCount_t curTime,
   candsAsHeap.removeNode(node);
   candsAsSet.erase(node);
   mcands.clear(); // ensure reset choices is called before any more choices
-  
+
   if (earliestReadyTime == getEarliestReadyTimeForNode(node)) {
     // earliestReadyTime may have been due to this node, so recompute it
     earliestReadyTime = HUGE_LATENCY;
     for (NodeHeap::const_iterator I=candsAsHeap.begin();
          I != candsAsHeap.end(); ++I)
       if (candsAsHeap.getNode(I)) {
-        earliestReadyTime = 
-          std::min(earliestReadyTime, 
+        earliestReadyTime =
+          std::min(earliestReadyTime,
                    getEarliestReadyTimeForNode(candsAsHeap.getNode(I)));
       }
   }
-  
+
   // Now update ready times for successors
   for (SchedGraphNode::const_iterator E=node->beginOutEdges();
        E != node->endOutEdges(); ++E) {
     CycleCount_t& etime =
       getEarliestReadyTimeForNodeRef((SchedGraphNode*)(*E)->getSink());
     etime = std::max(etime, curTime + (*E)->getMinDelay());
-  }    
+  }
 }
 
 
@@ -182,7 +182,7 @@ SchedPriorities::chooseByRule3(std::vector<candIndex>& mcands) {
       indexWithMaxUses = i;
     }
   }
-  return indexWithMaxUses; 
+  return indexWithMaxUses;
 }
 
 const SchedGraphNode*
@@ -190,22 +190,22 @@ SchedPriorities::getNextHighest(const SchedulingManager& S,
 				CycleCount_t curTime) {
   int nextIdx = -1;
   const SchedGraphNode* nextChoice = NULL;
-  
+
   if (mcands.size() == 0)
     findSetWithMaxDelay(mcands, S);
-  
+
   while (nextIdx < 0 && mcands.size() > 0) {
     nextIdx = chooseByRule1(mcands);	 // rule 1
-      
+
     if (nextIdx == -1)
       nextIdx = chooseByRule2(mcands); // rule 2
-      
+
     if (nextIdx == -1)
       nextIdx = chooseByRule3(mcands); // rule 3
-      
+
     if (nextIdx == -1)
       nextIdx = 0;			 // default to first choice by delays
-      
+
     // We have found the next best candidate.  Check if it ready in
     // the current cycle, and if it is feasible.
     // If not, remove it from mcands and continue.  Refill mcands if
@@ -220,7 +220,7 @@ SchedPriorities::getNextHighest(const SchedulingManager& S,
         findSetWithMaxDelay(mcands, S);
     }
   }
-  
+
   if (nextIdx >= 0) {
     mcands.erase(mcands.begin() + nextIdx);
     return nextChoice;
@@ -241,9 +241,9 @@ SchedPriorities::findSetWithMaxDelay(std::vector<candIndex>& mcands,
       for (; next != candsAsHeap.end()
 	     && candsAsHeap.getDelay(next) == maxDelay; ++next)
 	mcands.push_back(next);
-      
+
       nextToTry = next;
-      
+
       if (SchedDebugLevel >= Sched_PrintSchedTrace) {
         std::cerr << "    Cycle " << (long)getTime() << ": "
                   << "Next highest delay = " << (long)maxDelay << " : "
@@ -260,17 +260,17 @@ bool
 SchedPriorities::instructionHasLastUse(FunctionLiveVarInfo &LVI,
 				       const SchedGraphNode* graphNode) {
   const MachineInstr *MI = graphNode->getMachineInstr();
-  
+
   hash_map<const MachineInstr*, bool>::const_iterator
     ui = lastUseMap.find(MI);
   if (ui != lastUseMap.end())
     return ui->second;
-  
+
   // else check if instruction is a last use and save it in the hash_map
   bool hasLastUse = false;
   const BasicBlock* bb = graphNode->getMachineBasicBlock().getBasicBlock();
   const ValueSet &LVs = LVI.getLiveVarSetBeforeMInst(MI, bb);
-  
+
   for (MachineInstr::const_val_op_iterator OI = MI->begin(), OE = MI->end();
        OI != OE; ++OI)
     if (!LVs.count(*OI)) {