-//===-- llvm/Analysis/SlotCalculator.h - Calculate value slots ---*- C++ -*-==//
+//===-- llvm/SlotCalculator.h - Calculate value slots -----------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
//
-// 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 file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// 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!
- int getValSlot(const Value *D) const;
+ // getSlot returns < 0 on error!
+ int getSlot(const Value *D) const;
inline unsigned getNumPlanes() const { return Table.size(); }
inline unsigned getModuleLevel(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!
+ // 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.
+ // getOrCreateSlot - Values can be crammed into here at will... if
+ // they haven't been inserted already, they get inserted, otherwise
+ // they are ignored.
//
- virtual bool visitMethod(const Method *M);
+ int getOrCreateSlot(const Value *D);
- // 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...
+ // insertValue - 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 processConstant(const ConstPoolVal *CPV);
+ int insertValue(const Value *D, bool dontIgnore = false);
- // 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);
+ // doInsertValue - Small helper function to be called only be insertVal.
+ int doInsertValue(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
projects / oota-llvm.git / blobdiff