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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
//===-- llvm/Module.h - C++ class to represent a VM module -------*- C++ -*--=//
//
// This file contains the declarations for the Module class that is used to
// maintain all the information related to a VM module.
//
// A module also maintains a GlobalValRefMap object that is used to hold all
// constant references to global variables in the module. When a global
// variable is destroyed, it should have no entries in the GlobalValueRefMap.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_MODULE_H
#define LLVM_MODULE_H
#include "llvm/Value.h"
#include "llvm/SymTabValue.h"
#include "llvm/ValueHolder.h"
class GlobalVariable;
class GlobalValueRefMap; // Used by ConstantVals.cpp
class ConstantPointerRef;
class FunctionType;
class Module : public Value, public SymTabValue {
public:
typedef ValueHolder<GlobalVariable, Module, Module> GlobalListType;
typedef ValueHolder<Function, Module, Module> FunctionListType;
// Global Variable iterators...
typedef GlobalListType::iterator giterator;
typedef GlobalListType::const_iterator const_giterator;
typedef std::reverse_iterator<giterator> reverse_giterator;
typedef std::reverse_iterator<const_giterator> const_reverse_giterator;
// Function iterators...
typedef FunctionListType::iterator iterator;
typedef FunctionListType::const_iterator const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
private:
GlobalListType GlobalList; // The Global Variables
FunctionListType FunctionList; // The Functions
GlobalValueRefMap *GVRefMap;
// Accessor for the underlying GlobalValRefMap... only through the
// ConstantPointerRef class...
friend class ConstantPointerRef;
void mutateConstantPointerRef(GlobalValue *OldGV, GlobalValue *NewGV);
ConstantPointerRef *getConstantPointerRef(GlobalValue *GV);
public:
Module();
~Module();
// getOrInsertFunction - Look up the specified function in the module symbol
// table. If it does not exist, add a prototype for the function and return
// it.
Function *getOrInsertFunction(const std::string &Name, const FunctionType *T);
// getFunction - Look up the specified function in the module symbol table.
// If it does not exist, return null.
//
Function *getFunction(const std::string &Name, const FunctionType *Ty);
// addTypeName - Insert an entry in the symbol table mapping Str to Type. If
// there is already an entry for this name, true is returned and the symbol
// table is not modified.
//
bool addTypeName(const std::string &Name, const Type *Ty);
// Get the underlying elements of the Module...
inline const GlobalListType &getGlobalList() const { return GlobalList; }
inline GlobalListType &getGlobalList() { return GlobalList; }
inline const FunctionListType &getFunctionList() const { return FunctionList;}
inline FunctionListType &getFunctionList() { return FunctionList;}
//===--------------------------------------------------------------------===//
// Module iterator forwarding functions
//
inline giterator gbegin() { return GlobalList.begin(); }
inline const_giterator gbegin() const { return GlobalList.begin(); }
inline giterator gend () { return GlobalList.end(); }
inline const_giterator gend () const { return GlobalList.end(); }
inline reverse_giterator grbegin() { return GlobalList.rbegin(); }
inline const_reverse_giterator grbegin() const { return GlobalList.rbegin(); }
inline reverse_giterator grend () { return GlobalList.rend(); }
inline const_reverse_giterator grend () const { return GlobalList.rend(); }
inline unsigned gsize() const { return GlobalList.size(); }
inline bool gempty() const { return GlobalList.empty(); }
inline const GlobalVariable *gfront() const { return GlobalList.front(); }
inline GlobalVariable *gfront() { return GlobalList.front(); }
inline const GlobalVariable *gback() const { return GlobalList.back(); }
inline GlobalVariable *gback() { return GlobalList.back(); }
inline iterator begin() { return FunctionList.begin(); }
inline const_iterator begin() const { return FunctionList.begin(); }
inline iterator end () { return FunctionList.end(); }
inline const_iterator end () const { return FunctionList.end(); }
inline reverse_iterator rbegin() { return FunctionList.rbegin(); }
inline const_reverse_iterator rbegin() const { return FunctionList.rbegin(); }
inline reverse_iterator rend () { return FunctionList.rend(); }
inline const_reverse_iterator rend () const { return FunctionList.rend(); }
inline unsigned size() const { return FunctionList.size(); }
inline bool empty() const { return FunctionList.empty(); }
inline const Function *front() const { return FunctionList.front(); }
inline Function *front() { return FunctionList.front(); }
inline const Function *back() const { return FunctionList.back(); }
inline Function *back() { return FunctionList.back(); }
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const Module *T) { return true; }
static inline bool classof(const Value *V) {
return V->getValueType() == Value::ModuleVal;
}
// dropAllReferences() - This function causes all the subinstructions to "let
// go" of all references that they are maintaining. This allows one to
// 'delete' a whole class at a time, even though there may be circular
// references... first all references are dropped, and all use counts go to
// zero. Then everything is delete'd for real. Note that no operations are
// valid on an object that has "dropped all references", except operator
// delete.
//
void dropAllReferences();
};
#endif
|
