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
|
//=- Deserialize.h - Generic Object Deserialization from Bitcode --*- C++ -*-=//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Ted Kremenek and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the interface for generic object deserialization from
// LLVM bitcode.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_BITCODE_SERIALIZE_INPUT
#define LLVM_BITCODE_SERIALIZE_INPUT
#include "llvm/Bitcode/BitstreamReader.h"
#include "llvm/Bitcode/Serialization.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Allocator.h"
#include "llvm/Support/DataTypes.h"
#include <vector>
namespace llvm {
class Deserializer {
BitstreamReader& Stream;
SmallVector<uint64_t,10> Record;
unsigned RecIdx;
BumpPtrAllocator Allocator;
struct PtrIdInfo {
static inline unsigned getEmptyKey() { return ~((unsigned) 0x0); }
static inline unsigned getTombstoneKey() { return getEmptyKey()-1; }
static inline unsigned getHashValue(unsigned X) { return X; }
static inline bool isEqual(unsigned X, unsigned Y) { return X == Y; }
static inline bool isPod() { return true; }
};
struct BPatchNode {
BPatchNode* const Next;
uintptr_t& PtrRef;
BPatchNode(BPatchNode* n, void*& pref)
: Next(n), PtrRef(reinterpret_cast<uintptr_t&>(pref)) {
PtrRef = 0;
}
};
struct BPatchEntry {
BPatchNode* Head;
void* Ptr;
BPatchEntry() : Head(NULL), Ptr(NULL) {}
static inline bool isPod() { return true; }
};
typedef llvm::DenseMap<unsigned,BPatchEntry,PtrIdInfo,BPatchEntry> MapTy;
MapTy BPatchMap;
public:
Deserializer(BitstreamReader& stream);
~Deserializer();
uint64_t ReadInt();
bool ReadBool() {
return ReadInt() ? true : false;
}
template <typename T>
inline T& Read(T& X) {
SerializeTrait<T>::Read(*this,X);
return X;
}
template <typename T>
inline T ReadVal() {
return SerializeTrait<T>::ReadVal(*this);
}
template <typename T>
inline T* Materialize() {
return SerializeTrait<T>::Materialize(*this);
}
char* ReadCStr(char* cstr = NULL, unsigned MaxLen=0, bool isNullTerm=true);
void ReadCStr(std::vector<char>& buff, bool isNullTerm=false);
template <typename T>
inline T* ReadOwnedPtr() {
unsigned PtrId = ReadInt();
if (PtrId == 0)
return NULL;
T* x = SerializeTrait<T>::Materialize(*this);
RegisterPtr(PtrId,x);
return x;
}
void ReadPtr(void*& PtrRef);
void ReadPtr(uintptr_t& PtrRef) { ReadPtr(reinterpret_cast<void*&>(PtrRef)); }
void RegisterPtr(unsigned PtrId, void* Ptr);
void BackpatchPointers();
private:
void ReadRecord();
bool inRecord();
};
} // end namespace llvm
#endif
|
