blob: a0baa8a7ddebf8402cb4a2cbe7d58a93a0264a9f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
//===-- 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 <set>
class Type;
class Module;
class Method;
class BasicBlock;
class Instruction;
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);
// 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);
// 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
//
// 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
|
