Initial revision

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

1 files changed, 96 insertions, 0 deletions

diff --git a/include/llvm/SlotCalculator.h b/include/llvm/SlotCalculator.h
new file mode 100644
index 0000000..99e40cb
--- /dev/null
+++ b/include/llvm/SlotCalculator.h
@@ -0,0 +1,96 @@
+//===-- llvm/Analysis/SlotCalculator.h - Calculate value slots ---*- C++ -*-==//
+//
+// This ModuleAnalyzer subclass calculates the slots that values will land in.
+// This is useful for when writing bytecode or assembly out, because you have 
+// to know these things.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_SLOTCALCULATOR_H
+#define LLVM_ANALYSIS_SLOTCALCULATOR_H
+
+#include "llvm/Analysis/ModuleAnalyzer.h"
+#include "llvm/SymTabValue.h"
+#include <vector>
+#include <map>
+
+class SlotCalculator : public ModuleAnalyzer {
+  const Module *TheModule;
+  bool IgnoreNamedNodes;     // Shall we not count named nodes?
+
+  typedef vector<const Value*> TypePlane;
+  vector <TypePlane> Table;
+  map<const Value *, unsigned> NodeMap;
+
+  // ModuleLevel - Used to keep track of which values belong to the module,
+  // and which values belong to the currently incorporated method.
+  //
+  vector <unsigned> ModuleLevel;
+
+public:
+  SlotCalculator(const Module *M, bool IgnoreNamed);
+  SlotCalculator(const Method *M, bool IgnoreNamed);// Start out in incorp state
+  inline ~SlotCalculator() {}
+  
+  // getValSlot returns < 0 on error!
+  int getValSlot(const Value *D) const;
+
+  inline unsigned getNumPlanes() const { return Table.size(); }
+  inline unsigned getModuleLevel(unsigned Plane) const { 
+    return Plane < ModuleLevel.size() ? ModuleLevel[Plane] : 0; 
+  }
+
+  inline const TypePlane &getPlane(unsigned Plane) const { 
+    return Table[Plane]; 
+  }
+
+  // If you'd like to deal with a method, use these two methods to get its data
+  // into the SlotCalculator!
+  //
+  void incorporateMethod(const Method *M);
+  void purgeMethod();
+
+protected:
+  // insertVal - Insert a value into the value table...
+  //
+  void insertVal(const Value *D);
+
+  // visitMethod - This member is called after the constant pool has been 
+  // processed.  The default implementation of this is a noop.
+  //
+  virtual bool visitMethod(const Method *M);
+
+  // processConstant is called once per each constant in the constant pool.  It
+  // traverses the constant pool such that it visits each constant in the
+  // order of its type.  Thus, all 'int' typed constants shall be visited 
+  // sequentially, etc...
+  //
+  virtual bool processConstant(const ConstPoolVal *CPV);
+
+  // processType - This callback occurs when an derived type is discovered
+  // at the class level. This activity occurs when processing a constant pool.
+  //
+  virtual bool processType(const Type *Ty);
+
+  // processMethods - The default implementation of this method loops through 
+  // all of the methods in the module and processModule's them.  We don't want
+  // this (we want to explicitly visit them with incorporateMethod), so we 
+  // disable it.
+  //
+  virtual bool processMethods(const Module *M) { return false; }
+
+  // processMethodArgument - This member is called for every argument that 
+  // is passed into the method.
+  //
+  virtual bool processMethodArgument(const MethodArgument *MA);
+
+  // processBasicBlock - This member is called for each basic block in a methd.
+  //
+  virtual bool processBasicBlock(const BasicBlock *BB);
+
+  // processInstruction - This member is called for each Instruction in a methd.
+  //
+  virtual bool processInstruction(const Instruction *I);
+};
+
+#endif