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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
|
//===-LTOModule.h - LLVM Link Time Optimizer ------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the LTOModule class.
//
//===----------------------------------------------------------------------===//
#ifndef LTO_MODULE_H
#define LTO_MODULE_H
#include "llvm-c/lto.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCObjectFileInfo.h"
#include "llvm/Object/IRObjectFile.h"
#include "llvm/Target/TargetMachine.h"
#include <string>
#include <vector>
// Forward references to llvm classes.
namespace llvm {
class Function;
class GlobalValue;
class MemoryBuffer;
class TargetOptions;
class Value;
//===----------------------------------------------------------------------===//
/// C++ class which implements the opaque lto_module_t type.
///
struct LTOModule {
private:
typedef StringMap<uint8_t> StringSet;
struct NameAndAttributes {
const char *name;
uint32_t attributes;
bool isFunction;
const GlobalValue *symbol;
};
std::unique_ptr<object::IRObjectFile> IRFile;
std::unique_ptr<TargetMachine> _target;
StringSet _linkeropt_strings;
std::vector<const char *> _deplibs;
std::vector<const char *> _linkeropts;
std::vector<NameAndAttributes> _symbols;
// _defines and _undefines only needed to disambiguate tentative definitions
StringSet _defines;
StringMap<NameAndAttributes> _undefines;
std::vector<const char*> _asm_undefines;
LTOModule(std::unique_ptr<object::IRObjectFile> Obj, TargetMachine *TM);
public:
/// Returns 'true' if the file or memory contents is LLVM bitcode.
static bool isBitcodeFile(const void *mem, size_t length);
static bool isBitcodeFile(const char *path);
/// Returns 'true' if the memory buffer is LLVM bitcode for the specified
/// triple.
static bool isBitcodeForTarget(MemoryBuffer *memBuffer,
StringRef triplePrefix);
/// Create a MemoryBuffer from a memory range with an optional name.
static MemoryBuffer *makeBuffer(const void *mem, size_t length,
StringRef name = "");
/// Create an LTOModule. N.B. These methods take ownership of the buffer. The
/// caller must have initialized the Targets, the TargetMCs, the AsmPrinters,
/// and the AsmParsers by calling:
///
/// InitializeAllTargets();
/// InitializeAllTargetMCs();
/// InitializeAllAsmPrinters();
/// InitializeAllAsmParsers();
static LTOModule *createFromFile(const char *path, TargetOptions options,
std::string &errMsg);
static LTOModule *createFromOpenFile(int fd, const char *path, size_t size,
TargetOptions options,
std::string &errMsg);
static LTOModule *createFromOpenFileSlice(int fd, const char *path,
size_t map_size, off_t offset,
TargetOptions options,
std::string &errMsg);
static LTOModule *createFromBuffer(const void *mem, size_t length,
TargetOptions options, std::string &errMsg,
StringRef path = "");
const Module &getModule() const {
return const_cast<LTOModule*>(this)->getModule();
}
Module &getModule() {
return IRFile->getModule();
}
/// Return the Module's target triple.
const std::string &getTargetTriple() {
return getModule().getTargetTriple();
}
/// Set the Module's target triple.
void setTargetTriple(StringRef Triple) {
getModule().setTargetTriple(Triple);
}
/// Get the number of symbols
uint32_t getSymbolCount() {
return _symbols.size();
}
/// Get the attributes for a symbol at the specified index.
lto_symbol_attributes getSymbolAttributes(uint32_t index) {
if (index < _symbols.size())
return lto_symbol_attributes(_symbols[index].attributes);
return lto_symbol_attributes(0);
}
/// Get the name of the symbol at the specified index.
const char *getSymbolName(uint32_t index) {
if (index < _symbols.size())
return _symbols[index].name;
return nullptr;
}
/// Get the number of dependent libraries
uint32_t getDependentLibraryCount() {
return _deplibs.size();
}
/// Get the dependent library at the specified index.
const char *getDependentLibrary(uint32_t index) {
if (index < _deplibs.size())
return _deplibs[index];
return nullptr;
}
/// Get the number of linker options
uint32_t getLinkerOptCount() {
return _linkeropts.size();
}
/// Get the linker option at the specified index.
const char *getLinkerOpt(uint32_t index) {
if (index < _linkeropts.size())
return _linkeropts[index];
return nullptr;
}
const std::vector<const char*> &getAsmUndefinedRefs() {
return _asm_undefines;
}
private:
/// Parse metadata from the module
// FIXME: it only parses "Linker Options" metadata at the moment
void parseMetadata();
/// Parse the symbols from the module and model-level ASM and add them to
/// either the defined or undefined lists.
bool parseSymbols(std::string &errMsg);
/// Add a symbol which isn't defined just yet to a list to be resolved later.
void addPotentialUndefinedSymbol(const object::BasicSymbolRef &Sym,
bool isFunc);
/// Add a defined symbol to the list.
void addDefinedSymbol(const char *Name, const GlobalValue *def,
bool isFunction);
/// Add a data symbol as defined to the list.
void addDefinedDataSymbol(const object::BasicSymbolRef &Sym);
void addDefinedDataSymbol(const char*Name, const GlobalValue *v);
/// Add a function symbol as defined to the list.
void addDefinedFunctionSymbol(const object::BasicSymbolRef &Sym);
void addDefinedFunctionSymbol(const char *Name, const Function *F);
/// Add a global symbol from module-level ASM to the defined list.
void addAsmGlobalSymbol(const char *, lto_symbol_attributes scope);
/// Add a global symbol from module-level ASM to the undefined list.
void addAsmGlobalSymbolUndef(const char *);
/// Parse i386/ppc ObjC class data structure.
void addObjCClass(const GlobalVariable *clgv);
/// Parse i386/ppc ObjC category data structure.
void addObjCCategory(const GlobalVariable *clgv);
/// Parse i386/ppc ObjC class list data structure.
void addObjCClassRef(const GlobalVariable *clgv);
/// Get string that the data pointer points to.
bool objcClassNameFromExpression(const Constant *c, std::string &name);
/// Create an LTOModule (private version). N.B. This method takes ownership of
/// the buffer.
static LTOModule *makeLTOModule(std::unique_ptr<MemoryBuffer> Buffer,
TargetOptions options, std::string &errMsg);
};
}
#endif // LTO_MODULE_H
|
