Initial revision
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Bytecode/Writer/SlotCalculator.h b/lib/Bytecode/Writer/SlotCalculator.h
new file mode 100644
index 0000000..99e40cb
--- /dev/null
+++ b/lib/Bytecode/Writer/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