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
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
|
//===-lto.cpp - 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 implements the Link Time Optimization library. This library is
// intended to be used by linker to optimize code at link time.
//
//===----------------------------------------------------------------------===//
#include "llvm-c/lto.h"
#include "llvm-c/Core.h"
#include "LTOModule.h"
#include "LTOCodeGenerator.h"
// holds most recent error string
// *** not thread safe ***
static std::string sLastErrorString;
//
// returns a printable string
//
extern const char* lto_get_version()
{
return LTOCodeGenerator::getVersionString();
}
//
// returns the last error string or NULL if last operation was successful
//
const char* lto_get_error_message()
{
return sLastErrorString.c_str();
}
//
// validates if a file is a loadable object file
//
bool lto_module_is_object_file(const char* path)
{
return LTOModule::isBitcodeFile(path);
}
//
// validates if a file is a loadable object file compilable for requested target
//
bool lto_module_is_object_file_for_target(const char* path,
const char* target_triplet_prefix)
{
return LTOModule::isBitcodeFileForTarget(path, target_triplet_prefix);
}
//
// validates if a buffer is a loadable object file
//
bool lto_module_is_object_file_in_memory(const void* mem, size_t length)
{
return LTOModule::isBitcodeFile(mem, length);
}
//
// validates if a buffer is a loadable object file compilable for the target
//
bool lto_module_is_object_file_in_memory_for_target(const void* mem,
size_t length, const char* target_triplet_prefix)
{
return LTOModule::isBitcodeFileForTarget(mem, length, target_triplet_prefix);
}
//
// loads an object file from disk
// returns NULL on error (check lto_get_error_message() for details)
//
lto_module_t lto_module_create(const char* path, LLVMContextRef Ctxt)
{
return LTOModule::makeLTOModule(path, llvm::unwrap(Ctxt),
sLastErrorString);
}
//
// loads an object file from memory
// returns NULL on error (check lto_get_error_message() for details)
//
lto_module_t lto_module_create_from_memory(const void* mem, size_t length,
LLVMContextRef Ctxt)
{
return LTOModule::makeLTOModule(mem, length, llvm::unwrap(Ctxt),
sLastErrorString);
}
//
// frees all memory for a module
// upon return the lto_module_t is no longer valid
//
void lto_module_dispose(lto_module_t mod)
{
delete mod;
}
//
// returns triplet string which the object module was compiled under
//
const char* lto_module_get_target_triple(lto_module_t mod)
{
return mod->getTargetTriple();
}
//
// returns the number of symbols in the object module
//
uint32_t lto_module_get_num_symbols(lto_module_t mod)
{
return mod->getSymbolCount();
}
//
// returns the name of the ith symbol in the object module
//
const char* lto_module_get_symbol_name(lto_module_t mod, uint32_t index)
{
return mod->getSymbolName(index);
}
//
// returns the attributes of the ith symbol in the object module
//
lto_symbol_attributes lto_module_get_symbol_attribute(lto_module_t mod,
uint32_t index)
{
return mod->getSymbolAttributes(index);
}
//
// instantiates a code generator
// returns NULL if there is an error
//
lto_code_gen_t lto_codegen_create()
{
return new LTOCodeGenerator();
}
//
// frees all memory for a code generator
// upon return the lto_code_gen_t is no longer valid
//
void lto_codegen_dispose(lto_code_gen_t cg)
{
delete cg;
}
//
// add an object module to the set of modules for which code will be generated
// returns true on error (check lto_get_error_message() for details)
//
bool lto_codegen_add_module(lto_code_gen_t cg, lto_module_t mod)
{
return cg->addModule(mod, sLastErrorString);
}
//
// sets what if any format of debug info should be generated
// returns true on error (check lto_get_error_message() for details)
//
bool lto_codegen_set_debug_model(lto_code_gen_t cg, lto_debug_model debug)
{
return cg->setDebugInfo(debug, sLastErrorString);
}
//
// sets what code model to generated
// returns true on error (check lto_get_error_message() for details)
//
bool lto_codegen_set_pic_model(lto_code_gen_t cg, lto_codegen_model model)
{
return cg->setCodePICModel(model, sLastErrorString);
}
//
// sets the path to gcc
//
void lto_codegen_set_gcc_path(lto_code_gen_t cg, const char* path)
{
cg->setGccPath(path);
}
//
// sets the path to the assembler tool
//
void lto_codegen_set_assembler_path(lto_code_gen_t cg, const char* path)
{
cg->setAssemblerPath(path);
}
//
// adds to a list of all global symbols that must exist in the final
// generated code. If a function is not listed there, it might be
// inlined into every usage and optimized away.
//
void lto_codegen_add_must_preserve_symbol(lto_code_gen_t cg, const char* symbol)
{
cg->addMustPreserveSymbol(symbol);
}
//
// writes a new file at the specified path that contains the
// merged contents of all modules added so far.
// returns true on error (check lto_get_error_message() for details)
//
bool lto_codegen_write_merged_modules(lto_code_gen_t cg, const char* path)
{
return cg->writeMergedModules(path, sLastErrorString);
}
//
// Generates code for all added modules into one native object file.
// On sucess returns a pointer to a generated mach-o/ELF buffer and
// length set to the buffer size. The buffer is owned by the
// lto_code_gen_t and will be freed when lto_codegen_dispose()
// is called, or lto_codegen_compile() is called again.
// On failure, returns NULL (check lto_get_error_message() for details).
//
extern const void*
lto_codegen_compile(lto_code_gen_t cg, size_t* length)
{
return cg->compile(length, sLastErrorString);
}
//
// Used to pass extra options to the code generator
//
extern void
lto_codegen_debug_options(lto_code_gen_t cg, const char * opt)
{
cg->setCodeGenDebugOptions(opt);
}
|