File: | tools/gold/gold-plugin.cpp |
Location: | line 712, column 37 |
Description: | Called C++ object pointer is null |
1 | //===-- gold-plugin.cpp - Plugin to gold for Link Time Optimization ------===// | |||
2 | // | |||
3 | // The LLVM Compiler Infrastructure | |||
4 | // | |||
5 | // This file is distributed under the University of Illinois Open Source | |||
6 | // License. See LICENSE.TXT for details. | |||
7 | // | |||
8 | //===----------------------------------------------------------------------===// | |||
9 | // | |||
10 | // This is a gold plugin for LLVM. It provides an LLVM implementation of the | |||
11 | // interface described in http://gcc.gnu.org/wiki/whopr/driver . | |||
12 | // | |||
13 | //===----------------------------------------------------------------------===// | |||
14 | ||||
15 | #include "llvm/Config/config.h" // plugin-api.h requires HAVE_STDINT_H | |||
16 | #include "llvm/ADT/DenseSet.h" | |||
17 | #include "llvm/ADT/StringSet.h" | |||
18 | #include "llvm/Bitcode/ReaderWriter.h" | |||
19 | #include "llvm/CodeGen/Analysis.h" | |||
20 | #include "llvm/CodeGen/CommandFlags.h" | |||
21 | #include "llvm/IR/Constants.h" | |||
22 | #include "llvm/IR/LLVMContext.h" | |||
23 | #include "llvm/IR/Module.h" | |||
24 | #include "llvm/IR/Verifier.h" | |||
25 | #include "llvm/Linker/Linker.h" | |||
26 | #include "llvm/MC/SubtargetFeature.h" | |||
27 | #include "llvm/Object/IRObjectFile.h" | |||
28 | #include "llvm/PassManager.h" | |||
29 | #include "llvm/Support/FormattedStream.h" | |||
30 | #include "llvm/Support/Host.h" | |||
31 | #include "llvm/Support/MemoryBuffer.h" | |||
32 | #include "llvm/Support/TargetRegistry.h" | |||
33 | #include "llvm/Support/TargetSelect.h" | |||
34 | #include "llvm/Target/TargetLibraryInfo.h" | |||
35 | #include "llvm/Transforms/IPO.h" | |||
36 | #include "llvm/Transforms/IPO/PassManagerBuilder.h" | |||
37 | #include "llvm/Transforms/Utils/GlobalStatus.h" | |||
38 | #include "llvm/Transforms/Utils/ModuleUtils.h" | |||
39 | #include "llvm/Transforms/Utils/ValueMapper.h" | |||
40 | #include <list> | |||
41 | #include <plugin-api.h> | |||
42 | #include <system_error> | |||
43 | #include <vector> | |||
44 | ||||
45 | #ifndef LDPO_PIE3 | |||
46 | // FIXME: remove this declaration when we stop maintaining Ubuntu Quantal and | |||
47 | // Precise and Debian Wheezy (binutils 2.23 is required) | |||
48 | # define LDPO_PIE3 3 | |||
49 | #endif | |||
50 | ||||
51 | using namespace llvm; | |||
52 | ||||
53 | namespace { | |||
54 | struct claimed_file { | |||
55 | void *handle; | |||
56 | std::vector<ld_plugin_symbol> syms; | |||
57 | }; | |||
58 | } | |||
59 | ||||
60 | static ld_plugin_status discard_message(int level, const char *format, ...) { | |||
61 | // Die loudly. Recent versions of Gold pass ld_plugin_message as the first | |||
62 | // callback in the transfer vector. This should never be called. | |||
63 | abort(); | |||
64 | } | |||
65 | ||||
66 | static ld_plugin_get_input_file get_input_file = nullptr; | |||
67 | static ld_plugin_release_input_file release_input_file = nullptr; | |||
68 | static ld_plugin_add_symbols add_symbols = nullptr; | |||
69 | static ld_plugin_get_symbols get_symbols = nullptr; | |||
70 | static ld_plugin_add_input_file add_input_file = nullptr; | |||
71 | static ld_plugin_set_extra_library_path set_extra_library_path = nullptr; | |||
72 | static ld_plugin_get_view get_view = nullptr; | |||
73 | static ld_plugin_message message = discard_message; | |||
74 | static Reloc::Model RelocationModel = Reloc::Default; | |||
75 | static std::string output_name = ""; | |||
76 | static std::list<claimed_file> Modules; | |||
77 | static std::vector<std::string> Cleanup; | |||
78 | static llvm::TargetOptions TargetOpts; | |||
79 | ||||
80 | namespace options { | |||
81 | enum generate_bc { BC_NO, BC_ALSO, BC_ONLY }; | |||
82 | static bool generate_api_file = false; | |||
83 | static generate_bc generate_bc_file = BC_NO; | |||
84 | static std::string bc_path; | |||
85 | static std::string obj_path; | |||
86 | static std::string extra_library_path; | |||
87 | static std::string triple; | |||
88 | static std::string mcpu; | |||
89 | // Additional options to pass into the code generator. | |||
90 | // Note: This array will contain all plugin options which are not claimed | |||
91 | // as plugin exclusive to pass to the code generator. | |||
92 | // For example, "generate-api-file" and "as"options are for the plugin | |||
93 | // use only and will not be passed. | |||
94 | static std::vector<const char *> extra; | |||
95 | ||||
96 | static void process_plugin_option(const char* opt_) | |||
97 | { | |||
98 | if (opt_ == nullptr) | |||
99 | return; | |||
100 | llvm::StringRef opt = opt_; | |||
101 | ||||
102 | if (opt == "generate-api-file") { | |||
103 | generate_api_file = true; | |||
104 | } else if (opt.startswith("mcpu=")) { | |||
105 | mcpu = opt.substr(strlen("mcpu=")); | |||
106 | } else if (opt.startswith("extra-library-path=")) { | |||
107 | extra_library_path = opt.substr(strlen("extra_library_path=")); | |||
108 | } else if (opt.startswith("mtriple=")) { | |||
109 | triple = opt.substr(strlen("mtriple=")); | |||
110 | } else if (opt.startswith("obj-path=")) { | |||
111 | obj_path = opt.substr(strlen("obj-path=")); | |||
112 | } else if (opt == "emit-llvm") { | |||
113 | generate_bc_file = BC_ONLY; | |||
114 | } else if (opt == "also-emit-llvm") { | |||
115 | generate_bc_file = BC_ALSO; | |||
116 | } else if (opt.startswith("also-emit-llvm=")) { | |||
117 | llvm::StringRef path = opt.substr(strlen("also-emit-llvm=")); | |||
118 | generate_bc_file = BC_ALSO; | |||
119 | if (!bc_path.empty()) { | |||
120 | message(LDPL_WARNING, "Path to the output IL file specified twice. " | |||
121 | "Discarding %s", | |||
122 | opt_); | |||
123 | } else { | |||
124 | bc_path = path; | |||
125 | } | |||
126 | } else { | |||
127 | // Save this option to pass to the code generator. | |||
128 | // ParseCommandLineOptions() expects argv[0] to be program name. Lazily | |||
129 | // add that. | |||
130 | if (extra.empty()) | |||
131 | extra.push_back("LLVMgold"); | |||
132 | ||||
133 | extra.push_back(opt_); | |||
134 | } | |||
135 | } | |||
136 | } | |||
137 | ||||
138 | static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, | |||
139 | int *claimed); | |||
140 | static ld_plugin_status all_symbols_read_hook(void); | |||
141 | static ld_plugin_status cleanup_hook(void); | |||
142 | ||||
143 | extern "C" ld_plugin_status onload(ld_plugin_tv *tv); | |||
144 | ld_plugin_status onload(ld_plugin_tv *tv) { | |||
145 | InitializeAllTargetInfos(); | |||
146 | InitializeAllTargets(); | |||
147 | InitializeAllTargetMCs(); | |||
148 | InitializeAllAsmParsers(); | |||
149 | InitializeAllAsmPrinters(); | |||
150 | ||||
151 | // We're given a pointer to the first transfer vector. We read through them | |||
152 | // until we find one where tv_tag == LDPT_NULL. The REGISTER_* tagged values | |||
153 | // contain pointers to functions that we need to call to register our own | |||
154 | // hooks. The others are addresses of functions we can use to call into gold | |||
155 | // for services. | |||
156 | ||||
157 | bool registeredClaimFile = false; | |||
158 | bool RegisteredAllSymbolsRead = false; | |||
159 | ||||
160 | for (; tv->tv_tag != LDPT_NULL; ++tv) { | |||
161 | switch (tv->tv_tag) { | |||
162 | case LDPT_OUTPUT_NAME: | |||
163 | output_name = tv->tv_u.tv_string; | |||
164 | break; | |||
165 | case LDPT_LINKER_OUTPUT: | |||
166 | switch (tv->tv_u.tv_val) { | |||
167 | case LDPO_REL: // .o | |||
168 | case LDPO_DYN: // .so | |||
169 | case LDPO_PIE3: // position independent executable | |||
170 | RelocationModel = Reloc::PIC_; | |||
171 | break; | |||
172 | case LDPO_EXEC: // .exe | |||
173 | RelocationModel = Reloc::Static; | |||
174 | break; | |||
175 | default: | |||
176 | message(LDPL_ERROR, "Unknown output file type %d", tv->tv_u.tv_val); | |||
177 | return LDPS_ERR; | |||
178 | } | |||
179 | break; | |||
180 | case LDPT_OPTION: | |||
181 | options::process_plugin_option(tv->tv_u.tv_string); | |||
182 | break; | |||
183 | case LDPT_REGISTER_CLAIM_FILE_HOOK: { | |||
184 | ld_plugin_register_claim_file callback; | |||
185 | callback = tv->tv_u.tv_register_claim_file; | |||
186 | ||||
187 | if (callback(claim_file_hook) != LDPS_OK) | |||
188 | return LDPS_ERR; | |||
189 | ||||
190 | registeredClaimFile = true; | |||
191 | } break; | |||
192 | case LDPT_REGISTER_ALL_SYMBOLS_READ_HOOK: { | |||
193 | ld_plugin_register_all_symbols_read callback; | |||
194 | callback = tv->tv_u.tv_register_all_symbols_read; | |||
195 | ||||
196 | if (callback(all_symbols_read_hook) != LDPS_OK) | |||
197 | return LDPS_ERR; | |||
198 | ||||
199 | RegisteredAllSymbolsRead = true; | |||
200 | } break; | |||
201 | case LDPT_REGISTER_CLEANUP_HOOK: { | |||
202 | ld_plugin_register_cleanup callback; | |||
203 | callback = tv->tv_u.tv_register_cleanup; | |||
204 | ||||
205 | if (callback(cleanup_hook) != LDPS_OK) | |||
206 | return LDPS_ERR; | |||
207 | } break; | |||
208 | case LDPT_GET_INPUT_FILE: | |||
209 | get_input_file = tv->tv_u.tv_get_input_file; | |||
210 | break; | |||
211 | case LDPT_RELEASE_INPUT_FILE: | |||
212 | release_input_file = tv->tv_u.tv_release_input_file; | |||
213 | break; | |||
214 | case LDPT_ADD_SYMBOLS: | |||
215 | add_symbols = tv->tv_u.tv_add_symbols; | |||
216 | break; | |||
217 | case LDPT_GET_SYMBOLS_V2: | |||
218 | get_symbols = tv->tv_u.tv_get_symbols; | |||
219 | break; | |||
220 | case LDPT_ADD_INPUT_FILE: | |||
221 | add_input_file = tv->tv_u.tv_add_input_file; | |||
222 | break; | |||
223 | case LDPT_SET_EXTRA_LIBRARY_PATH: | |||
224 | set_extra_library_path = tv->tv_u.tv_set_extra_library_path; | |||
225 | break; | |||
226 | case LDPT_GET_VIEW: | |||
227 | get_view = tv->tv_u.tv_get_view; | |||
228 | break; | |||
229 | case LDPT_MESSAGE: | |||
230 | message = tv->tv_u.tv_message; | |||
231 | break; | |||
232 | default: | |||
233 | break; | |||
234 | } | |||
235 | } | |||
236 | ||||
237 | if (!registeredClaimFile) { | |||
238 | message(LDPL_ERROR, "register_claim_file not passed to LLVMgold."); | |||
239 | return LDPS_ERR; | |||
240 | } | |||
241 | if (!add_symbols) { | |||
242 | message(LDPL_ERROR, "add_symbols not passed to LLVMgold."); | |||
243 | return LDPS_ERR; | |||
244 | } | |||
245 | ||||
246 | if (!RegisteredAllSymbolsRead) | |||
247 | return LDPS_OK; | |||
248 | ||||
249 | if (!get_input_file) { | |||
250 | message(LDPL_ERROR, "get_input_file not passed to LLVMgold."); | |||
251 | return LDPS_ERR; | |||
252 | } | |||
253 | if (!release_input_file) { | |||
254 | message(LDPL_ERROR, "relesase_input_file not passed to LLVMgold."); | |||
255 | return LDPS_ERR; | |||
256 | } | |||
257 | ||||
258 | return LDPS_OK; | |||
259 | } | |||
260 | ||||
261 | static const GlobalObject *getBaseObject(const GlobalValue &GV) { | |||
262 | if (auto *GA = dyn_cast<GlobalAlias>(&GV)) | |||
263 | return GA->getBaseObject(); | |||
264 | return cast<GlobalObject>(&GV); | |||
265 | } | |||
266 | ||||
267 | /// Called by gold to see whether this file is one that our plugin can handle. | |||
268 | /// We'll try to open it and register all the symbols with add_symbol if | |||
269 | /// possible. | |||
270 | static ld_plugin_status claim_file_hook(const ld_plugin_input_file *file, | |||
271 | int *claimed) { | |||
272 | LLVMContext Context; | |||
273 | MemoryBufferRef BufferRef; | |||
274 | std::unique_ptr<MemoryBuffer> Buffer; | |||
275 | if (get_view) { | |||
276 | const void *view; | |||
277 | if (get_view(file->handle, &view) != LDPS_OK) { | |||
278 | message(LDPL_ERROR, "Failed to get a view of %s", file->name); | |||
279 | return LDPS_ERR; | |||
280 | } | |||
281 | BufferRef = MemoryBufferRef(StringRef((const char *)view, file->filesize), ""); | |||
282 | } else { | |||
283 | int64_t offset = 0; | |||
284 | // Gold has found what might be IR part-way inside of a file, such as | |||
285 | // an .a archive. | |||
286 | if (file->offset) { | |||
287 | offset = file->offset; | |||
288 | } | |||
289 | ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = | |||
290 | MemoryBuffer::getOpenFileSlice(file->fd, file->name, file->filesize, | |||
291 | offset); | |||
292 | if (std::error_code EC = BufferOrErr.getError()) { | |||
293 | message(LDPL_ERROR, EC.message().c_str()); | |||
294 | return LDPS_ERR; | |||
295 | } | |||
296 | Buffer = std::move(BufferOrErr.get()); | |||
297 | BufferRef = Buffer->getMemBufferRef(); | |||
298 | } | |||
299 | ||||
300 | ErrorOr<std::unique_ptr<object::IRObjectFile>> ObjOrErr = | |||
301 | object::IRObjectFile::createIRObjectFile(BufferRef, Context); | |||
302 | std::error_code EC = ObjOrErr.getError(); | |||
303 | if (EC == BitcodeError::InvalidBitcodeSignature || | |||
304 | EC == object::object_error::invalid_file_type || | |||
305 | EC == object::object_error::bitcode_section_not_found) | |||
306 | return LDPS_OK; | |||
307 | ||||
308 | *claimed = 1; | |||
309 | ||||
310 | if (EC) { | |||
311 | message(LDPL_ERROR, "LLVM gold plugin has failed to create LTO module: %s", | |||
312 | EC.message().c_str()); | |||
313 | return LDPS_ERR; | |||
314 | } | |||
315 | std::unique_ptr<object::IRObjectFile> Obj = std::move(*ObjOrErr); | |||
316 | ||||
317 | Modules.resize(Modules.size() + 1); | |||
318 | claimed_file &cf = Modules.back(); | |||
319 | ||||
320 | cf.handle = file->handle; | |||
321 | ||||
322 | for (auto &Sym : Obj->symbols()) { | |||
323 | uint32_t Symflags = Sym.getFlags(); | |||
324 | if (!(Symflags & object::BasicSymbolRef::SF_Global)) | |||
325 | continue; | |||
326 | ||||
327 | if (Symflags & object::BasicSymbolRef::SF_FormatSpecific) | |||
328 | continue; | |||
329 | ||||
330 | cf.syms.push_back(ld_plugin_symbol()); | |||
331 | ld_plugin_symbol &sym = cf.syms.back(); | |||
332 | sym.version = nullptr; | |||
333 | ||||
334 | SmallString<64> Name; | |||
335 | { | |||
336 | raw_svector_ostream OS(Name); | |||
337 | Sym.printName(OS); | |||
338 | } | |||
339 | sym.name = strdup(Name.c_str()); | |||
340 | ||||
341 | const GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl()); | |||
342 | ||||
343 | sym.visibility = LDPV_DEFAULT; | |||
344 | if (GV) { | |||
345 | switch (GV->getVisibility()) { | |||
346 | case GlobalValue::DefaultVisibility: | |||
347 | sym.visibility = LDPV_DEFAULT; | |||
348 | break; | |||
349 | case GlobalValue::HiddenVisibility: | |||
350 | sym.visibility = LDPV_HIDDEN; | |||
351 | break; | |||
352 | case GlobalValue::ProtectedVisibility: | |||
353 | sym.visibility = LDPV_PROTECTED; | |||
354 | break; | |||
355 | } | |||
356 | } | |||
357 | ||||
358 | if (Symflags & object::BasicSymbolRef::SF_Undefined) { | |||
359 | sym.def = LDPK_UNDEF; | |||
360 | if (GV && GV->hasExternalWeakLinkage()) | |||
361 | sym.def = LDPK_WEAKUNDEF; | |||
362 | } else { | |||
363 | sym.def = LDPK_DEF; | |||
364 | if (GV) { | |||
365 | assert(!GV->hasExternalWeakLinkage() &&((!GV->hasExternalWeakLinkage() && !GV->hasAvailableExternallyLinkage () && "Not a declaration!") ? static_cast<void> (0) : __assert_fail ("!GV->hasExternalWeakLinkage() && !GV->hasAvailableExternallyLinkage() && \"Not a declaration!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 366, __PRETTY_FUNCTION__)) | |||
366 | !GV->hasAvailableExternallyLinkage() && "Not a declaration!")((!GV->hasExternalWeakLinkage() && !GV->hasAvailableExternallyLinkage () && "Not a declaration!") ? static_cast<void> (0) : __assert_fail ("!GV->hasExternalWeakLinkage() && !GV->hasAvailableExternallyLinkage() && \"Not a declaration!\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 366, __PRETTY_FUNCTION__)); | |||
367 | if (GV->hasCommonLinkage()) | |||
368 | sym.def = LDPK_COMMON; | |||
369 | else if (GV->isWeakForLinker()) | |||
370 | sym.def = LDPK_WEAKDEF; | |||
371 | } | |||
372 | } | |||
373 | ||||
374 | sym.size = 0; | |||
375 | sym.comdat_key = nullptr; | |||
376 | if (GV) { | |||
377 | const GlobalObject *Base = getBaseObject(*GV); | |||
378 | if (!Base) | |||
379 | message(LDPL_FATAL, "Unable to determine comdat of alias!"); | |||
380 | const Comdat *C = Base->getComdat(); | |||
381 | if (C) | |||
382 | sym.comdat_key = strdup(C->getName().str().c_str()); | |||
383 | else if (Base->hasWeakLinkage() || Base->hasLinkOnceLinkage()) | |||
384 | sym.comdat_key = strdup(sym.name); | |||
385 | } | |||
386 | ||||
387 | sym.resolution = LDPR_UNKNOWN; | |||
388 | } | |||
389 | ||||
390 | if (!cf.syms.empty()) { | |||
391 | if (add_symbols(cf.handle, cf.syms.size(), &cf.syms[0]) != LDPS_OK) { | |||
392 | message(LDPL_ERROR, "Unable to add symbols!"); | |||
393 | return LDPS_ERR; | |||
394 | } | |||
395 | } | |||
396 | ||||
397 | return LDPS_OK; | |||
398 | } | |||
399 | ||||
400 | static void keepGlobalValue(GlobalValue &GV, | |||
401 | std::vector<GlobalAlias *> &KeptAliases) { | |||
402 | assert(!GV.hasLocalLinkage())((!GV.hasLocalLinkage()) ? static_cast<void> (0) : __assert_fail ("!GV.hasLocalLinkage()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 402, __PRETTY_FUNCTION__)); | |||
403 | ||||
404 | if (auto *GA = dyn_cast<GlobalAlias>(&GV)) | |||
405 | KeptAliases.push_back(GA); | |||
406 | ||||
407 | switch (GV.getLinkage()) { | |||
408 | default: | |||
409 | break; | |||
410 | case GlobalValue::LinkOnceAnyLinkage: | |||
411 | GV.setLinkage(GlobalValue::WeakAnyLinkage); | |||
412 | break; | |||
413 | case GlobalValue::LinkOnceODRLinkage: | |||
414 | GV.setLinkage(GlobalValue::WeakODRLinkage); | |||
415 | break; | |||
416 | } | |||
417 | ||||
418 | assert(!GV.isDiscardableIfUnused())((!GV.isDiscardableIfUnused()) ? static_cast<void> (0) : __assert_fail ("!GV.isDiscardableIfUnused()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 418, __PRETTY_FUNCTION__)); | |||
419 | } | |||
420 | ||||
421 | static void internalize(GlobalValue &GV) { | |||
422 | if (GV.isDeclarationForLinker()) | |||
423 | return; // We get here if there is a matching asm definition. | |||
424 | if (!GV.hasLocalLinkage()) | |||
425 | GV.setLinkage(GlobalValue::InternalLinkage); | |||
426 | } | |||
427 | ||||
428 | static void drop(GlobalValue &GV) { | |||
429 | if (auto *F = dyn_cast<Function>(&GV)) { | |||
430 | F->deleteBody(); | |||
431 | F->setComdat(nullptr); // Should deleteBody do this? | |||
432 | return; | |||
433 | } | |||
434 | ||||
435 | if (auto *Var = dyn_cast<GlobalVariable>(&GV)) { | |||
436 | Var->setInitializer(nullptr); | |||
437 | Var->setLinkage( | |||
438 | GlobalValue::ExternalLinkage); // Should setInitializer do this? | |||
439 | Var->setComdat(nullptr); // and this? | |||
440 | return; | |||
441 | } | |||
442 | ||||
443 | auto &Alias = cast<GlobalAlias>(GV); | |||
444 | Module &M = *Alias.getParent(); | |||
445 | PointerType &Ty = *cast<PointerType>(Alias.getType()); | |||
446 | GlobalValue::LinkageTypes L = Alias.getLinkage(); | |||
447 | auto *Var = | |||
448 | new GlobalVariable(M, Ty.getElementType(), /*isConstant*/ false, L, | |||
449 | /*Initializer*/ nullptr); | |||
450 | Var->takeName(&Alias); | |||
451 | Alias.replaceAllUsesWith(Var); | |||
452 | Alias.eraseFromParent(); | |||
453 | } | |||
454 | ||||
455 | static const char *getResolutionName(ld_plugin_symbol_resolution R) { | |||
456 | switch (R) { | |||
457 | case LDPR_UNKNOWN: | |||
458 | return "UNKNOWN"; | |||
459 | case LDPR_UNDEF: | |||
460 | return "UNDEF"; | |||
461 | case LDPR_PREVAILING_DEF: | |||
462 | return "PREVAILING_DEF"; | |||
463 | case LDPR_PREVAILING_DEF_IRONLY: | |||
464 | return "PREVAILING_DEF_IRONLY"; | |||
465 | case LDPR_PREEMPTED_REG: | |||
466 | return "PREEMPTED_REG"; | |||
467 | case LDPR_PREEMPTED_IR: | |||
468 | return "PREEMPTED_IR"; | |||
469 | case LDPR_RESOLVED_IR: | |||
470 | return "RESOLVED_IR"; | |||
471 | case LDPR_RESOLVED_EXEC: | |||
472 | return "RESOLVED_EXEC"; | |||
473 | case LDPR_RESOLVED_DYN: | |||
474 | return "RESOLVED_DYN"; | |||
475 | case LDPR_PREVAILING_DEF_IRONLY_EXP: | |||
476 | return "PREVAILING_DEF_IRONLY_EXP"; | |||
477 | } | |||
478 | llvm_unreachable("Unknown resolution")::llvm::llvm_unreachable_internal("Unknown resolution", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 478); | |||
479 | } | |||
480 | ||||
481 | static GlobalObject *makeInternalReplacement(GlobalObject *GO) { | |||
482 | Module *M = GO->getParent(); | |||
483 | GlobalObject *Ret; | |||
484 | if (auto *F = dyn_cast<Function>(GO)) { | |||
485 | if (F->isMaterializable()) { | |||
486 | if (F->materialize()) | |||
487 | message(LDPL_FATAL, "LLVM gold plugin has failed to read a function"); | |||
488 | ||||
489 | } | |||
490 | ||||
491 | auto *NewF = Function::Create(F->getFunctionType(), F->getLinkage(), | |||
492 | F->getName(), M); | |||
493 | ||||
494 | ValueToValueMapTy VM; | |||
495 | Function::arg_iterator NewI = NewF->arg_begin(); | |||
496 | for (auto &Arg : F->args()) { | |||
497 | NewI->setName(Arg.getName()); | |||
498 | VM[&Arg] = NewI; | |||
499 | ++NewI; | |||
500 | } | |||
501 | ||||
502 | NewF->getBasicBlockList().splice(NewF->end(), F->getBasicBlockList()); | |||
503 | for (auto &BB : *NewF) { | |||
504 | for (auto &Inst : BB) | |||
505 | RemapInstruction(&Inst, VM, RF_IgnoreMissingEntries); | |||
506 | } | |||
507 | ||||
508 | Ret = NewF; | |||
509 | F->deleteBody(); | |||
510 | } else { | |||
511 | auto *Var = cast<GlobalVariable>(GO); | |||
512 | Ret = new GlobalVariable( | |||
513 | *M, Var->getType()->getElementType(), Var->isConstant(), | |||
514 | Var->getLinkage(), Var->getInitializer(), Var->getName(), | |||
515 | nullptr, Var->getThreadLocalMode(), Var->getType()->getAddressSpace(), | |||
516 | Var->isExternallyInitialized()); | |||
517 | Var->setInitializer(nullptr); | |||
518 | } | |||
519 | Ret->copyAttributesFrom(GO); | |||
520 | Ret->setLinkage(GlobalValue::InternalLinkage); | |||
521 | Ret->setComdat(GO->getComdat()); | |||
522 | ||||
523 | return Ret; | |||
524 | } | |||
525 | ||||
526 | namespace { | |||
527 | class LocalValueMaterializer : public ValueMaterializer { | |||
528 | DenseSet<GlobalValue *> &Dropped; | |||
529 | ||||
530 | public: | |||
531 | LocalValueMaterializer(DenseSet<GlobalValue *> &Dropped) : Dropped(Dropped) {} | |||
532 | Value *materializeValueFor(Value *V) override; | |||
533 | }; | |||
534 | } | |||
535 | ||||
536 | Value *LocalValueMaterializer::materializeValueFor(Value *V) { | |||
537 | auto *GV = dyn_cast<GlobalValue>(V); | |||
538 | if (!GV) | |||
539 | return nullptr; | |||
540 | if (!Dropped.count(GV)) | |||
541 | return nullptr; | |||
542 | assert(!isa<GlobalAlias>(GV) && "Found alias point to weak alias.")((!isa<GlobalAlias>(GV) && "Found alias point to weak alias." ) ? static_cast<void> (0) : __assert_fail ("!isa<GlobalAlias>(GV) && \"Found alias point to weak alias.\"" , "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 542, __PRETTY_FUNCTION__)); | |||
543 | return makeInternalReplacement(cast<GlobalObject>(GV)); | |||
544 | } | |||
545 | ||||
546 | static Constant *mapConstantToLocalCopy(Constant *C, ValueToValueMapTy &VM, | |||
547 | LocalValueMaterializer *Materializer) { | |||
548 | return MapValue(C, VM, RF_IgnoreMissingEntries, nullptr, Materializer); | |||
549 | } | |||
550 | ||||
551 | static std::unique_ptr<Module> | |||
552 | getModuleForFile(LLVMContext &Context, claimed_file &F, raw_fd_ostream *ApiFile, | |||
553 | StringSet<> &Internalize, StringSet<> &Maybe) { | |||
554 | ld_plugin_input_file File; | |||
555 | if (get_input_file(F.handle, &File) != LDPS_OK) | |||
556 | message(LDPL_FATAL, "Failed to get file information"); | |||
557 | ||||
558 | if (get_symbols(F.handle, F.syms.size(), &F.syms[0]) != LDPS_OK) | |||
559 | message(LDPL_FATAL, "Failed to get symbol information"); | |||
560 | ||||
561 | const void *View; | |||
562 | if (get_view(F.handle, &View) != LDPS_OK) | |||
563 | message(LDPL_FATAL, "Failed to get a view of file"); | |||
564 | ||||
565 | llvm::ErrorOr<MemoryBufferRef> MBOrErr = | |||
566 | object::IRObjectFile::findBitcodeInMemBuffer( | |||
567 | MemoryBufferRef(StringRef((const char *)View, File.filesize), "")); | |||
568 | if (std::error_code EC = MBOrErr.getError()) | |||
569 | message(LDPL_FATAL, "Could not read bitcode from file : %s", | |||
570 | EC.message().c_str()); | |||
571 | ||||
572 | std::unique_ptr<MemoryBuffer> Buffer = | |||
573 | MemoryBuffer::getMemBuffer(MBOrErr->getBuffer(), "", false); | |||
574 | ||||
575 | if (release_input_file(F.handle) != LDPS_OK) | |||
576 | message(LDPL_FATAL, "Failed to release file information"); | |||
577 | ||||
578 | ErrorOr<Module *> MOrErr = getLazyBitcodeModule(std::move(Buffer), Context); | |||
579 | ||||
580 | if (std::error_code EC = MOrErr.getError()) | |||
581 | message(LDPL_FATAL, "Could not read bitcode from file : %s", | |||
582 | EC.message().c_str()); | |||
583 | ||||
584 | std::unique_ptr<Module> M(MOrErr.get()); | |||
585 | ||||
586 | SmallPtrSet<GlobalValue *, 8> Used; | |||
587 | collectUsedGlobalVariables(*M, Used, /*CompilerUsed*/ false); | |||
588 | ||||
589 | DenseSet<GlobalValue *> Drop; | |||
590 | std::vector<GlobalAlias *> KeptAliases; | |||
591 | for (ld_plugin_symbol &Sym : F.syms) { | |||
592 | ld_plugin_symbol_resolution Resolution = | |||
593 | (ld_plugin_symbol_resolution)Sym.resolution; | |||
594 | ||||
595 | if (options::generate_api_file) | |||
596 | *ApiFile << Sym.name << ' ' << getResolutionName(Resolution) << '\n'; | |||
597 | ||||
598 | GlobalValue *GV = M->getNamedValue(Sym.name); | |||
599 | if (!GV) | |||
600 | continue; // Asm symbol. | |||
601 | ||||
602 | if (Resolution != LDPR_PREVAILING_DEF_IRONLY && GV->hasCommonLinkage()) { | |||
603 | // Common linkage is special. There is no single symbol that wins the | |||
604 | // resolution. Instead we have to collect the maximum alignment and size. | |||
605 | // The IR linker does that for us if we just pass it every common GV. | |||
606 | // We still have to keep track of LDPR_PREVAILING_DEF_IRONLY so we | |||
607 | // internalize once the IR linker has done its job. | |||
608 | continue; | |||
609 | } | |||
610 | ||||
611 | switch (Resolution) { | |||
612 | case LDPR_UNKNOWN: | |||
613 | llvm_unreachable("Unexpected resolution")::llvm::llvm_unreachable_internal("Unexpected resolution", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 613); | |||
614 | ||||
615 | case LDPR_RESOLVED_IR: | |||
616 | case LDPR_RESOLVED_EXEC: | |||
617 | case LDPR_RESOLVED_DYN: | |||
618 | case LDPR_UNDEF: | |||
619 | assert(GV->isDeclarationForLinker())((GV->isDeclarationForLinker()) ? static_cast<void> ( 0) : __assert_fail ("GV->isDeclarationForLinker()", "/tmp/buildd/llvm-toolchain-snapshot-3.6~svn220848/tools/gold/gold-plugin.cpp" , 619, __PRETTY_FUNCTION__)); | |||
620 | break; | |||
621 | ||||
622 | case LDPR_PREVAILING_DEF_IRONLY: { | |||
623 | keepGlobalValue(*GV, KeptAliases); | |||
624 | if (!Used.count(GV)) { | |||
625 | // Since we use the regular lib/Linker, we cannot just internalize GV | |||
626 | // now or it will not be copied to the merged module. Instead we force | |||
627 | // it to be copied and then internalize it. | |||
628 | Internalize.insert(Sym.name); | |||
629 | } | |||
630 | break; | |||
631 | } | |||
632 | ||||
633 | case LDPR_PREVAILING_DEF: | |||
634 | keepGlobalValue(*GV, KeptAliases); | |||
635 | break; | |||
636 | ||||
637 | case LDPR_PREEMPTED_IR: | |||
638 | // Gold might have selected a linkonce_odr and preempted a weak_odr. | |||
639 | // In that case we have to make sure we don't end up internalizing it. | |||
640 | if (!GV->isDiscardableIfUnused()) | |||
641 | Maybe.erase(Sym.name); | |||
642 | ||||
643 | // fall-through | |||
644 | case LDPR_PREEMPTED_REG: | |||
645 | Drop.insert(GV); | |||
646 | break; | |||
647 | ||||
648 | case LDPR_PREVAILING_DEF_IRONLY_EXP: { | |||
649 | // We can only check for address uses after we merge the modules. The | |||
650 | // reason is that this GV might have a copy in another module | |||
651 | // and in that module the address might be significant, but that | |||
652 | // copy will be LDPR_PREEMPTED_IR. | |||
653 | if (GV->hasLinkOnceODRLinkage()) | |||
654 | Maybe.insert(Sym.name); | |||
655 | keepGlobalValue(*GV, KeptAliases); | |||
656 | break; | |||
657 | } | |||
658 | } | |||
659 | ||||
660 | free(Sym.name); | |||
661 | free(Sym.comdat_key); | |||
662 | Sym.name = nullptr; | |||
663 | Sym.comdat_key = nullptr; | |||
664 | } | |||
665 | ||||
666 | ValueToValueMapTy VM; | |||
667 | LocalValueMaterializer Materializer(Drop); | |||
668 | for (GlobalAlias *GA : KeptAliases) { | |||
669 | // Gold told us to keep GA. It is possible that a GV usied in the aliasee | |||
670 | // expression is being dropped. If that is the case, that GV must be copied. | |||
671 | Constant *Aliasee = GA->getAliasee(); | |||
672 | Constant *Replacement = mapConstantToLocalCopy(Aliasee, VM, &Materializer); | |||
673 | if (Aliasee != Replacement) | |||
674 | GA->setAliasee(Replacement); | |||
675 | } | |||
676 | ||||
677 | for (auto *GV : Drop) | |||
678 | drop(*GV); | |||
679 | ||||
680 | return M; | |||
681 | } | |||
682 | ||||
683 | static void runLTOPasses(Module &M, TargetMachine &TM) { | |||
684 | PassManager passes; | |||
685 | PassManagerBuilder PMB; | |||
686 | PMB.LibraryInfo = new TargetLibraryInfo(Triple(TM.getTargetTriple())); | |||
687 | PMB.Inliner = createFunctionInliningPass(); | |||
688 | PMB.VerifyInput = true; | |||
689 | PMB.VerifyOutput = true; | |||
690 | PMB.populateLTOPassManager(passes, &TM); | |||
691 | passes.run(M); | |||
692 | } | |||
693 | ||||
694 | static void codegen(Module &M) { | |||
695 | const std::string &TripleStr = M.getTargetTriple(); | |||
696 | Triple TheTriple(TripleStr); | |||
697 | ||||
698 | std::string ErrMsg; | |||
699 | const Target *TheTarget = TargetRegistry::lookupTarget(TripleStr, ErrMsg); | |||
700 | if (!TheTarget) | |||
701 | message(LDPL_FATAL, "Target not found: %s", ErrMsg.c_str()); | |||
702 | ||||
703 | if (unsigned NumOpts = options::extra.size()) | |||
704 | cl::ParseCommandLineOptions(NumOpts, &options::extra[0]); | |||
705 | ||||
706 | SubtargetFeatures Features; | |||
707 | Features.getDefaultSubtargetFeatures(TheTriple); | |||
708 | for (const std::string &A : MAttrs) | |||
709 | Features.AddFeature(A); | |||
710 | ||||
711 | TargetOptions Options = InitTargetOptionsFromCodeGenFlags(); | |||
712 | std::unique_ptr<TargetMachine> TM(TheTarget->createTargetMachine( | |||
| ||||
713 | TripleStr, options::mcpu, Features.getString(), Options, RelocationModel, | |||
714 | CodeModel::Default, CodeGenOpt::Aggressive)); | |||
715 | ||||
716 | runLTOPasses(M, *TM); | |||
717 | ||||
718 | PassManager CodeGenPasses; | |||
719 | CodeGenPasses.add(new DataLayoutPass()); | |||
720 | ||||
721 | SmallString<128> Filename; | |||
722 | int FD; | |||
723 | if (options::obj_path.empty()) { | |||
724 | std::error_code EC = | |||
725 | sys::fs::createTemporaryFile("lto-llvm", "o", FD, Filename); | |||
726 | if (EC) | |||
727 | message(LDPL_FATAL, "Could not create temorary file: %s", | |||
728 | EC.message().c_str()); | |||
729 | } else { | |||
730 | Filename = options::obj_path; | |||
731 | std::error_code EC = | |||
732 | sys::fs::openFileForWrite(Filename.c_str(), FD, sys::fs::F_None); | |||
733 | if (EC) | |||
734 | message(LDPL_FATAL, "Could not open file: %s", EC.message().c_str()); | |||
735 | } | |||
736 | ||||
737 | { | |||
738 | raw_fd_ostream OS(FD, true); | |||
739 | formatted_raw_ostream FOS(OS); | |||
740 | ||||
741 | if (TM->addPassesToEmitFile(CodeGenPasses, FOS, | |||
742 | TargetMachine::CGFT_ObjectFile)) | |||
743 | message(LDPL_FATAL, "Failed to setup codegen"); | |||
744 | CodeGenPasses.run(M); | |||
745 | } | |||
746 | ||||
747 | if (add_input_file(Filename.c_str()) != LDPS_OK) | |||
748 | message(LDPL_FATAL, | |||
749 | "Unable to add .o file to the link. File left behind in: %s", | |||
750 | Filename.c_str()); | |||
751 | ||||
752 | if (options::obj_path.empty()) | |||
753 | Cleanup.push_back(Filename.c_str()); | |||
754 | } | |||
755 | ||||
756 | /// gold informs us that all symbols have been read. At this point, we use | |||
757 | /// get_symbols to see if any of our definitions have been overridden by a | |||
758 | /// native object file. Then, perform optimization and codegen. | |||
759 | static ld_plugin_status allSymbolsReadHook(raw_fd_ostream *ApiFile) { | |||
760 | if (Modules.empty()) | |||
761 | return LDPS_OK; | |||
762 | ||||
763 | LLVMContext Context; | |||
764 | std::unique_ptr<Module> Combined(new Module("ld-temp.o", Context)); | |||
765 | Linker L(Combined.get()); | |||
766 | ||||
767 | std::string DefaultTriple = sys::getDefaultTargetTriple(); | |||
768 | ||||
769 | StringSet<> Internalize; | |||
770 | StringSet<> Maybe; | |||
771 | for (claimed_file &F : Modules) { | |||
772 | std::unique_ptr<Module> M = | |||
773 | getModuleForFile(Context, F, ApiFile, Internalize, Maybe); | |||
774 | if (!options::triple.empty()) | |||
775 | M->setTargetTriple(options::triple.c_str()); | |||
776 | else if (M->getTargetTriple().empty()) { | |||
777 | M->setTargetTriple(DefaultTriple); | |||
778 | } | |||
779 | ||||
780 | if (L.linkInModule(M.get())) | |||
781 | message(LDPL_FATAL, "Failed to link module"); | |||
782 | } | |||
783 | ||||
784 | for (const auto &Name : Internalize) { | |||
785 | GlobalValue *GV = Combined->getNamedValue(Name.first()); | |||
786 | if (GV) | |||
787 | internalize(*GV); | |||
788 | } | |||
789 | ||||
790 | for (const auto &Name : Maybe) { | |||
791 | GlobalValue *GV = Combined->getNamedValue(Name.first()); | |||
792 | if (!GV) | |||
793 | continue; | |||
794 | GV->setLinkage(GlobalValue::LinkOnceODRLinkage); | |||
795 | if (canBeOmittedFromSymbolTable(GV)) | |||
796 | internalize(*GV); | |||
797 | } | |||
798 | ||||
799 | if (options::generate_bc_file != options::BC_NO) { | |||
800 | std::string path; | |||
801 | if (options::generate_bc_file == options::BC_ONLY) | |||
802 | path = output_name; | |||
803 | else if (!options::bc_path.empty()) | |||
804 | path = options::bc_path; | |||
805 | else | |||
806 | path = output_name + ".bc"; | |||
807 | { | |||
808 | std::error_code EC; | |||
809 | raw_fd_ostream OS(path, EC, sys::fs::OpenFlags::F_None); | |||
810 | if (EC) | |||
811 | message(LDPL_FATAL, "Failed to write the output file."); | |||
812 | WriteBitcodeToFile(L.getModule(), OS); | |||
813 | } | |||
814 | if (options::generate_bc_file == options::BC_ONLY) | |||
815 | return LDPS_OK; | |||
816 | } | |||
817 | ||||
818 | codegen(*L.getModule()); | |||
819 | ||||
820 | if (!options::extra_library_path.empty() && | |||
821 | set_extra_library_path(options::extra_library_path.c_str()) != LDPS_OK) | |||
822 | message(LDPL_FATAL, "Unable to set the extra library path."); | |||
823 | ||||
824 | return LDPS_OK; | |||
825 | } | |||
826 | ||||
827 | static ld_plugin_status all_symbols_read_hook(void) { | |||
828 | ld_plugin_status Ret; | |||
829 | if (!options::generate_api_file) { | |||
| ||||
830 | Ret = allSymbolsReadHook(nullptr); | |||
831 | } else { | |||
832 | std::error_code EC; | |||
833 | raw_fd_ostream ApiFile("apifile.txt", EC, sys::fs::F_None); | |||
834 | if (EC) | |||
835 | message(LDPL_FATAL, "Unable to open apifile.txt for writing: %s", | |||
836 | EC.message().c_str()); | |||
837 | Ret = allSymbolsReadHook(&ApiFile); | |||
838 | } | |||
839 | ||||
840 | if (options::generate_bc_file == options::BC_ONLY) | |||
841 | exit(0); | |||
842 | ||||
843 | return Ret; | |||
844 | } | |||
845 | ||||
846 | static ld_plugin_status cleanup_hook(void) { | |||
847 | for (std::string &Name : Cleanup) { | |||
848 | std::error_code EC = sys::fs::remove(Name); | |||
849 | if (EC) | |||
850 | message(LDPL_ERROR, "Failed to delete '%s': %s", Name.c_str(), | |||
851 | EC.message().c_str()); | |||
852 | } | |||
853 | ||||
854 | return LDPS_OK; | |||
855 | } |