X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FSlotCalculator.h;h=91006d70175cdf77eefa3b1cdc79ff3fd010916d;hb=87944916a4764dabc2f89cbec0a6c7e439c28530;hp=99e40cbeb5fe6ec19b09852fc670bdb707acadef;hpb=009505452b713ed2e3a8e99c5545a6e721c65495;p=oota-llvm.git

diff --git a/include/llvm/SlotCalculator.h b/include/llvm/SlotCalculator.h
index 99e40cbeb5f..91006d70175 100644
--- a/include/llvm/SlotCalculator.h
+++ b/include/llvm/SlotCalculator.h
@@ -1,35 +1,42 @@
-//===-- llvm/Analysis/SlotCalculator.h - Calculate value slots ---*- C++ -*-==//
+//===-- llvm/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.
+// This class 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.
+//
+// Specifically, this class calculates the "type plane numbering" that you see
+// for a function if you strip out all of the symbols in it.  For assembly
+// writing, this is used when a symbol does not have a name.  For bytecode
+// writing, this is always used, and the symbol table is added on later.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ANALYSIS_SLOTCALCULATOR_H
-#define LLVM_ANALYSIS_SLOTCALCULATOR_H
+#ifndef LLVM_SLOTCALCULATOR_H
+#define LLVM_SLOTCALCULATOR_H
 
-#include "llvm/Analysis/ModuleAnalyzer.h"
-#include "llvm/SymTabValue.h"
 #include <vector>
 #include <map>
+class Value;
+class Module;
+class Function;
+class SymbolTable;
 
-class SlotCalculator : public ModuleAnalyzer {
+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.
+  // and which values belong to the currently incorporated function.
   //
-  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!
@@ -44,53 +51,37 @@ public:
     return Table[Plane]; 
   }
 
-  // If you'd like to deal with a method, use these two methods to get its data
-  // into the SlotCalculator!
+  // If you'd like to deal with a function, use these two methods to get its
+  // data into the SlotCalculator!
   //
-  void incorporateMethod(const Method *M);
-  void purgeMethod();
+  void incorporateFunction(const Function *F);
+  void purgeFunction();
 
 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 function 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