Initial checkin of the StableBasicBlockNumbering, a little helper class for computing

(strangely enough) a stable (determinstic) numbering for basic blocks.


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

include/llvm/Support/StableBasicBlockNumbering.h

@@ -0,0 +1,70 @@
+//===- StableBasicBlockNumbering.h - Provide BB identifiers -----*- 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 class provides a *stable* numbering of basic blocks that does not depend
+// on their address in memory (which is nondeterministic).  When requested, this
+// class simply provides a unique ID for each basic block in the function
+// specified and the inverse mapping.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_STABLEBASICBLOCKNUMBERING_H
+#define LLVM_SUPPORT_STABLEBASICBLOCKNUMBERING_H
+
+#include "llvm/Function.h"
+#include <map>
+
+namespace llvm {
+  class StableBasicBlockNumbering {
+    // BasicBlockNumbering - Holds a numbering of the basic blocks in the
+    // function in a stable order that does not depend on their address.
+    std::map<BasicBlock*, unsigned> BasicBlockNumbering;
+
+    // NumberedBasicBlock - Holds the inverse mapping of BasicBlockNumbering.
+    std::vector<BasicBlock*> NumberedBasicBlock;
+  public:
+
+    StableBasicBlockNumbering(Function *F = 0) {
+      if (F) compute(*F);
+    }
+
+    /// compute - If we have not computed a numbering for the function yet, do
+    /// so.
+    void compute(Function &F) {
+      if (NumberedBasicBlock.empty()) {
+        unsigned n = 0;
+        for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I, ++n) {
+          NumberedBasicBlock.push_back(I);
+          BasicBlockNumbering[I] = n;
+        }
+      }
+    }
+
+    /// getNumber - Return the ID number for the specified BasicBlock.
+    ///
+    unsigned getNumber(BasicBlock *BB) const {
+      std::map<BasicBlock*, unsigned>::const_iterator I =
+        BasicBlockNumbering.find(BB);
+      assert(I != BasicBlockNumbering.end() &&
+             "Invalid basic block or numbering not computed!");
+      return I->second;
+    }
+
+    /// getBlock - Return the BasicBlock corresponding to a particular ID.
+    ///
+    BasicBlock *getBlock(unsigned N) const {
+      assert(N < NumberedBasicBlock.size() &&
+             "Block ID out of range or numbering not computed!");
+      return NumberedBasicBlock[N];
+    }
+
+  };
+}
+
+#endif