diff options
author | Chris Lattner <sabre@nondot.org> | 2001-06-06 20:29:01 +0000 |
---|---|---|
committer | Chris Lattner <sabre@nondot.org> | 2001-06-06 20:29:01 +0000 |
commit | 009505452b713ed2e3a8e99c5545a6e721c65495 (patch) | |
tree | 136a71c5b87bdf534d1f20a67558b49226b5a4d6 /include/llvm/Analysis/ModuleAnalyzer.h | |
parent | 8d0afd3d32d1d67f9aa5df250a1d6955aa8f1ac9 (diff) | |
download | llvm-009505452b713ed2e3a8e99c5545a6e721c65495.tar.gz llvm-009505452b713ed2e3a8e99c5545a6e721c65495.tar.bz2 llvm-009505452b713ed2e3a8e99c5545a6e721c65495.tar.xz |
Initial revision
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'include/llvm/Analysis/ModuleAnalyzer.h')
-rw-r--r-- | include/llvm/Analysis/ModuleAnalyzer.h | 113 |
1 files changed, 113 insertions, 0 deletions
diff --git a/include/llvm/Analysis/ModuleAnalyzer.h b/include/llvm/Analysis/ModuleAnalyzer.h new file mode 100644 index 0000000000..3abdd49afe --- /dev/null +++ b/include/llvm/Analysis/ModuleAnalyzer.h @@ -0,0 +1,113 @@ +//===-- llvm/Analysis/ModuleAnalyzer.h - Module analysis driver --*- C++ -*-==// +// +// This class provides a nice interface to traverse a module in a predictable +// way. This is used by the AssemblyWriter, BytecodeWriter, and SlotCalculator +// to do analysis of a module. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_ANALYSIS_MODULEANALYZER_H +#define LLVM_ANALYSIS_MODULEANALYZER_H + +#include "llvm/ConstantPool.h" +#include <set> + +class Module; +class Method; +class BasicBlock; +class Instruction; +class ConstPoolVal; +class MethodType; +class MethodArgument; + +class ModuleAnalyzer { + ModuleAnalyzer(const ModuleAnalyzer &); // do not impl + const ModuleAnalyzer &operator=(const ModuleAnalyzer &); // do not impl +public: + ModuleAnalyzer() {} + virtual ~ModuleAnalyzer() {} + +protected: + // processModule - Driver function to call all of my subclasses virtual + // methods. Commonly called by derived type's constructor. + // + bool processModule(const Module *M); + + //===--------------------------------------------------------------------===// + // Stages of processing Module level information + // + virtual bool processConstPool(const ConstantPool &CP, bool isMethod); + + // 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) { return false; } + + // processMethods - The default implementation of this method loops through + // all of the methods in the module and processModule's them. + // + virtual bool processMethods(const Module *M); + + //===--------------------------------------------------------------------===// + // Stages of processing a constant pool + // + + // processConstPoolPlane - Called once for every populated plane in the + // constant pool. The default action is to do nothing. The processConstPool + // method does the iteration over constants. + // + virtual bool processConstPoolPlane(const ConstantPool &CP, + const ConstantPool::PlaneType &Pl, + bool isMethod) { + return false; + } + + // 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) { return false; } + + // 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) { return false; } + + //===--------------------------------------------------------------------===// + // Stages of processing Method level information + // + // (processConstPool is also used above, with the isMethod flag set to true) + // + + // processMethod - Process all aspects of a method. + // + virtual bool processMethod(const Method *M); + + // processMethodArgument - This member is called for every argument that + // is passed into the method. + // + virtual bool processMethodArgument(const MethodArgument *MA) { return false; } + + // processBasicBlock - This member is called for each basic block in a methd. + // + virtual bool processBasicBlock(const BasicBlock *BB); + + //===--------------------------------------------------------------------===// + // Stages of processing BasicBlock level information + // + + // preProcessInstruction - This member is called for each Instruction in a + // method before processInstruction. + // + virtual bool preProcessInstruction(const Instruction *I); + + // processInstruction - This member is called for each Instruction in a method + // + virtual bool processInstruction(const Instruction *I) { return false; } + +private: + bool handleType(set<const Type *> &TypeSet, const Type *T); +}; + +#endif |