mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 03:02:36 +01:00
97 lines
3.2 KiB
C++
97 lines
3.2 KiB
C++
//===-- 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
|