Rename Method to Function

[oota-llvm.git] / include / llvm / Analysis / SlotCalculator.h

diff --git a/include/llvm/Analysis/SlotCalculator.h b/include/llvm/Analysis/SlotCalculator.h
index 99e40cbeb5fe6ec19b09852fc670bdb707acadef..e8fead76bb7b61f0da8e1966dabc8a4abc2c6a23 100644 (file)
--- a/include/llvm/Analysis/SlotCalculator.h
+++ b/include/llvm/Analysis/SlotCalculator.h
@@ -9,27 +9,33 @@
 #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 {
+class Value;
+class Module;
+class Function;
+class MethodArgument;
+class BasicBlock;
+class Instruction;
+
+class SlotCalculator {
   const Module *TheModule;
   bool IgnoreNamedNodes;     // Shall we not count named nodes?
 
-  typedef vector<const Value*> TypePlane;
-  vector <TypePlane> Table;
-  map<const Value *, unsigned> NodeMap;
+  typedef std::vector<const Value*> TypePlane;
+  std::vector<TypePlane> Table;
+  std::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;
+  std::vector<unsigned> ModuleLevel;
 
 public:
   SlotCalculator(const Module *M, bool IgnoreNamed);
-  SlotCalculator(const Method *M, bool IgnoreNamed);// Start out in incorp state
+  // Start out in incorp state
+  SlotCalculator(const Function *M, bool IgnoreNamed);
   inline ~SlotCalculator() {}
   
   // getValSlot returns < 0 on error!
@@ -47,50 +53,34 @@ public:
   // 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 incorporateMethod(const Function *F);
   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.
+  // insertVal - Insert a value into the value table... Return the slot that it
+  // occupies, or -1 if the declaration is to be ignored because of the
+  // IgnoreNamedNodes flag.
   //
-  virtual bool processType(const Type *Ty);
+  int insertVal(const Value *D, bool dontIgnore = false);
 
-  // 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.
+  // insertValue - Values can be crammed into here at will... if they haven't
+  // been inserted already, they get inserted, otherwise they are ignored.
   //
-  virtual bool processMethods(const Module *M) { return false; }
+  int insertValue(const Value *D);
 
-  // processMethodArgument - This member is called for every argument that 
-  // is passed into the method.
-  //
-  virtual bool processMethodArgument(const MethodArgument *MA);
+  // doInsertVal - Small helper function to be called only be insertVal.
+  int doInsertVal(const Value *D);
 
-  // processBasicBlock - This member is called for each basic block in a methd.
+  // processModule - Process all of the module level method declarations and
+  // types that are available.
   //
-  virtual bool processBasicBlock(const BasicBlock *BB);
+  void processModule();
 
-  // processInstruction - This member is called for each Instruction in a methd.
+  // processSymbolTable - Insert all of the values in the specified symbol table
+  // into the values table...
   //
-  virtual bool processInstruction(const Instruction *I);
+  void processSymbolTable(const SymbolTable *ST);
+  void processSymbolTableConstants(const SymbolTable *ST);
 };
 
 #endif