Rename PBQP RegAllocSolver local variables to conform to LLVM coding style.

No functional change.

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

diff --git a/include/llvm/CodeGen/PBQP/RegAllocSolver.h b/include/llvm/CodeGen/PBQP/RegAllocSolver.h
index 80eba31b8c0de6bd1c0a6b06857d1c22b6c16cfb..ae488e9afe57a40e0a14863623d7fc7085c29b77 100644 (file)
--- a/include/llvm/CodeGen/PBQP/RegAllocSolver.h
+++ b/include/llvm/CodeGen/PBQP/RegAllocSolver.h
@@ -35,48 +35,48 @@ namespace PBQP {
     /// Keeps track of the number of infinities in each row and column.
     class MatrixMetadata {
     private:
-      MatrixMetadata(const MatrixMetadata&);
-      void operator=(const MatrixMetadata&);
+      MatrixMetadata(const MatrixMetadata&) = delete;
+      void operator=(const MatrixMetadata&) = delete;
     public:
-      MatrixMetadata(const PBQP::Matrix& m)
-        : worstRow(0), worstCol(0),
-          unsafeRows(new bool[m.getRows() - 1]()),
-          unsafeCols(new bool[m.getCols() - 1]()) {
-
-        unsigned* colCounts = new unsigned[m.getCols() - 1]();
-
-        for (unsigned i = 1; i < m.getRows(); ++i) {
-          unsigned rowCount = 0;
-          for (unsigned j = 1; j < m.getCols(); ++j) {
-            if (m[i][j] == std::numeric_limits<PBQP::PBQPNum>::infinity()) {
-              ++rowCount;
-              ++colCounts[j - 1];
-              unsafeRows[i - 1] = true;
-              unsafeCols[j - 1] = true;
+      MatrixMetadata(const PBQP::Matrix& M)
+        : WorstRow(0), WorstCol(0),
+          UnsafeRows(new bool[M.getRows() - 1]()),
+          UnsafeCols(new bool[M.getCols() - 1]()) {
+
+        unsigned* ColCounts = new unsigned[M.getCols() - 1]();
+
+        for (unsigned i = 1; i < M.getRows(); ++i) {
+          unsigned RowCount = 0;
+          for (unsigned j = 1; j < M.getCols(); ++j) {
+            if (M[i][j] == std::numeric_limits<PBQP::PBQPNum>::infinity()) {
+              ++RowCount;
+              ++ColCounts[j - 1];
+              UnsafeRows[i - 1] = true;
+              UnsafeCols[j - 1] = true;
             }
           }
-          worstRow = std::max(worstRow, rowCount);
+          WorstRow = std::max(WorstRow, RowCount);
         }
-        unsigned worstColCountForCurRow =
-          *std::max_element(colCounts, colCounts + m.getCols() - 1);
-        worstCol = std::max(worstCol, worstColCountForCurRow);
-        delete[] colCounts;
+        unsigned WorstColCountForCurRow =
+          *std::max_element(ColCounts, ColCounts + M.getCols() - 1);
+        WorstCol = std::max(WorstCol, WorstColCountForCurRow);
+        delete[] ColCounts;
       }
 
       ~MatrixMetadata() {
-        delete[] unsafeRows;
-        delete[] unsafeCols;
+        delete[] UnsafeRows;
+        delete[] UnsafeCols;
       }
 
-      unsigned getWorstRow() const { return worstRow; }
-      unsigned getWorstCol() const { return worstCol; }
-      const bool* getUnsafeRows() const { return unsafeRows; }
-      const bool* getUnsafeCols() const { return unsafeCols; }
+      unsigned getWorstRow() const { return WorstRow; }
+      unsigned getWorstCol() const { return WorstCol; }
+      const bool* getUnsafeRows() const { return UnsafeRows; }
+      const bool* getUnsafeCols() const { return UnsafeCols; }
 
     private:
-      unsigned worstRow, worstCol;
-      bool* unsafeRows;
-      bool* unsafeCols;
+      unsigned WorstRow, WorstCol;
+      bool* UnsafeRows;
+      bool* UnsafeCols;
     };
 
     class NodeMetadata {
@@ -86,44 +86,44 @@ namespace PBQP {
                      ConservativelyAllocatable,
                      NotProvablyAllocatable } ReductionState;
 
-      NodeMetadata() : rs(Unprocessed), deniedOpts(0), optUnsafeEdges(0) {}
-      ~NodeMetadata() { delete[] optUnsafeEdges; }
+      NodeMetadata() : RS(Unprocessed), DeniedOpts(0), OptUnsafeEdges(0) {}
+      ~NodeMetadata() { delete[] OptUnsafeEdges; }
 
-      void setup(const Vector& costs) {
-        numOpts = costs.getLength() - 1;
-        optUnsafeEdges = new unsigned[numOpts]();
+      void setup(const Vector& Costs) {
+        NumOpts = Costs.getLength() - 1;
+        OptUnsafeEdges = new unsigned[NumOpts]();
       }
 
-      ReductionState getReductionState() const { return rs; }
-      void setReductionState(ReductionState rs) { this->rs = rs; }
+      ReductionState getReductionState() const { return RS; }
+      void setReductionState(ReductionState RS) { this->RS = RS; }
 
-      void handleAddEdge(const MatrixMetadata& md, bool transpose) {
-        deniedOpts += transpose ? md.getWorstCol() : md.getWorstRow();
-        const bool* unsafeOpts =
-          transpose ? md.getUnsafeCols() : md.getUnsafeRows();
-        for (unsigned i = 0; i < numOpts; ++i)
-          optUnsafeEdges[i] += unsafeOpts[i];
+      void handleAddEdge(const MatrixMetadata& MD, bool Transpose) {
+        DeniedOpts += Transpose ? MD.getWorstCol() : MD.getWorstRow();
+        const bool* UnsafeOpts =
+          Transpose ? MD.getUnsafeCols() : MD.getUnsafeRows();
+        for (unsigned i = 0; i < NumOpts; ++i)
+          OptUnsafeEdges[i] += UnsafeOpts[i];
       }
 
-      void handleRemoveEdge(const MatrixMetadata& md, bool transpose) {
-        deniedOpts -= transpose ? md.getWorstCol() : md.getWorstRow();
-        const bool* unsafeOpts =
-          transpose ? md.getUnsafeCols() : md.getUnsafeRows();
-        for (unsigned i = 0; i < numOpts; ++i)
-          optUnsafeEdges[i] -= unsafeOpts[i];
+      void handleRemoveEdge(const MatrixMetadata& MD, bool Transpose) {
+        DeniedOpts -= Transpose ? MD.getWorstCol() : MD.getWorstRow();
+        const bool* UnsafeOpts =
+          Transpose ? MD.getUnsafeCols() : MD.getUnsafeRows();
+        for (unsigned i = 0; i < NumOpts; ++i)
+          OptUnsafeEdges[i] -= UnsafeOpts[i];
       }
 
       bool isConservativelyAllocatable() const {
-        return (deniedOpts < numOpts) ||
-               (std::find(optUnsafeEdges, optUnsafeEdges + numOpts, 0) !=
-                  optUnsafeEdges + numOpts);
+        return (DeniedOpts < NumOpts) ||
+               (std::find(OptUnsafeEdges, OptUnsafeEdges + NumOpts, 0) !=
+                  OptUnsafeEdges + NumOpts);
       }
 
     private:
-      ReductionState rs;
-      unsigned numOpts;
-      unsigned deniedOpts;
-      unsigned* optUnsafeEdges;
+      ReductionState RS;
+      unsigned NumOpts;
+      unsigned DeniedOpts;
+      unsigned* OptUnsafeEdges;
     };
 
     class RegAllocSolverImpl {
@@ -175,36 +175,36 @@ namespace PBQP {
       }
 
       void handleDisconnectEdge(EdgeId EId, NodeId NId) {
-        NodeMetadata& nMd = G.getNodeMetadata(NId);
-        const MatrixMetadata& mMd = G.getEdgeCosts(EId).getMetadata();
-        nMd.handleRemoveEdge(mMd, NId == G.getEdgeNode2Id(EId));
+        NodeMetadata& NMd = G.getNodeMetadata(NId);
+        const MatrixMetadata& MMd = G.getEdgeCosts(EId).getMetadata();
+        NMd.handleRemoveEdge(MMd, NId == G.getEdgeNode2Id(EId));
         if (G.getNodeDegree(NId) == 3) {
           // This node is becoming optimally reducible.
           moveToOptimallyReducibleNodes(NId);
-        } else if (nMd.getReductionState() ==
+        } else if (NMd.getReductionState() ==
                      NodeMetadata::NotProvablyAllocatable &&
-                   nMd.isConservativelyAllocatable()) {
+                   NMd.isConservativelyAllocatable()) {
           // This node just became conservatively allocatable.
           moveToConservativelyAllocatableNodes(NId);
         }
       }
 
       void handleReconnectEdge(EdgeId EId, NodeId NId) {
-        NodeMetadata& nMd = G.getNodeMetadata(NId);
-        const MatrixMetadata& mMd = G.getEdgeCosts(EId).getMetadata();
-        nMd.handleAddEdge(mMd, NId == G.getEdgeNode2Id(EId));
+        NodeMetadata& NMd = G.getNodeMetadata(NId);
+        const MatrixMetadata& MMd = G.getEdgeCosts(EId).getMetadata();
+        NMd.handleAddEdge(MMd, NId == G.getEdgeNode2Id(EId));
       }
 
       void handleSetEdgeCosts(EdgeId EId, const Matrix& NewCosts) {
         handleRemoveEdge(EId);
 
-        NodeId n1Id = G.getEdgeNode1Id(EId);
-        NodeId n2Id = G.getEdgeNode2Id(EId);
-        NodeMetadata& n1Md = G.getNodeMetadata(n1Id);
-        NodeMetadata& n2Md = G.getNodeMetadata(n2Id);
-        const MatrixMetadata& mMd = NewCosts.getMetadata();
-        n1Md.handleAddEdge(mMd, n1Id != G.getEdgeNode1Id(EId));
-        n2Md.handleAddEdge(mMd, n2Id != G.getEdgeNode1Id(EId));
+        NodeId N1Id = G.getEdgeNode1Id(EId);
+        NodeId N2Id = G.getEdgeNode2Id(EId);
+        NodeMetadata& N1Md = G.getNodeMetadata(N1Id);
+        NodeMetadata& N2Md = G.getNodeMetadata(N2Id);
+        const MatrixMetadata& MMd = NewCosts.getMetadata();
+        N1Md.handleAddEdge(MMd, N1Id != G.getEdgeNode1Id(EId));
+        N2Md.handleAddEdge(MMd, N2Id != G.getEdgeNode1Id(EId));
       }
 
     private:
@@ -281,9 +281,9 @@ namespace PBQP {
         // Consume worklists.
         while (true) {
           if (!OptimallyReducibleNodes.empty()) {
-            NodeSet::iterator nItr = OptimallyReducibleNodes.begin();
-            NodeId NId = *nItr;
-            OptimallyReducibleNodes.erase(nItr);
+            NodeSet::iterator NItr = OptimallyReducibleNodes.begin();
+            NodeId NId = *NItr;
+            OptimallyReducibleNodes.erase(NItr);
             NodeStack.push_back(NId);
             switch (G.getNodeDegree(NId)) {
               case 0:
@@ -303,19 +303,19 @@ namespace PBQP {
             // would be better to push nodes with lower 'expected' or worst-case
             // register costs first (since early nodes are the most
             // constrained).
-            NodeSet::iterator nItr = ConservativelyAllocatableNodes.begin();
-            NodeId NId = *nItr;
-            ConservativelyAllocatableNodes.erase(nItr);
+            NodeSet::iterator NItr = ConservativelyAllocatableNodes.begin();
+            NodeId NId = *NItr;
+            ConservativelyAllocatableNodes.erase(NItr);
             NodeStack.push_back(NId);
             G.disconnectAllNeighborsFromNode(NId);
 
           } else if (!NotProvablyAllocatableNodes.empty()) {
-            NodeSet::iterator nItr =
+            NodeSet::iterator NItr =
               std::min_element(NotProvablyAllocatableNodes.begin(),
                                NotProvablyAllocatableNodes.end(),
                                SpillCostComparator(G));
-            NodeId NId = *nItr;
-            NotProvablyAllocatableNodes.erase(nItr);
+            NodeId NId = *NItr;
+            NotProvablyAllocatableNodes.erase(NItr);
             NodeStack.push_back(NId);
             G.disconnectAllNeighborsFromNode(NId);
           } else