1 //===-LTOCodeGenerator.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/LTOCodeGenerator.h"
15
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/ADT/StringExtras.h"
18 #include "llvm/Analysis/Passes.h"
19 #include "llvm/Analysis/TargetLibraryInfo.h"
20 #include "llvm/Analysis/TargetTransformInfo.h"
21 #include "llvm/Bitcode/BitcodeWriter.h"
22 #include "llvm/CodeGen/ParallelCG.h"
23 #include "llvm/CodeGen/TargetSubtargetInfo.h"
24 #include "llvm/Config/config.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/DataLayout.h"
27 #include "llvm/IR/DebugInfo.h"
28 #include "llvm/IR/DerivedTypes.h"
29 #include "llvm/IR/DiagnosticInfo.h"
30 #include "llvm/IR/DiagnosticPrinter.h"
31 #include "llvm/IR/LLVMContext.h"
32 #include "llvm/IR/LLVMRemarkStreamer.h"
33 #include "llvm/IR/LegacyPassManager.h"
34 #include "llvm/IR/Mangler.h"
35 #include "llvm/IR/Module.h"
36 #include "llvm/IR/PassTimingInfo.h"
37 #include "llvm/IR/Verifier.h"
38 #include "llvm/InitializePasses.h"
39 #include "llvm/LTO/LTO.h"
40 #include "llvm/LTO/LTOBackend.h"
41 #include "llvm/LTO/legacy/LTOModule.h"
42 #include "llvm/LTO/legacy/UpdateCompilerUsed.h"
43 #include "llvm/Linker/Linker.h"
44 #include "llvm/MC/MCAsmInfo.h"
45 #include "llvm/MC/MCContext.h"
46 #include "llvm/MC/SubtargetFeature.h"
47 #include "llvm/Remarks/HotnessThresholdParser.h"
48 #include "llvm/Support/CommandLine.h"
49 #include "llvm/Support/FileSystem.h"
50 #include "llvm/Support/Host.h"
51 #include "llvm/Support/MemoryBuffer.h"
52 #include "llvm/Support/Signals.h"
53 #include "llvm/Support/TargetRegistry.h"
54 #include "llvm/Support/TargetSelect.h"
55 #include "llvm/Support/ToolOutputFile.h"
56 #include "llvm/Support/YAMLTraits.h"
57 #include "llvm/Support/raw_ostream.h"
58 #include "llvm/Target/TargetOptions.h"
59 #include "llvm/Transforms/IPO.h"
60 #include "llvm/Transforms/IPO/Internalize.h"
61 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
62 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
63 #include "llvm/Transforms/ObjCARC.h"
64 #include "llvm/Transforms/Utils/ModuleUtils.h"
65 #include <system_error>
66 using namespace llvm;
67
getVersionString()68 const char* LTOCodeGenerator::getVersionString() {
69 #ifdef LLVM_VERSION_INFO
70 return PACKAGE_NAME " version " PACKAGE_VERSION ", " LLVM_VERSION_INFO;
71 #else
72 return PACKAGE_NAME " version " PACKAGE_VERSION;
73 #endif
74 }
75
76 namespace llvm {
77 cl::opt<bool> LTODiscardValueNames(
78 "lto-discard-value-names",
79 cl::desc("Strip names from Value during LTO (other than GlobalValue)."),
80 #ifdef NDEBUG
81 cl::init(true),
82 #else
83 cl::init(false),
84 #endif
85 cl::Hidden);
86
87 cl::opt<bool> RemarksWithHotness(
88 "lto-pass-remarks-with-hotness",
89 cl::desc("With PGO, include profile count in optimization remarks"),
90 cl::Hidden);
91
92 cl::opt<Optional<uint64_t>, false, remarks::HotnessThresholdParser>
93 RemarksHotnessThreshold(
94 "lto-pass-remarks-hotness-threshold",
95 cl::desc("Minimum profile count required for an "
96 "optimization remark to be output."
97 " Use 'auto' to apply the threshold from profile summary."),
98 cl::value_desc("uint or 'auto'"), cl::init(0), cl::Hidden);
99
100 cl::opt<std::string>
101 RemarksFilename("lto-pass-remarks-output",
102 cl::desc("Output filename for pass remarks"),
103 cl::value_desc("filename"));
104
105 cl::opt<std::string>
106 RemarksPasses("lto-pass-remarks-filter",
107 cl::desc("Only record optimization remarks from passes whose "
108 "names match the given regular expression"),
109 cl::value_desc("regex"));
110
111 cl::opt<std::string> RemarksFormat(
112 "lto-pass-remarks-format",
113 cl::desc("The format used for serializing remarks (default: YAML)"),
114 cl::value_desc("format"), cl::init("yaml"));
115
116 cl::opt<std::string> LTOStatsFile(
117 "lto-stats-file",
118 cl::desc("Save statistics to the specified file"),
119 cl::Hidden);
120 }
121
LTOCodeGenerator(LLVMContext & Context)122 LTOCodeGenerator::LTOCodeGenerator(LLVMContext &Context)
123 : Context(Context), MergedModule(new Module("ld-temp.o", Context)),
124 TheLinker(new Linker(*MergedModule)) {
125 Context.setDiscardValueNames(LTODiscardValueNames);
126 Context.enableDebugTypeODRUniquing();
127
128 Config.CodeModel = None;
129 Config.StatsFile = LTOStatsFile;
130 Config.PreCodeGenPassesHook = [](legacy::PassManager &PM) {
131 PM.add(createObjCARCContractPass());
132 };
133 }
134
~LTOCodeGenerator()135 LTOCodeGenerator::~LTOCodeGenerator() {}
136
setAsmUndefinedRefs(LTOModule * Mod)137 void LTOCodeGenerator::setAsmUndefinedRefs(LTOModule *Mod) {
138 const std::vector<StringRef> &undefs = Mod->getAsmUndefinedRefs();
139 for (int i = 0, e = undefs.size(); i != e; ++i)
140 AsmUndefinedRefs.insert(undefs[i]);
141 }
142
addModule(LTOModule * Mod)143 bool LTOCodeGenerator::addModule(LTOModule *Mod) {
144 assert(&Mod->getModule().getContext() == &Context &&
145 "Expected module in same context");
146
147 bool ret = TheLinker->linkInModule(Mod->takeModule());
148 setAsmUndefinedRefs(Mod);
149
150 // We've just changed the input, so let's make sure we verify it.
151 HasVerifiedInput = false;
152
153 return !ret;
154 }
155
setModule(std::unique_ptr<LTOModule> Mod)156 void LTOCodeGenerator::setModule(std::unique_ptr<LTOModule> Mod) {
157 assert(&Mod->getModule().getContext() == &Context &&
158 "Expected module in same context");
159
160 AsmUndefinedRefs.clear();
161
162 MergedModule = Mod->takeModule();
163 TheLinker = std::make_unique<Linker>(*MergedModule);
164 setAsmUndefinedRefs(&*Mod);
165
166 // We've just changed the input, so let's make sure we verify it.
167 HasVerifiedInput = false;
168 }
169
setTargetOptions(const TargetOptions & Options)170 void LTOCodeGenerator::setTargetOptions(const TargetOptions &Options) {
171 Config.Options = Options;
172 }
173
setDebugInfo(lto_debug_model Debug)174 void LTOCodeGenerator::setDebugInfo(lto_debug_model Debug) {
175 switch (Debug) {
176 case LTO_DEBUG_MODEL_NONE:
177 EmitDwarfDebugInfo = false;
178 return;
179
180 case LTO_DEBUG_MODEL_DWARF:
181 EmitDwarfDebugInfo = true;
182 return;
183 }
184 llvm_unreachable("Unknown debug format!");
185 }
186
setOptLevel(unsigned Level)187 void LTOCodeGenerator::setOptLevel(unsigned Level) {
188 Config.OptLevel = Level;
189 Config.PTO.LoopVectorization = Config.OptLevel > 1;
190 Config.PTO.SLPVectorization = Config.OptLevel > 1;
191 switch (Config.OptLevel) {
192 case 0:
193 Config.CGOptLevel = CodeGenOpt::None;
194 return;
195 case 1:
196 Config.CGOptLevel = CodeGenOpt::Less;
197 return;
198 case 2:
199 Config.CGOptLevel = CodeGenOpt::Default;
200 return;
201 case 3:
202 Config.CGOptLevel = CodeGenOpt::Aggressive;
203 return;
204 }
205 llvm_unreachable("Unknown optimization level!");
206 }
207
writeMergedModules(StringRef Path)208 bool LTOCodeGenerator::writeMergedModules(StringRef Path) {
209 if (!determineTarget())
210 return false;
211
212 // We always run the verifier once on the merged module.
213 verifyMergedModuleOnce();
214
215 // mark which symbols can not be internalized
216 applyScopeRestrictions();
217
218 // create output file
219 std::error_code EC;
220 ToolOutputFile Out(Path, EC, sys::fs::OF_None);
221 if (EC) {
222 std::string ErrMsg = "could not open bitcode file for writing: ";
223 ErrMsg += Path.str() + ": " + EC.message();
224 emitError(ErrMsg);
225 return false;
226 }
227
228 // write bitcode to it
229 WriteBitcodeToFile(*MergedModule, Out.os(), ShouldEmbedUselists);
230 Out.os().close();
231
232 if (Out.os().has_error()) {
233 std::string ErrMsg = "could not write bitcode file: ";
234 ErrMsg += Path.str() + ": " + Out.os().error().message();
235 emitError(ErrMsg);
236 Out.os().clear_error();
237 return false;
238 }
239
240 Out.keep();
241 return true;
242 }
243
compileOptimizedToFile(const char ** Name)244 bool LTOCodeGenerator::compileOptimizedToFile(const char **Name) {
245 // make unique temp output file to put generated code
246 SmallString<128> Filename;
247
248 auto AddStream =
249 [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
250 StringRef Extension(Config.CGFileType == CGFT_AssemblyFile ? "s" : "o");
251
252 int FD;
253 std::error_code EC =
254 sys::fs::createTemporaryFile("lto-llvm", Extension, FD, Filename);
255 if (EC)
256 emitError(EC.message());
257
258 return std::make_unique<lto::NativeObjectStream>(
259 std::make_unique<llvm::raw_fd_ostream>(FD, true));
260 };
261
262 bool genResult = compileOptimized(AddStream, 1);
263
264 if (!genResult) {
265 sys::fs::remove(Twine(Filename));
266 return false;
267 }
268
269 // If statistics were requested, save them to the specified file or
270 // print them out after codegen.
271 if (StatsFile)
272 PrintStatisticsJSON(StatsFile->os());
273 else if (AreStatisticsEnabled())
274 PrintStatistics();
275
276 NativeObjectPath = Filename.c_str();
277 *Name = NativeObjectPath.c_str();
278 return true;
279 }
280
281 std::unique_ptr<MemoryBuffer>
compileOptimized()282 LTOCodeGenerator::compileOptimized() {
283 const char *name;
284 if (!compileOptimizedToFile(&name))
285 return nullptr;
286
287 // read .o file into memory buffer
288 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = MemoryBuffer::getFile(
289 name, /*IsText=*/false, /*RequiresNullTerminator=*/false);
290 if (std::error_code EC = BufferOrErr.getError()) {
291 emitError(EC.message());
292 sys::fs::remove(NativeObjectPath);
293 return nullptr;
294 }
295
296 // remove temp files
297 sys::fs::remove(NativeObjectPath);
298
299 return std::move(*BufferOrErr);
300 }
301
compile_to_file(const char ** Name)302 bool LTOCodeGenerator::compile_to_file(const char **Name) {
303 if (!optimize())
304 return false;
305
306 return compileOptimizedToFile(Name);
307 }
308
compile()309 std::unique_ptr<MemoryBuffer> LTOCodeGenerator::compile() {
310 if (!optimize())
311 return nullptr;
312
313 return compileOptimized();
314 }
315
determineTarget()316 bool LTOCodeGenerator::determineTarget() {
317 if (TargetMach)
318 return true;
319
320 TripleStr = MergedModule->getTargetTriple();
321 if (TripleStr.empty()) {
322 TripleStr = sys::getDefaultTargetTriple();
323 MergedModule->setTargetTriple(TripleStr);
324 }
325 llvm::Triple Triple(TripleStr);
326
327 // create target machine from info for merged modules
328 std::string ErrMsg;
329 MArch = TargetRegistry::lookupTarget(TripleStr, ErrMsg);
330 if (!MArch) {
331 emitError(ErrMsg);
332 return false;
333 }
334
335 // Construct LTOModule, hand over ownership of module and target. Use MAttr as
336 // the default set of features.
337 SubtargetFeatures Features(join(Config.MAttrs, ""));
338 Features.getDefaultSubtargetFeatures(Triple);
339 FeatureStr = Features.getString();
340 // Set a default CPU for Darwin triples.
341 if (Config.CPU.empty() && Triple.isOSDarwin()) {
342 if (Triple.getArch() == llvm::Triple::x86_64)
343 Config.CPU = "core2";
344 else if (Triple.getArch() == llvm::Triple::x86)
345 Config.CPU = "yonah";
346 else if (Triple.isArm64e())
347 Config.CPU = "apple-a12";
348 else if (Triple.getArch() == llvm::Triple::aarch64 ||
349 Triple.getArch() == llvm::Triple::aarch64_32)
350 Config.CPU = "cyclone";
351 }
352
353 TargetMach = createTargetMachine();
354 assert(TargetMach && "Unable to create target machine");
355
356 return true;
357 }
358
createTargetMachine()359 std::unique_ptr<TargetMachine> LTOCodeGenerator::createTargetMachine() {
360 assert(MArch && "MArch is not set!");
361 return std::unique_ptr<TargetMachine>(MArch->createTargetMachine(
362 TripleStr, Config.CPU, FeatureStr, Config.Options, Config.RelocModel,
363 None, Config.CGOptLevel));
364 }
365
366 // If a linkonce global is present in the MustPreserveSymbols, we need to make
367 // sure we honor this. To force the compiler to not drop it, we add it to the
368 // "llvm.compiler.used" global.
preserveDiscardableGVs(Module & TheModule,llvm::function_ref<bool (const GlobalValue &)> mustPreserveGV)369 void LTOCodeGenerator::preserveDiscardableGVs(
370 Module &TheModule,
371 llvm::function_ref<bool(const GlobalValue &)> mustPreserveGV) {
372 std::vector<GlobalValue *> Used;
373 auto mayPreserveGlobal = [&](GlobalValue &GV) {
374 if (!GV.isDiscardableIfUnused() || GV.isDeclaration() ||
375 !mustPreserveGV(GV))
376 return;
377 if (GV.hasAvailableExternallyLinkage())
378 return emitWarning(
379 (Twine("Linker asked to preserve available_externally global: '") +
380 GV.getName() + "'").str());
381 if (GV.hasInternalLinkage())
382 return emitWarning((Twine("Linker asked to preserve internal global: '") +
383 GV.getName() + "'").str());
384 Used.push_back(&GV);
385 };
386 for (auto &GV : TheModule)
387 mayPreserveGlobal(GV);
388 for (auto &GV : TheModule.globals())
389 mayPreserveGlobal(GV);
390 for (auto &GV : TheModule.aliases())
391 mayPreserveGlobal(GV);
392
393 if (Used.empty())
394 return;
395
396 appendToCompilerUsed(TheModule, Used);
397 }
398
applyScopeRestrictions()399 void LTOCodeGenerator::applyScopeRestrictions() {
400 if (ScopeRestrictionsDone)
401 return;
402
403 // Declare a callback for the internalize pass that will ask for every
404 // candidate GlobalValue if it can be internalized or not.
405 Mangler Mang;
406 SmallString<64> MangledName;
407 auto mustPreserveGV = [&](const GlobalValue &GV) -> bool {
408 // Unnamed globals can't be mangled, but they can't be preserved either.
409 if (!GV.hasName())
410 return false;
411
412 // Need to mangle the GV as the "MustPreserveSymbols" StringSet is filled
413 // with the linker supplied name, which on Darwin includes a leading
414 // underscore.
415 MangledName.clear();
416 MangledName.reserve(GV.getName().size() + 1);
417 Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
418 return MustPreserveSymbols.count(MangledName);
419 };
420
421 // Preserve linkonce value on linker request
422 preserveDiscardableGVs(*MergedModule, mustPreserveGV);
423
424 if (!ShouldInternalize)
425 return;
426
427 if (ShouldRestoreGlobalsLinkage) {
428 // Record the linkage type of non-local symbols so they can be restored
429 // prior
430 // to module splitting.
431 auto RecordLinkage = [&](const GlobalValue &GV) {
432 if (!GV.hasAvailableExternallyLinkage() && !GV.hasLocalLinkage() &&
433 GV.hasName())
434 ExternalSymbols.insert(std::make_pair(GV.getName(), GV.getLinkage()));
435 };
436 for (auto &GV : *MergedModule)
437 RecordLinkage(GV);
438 for (auto &GV : MergedModule->globals())
439 RecordLinkage(GV);
440 for (auto &GV : MergedModule->aliases())
441 RecordLinkage(GV);
442 }
443
444 // Update the llvm.compiler_used globals to force preserving libcalls and
445 // symbols referenced from asm
446 updateCompilerUsed(*MergedModule, *TargetMach, AsmUndefinedRefs);
447
448 internalizeModule(*MergedModule, mustPreserveGV);
449
450 ScopeRestrictionsDone = true;
451 }
452
453 /// Restore original linkage for symbols that may have been internalized
restoreLinkageForExternals()454 void LTOCodeGenerator::restoreLinkageForExternals() {
455 if (!ShouldInternalize || !ShouldRestoreGlobalsLinkage)
456 return;
457
458 assert(ScopeRestrictionsDone &&
459 "Cannot externalize without internalization!");
460
461 if (ExternalSymbols.empty())
462 return;
463
464 auto externalize = [this](GlobalValue &GV) {
465 if (!GV.hasLocalLinkage() || !GV.hasName())
466 return;
467
468 auto I = ExternalSymbols.find(GV.getName());
469 if (I == ExternalSymbols.end())
470 return;
471
472 GV.setLinkage(I->second);
473 };
474
475 llvm::for_each(MergedModule->functions(), externalize);
476 llvm::for_each(MergedModule->globals(), externalize);
477 llvm::for_each(MergedModule->aliases(), externalize);
478 }
479
verifyMergedModuleOnce()480 void LTOCodeGenerator::verifyMergedModuleOnce() {
481 // Only run on the first call.
482 if (HasVerifiedInput)
483 return;
484 HasVerifiedInput = true;
485
486 bool BrokenDebugInfo = false;
487 if (verifyModule(*MergedModule, &dbgs(), &BrokenDebugInfo))
488 report_fatal_error("Broken module found, compilation aborted!");
489 if (BrokenDebugInfo) {
490 emitWarning("Invalid debug info found, debug info will be stripped");
491 StripDebugInfo(*MergedModule);
492 }
493 }
494
finishOptimizationRemarks()495 void LTOCodeGenerator::finishOptimizationRemarks() {
496 if (DiagnosticOutputFile) {
497 DiagnosticOutputFile->keep();
498 // FIXME: LTOCodeGenerator dtor is not invoked on Darwin
499 DiagnosticOutputFile->os().flush();
500 }
501 }
502
503 /// Optimize merged modules using various IPO passes
optimize()504 bool LTOCodeGenerator::optimize() {
505 if (!this->determineTarget())
506 return false;
507
508 auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
509 Context, RemarksFilename, RemarksPasses, RemarksFormat,
510 RemarksWithHotness, RemarksHotnessThreshold);
511 if (!DiagFileOrErr) {
512 errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
513 report_fatal_error("Can't get an output file for the remarks");
514 }
515 DiagnosticOutputFile = std::move(*DiagFileOrErr);
516
517 // Setup output file to emit statistics.
518 auto StatsFileOrErr = lto::setupStatsFile(LTOStatsFile);
519 if (!StatsFileOrErr) {
520 errs() << "Error: " << toString(StatsFileOrErr.takeError()) << "\n";
521 report_fatal_error("Can't get an output file for the statistics");
522 }
523 StatsFile = std::move(StatsFileOrErr.get());
524
525 // Currently there is no support for enabling whole program visibility via a
526 // linker option in the old LTO API, but this call allows it to be specified
527 // via the internal option. Must be done before WPD invoked via the optimizer
528 // pipeline run below.
529 updateVCallVisibilityInModule(*MergedModule,
530 /* WholeProgramVisibilityEnabledInLTO */ false,
531 // FIXME: This needs linker information via a
532 // TBD new interface.
533 /* DynamicExportSymbols */ {});
534
535 // We always run the verifier once on the merged module, the `DisableVerify`
536 // parameter only applies to subsequent verify.
537 verifyMergedModuleOnce();
538
539 // Mark which symbols can not be internalized
540 this->applyScopeRestrictions();
541
542 // Write LTOPostLink flag for passes that require all the modules.
543 MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
544
545 // Add an appropriate DataLayout instance for this module...
546 MergedModule->setDataLayout(TargetMach->createDataLayout());
547
548 ModuleSummaryIndex CombinedIndex(false);
549 TargetMach = createTargetMachine();
550 if (!opt(Config, TargetMach.get(), 0, *MergedModule, /*IsThinLTO=*/false,
551 /*ExportSummary=*/&CombinedIndex, /*ImportSummary=*/nullptr,
552 /*CmdArgs*/ std::vector<uint8_t>())) {
553 emitError("LTO middle-end optimizations failed");
554 return false;
555 }
556
557 return true;
558 }
559
compileOptimized(lto::AddStreamFn AddStream,unsigned ParallelismLevel)560 bool LTOCodeGenerator::compileOptimized(lto::AddStreamFn AddStream,
561 unsigned ParallelismLevel) {
562 if (!this->determineTarget())
563 return false;
564
565 // We always run the verifier once on the merged module. If it has already
566 // been called in optimize(), this call will return early.
567 verifyMergedModuleOnce();
568
569 // Re-externalize globals that may have been internalized to increase scope
570 // for splitting
571 restoreLinkageForExternals();
572
573 ModuleSummaryIndex CombinedIndex(false);
574
575 Config.CodeGenOnly = true;
576 Error Err = backend(Config, AddStream, ParallelismLevel, *MergedModule,
577 CombinedIndex);
578 assert(!Err && "unexpected code-generation failure");
579 (void)Err;
580
581 // If statistics were requested, save them to the specified file or
582 // print them out after codegen.
583 if (StatsFile)
584 PrintStatisticsJSON(StatsFile->os());
585 else if (AreStatisticsEnabled())
586 PrintStatistics();
587
588 reportAndResetTimings();
589
590 finishOptimizationRemarks();
591
592 return true;
593 }
594
setCodeGenDebugOptions(ArrayRef<StringRef> Options)595 void LTOCodeGenerator::setCodeGenDebugOptions(ArrayRef<StringRef> Options) {
596 for (StringRef Option : Options)
597 CodegenOptions.push_back(Option.str());
598 }
599
parseCodeGenDebugOptions()600 void LTOCodeGenerator::parseCodeGenDebugOptions() {
601 if (!CodegenOptions.empty())
602 llvm::parseCommandLineOptions(CodegenOptions);
603 }
604
parseCommandLineOptions(std::vector<std::string> & Options)605 void llvm::parseCommandLineOptions(std::vector<std::string> &Options) {
606 if (!Options.empty()) {
607 // ParseCommandLineOptions() expects argv[0] to be program name.
608 std::vector<const char *> CodegenArgv(1, "libLLVMLTO");
609 for (std::string &Arg : Options)
610 CodegenArgv.push_back(Arg.c_str());
611 cl::ParseCommandLineOptions(CodegenArgv.size(), CodegenArgv.data());
612 }
613 }
614
DiagnosticHandler(const DiagnosticInfo & DI)615 void LTOCodeGenerator::DiagnosticHandler(const DiagnosticInfo &DI) {
616 // Map the LLVM internal diagnostic severity to the LTO diagnostic severity.
617 lto_codegen_diagnostic_severity_t Severity;
618 switch (DI.getSeverity()) {
619 case DS_Error:
620 Severity = LTO_DS_ERROR;
621 break;
622 case DS_Warning:
623 Severity = LTO_DS_WARNING;
624 break;
625 case DS_Remark:
626 Severity = LTO_DS_REMARK;
627 break;
628 case DS_Note:
629 Severity = LTO_DS_NOTE;
630 break;
631 }
632 // Create the string that will be reported to the external diagnostic handler.
633 std::string MsgStorage;
634 raw_string_ostream Stream(MsgStorage);
635 DiagnosticPrinterRawOStream DP(Stream);
636 DI.print(DP);
637 Stream.flush();
638
639 // If this method has been called it means someone has set up an external
640 // diagnostic handler. Assert on that.
641 assert(DiagHandler && "Invalid diagnostic handler");
642 (*DiagHandler)(Severity, MsgStorage.c_str(), DiagContext);
643 }
644
645 namespace {
646 struct LTODiagnosticHandler : public DiagnosticHandler {
647 LTOCodeGenerator *CodeGenerator;
LTODiagnosticHandler__anond9b8969a0711::LTODiagnosticHandler648 LTODiagnosticHandler(LTOCodeGenerator *CodeGenPtr)
649 : CodeGenerator(CodeGenPtr) {}
handleDiagnostics__anond9b8969a0711::LTODiagnosticHandler650 bool handleDiagnostics(const DiagnosticInfo &DI) override {
651 CodeGenerator->DiagnosticHandler(DI);
652 return true;
653 }
654 };
655 }
656
657 void
setDiagnosticHandler(lto_diagnostic_handler_t DiagHandler,void * Ctxt)658 LTOCodeGenerator::setDiagnosticHandler(lto_diagnostic_handler_t DiagHandler,
659 void *Ctxt) {
660 this->DiagHandler = DiagHandler;
661 this->DiagContext = Ctxt;
662 if (!DiagHandler)
663 return Context.setDiagnosticHandler(nullptr);
664 // Register the LTOCodeGenerator stub in the LLVMContext to forward the
665 // diagnostic to the external DiagHandler.
666 Context.setDiagnosticHandler(std::make_unique<LTODiagnosticHandler>(this),
667 true);
668 }
669
670 namespace {
671 class LTODiagnosticInfo : public DiagnosticInfo {
672 const Twine &Msg;
673 public:
LTODiagnosticInfo(const Twine & DiagMsg,DiagnosticSeverity Severity=DS_Error)674 LTODiagnosticInfo(const Twine &DiagMsg, DiagnosticSeverity Severity=DS_Error)
675 : DiagnosticInfo(DK_Linker, Severity), Msg(DiagMsg) {}
print(DiagnosticPrinter & DP) const676 void print(DiagnosticPrinter &DP) const override { DP << Msg; }
677 };
678 }
679
emitError(const std::string & ErrMsg)680 void LTOCodeGenerator::emitError(const std::string &ErrMsg) {
681 if (DiagHandler)
682 (*DiagHandler)(LTO_DS_ERROR, ErrMsg.c_str(), DiagContext);
683 else
684 Context.diagnose(LTODiagnosticInfo(ErrMsg));
685 }
686
emitWarning(const std::string & ErrMsg)687 void LTOCodeGenerator::emitWarning(const std::string &ErrMsg) {
688 if (DiagHandler)
689 (*DiagHandler)(LTO_DS_WARNING, ErrMsg.c_str(), DiagContext);
690 else
691 Context.diagnose(LTODiagnosticInfo(ErrMsg, DS_Warning));
692 }
693