1 //===-- LTOModule.cpp - LLVM Link Time Optimizer --------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the Link Time Optimization library. This library is
10 // intended to be used by linker to optimize code at link time.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "llvm/LTO/legacy/LTOModule.h"
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/Bitcode/BitcodeReader.h"
17 #include "llvm/CodeGen/TargetSubtargetInfo.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/Mangler.h"
21 #include "llvm/IR/Metadata.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/MC/MCExpr.h"
24 #include "llvm/MC/MCInst.h"
25 #include "llvm/MC/MCParser/MCAsmParser.h"
26 #include "llvm/MC/MCSection.h"
27 #include "llvm/MC/MCSubtargetInfo.h"
28 #include "llvm/MC/MCSymbol.h"
29 #include "llvm/MC/SubtargetFeature.h"
30 #include "llvm/Object/IRObjectFile.h"
31 #include "llvm/Object/ObjectFile.h"
32 #include "llvm/Support/FileSystem.h"
33 #include "llvm/Support/Host.h"
34 #include "llvm/Support/MemoryBuffer.h"
35 #include "llvm/Support/Path.h"
36 #include "llvm/Support/SourceMgr.h"
37 #include "llvm/Support/TargetRegistry.h"
38 #include "llvm/Support/TargetSelect.h"
39 #include "llvm/Target/TargetLoweringObjectFile.h"
40 #include "llvm/Transforms/Utils/GlobalStatus.h"
41 #include <system_error>
42 using namespace llvm;
43 using namespace llvm::object;
44
LTOModule(std::unique_ptr<Module> M,MemoryBufferRef MBRef,llvm::TargetMachine * TM)45 LTOModule::LTOModule(std::unique_ptr<Module> M, MemoryBufferRef MBRef,
46 llvm::TargetMachine *TM)
47 : Mod(std::move(M)), MBRef(MBRef), _target(TM) {
48 SymTab.addModule(Mod.get());
49 }
50
~LTOModule()51 LTOModule::~LTOModule() {}
52
53 /// isBitcodeFile - Returns 'true' if the file (or memory contents) is LLVM
54 /// bitcode.
isBitcodeFile(const void * Mem,size_t Length)55 bool LTOModule::isBitcodeFile(const void *Mem, size_t Length) {
56 Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
57 MemoryBufferRef(StringRef((const char *)Mem, Length), "<mem>"));
58 return !errorToBool(BCData.takeError());
59 }
60
isBitcodeFile(StringRef Path)61 bool LTOModule::isBitcodeFile(StringRef Path) {
62 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
63 MemoryBuffer::getFile(Path);
64 if (!BufferOrErr)
65 return false;
66
67 Expected<MemoryBufferRef> BCData = IRObjectFile::findBitcodeInMemBuffer(
68 BufferOrErr.get()->getMemBufferRef());
69 return !errorToBool(BCData.takeError());
70 }
71
isThinLTO()72 bool LTOModule::isThinLTO() {
73 Expected<BitcodeLTOInfo> Result = getBitcodeLTOInfo(MBRef);
74 if (!Result) {
75 logAllUnhandledErrors(Result.takeError(), errs());
76 return false;
77 }
78 return Result->IsThinLTO;
79 }
80
isBitcodeForTarget(MemoryBuffer * Buffer,StringRef TriplePrefix)81 bool LTOModule::isBitcodeForTarget(MemoryBuffer *Buffer,
82 StringRef TriplePrefix) {
83 Expected<MemoryBufferRef> BCOrErr =
84 IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
85 if (errorToBool(BCOrErr.takeError()))
86 return false;
87 LLVMContext Context;
88 ErrorOr<std::string> TripleOrErr =
89 expectedToErrorOrAndEmitErrors(Context, getBitcodeTargetTriple(*BCOrErr));
90 if (!TripleOrErr)
91 return false;
92 return StringRef(*TripleOrErr).startswith(TriplePrefix);
93 }
94
getProducerString(MemoryBuffer * Buffer)95 std::string LTOModule::getProducerString(MemoryBuffer *Buffer) {
96 Expected<MemoryBufferRef> BCOrErr =
97 IRObjectFile::findBitcodeInMemBuffer(Buffer->getMemBufferRef());
98 if (errorToBool(BCOrErr.takeError()))
99 return "";
100 LLVMContext Context;
101 ErrorOr<std::string> ProducerOrErr = expectedToErrorOrAndEmitErrors(
102 Context, getBitcodeProducerString(*BCOrErr));
103 if (!ProducerOrErr)
104 return "";
105 return *ProducerOrErr;
106 }
107
108 ErrorOr<std::unique_ptr<LTOModule>>
createFromFile(LLVMContext & Context,StringRef path,const TargetOptions & options)109 LTOModule::createFromFile(LLVMContext &Context, StringRef path,
110 const TargetOptions &options) {
111 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
112 MemoryBuffer::getFile(path);
113 if (std::error_code EC = BufferOrErr.getError()) {
114 Context.emitError(EC.message());
115 return EC;
116 }
117 std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
118 return makeLTOModule(Buffer->getMemBufferRef(), options, Context,
119 /* ShouldBeLazy*/ false);
120 }
121
122 ErrorOr<std::unique_ptr<LTOModule>>
createFromOpenFile(LLVMContext & Context,int fd,StringRef path,size_t size,const TargetOptions & options)123 LTOModule::createFromOpenFile(LLVMContext &Context, int fd, StringRef path,
124 size_t size, const TargetOptions &options) {
125 return createFromOpenFileSlice(Context, fd, path, size, 0, options);
126 }
127
128 ErrorOr<std::unique_ptr<LTOModule>>
createFromOpenFileSlice(LLVMContext & Context,int fd,StringRef path,size_t map_size,off_t offset,const TargetOptions & options)129 LTOModule::createFromOpenFileSlice(LLVMContext &Context, int fd, StringRef path,
130 size_t map_size, off_t offset,
131 const TargetOptions &options) {
132 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
133 MemoryBuffer::getOpenFileSlice(sys::fs::convertFDToNativeFile(fd), path,
134 map_size, offset);
135 if (std::error_code EC = BufferOrErr.getError()) {
136 Context.emitError(EC.message());
137 return EC;
138 }
139 std::unique_ptr<MemoryBuffer> Buffer = std::move(BufferOrErr.get());
140 return makeLTOModule(Buffer->getMemBufferRef(), options, Context,
141 /* ShouldBeLazy */ false);
142 }
143
144 ErrorOr<std::unique_ptr<LTOModule>>
createFromBuffer(LLVMContext & Context,const void * mem,size_t length,const TargetOptions & options,StringRef path)145 LTOModule::createFromBuffer(LLVMContext &Context, const void *mem,
146 size_t length, const TargetOptions &options,
147 StringRef path) {
148 StringRef Data((const char *)mem, length);
149 MemoryBufferRef Buffer(Data, path);
150 return makeLTOModule(Buffer, options, Context, /* ShouldBeLazy */ false);
151 }
152
153 ErrorOr<std::unique_ptr<LTOModule>>
createInLocalContext(std::unique_ptr<LLVMContext> Context,const void * mem,size_t length,const TargetOptions & options,StringRef path)154 LTOModule::createInLocalContext(std::unique_ptr<LLVMContext> Context,
155 const void *mem, size_t length,
156 const TargetOptions &options, StringRef path) {
157 StringRef Data((const char *)mem, length);
158 MemoryBufferRef Buffer(Data, path);
159 // If we own a context, we know this is being used only for symbol extraction,
160 // not linking. Be lazy in that case.
161 ErrorOr<std::unique_ptr<LTOModule>> Ret =
162 makeLTOModule(Buffer, options, *Context, /* ShouldBeLazy */ true);
163 if (Ret)
164 (*Ret)->OwnedContext = std::move(Context);
165 return Ret;
166 }
167
168 static ErrorOr<std::unique_ptr<Module>>
parseBitcodeFileImpl(MemoryBufferRef Buffer,LLVMContext & Context,bool ShouldBeLazy)169 parseBitcodeFileImpl(MemoryBufferRef Buffer, LLVMContext &Context,
170 bool ShouldBeLazy) {
171 // Find the buffer.
172 Expected<MemoryBufferRef> MBOrErr =
173 IRObjectFile::findBitcodeInMemBuffer(Buffer);
174 if (Error E = MBOrErr.takeError()) {
175 std::error_code EC = errorToErrorCode(std::move(E));
176 Context.emitError(EC.message());
177 return EC;
178 }
179
180 if (!ShouldBeLazy) {
181 // Parse the full file.
182 return expectedToErrorOrAndEmitErrors(Context,
183 parseBitcodeFile(*MBOrErr, Context));
184 }
185
186 // Parse lazily.
187 return expectedToErrorOrAndEmitErrors(
188 Context,
189 getLazyBitcodeModule(*MBOrErr, Context, true /*ShouldLazyLoadMetadata*/));
190 }
191
192 ErrorOr<std::unique_ptr<LTOModule>>
makeLTOModule(MemoryBufferRef Buffer,const TargetOptions & options,LLVMContext & Context,bool ShouldBeLazy)193 LTOModule::makeLTOModule(MemoryBufferRef Buffer, const TargetOptions &options,
194 LLVMContext &Context, bool ShouldBeLazy) {
195 ErrorOr<std::unique_ptr<Module>> MOrErr =
196 parseBitcodeFileImpl(Buffer, Context, ShouldBeLazy);
197 if (std::error_code EC = MOrErr.getError())
198 return EC;
199 std::unique_ptr<Module> &M = *MOrErr;
200
201 std::string TripleStr = M->getTargetTriple();
202 if (TripleStr.empty())
203 TripleStr = sys::getDefaultTargetTriple();
204 llvm::Triple Triple(TripleStr);
205
206 // find machine architecture for this module
207 std::string errMsg;
208 const Target *march = TargetRegistry::lookupTarget(TripleStr, errMsg);
209 if (!march)
210 return make_error_code(object::object_error::arch_not_found);
211
212 // construct LTOModule, hand over ownership of module and target
213 SubtargetFeatures Features;
214 Features.getDefaultSubtargetFeatures(Triple);
215 std::string FeatureStr = Features.getString();
216 // Set a default CPU for Darwin triples.
217 std::string CPU;
218 if (Triple.isOSDarwin()) {
219 if (Triple.getArch() == llvm::Triple::x86_64)
220 CPU = "core2";
221 else if (Triple.getArch() == llvm::Triple::x86)
222 CPU = "yonah";
223 else if (Triple.getArch() == llvm::Triple::aarch64)
224 CPU = "cyclone";
225 }
226
227 TargetMachine *target =
228 march->createTargetMachine(TripleStr, CPU, FeatureStr, options, None);
229
230 std::unique_ptr<LTOModule> Ret(new LTOModule(std::move(M), Buffer, target));
231 Ret->parseSymbols();
232 Ret->parseMetadata();
233
234 return std::move(Ret);
235 }
236
237 /// Create a MemoryBuffer from a memory range with an optional name.
238 std::unique_ptr<MemoryBuffer>
makeBuffer(const void * mem,size_t length,StringRef name)239 LTOModule::makeBuffer(const void *mem, size_t length, StringRef name) {
240 const char *startPtr = (const char*)mem;
241 return MemoryBuffer::getMemBuffer(StringRef(startPtr, length), name, false);
242 }
243
244 /// objcClassNameFromExpression - Get string that the data pointer points to.
245 bool
objcClassNameFromExpression(const Constant * c,std::string & name)246 LTOModule::objcClassNameFromExpression(const Constant *c, std::string &name) {
247 if (const ConstantExpr *ce = dyn_cast<ConstantExpr>(c)) {
248 Constant *op = ce->getOperand(0);
249 if (GlobalVariable *gvn = dyn_cast<GlobalVariable>(op)) {
250 Constant *cn = gvn->getInitializer();
251 if (ConstantDataArray *ca = dyn_cast<ConstantDataArray>(cn)) {
252 if (ca->isCString()) {
253 name = (".objc_class_name_" + ca->getAsCString()).str();
254 return true;
255 }
256 }
257 }
258 }
259 return false;
260 }
261
262 /// addObjCClass - Parse i386/ppc ObjC class data structure.
addObjCClass(const GlobalVariable * clgv)263 void LTOModule::addObjCClass(const GlobalVariable *clgv) {
264 const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
265 if (!c) return;
266
267 // second slot in __OBJC,__class is pointer to superclass name
268 std::string superclassName;
269 if (objcClassNameFromExpression(c->getOperand(1), superclassName)) {
270 auto IterBool =
271 _undefines.insert(std::make_pair(superclassName, NameAndAttributes()));
272 if (IterBool.second) {
273 NameAndAttributes &info = IterBool.first->second;
274 info.name = IterBool.first->first();
275 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
276 info.isFunction = false;
277 info.symbol = clgv;
278 }
279 }
280
281 // third slot in __OBJC,__class is pointer to class name
282 std::string className;
283 if (objcClassNameFromExpression(c->getOperand(2), className)) {
284 auto Iter = _defines.insert(className).first;
285
286 NameAndAttributes info;
287 info.name = Iter->first();
288 info.attributes = LTO_SYMBOL_PERMISSIONS_DATA |
289 LTO_SYMBOL_DEFINITION_REGULAR | LTO_SYMBOL_SCOPE_DEFAULT;
290 info.isFunction = false;
291 info.symbol = clgv;
292 _symbols.push_back(info);
293 }
294 }
295
296 /// addObjCCategory - Parse i386/ppc ObjC category data structure.
addObjCCategory(const GlobalVariable * clgv)297 void LTOModule::addObjCCategory(const GlobalVariable *clgv) {
298 const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
299 if (!c) return;
300
301 // second slot in __OBJC,__category is pointer to target class name
302 std::string targetclassName;
303 if (!objcClassNameFromExpression(c->getOperand(1), targetclassName))
304 return;
305
306 auto IterBool =
307 _undefines.insert(std::make_pair(targetclassName, NameAndAttributes()));
308
309 if (!IterBool.second)
310 return;
311
312 NameAndAttributes &info = IterBool.first->second;
313 info.name = IterBool.first->first();
314 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
315 info.isFunction = false;
316 info.symbol = clgv;
317 }
318
319 /// addObjCClassRef - Parse i386/ppc ObjC class list data structure.
addObjCClassRef(const GlobalVariable * clgv)320 void LTOModule::addObjCClassRef(const GlobalVariable *clgv) {
321 std::string targetclassName;
322 if (!objcClassNameFromExpression(clgv->getInitializer(), targetclassName))
323 return;
324
325 auto IterBool =
326 _undefines.insert(std::make_pair(targetclassName, NameAndAttributes()));
327
328 if (!IterBool.second)
329 return;
330
331 NameAndAttributes &info = IterBool.first->second;
332 info.name = IterBool.first->first();
333 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
334 info.isFunction = false;
335 info.symbol = clgv;
336 }
337
addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym)338 void LTOModule::addDefinedDataSymbol(ModuleSymbolTable::Symbol Sym) {
339 SmallString<64> Buffer;
340 {
341 raw_svector_ostream OS(Buffer);
342 SymTab.printSymbolName(OS, Sym);
343 Buffer.c_str();
344 }
345
346 const GlobalValue *V = Sym.get<GlobalValue *>();
347 addDefinedDataSymbol(Buffer, V);
348 }
349
addDefinedDataSymbol(StringRef Name,const GlobalValue * v)350 void LTOModule::addDefinedDataSymbol(StringRef Name, const GlobalValue *v) {
351 // Add to list of defined symbols.
352 addDefinedSymbol(Name, v, false);
353
354 if (!v->hasSection() /* || !isTargetDarwin */)
355 return;
356
357 // Special case i386/ppc ObjC data structures in magic sections:
358 // The issue is that the old ObjC object format did some strange
359 // contortions to avoid real linker symbols. For instance, the
360 // ObjC class data structure is allocated statically in the executable
361 // that defines that class. That data structures contains a pointer to
362 // its superclass. But instead of just initializing that part of the
363 // struct to the address of its superclass, and letting the static and
364 // dynamic linkers do the rest, the runtime works by having that field
365 // instead point to a C-string that is the name of the superclass.
366 // At runtime the objc initialization updates that pointer and sets
367 // it to point to the actual super class. As far as the linker
368 // knows it is just a pointer to a string. But then someone wanted the
369 // linker to issue errors at build time if the superclass was not found.
370 // So they figured out a way in mach-o object format to use an absolute
371 // symbols (.objc_class_name_Foo = 0) and a floating reference
372 // (.reference .objc_class_name_Bar) to cause the linker into erroring when
373 // a class was missing.
374 // The following synthesizes the implicit .objc_* symbols for the linker
375 // from the ObjC data structures generated by the front end.
376
377 // special case if this data blob is an ObjC class definition
378 if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(v)) {
379 StringRef Section = GV->getSection();
380 if (Section.startswith("__OBJC,__class,")) {
381 addObjCClass(GV);
382 }
383
384 // special case if this data blob is an ObjC category definition
385 else if (Section.startswith("__OBJC,__category,")) {
386 addObjCCategory(GV);
387 }
388
389 // special case if this data blob is the list of referenced classes
390 else if (Section.startswith("__OBJC,__cls_refs,")) {
391 addObjCClassRef(GV);
392 }
393 }
394 }
395
addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym)396 void LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) {
397 SmallString<64> Buffer;
398 {
399 raw_svector_ostream OS(Buffer);
400 SymTab.printSymbolName(OS, Sym);
401 Buffer.c_str();
402 }
403
404 const Function *F = cast<Function>(Sym.get<GlobalValue *>());
405 addDefinedFunctionSymbol(Buffer, F);
406 }
407
addDefinedFunctionSymbol(StringRef Name,const Function * F)408 void LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) {
409 // add to list of defined symbols
410 addDefinedSymbol(Name, F, true);
411 }
412
addDefinedSymbol(StringRef Name,const GlobalValue * def,bool isFunction)413 void LTOModule::addDefinedSymbol(StringRef Name, const GlobalValue *def,
414 bool isFunction) {
415 // set alignment part log2() can have rounding errors
416 uint32_t align = def->getAlignment();
417 uint32_t attr = align ? countTrailingZeros(align) : 0;
418
419 // set permissions part
420 if (isFunction) {
421 attr |= LTO_SYMBOL_PERMISSIONS_CODE;
422 } else {
423 const GlobalVariable *gv = dyn_cast<GlobalVariable>(def);
424 if (gv && gv->isConstant())
425 attr |= LTO_SYMBOL_PERMISSIONS_RODATA;
426 else
427 attr |= LTO_SYMBOL_PERMISSIONS_DATA;
428 }
429
430 // set definition part
431 if (def->hasWeakLinkage() || def->hasLinkOnceLinkage())
432 attr |= LTO_SYMBOL_DEFINITION_WEAK;
433 else if (def->hasCommonLinkage())
434 attr |= LTO_SYMBOL_DEFINITION_TENTATIVE;
435 else
436 attr |= LTO_SYMBOL_DEFINITION_REGULAR;
437
438 // set scope part
439 if (def->hasLocalLinkage())
440 // Ignore visibility if linkage is local.
441 attr |= LTO_SYMBOL_SCOPE_INTERNAL;
442 else if (def->hasHiddenVisibility())
443 attr |= LTO_SYMBOL_SCOPE_HIDDEN;
444 else if (def->hasProtectedVisibility())
445 attr |= LTO_SYMBOL_SCOPE_PROTECTED;
446 else if (def->canBeOmittedFromSymbolTable())
447 attr |= LTO_SYMBOL_SCOPE_DEFAULT_CAN_BE_HIDDEN;
448 else
449 attr |= LTO_SYMBOL_SCOPE_DEFAULT;
450
451 if (def->hasComdat())
452 attr |= LTO_SYMBOL_COMDAT;
453
454 if (isa<GlobalAlias>(def))
455 attr |= LTO_SYMBOL_ALIAS;
456
457 auto Iter = _defines.insert(Name).first;
458
459 // fill information structure
460 NameAndAttributes info;
461 StringRef NameRef = Iter->first();
462 info.name = NameRef;
463 assert(NameRef.data()[NameRef.size()] == '\0');
464 info.attributes = attr;
465 info.isFunction = isFunction;
466 info.symbol = def;
467
468 // add to table of symbols
469 _symbols.push_back(info);
470 }
471
472 /// addAsmGlobalSymbol - Add a global symbol from module-level ASM to the
473 /// defined list.
addAsmGlobalSymbol(StringRef name,lto_symbol_attributes scope)474 void LTOModule::addAsmGlobalSymbol(StringRef name,
475 lto_symbol_attributes scope) {
476 auto IterBool = _defines.insert(name);
477
478 // only add new define if not already defined
479 if (!IterBool.second)
480 return;
481
482 NameAndAttributes &info = _undefines[IterBool.first->first()];
483
484 if (info.symbol == nullptr) {
485 // FIXME: This is trying to take care of module ASM like this:
486 //
487 // module asm ".zerofill __FOO, __foo, _bar_baz_qux, 0"
488 //
489 // but is gross and its mother dresses it funny. Have the ASM parser give us
490 // more details for this type of situation so that we're not guessing so
491 // much.
492
493 // fill information structure
494 info.name = IterBool.first->first();
495 info.attributes =
496 LTO_SYMBOL_PERMISSIONS_DATA | LTO_SYMBOL_DEFINITION_REGULAR | scope;
497 info.isFunction = false;
498 info.symbol = nullptr;
499
500 // add to table of symbols
501 _symbols.push_back(info);
502 return;
503 }
504
505 if (info.isFunction)
506 addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol));
507 else
508 addDefinedDataSymbol(info.name, info.symbol);
509
510 _symbols.back().attributes &= ~LTO_SYMBOL_SCOPE_MASK;
511 _symbols.back().attributes |= scope;
512 }
513
514 /// addAsmGlobalSymbolUndef - Add a global symbol from module-level ASM to the
515 /// undefined list.
addAsmGlobalSymbolUndef(StringRef name)516 void LTOModule::addAsmGlobalSymbolUndef(StringRef name) {
517 auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes()));
518
519 _asm_undefines.push_back(IterBool.first->first());
520
521 // we already have the symbol
522 if (!IterBool.second)
523 return;
524
525 uint32_t attr = LTO_SYMBOL_DEFINITION_UNDEFINED;
526 attr |= LTO_SYMBOL_SCOPE_DEFAULT;
527 NameAndAttributes &info = IterBool.first->second;
528 info.name = IterBool.first->first();
529 info.attributes = attr;
530 info.isFunction = false;
531 info.symbol = nullptr;
532 }
533
534 /// Add a symbol which isn't defined just yet to a list to be resolved later.
addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym,bool isFunc)535 void LTOModule::addPotentialUndefinedSymbol(ModuleSymbolTable::Symbol Sym,
536 bool isFunc) {
537 SmallString<64> name;
538 {
539 raw_svector_ostream OS(name);
540 SymTab.printSymbolName(OS, Sym);
541 name.c_str();
542 }
543
544 auto IterBool = _undefines.insert(std::make_pair(name, NameAndAttributes()));
545
546 // we already have the symbol
547 if (!IterBool.second)
548 return;
549
550 NameAndAttributes &info = IterBool.first->second;
551
552 info.name = IterBool.first->first();
553
554 const GlobalValue *decl = Sym.dyn_cast<GlobalValue *>();
555
556 if (decl->hasExternalWeakLinkage())
557 info.attributes = LTO_SYMBOL_DEFINITION_WEAKUNDEF;
558 else
559 info.attributes = LTO_SYMBOL_DEFINITION_UNDEFINED;
560
561 info.isFunction = isFunc;
562 info.symbol = decl;
563 }
564
parseSymbols()565 void LTOModule::parseSymbols() {
566 for (auto Sym : SymTab.symbols()) {
567 auto *GV = Sym.dyn_cast<GlobalValue *>();
568 uint32_t Flags = SymTab.getSymbolFlags(Sym);
569 if (Flags & object::BasicSymbolRef::SF_FormatSpecific)
570 continue;
571
572 bool IsUndefined = Flags & object::BasicSymbolRef::SF_Undefined;
573
574 if (!GV) {
575 SmallString<64> Buffer;
576 {
577 raw_svector_ostream OS(Buffer);
578 SymTab.printSymbolName(OS, Sym);
579 Buffer.c_str();
580 }
581 StringRef Name(Buffer);
582
583 if (IsUndefined)
584 addAsmGlobalSymbolUndef(Name);
585 else if (Flags & object::BasicSymbolRef::SF_Global)
586 addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_DEFAULT);
587 else
588 addAsmGlobalSymbol(Name, LTO_SYMBOL_SCOPE_INTERNAL);
589 continue;
590 }
591
592 auto *F = dyn_cast<Function>(GV);
593 if (IsUndefined) {
594 addPotentialUndefinedSymbol(Sym, F != nullptr);
595 continue;
596 }
597
598 if (F) {
599 addDefinedFunctionSymbol(Sym);
600 continue;
601 }
602
603 if (isa<GlobalVariable>(GV)) {
604 addDefinedDataSymbol(Sym);
605 continue;
606 }
607
608 assert(isa<GlobalAlias>(GV));
609 addDefinedDataSymbol(Sym);
610 }
611
612 // make symbols for all undefines
613 for (StringMap<NameAndAttributes>::iterator u =_undefines.begin(),
614 e = _undefines.end(); u != e; ++u) {
615 // If this symbol also has a definition, then don't make an undefine because
616 // it is a tentative definition.
617 if (_defines.count(u->getKey())) continue;
618 NameAndAttributes info = u->getValue();
619 _symbols.push_back(info);
620 }
621 }
622
623 /// parseMetadata - Parse metadata from the module
parseMetadata()624 void LTOModule::parseMetadata() {
625 raw_string_ostream OS(LinkerOpts);
626
627 // Linker Options
628 if (NamedMDNode *LinkerOptions =
629 getModule().getNamedMetadata("llvm.linker.options")) {
630 for (unsigned i = 0, e = LinkerOptions->getNumOperands(); i != e; ++i) {
631 MDNode *MDOptions = LinkerOptions->getOperand(i);
632 for (unsigned ii = 0, ie = MDOptions->getNumOperands(); ii != ie; ++ii) {
633 MDString *MDOption = cast<MDString>(MDOptions->getOperand(ii));
634 OS << " " << MDOption->getString();
635 }
636 }
637 }
638
639 // Globals - we only need to do this for COFF.
640 const Triple TT(_target->getTargetTriple());
641 if (!TT.isOSBinFormatCOFF())
642 return;
643 Mangler M;
644 for (const NameAndAttributes &Sym : _symbols) {
645 if (!Sym.symbol)
646 continue;
647 emitLinkerFlagsForGlobalCOFF(OS, Sym.symbol, TT, M);
648 }
649 }
650
createInputFile(const void * buffer,size_t buffer_size,const char * path,std::string & outErr)651 lto::InputFile *LTOModule::createInputFile(const void *buffer,
652 size_t buffer_size, const char *path,
653 std::string &outErr) {
654 StringRef Data((const char *)buffer, buffer_size);
655 MemoryBufferRef BufferRef(Data, path);
656
657 Expected<std::unique_ptr<lto::InputFile>> ObjOrErr =
658 lto::InputFile::create(BufferRef);
659
660 if (ObjOrErr)
661 return ObjOrErr->release();
662
663 outErr = std::string(path) +
664 ": Could not read LTO input file: " + toString(ObjOrErr.takeError());
665 return nullptr;
666 }
667
getDependentLibraryCount(lto::InputFile * input)668 size_t LTOModule::getDependentLibraryCount(lto::InputFile *input) {
669 return input->getDependentLibraries().size();
670 }
671
getDependentLibrary(lto::InputFile * input,size_t index,size_t * size)672 const char *LTOModule::getDependentLibrary(lto::InputFile *input, size_t index,
673 size_t *size) {
674 StringRef S = input->getDependentLibraries()[index];
675 *size = S.size();
676 return S.data();
677 }
678