include/llvm/SlotCalculator.h

   1 //===-- llvm/Analysis/SlotCalculator.h - Calculate value slots ---*- C++ -*-==//
   2 //
   3 // This ModuleAnalyzer subclass calculates the slots that values will land in.
   4 // This is useful for when writing bytecode or assembly out, because you have
   5 // to know these things.
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLVM_ANALYSIS_SLOTCALCULATOR_H
  10 #define LLVM_ANALYSIS_SLOTCALCULATOR_H
  11
  12 #include "llvm/SymTabValue.h"
  13 #include <vector>
  14 #include <map>
  15 class Value;
  16 class Module;
  17 class Function;
  18 class MethodArgument;
  19 class BasicBlock;
  20 class Instruction;
  21
  22 class SlotCalculator {
  23   const Module *TheModule;
  24   bool IgnoreNamedNodes;     // Shall we not count named nodes?
  25
  26   typedef std::vector<const Value*> TypePlane;
  27   std::vector<TypePlane> Table;
  28   std::map<const Value *, unsigned> NodeMap;
  29
  30   // ModuleLevel - Used to keep track of which values belong to the module,
  31   // and which values belong to the currently incorporated method.
  32   //
  33   std::vector<unsigned> ModuleLevel;
  34
  35 public:
  36   SlotCalculator(const Module *M, bool IgnoreNamed);
  37   // Start out in incorp state
  38   SlotCalculator(const Function *M, bool IgnoreNamed);
  39   inline ~SlotCalculator() {}
  40
  41   // getValSlot returns < 0 on error!
  42   int getValSlot(const Value *D) const;
  43
  44   inline unsigned getNumPlanes() const { return Table.size(); }
  45   inline unsigned getModuleLevel(unsigned Plane) const {
  46     return Plane < ModuleLevel.size() ? ModuleLevel[Plane] : 0;
  47   }
  48
  49   inline const TypePlane &getPlane(unsigned Plane) const {
  50     return Table[Plane];
  51   }
  52
  53   // If you'd like to deal with a method, use these two methods to get its data
  54   // into the SlotCalculator!
  55   //
  56   void incorporateMethod(const Function *F);
  57   void purgeMethod();
  58
  59 protected:
  60   // insertVal - Insert a value into the value table... Return the slot that it
  61   // occupies, or -1 if the declaration is to be ignored because of the
  62   // IgnoreNamedNodes flag.
  63   //
  64   int insertVal(const Value *D, bool dontIgnore = false);
  65
  66   // insertValue - Values can be crammed into here at will... if they haven't
  67   // been inserted already, they get inserted, otherwise they are ignored.
  68   //
  69   int insertValue(const Value *D);
  70
  71   // doInsertVal - Small helper function to be called only be insertVal.
  72   int doInsertVal(const Value *D);
  73
  74   // processModule - Process all of the module level method declarations and
  75   // types that are available.
  76   //
  77   void processModule();
  78
  79   // processSymbolTable - Insert all of the values in the specified symbol table
  80   // into the values table...
  81   //
  82   void processSymbolTable(const SymbolTable *ST);
  83   void processSymbolTableConstants(const SymbolTable *ST);
  84 };
  85
  86 #endif