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
135
136
137
|
//===-- Analysis/SlotCalculator.h - Calculate value slots -------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// 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
#include "llvm/ADT/DenseMap.h"
#include <vector>
#include <map>
namespace llvm {
class Value;
class Type;
class Module;
class Function;
class SymbolTable;
class TypeSymbolTable;
class ValueSymbolTable;
class ConstantArray;
struct ModuleLevelDenseMapKeyInfo {
static inline unsigned getEmptyKey() { return ~0U; }
static inline unsigned getTombstoneKey() { return ~1U; }
static unsigned getHashValue(unsigned Val) { return Val ^ Val >> 4; }
static bool isPod() { return true; }
};
class SlotCalculator {
const Module *TheModule;
typedef std::vector<const Type*> TypeList;
typedef std::vector<const Value*> TypePlane;
std::vector<TypePlane> Table;
TypeList Types;
typedef std::map<const Value*, unsigned> NodeMapType;
NodeMapType NodeMap;
typedef std::map<const Type*, unsigned> TypeMapType;
TypeMapType TypeMap;
/// ConstantStrings - If we are indexing for a bytecode file, this keeps track
/// of all of the constants strings that need to be emitted.
std::vector<const ConstantArray*> ConstantStrings;
/// ModuleLevel - Used to keep track of which values belong to the module,
/// and which values belong to the currently incorporated function.
///
DenseMap<unsigned,unsigned,ModuleLevelDenseMapKeyInfo> ModuleLevel;
unsigned NumModuleTypes;
SlotCalculator(const SlotCalculator &); // DO NOT IMPLEMENT
void operator=(const SlotCalculator &); // DO NOT IMPLEMENT
public:
SlotCalculator(const Module *M);
/// getSlot - Return the slot number of the specified value in it's type
/// plane. This returns < 0 on error!
///
unsigned getSlot(const Value *V) const {
NodeMapType::const_iterator I = NodeMap.find(V);
assert(I != NodeMap.end() && "Value not in slotcalculator!");
return I->second;
}
unsigned getTypeSlot(const Type* T) const {
TypeMapType::const_iterator I = TypeMap.find(T);
assert(I != TypeMap.end() && "Type not in slotcalc!");
return I->second;
}
inline unsigned getNumPlanes() const { return Table.size(); }
inline unsigned getNumTypes() const { return Types.size(); }
TypePlane &getPlane(unsigned Plane) {
// Okay we are just returning an entry out of the main Table. Make sure the
// plane exists and return it.
if (Plane >= Table.size())
Table.resize(Plane+1);
return Table[Plane];
}
TypeList& getTypes() { return Types; }
/// incorporateFunction/purgeFunction - If you'd like to deal with a function,
/// use these two methods to get its data into the SlotCalculator!
///
void incorporateFunction(const Function *F);
void purgeFunction();
/// string_iterator/string_begin/end - Access the list of module-level
/// constant strings that have been incorporated. This is only applicable to
/// bytecode files.
typedef std::vector<const ConstantArray*>::const_iterator string_iterator;
string_iterator string_begin() const { return ConstantStrings.begin(); }
string_iterator string_end() const { return ConstantStrings.end(); }
private:
void CreateSlotIfNeeded(const Value *V);
void CreateFunctionValueSlot(const Value *V);
unsigned getOrCreateTypeSlot(const Type *T);
// processModule - Process all of the module level function declarations and
// types that are available.
//
void processModule();
// processSymbolTable - Insert all of the values in the specified symbol table
// into the values table...
//
void processTypeSymbolTable(const TypeSymbolTable *ST);
void processValueSymbolTable(const ValueSymbolTable *ST);
// insertPrimitives - helper for constructors to insert primitive types.
void insertPrimitives();
};
} // End llvm namespace
#endif
|
