src/rustllvm/PassWrapper.cpp

   1 #include <stdio.h>
   2
   3 #include <vector>
   4 #include <set>
   5
   6 #include "rustllvm.h"
   7
   8 #include "llvm/Analysis/TargetLibraryInfo.h"
   9 #include "llvm/Analysis/TargetTransformInfo.h"
  10 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  11 #include "llvm/IR/AutoUpgrade.h"
  12 #include "llvm/IR/AssemblyAnnotationWriter.h"
  13 #include "llvm/IR/IntrinsicInst.h"
  14 #include "llvm/Support/CBindingWrapping.h"
  15 #include "llvm/Support/FileSystem.h"
  16 #include "llvm/Support/Host.h"
  17 #include "llvm/Target/TargetMachine.h"
  18 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
  19 #include "llvm/Transforms/IPO/AlwaysInliner.h"
  20 #include "llvm/Transforms/IPO/FunctionImport.h"
  21 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
  22 #include "llvm/LTO/LTO.h"
  23 #include "llvm-c/Transforms/PassManagerBuilder.h"
  24
  25 #include "llvm/Transforms/Instrumentation.h"
  26 #if LLVM_VERSION_GE(9, 0)
  27 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
  28 #endif
  29 #if LLVM_VERSION_GE(8, 0)
  30 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
  31 #include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
  32 #endif
  33
  34 using namespace llvm;
  35 using namespace llvm::legacy;
  36
  37 typedef struct LLVMOpaquePass *LLVMPassRef;
  38 typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef;
  39
  40 DEFINE_STDCXX_CONVERSION_FUNCTIONS(Pass, LLVMPassRef)
  41 DEFINE_STDCXX_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
  42 DEFINE_STDCXX_CONVERSION_FUNCTIONS(PassManagerBuilder,
  43                                    LLVMPassManagerBuilderRef)
  44
  45 extern "C" void LLVMInitializePasses() {
  46   PassRegistry &Registry = *PassRegistry::getPassRegistry();
  47   initializeCore(Registry);
  48   initializeCodeGen(Registry);
  49   initializeScalarOpts(Registry);
  50   initializeVectorization(Registry);
  51   initializeIPO(Registry);
  52   initializeAnalysis(Registry);
  53   initializeTransformUtils(Registry);
  54   initializeInstCombine(Registry);
  55   initializeInstrumentation(Registry);
  56   initializeTarget(Registry);
  57 }
  58
  59 enum class LLVMRustPassKind {
  60   Other,
  61   Function,
  62   Module,
  63 };
  64
  65 static LLVMRustPassKind toRust(PassKind Kind) {
  66   switch (Kind) {
  67   case PT_Function:
  68     return LLVMRustPassKind::Function;
  69   case PT_Module:
  70     return LLVMRustPassKind::Module;
  71   default:
  72     return LLVMRustPassKind::Other;
  73   }
  74 }
  75
  76 extern "C" LLVMPassRef LLVMRustFindAndCreatePass(const char *PassName) {
  77   StringRef SR(PassName);
  78   PassRegistry *PR = PassRegistry::getPassRegistry();
  79
  80   const PassInfo *PI = PR->getPassInfo(SR);
  81   if (PI) {
  82     return wrap(PI->createPass());
  83   }
  84   return nullptr;
  85 }
  86
  87 extern "C" LLVMPassRef LLVMRustCreateAddressSanitizerFunctionPass(bool Recover) {
  88   const bool CompileKernel = false;
  89
  90   return wrap(createAddressSanitizerFunctionPass(CompileKernel, Recover));
  91 }
  92
  93 extern "C" LLVMPassRef LLVMRustCreateModuleAddressSanitizerPass(bool Recover) {
  94   const bool CompileKernel = false;
  95
  96 #if LLVM_VERSION_GE(9, 0)
  97   return wrap(createModuleAddressSanitizerLegacyPassPass(CompileKernel, Recover));
  98 #else
  99   return wrap(createAddressSanitizerModulePass(CompileKernel, Recover));
 100 #endif
 101 }
 102
 103 extern "C" LLVMPassRef LLVMRustCreateMemorySanitizerPass(int TrackOrigins, bool Recover) {
 104 #if LLVM_VERSION_GE(8, 0)
 105   const bool CompileKernel = false;
 106
 107   return wrap(createMemorySanitizerLegacyPassPass(
 108       MemorySanitizerOptions{TrackOrigins, Recover, CompileKernel}));
 109 #else
 110   return wrap(createMemorySanitizerPass(TrackOrigins, Recover));
 111 #endif
 112 }
 113
 114 extern "C" LLVMPassRef LLVMRustCreateThreadSanitizerPass() {
 115 #if LLVM_VERSION_GE(8, 0)
 116   return wrap(createThreadSanitizerLegacyPassPass());
 117 #else
 118   return wrap(createThreadSanitizerPass());
 119 #endif
 120 }
 121
 122 extern "C" LLVMRustPassKind LLVMRustPassKind(LLVMPassRef RustPass) {
 123   assert(RustPass);
 124   Pass *Pass = unwrap(RustPass);
 125   return toRust(Pass->getPassKind());
 126 }
 127
 128 extern "C" void LLVMRustAddPass(LLVMPassManagerRef PMR, LLVMPassRef RustPass) {
 129   assert(RustPass);
 130   Pass *Pass = unwrap(RustPass);
 131   PassManagerBase *PMB = unwrap(PMR);
 132   PMB->add(Pass);
 133 }
 134
 135 extern "C"
 136 void LLVMRustPassManagerBuilderPopulateThinLTOPassManager(
 137   LLVMPassManagerBuilderRef PMBR,
 138   LLVMPassManagerRef PMR
 139 ) {
 140   unwrap(PMBR)->populateThinLTOPassManager(*unwrap(PMR));
 141 }
 142
 143 extern "C"
 144 void LLVMRustAddLastExtensionPasses(
 145     LLVMPassManagerBuilderRef PMBR, LLVMPassRef *Passes, size_t NumPasses) {
 146   auto AddExtensionPasses = [Passes, NumPasses](
 147       const PassManagerBuilder &Builder, PassManagerBase &PM) {
 148     for (size_t I = 0; I < NumPasses; I++) {
 149       PM.add(unwrap(Passes[I]));
 150     }
 151   };
 152   // Add the passes to both of the pre-finalization extension points,
 153   // so they are run for optimized and non-optimized builds.
 154   unwrap(PMBR)->addExtension(PassManagerBuilder::EP_OptimizerLast,
 155                              AddExtensionPasses);
 156   unwrap(PMBR)->addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
 157                              AddExtensionPasses);
 158 }
 159
 160 #ifdef LLVM_COMPONENT_X86
 161 #define SUBTARGET_X86 SUBTARGET(X86)
 162 #else
 163 #define SUBTARGET_X86
 164 #endif
 165
 166 #ifdef LLVM_COMPONENT_ARM
 167 #define SUBTARGET_ARM SUBTARGET(ARM)
 168 #else
 169 #define SUBTARGET_ARM
 170 #endif
 171
 172 #ifdef LLVM_COMPONENT_AARCH64
 173 #define SUBTARGET_AARCH64 SUBTARGET(AArch64)
 174 #else
 175 #define SUBTARGET_AARCH64
 176 #endif
 177
 178 #ifdef LLVM_COMPONENT_MIPS
 179 #define SUBTARGET_MIPS SUBTARGET(Mips)
 180 #else
 181 #define SUBTARGET_MIPS
 182 #endif
 183
 184 #ifdef LLVM_COMPONENT_POWERPC
 185 #define SUBTARGET_PPC SUBTARGET(PPC)
 186 #else
 187 #define SUBTARGET_PPC
 188 #endif
 189
 190 #ifdef LLVM_COMPONENT_SYSTEMZ
 191 #define SUBTARGET_SYSTEMZ SUBTARGET(SystemZ)
 192 #else
 193 #define SUBTARGET_SYSTEMZ
 194 #endif
 195
 196 #ifdef LLVM_COMPONENT_MSP430
 197 #define SUBTARGET_MSP430 SUBTARGET(MSP430)
 198 #else
 199 #define SUBTARGET_MSP430
 200 #endif
 201
 202 #ifdef LLVM_COMPONENT_RISCV
 203 #define SUBTARGET_RISCV SUBTARGET(RISCV)
 204 #else
 205 #define SUBTARGET_RISCV
 206 #endif
 207
 208 #ifdef LLVM_COMPONENT_SPARC
 209 #define SUBTARGET_SPARC SUBTARGET(Sparc)
 210 #else
 211 #define SUBTARGET_SPARC
 212 #endif
 213
 214 #ifdef LLVM_COMPONENT_HEXAGON
 215 #define SUBTARGET_HEXAGON SUBTARGET(Hexagon)
 216 #else
 217 #define SUBTARGET_HEXAGON
 218 #endif
 219
 220 #define GEN_SUBTARGETS                                                         \
 221   SUBTARGET_X86                                                                \
 222   SUBTARGET_ARM                                                                \
 223   SUBTARGET_AARCH64                                                            \
 224   SUBTARGET_MIPS                                                               \
 225   SUBTARGET_PPC                                                                \
 226   SUBTARGET_SYSTEMZ                                                            \
 227   SUBTARGET_MSP430                                                             \
 228   SUBTARGET_SPARC                                                              \
 229   SUBTARGET_HEXAGON                                                            \
 230   SUBTARGET_RISCV                                                              \
 231
 232 #define SUBTARGET(x)                                                           \
 233   namespace llvm {                                                             \
 234   extern const SubtargetFeatureKV x##FeatureKV[];                              \
 235   extern const SubtargetFeatureKV x##SubTypeKV[];                              \
 236   }
 237
 238 GEN_SUBTARGETS
 239 #undef SUBTARGET
 240
 241 extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM,
 242                                    const char *Feature) {
 243   TargetMachine *Target = unwrap(TM);
 244   const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
 245   return MCInfo->checkFeatures(std::string("+") + Feature);
 246 }
 247
 248 enum class LLVMRustCodeModel {
 249   Other,
 250   Small,
 251   Kernel,
 252   Medium,
 253   Large,
 254   None,
 255 };
 256
 257 static CodeModel::Model fromRust(LLVMRustCodeModel Model) {
 258   switch (Model) {
 259   case LLVMRustCodeModel::Small:
 260     return CodeModel::Small;
 261   case LLVMRustCodeModel::Kernel:
 262     return CodeModel::Kernel;
 263   case LLVMRustCodeModel::Medium:
 264     return CodeModel::Medium;
 265   case LLVMRustCodeModel::Large:
 266     return CodeModel::Large;
 267   default:
 268     report_fatal_error("Bad CodeModel.");
 269   }
 270 }
 271
 272 enum class LLVMRustCodeGenOptLevel {
 273   Other,
 274   None,
 275   Less,
 276   Default,
 277   Aggressive,
 278 };
 279
 280 static CodeGenOpt::Level fromRust(LLVMRustCodeGenOptLevel Level) {
 281   switch (Level) {
 282   case LLVMRustCodeGenOptLevel::None:
 283     return CodeGenOpt::None;
 284   case LLVMRustCodeGenOptLevel::Less:
 285     return CodeGenOpt::Less;
 286   case LLVMRustCodeGenOptLevel::Default:
 287     return CodeGenOpt::Default;
 288   case LLVMRustCodeGenOptLevel::Aggressive:
 289     return CodeGenOpt::Aggressive;
 290   default:
 291     report_fatal_error("Bad CodeGenOptLevel.");
 292   }
 293 }
 294
 295 enum class LLVMRustRelocMode {
 296   Default,
 297   Static,
 298   PIC,
 299   DynamicNoPic,
 300   ROPI,
 301   RWPI,
 302   ROPIRWPI,
 303 };
 304
 305 static Optional<Reloc::Model> fromRust(LLVMRustRelocMode RustReloc) {
 306   switch (RustReloc) {
 307   case LLVMRustRelocMode::Default:
 308     return None;
 309   case LLVMRustRelocMode::Static:
 310     return Reloc::Static;
 311   case LLVMRustRelocMode::PIC:
 312     return Reloc::PIC_;
 313   case LLVMRustRelocMode::DynamicNoPic:
 314     return Reloc::DynamicNoPIC;
 315   case LLVMRustRelocMode::ROPI:
 316     return Reloc::ROPI;
 317   case LLVMRustRelocMode::RWPI:
 318     return Reloc::RWPI;
 319   case LLVMRustRelocMode::ROPIRWPI:
 320     return Reloc::ROPI_RWPI;
 321   }
 322   report_fatal_error("Bad RelocModel.");
 323 }
 324
 325 #ifdef LLVM_RUSTLLVM
 326 /// getLongestEntryLength - Return the length of the longest entry in the table.
 327 template<typename KV>
 328 static size_t getLongestEntryLength(ArrayRef<KV> Table) {
 329   size_t MaxLen = 0;
 330   for (auto &I : Table)
 331     MaxLen = std::max(MaxLen, std::strlen(I.Key));
 332   return MaxLen;
 333 }
 334
 335 extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef TM) {
 336   const TargetMachine *Target = unwrap(TM);
 337   const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
 338   const Triple::ArchType HostArch = Triple(sys::getProcessTriple()).getArch();
 339   const Triple::ArchType TargetArch = Target->getTargetTriple().getArch();
 340   const ArrayRef<SubtargetSubTypeKV> CPUTable = MCInfo->getCPUTable();
 341   unsigned MaxCPULen = getLongestEntryLength(CPUTable);
 342
 343   printf("Available CPUs for this target:\n");
 344   if (HostArch == TargetArch) {
 345     const StringRef HostCPU = sys::getHostCPUName();
 346     printf("    %-*s - Select the CPU of the current host (currently %.*s).\n",
 347       MaxCPULen, "native", (int)HostCPU.size(), HostCPU.data());
 348   }
 349   for (auto &CPU : CPUTable)
 350     printf("    %-*s\n", MaxCPULen, CPU.Key);
 351   printf("\n");
 352 }
 353
 354 extern "C" void LLVMRustPrintTargetFeatures(LLVMTargetMachineRef TM) {
 355   const TargetMachine *Target = unwrap(TM);
 356   const MCSubtargetInfo *MCInfo = Target->getMCSubtargetInfo();
 357   const ArrayRef<SubtargetFeatureKV> FeatTable = MCInfo->getFeatureTable();
 358   unsigned MaxFeatLen = getLongestEntryLength(FeatTable);
 359
 360   printf("Available features for this target:\n");
 361   for (auto &Feature : FeatTable)
 362     printf("    %-*s - %s.\n", MaxFeatLen, Feature.Key, Feature.Desc);
 363   printf("\n");
 364
 365   printf("Use +feature to enable a feature, or -feature to disable it.\n"
 366          "For example, rustc -C -target-cpu=mycpu -C "
 367          "target-feature=+feature1,-feature2\n\n");
 368 }
 369
 370 #else
 371
 372 extern "C" void LLVMRustPrintTargetCPUs(LLVMTargetMachineRef) {
 373   printf("Target CPU help is not supported by this LLVM version.\n\n");
 374 }
 375
 376 extern "C" void LLVMRustPrintTargetFeatures(LLVMTargetMachineRef) {
 377   printf("Target features help is not supported by this LLVM version.\n\n");
 378 }
 379 #endif
 380
 381 extern "C" const char* LLVMRustGetHostCPUName(size_t *len) {
 382   StringRef Name = sys::getHostCPUName();
 383   *len = Name.size();
 384   return Name.data();
 385 }
 386
 387 extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
 388     const char *TripleStr, const char *CPU, const char *Feature,
 389     const char *ABIStr, LLVMRustCodeModel RustCM, LLVMRustRelocMode RustReloc,
 390     LLVMRustCodeGenOptLevel RustOptLevel, bool UseSoftFloat,
 391     bool PositionIndependentExecutable, bool FunctionSections,
 392     bool DataSections,
 393     bool TrapUnreachable,
 394     bool Singlethread,
 395     bool AsmComments,
 396     bool EmitStackSizeSection) {
 397
 398   auto OptLevel = fromRust(RustOptLevel);
 399   auto RM = fromRust(RustReloc);
 400
 401   std::string Error;
 402   Triple Trip(Triple::normalize(TripleStr));
 403   const llvm::Target *TheTarget =
 404       TargetRegistry::lookupTarget(Trip.getTriple(), Error);
 405   if (TheTarget == nullptr) {
 406     LLVMRustSetLastError(Error.c_str());
 407     return nullptr;
 408   }
 409
 410   TargetOptions Options;
 411
 412   Options.FloatABIType = FloatABI::Default;
 413   if (UseSoftFloat) {
 414     Options.FloatABIType = FloatABI::Soft;
 415   }
 416   Options.DataSections = DataSections;
 417   Options.FunctionSections = FunctionSections;
 418   Options.MCOptions.AsmVerbose = AsmComments;
 419   Options.MCOptions.PreserveAsmComments = AsmComments;
 420   Options.MCOptions.ABIName = ABIStr;
 421
 422   if (TrapUnreachable) {
 423     // Tell LLVM to codegen `unreachable` into an explicit trap instruction.
 424     // This limits the extent of possible undefined behavior in some cases, as
 425     // it prevents control flow from "falling through" into whatever code
 426     // happens to be laid out next in memory.
 427     Options.TrapUnreachable = true;
 428   }
 429
 430   if (Singlethread) {
 431     Options.ThreadModel = ThreadModel::Single;
 432   }
 433
 434   Options.EmitStackSizeSection = EmitStackSizeSection;
 435
 436   Optional<CodeModel::Model> CM;
 437   if (RustCM != LLVMRustCodeModel::None)
 438     CM = fromRust(RustCM);
 439   TargetMachine *TM = TheTarget->createTargetMachine(
 440       Trip.getTriple(), CPU, Feature, Options, RM, CM, OptLevel);
 441   return wrap(TM);
 442 }
 443
 444 extern "C" void LLVMRustDisposeTargetMachine(LLVMTargetMachineRef TM) {
 445   delete unwrap(TM);
 446 }
 447
 448 extern "C" void LLVMRustConfigurePassManagerBuilder(
 449     LLVMPassManagerBuilderRef PMBR, LLVMRustCodeGenOptLevel OptLevel,
 450     bool MergeFunctions, bool SLPVectorize, bool LoopVectorize, bool PrepareForThinLTO,
 451     const char* PGOGenPath, const char* PGOUsePath) {
 452 #if LLVM_VERSION_GE(7, 0)
 453   unwrap(PMBR)->MergeFunctions = MergeFunctions;
 454 #endif
 455   unwrap(PMBR)->SLPVectorize = SLPVectorize;
 456   unwrap(PMBR)->OptLevel = fromRust(OptLevel);
 457   unwrap(PMBR)->LoopVectorize = LoopVectorize;
 458   unwrap(PMBR)->PrepareForThinLTO = PrepareForThinLTO;
 459
 460   if (PGOGenPath) {
 461     assert(!PGOUsePath);
 462     unwrap(PMBR)->EnablePGOInstrGen = true;
 463     unwrap(PMBR)->PGOInstrGen = PGOGenPath;
 464   }
 465   if (PGOUsePath) {
 466     assert(!PGOGenPath);
 467     unwrap(PMBR)->PGOInstrUse = PGOUsePath;
 468   }
 469 }
 470
 471 // Unfortunately, the LLVM C API doesn't provide a way to set the `LibraryInfo`
 472 // field of a PassManagerBuilder, we expose our own method of doing so.
 473 extern "C" void LLVMRustAddBuilderLibraryInfo(LLVMPassManagerBuilderRef PMBR,
 474                                               LLVMModuleRef M,
 475                                               bool DisableSimplifyLibCalls) {
 476   Triple TargetTriple(unwrap(M)->getTargetTriple());
 477   TargetLibraryInfoImpl *TLI = new TargetLibraryInfoImpl(TargetTriple);
 478   if (DisableSimplifyLibCalls)
 479     TLI->disableAllFunctions();
 480   unwrap(PMBR)->LibraryInfo = TLI;
 481 }
 482
 483 // Unfortunately, the LLVM C API doesn't provide a way to create the
 484 // TargetLibraryInfo pass, so we use this method to do so.
 485 extern "C" void LLVMRustAddLibraryInfo(LLVMPassManagerRef PMR, LLVMModuleRef M,
 486                                        bool DisableSimplifyLibCalls) {
 487   Triple TargetTriple(unwrap(M)->getTargetTriple());
 488   TargetLibraryInfoImpl TLII(TargetTriple);
 489   if (DisableSimplifyLibCalls)
 490     TLII.disableAllFunctions();
 491   unwrap(PMR)->add(new TargetLibraryInfoWrapperPass(TLII));
 492 }
 493
 494 // Unfortunately, the LLVM C API doesn't provide an easy way of iterating over
 495 // all the functions in a module, so we do that manually here. You'll find
 496 // similar code in clang's BackendUtil.cpp file.
 497 extern "C" void LLVMRustRunFunctionPassManager(LLVMPassManagerRef PMR,
 498                                                LLVMModuleRef M) {
 499   llvm::legacy::FunctionPassManager *P =
 500       unwrap<llvm::legacy::FunctionPassManager>(PMR);
 501   P->doInitialization();
 502
 503   // Upgrade all calls to old intrinsics first.
 504   for (Module::iterator I = unwrap(M)->begin(), E = unwrap(M)->end(); I != E;)
 505     UpgradeCallsToIntrinsic(&*I++); // must be post-increment, as we remove
 506
 507   for (Module::iterator I = unwrap(M)->begin(), E = unwrap(M)->end(); I != E;
 508        ++I)
 509     if (!I->isDeclaration())
 510       P->run(*I);
 511
 512   P->doFinalization();
 513 }
 514
 515 extern "C" void LLVMRustSetLLVMOptions(int Argc, char **Argv) {
 516   // Initializing the command-line options more than once is not allowed. So,
 517   // check if they've already been initialized.  (This could happen if we're
 518   // being called from rustpkg, for example). If the arguments change, then
 519   // that's just kinda unfortunate.
 520   static bool Initialized = false;
 521   if (Initialized)
 522     return;
 523   Initialized = true;
 524   cl::ParseCommandLineOptions(Argc, Argv);
 525 }
 526
 527 enum class LLVMRustFileType {
 528   Other,
 529   AssemblyFile,
 530   ObjectFile,
 531 };
 532
 533 static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) {
 534   switch (Type) {
 535   case LLVMRustFileType::AssemblyFile:
 536     return TargetMachine::CGFT_AssemblyFile;
 537   case LLVMRustFileType::ObjectFile:
 538     return TargetMachine::CGFT_ObjectFile;
 539   default:
 540     report_fatal_error("Bad FileType.");
 541   }
 542 }
 543
 544 extern "C" LLVMRustResult
 545 LLVMRustWriteOutputFile(LLVMTargetMachineRef Target, LLVMPassManagerRef PMR,
 546                         LLVMModuleRef M, const char *Path,
 547                         LLVMRustFileType RustFileType) {
 548   llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
 549   auto FileType = fromRust(RustFileType);
 550
 551   std::string ErrorInfo;
 552   std::error_code EC;
 553   raw_fd_ostream OS(Path, EC, sys::fs::F_None);
 554   if (EC)
 555     ErrorInfo = EC.message();
 556   if (ErrorInfo != "") {
 557     LLVMRustSetLastError(ErrorInfo.c_str());
 558     return LLVMRustResult::Failure;
 559   }
 560
 561 #if LLVM_VERSION_GE(7, 0)
 562   buffer_ostream BOS(OS);
 563   unwrap(Target)->addPassesToEmitFile(*PM, BOS, nullptr, FileType, false);
 564 #else
 565   unwrap(Target)->addPassesToEmitFile(*PM, OS, FileType, false);
 566 #endif
 567   PM->run(*unwrap(M));
 568
 569   // Apparently `addPassesToEmitFile` adds a pointer to our on-the-stack output
 570   // stream (OS), so the only real safe place to delete this is here? Don't we
 571   // wish this was written in Rust?
 572   LLVMDisposePassManager(PMR);
 573   return LLVMRustResult::Success;
 574 }
 575
 576
 577 // Callback to demangle function name
 578 // Parameters:
 579 // * name to be demangled
 580 // * name len
 581 // * output buffer
 582 // * output buffer len
 583 // Returns len of demangled string, or 0 if demangle failed.
 584 typedef size_t (*DemangleFn)(const char*, size_t, char*, size_t);
 585
 586
 587 namespace {
 588
 589 class RustAssemblyAnnotationWriter : public AssemblyAnnotationWriter {
 590   DemangleFn Demangle;
 591   std::vector<char> Buf;
 592
 593 public:
 594   RustAssemblyAnnotationWriter(DemangleFn Demangle) : Demangle(Demangle) {}
 595
 596   // Return empty string if demangle failed
 597   // or if name does not need to be demangled
 598   StringRef CallDemangle(StringRef name) {
 599     if (!Demangle) {
 600       return StringRef();
 601     }
 602
 603     if (Buf.size() < name.size() * 2) {
 604       // Semangled name usually shorter than mangled,
 605       // but allocate twice as much memory just in case
 606       Buf.resize(name.size() * 2);
 607     }
 608
 609     auto R = Demangle(name.data(), name.size(), Buf.data(), Buf.size());
 610     if (!R) {
 611       // Demangle failed.
 612       return StringRef();
 613     }
 614
 615     auto Demangled = StringRef(Buf.data(), R);
 616     if (Demangled == name) {
 617       // Do not print anything if demangled name is equal to mangled.
 618       return StringRef();
 619     }
 620
 621     return Demangled;
 622   }
 623
 624   void emitFunctionAnnot(const Function *F,
 625                          formatted_raw_ostream &OS) override {
 626     StringRef Demangled = CallDemangle(F->getName());
 627     if (Demangled.empty()) {
 628         return;
 629     }
 630
 631     OS << "; " << Demangled << "\n";
 632   }
 633
 634   void emitInstructionAnnot(const Instruction *I,
 635                             formatted_raw_ostream &OS) override {
 636     const char *Name;
 637     const Value *Value;
 638     if (const CallInst *CI = dyn_cast<CallInst>(I)) {
 639       Name = "call";
 640       Value = CI->getCalledValue();
 641     } else if (const InvokeInst* II = dyn_cast<InvokeInst>(I)) {
 642       Name = "invoke";
 643       Value = II->getCalledValue();
 644     } else {
 645       // Could demangle more operations, e. g.
 646       // `store %place, @function`.
 647       return;
 648     }
 649
 650     if (!Value->hasName()) {
 651       return;
 652     }
 653
 654     StringRef Demangled = CallDemangle(Value->getName());
 655     if (Demangled.empty()) {
 656       return;
 657     }
 658
 659     OS << "; " << Name << " " << Demangled << "\n";
 660   }
 661 };
 662
 663 } // namespace
 664
 665 extern "C" LLVMRustResult
 666 LLVMRustPrintModule(LLVMModuleRef M, const char *Path, DemangleFn Demangle) {
 667   std::string ErrorInfo;
 668   std::error_code EC;
 669   raw_fd_ostream OS(Path, EC, sys::fs::F_None);
 670   if (EC)
 671     ErrorInfo = EC.message();
 672   if (ErrorInfo != "") {
 673     LLVMRustSetLastError(ErrorInfo.c_str());
 674     return LLVMRustResult::Failure;
 675   }
 676
 677   RustAssemblyAnnotationWriter AAW(Demangle);
 678   formatted_raw_ostream FOS(OS);
 679   unwrap(M)->print(FOS, &AAW);
 680
 681   return LLVMRustResult::Success;
 682 }
 683
 684 extern "C" void LLVMRustPrintPasses() {
 685   LLVMInitializePasses();
 686   struct MyListener : PassRegistrationListener {
 687     void passEnumerate(const PassInfo *Info) {
 688       StringRef PassArg = Info->getPassArgument();
 689       StringRef PassName = Info->getPassName();
 690       if (!PassArg.empty()) {
 691         // These unsigned->signed casts could theoretically overflow, but
 692         // realistically never will (and even if, the result is implementation
 693         // defined rather plain UB).
 694         printf("%15.*s - %.*s\n", (int)PassArg.size(), PassArg.data(),
 695                (int)PassName.size(), PassName.data());
 696       }
 697     }
 698   } Listener;
 699
 700   PassRegistry *PR = PassRegistry::getPassRegistry();
 701   PR->enumerateWith(&Listener);
 702 }
 703
 704 extern "C" void LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMBR,
 705                                             bool AddLifetimes) {
 706   unwrap(PMBR)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes);
 707 }
 708
 709 extern "C" void LLVMRustRunRestrictionPass(LLVMModuleRef M, char **Symbols,
 710                                            size_t Len) {
 711   llvm::legacy::PassManager passes;
 712
 713   auto PreserveFunctions = [=](const GlobalValue &GV) {
 714     for (size_t I = 0; I < Len; I++) {
 715       if (GV.getName() == Symbols[I]) {
 716         return true;
 717       }
 718     }
 719     return false;
 720   };
 721
 722   passes.add(llvm::createInternalizePass(PreserveFunctions));
 723
 724   passes.run(*unwrap(M));
 725 }
 726
 727 extern "C" void LLVMRustMarkAllFunctionsNounwind(LLVMModuleRef M) {
 728   for (Module::iterator GV = unwrap(M)->begin(), E = unwrap(M)->end(); GV != E;
 729        ++GV) {
 730     GV->setDoesNotThrow();
 731     Function *F = dyn_cast<Function>(GV);
 732     if (F == nullptr)
 733       continue;
 734
 735     for (Function::iterator B = F->begin(), BE = F->end(); B != BE; ++B) {
 736       for (BasicBlock::iterator I = B->begin(), IE = B->end(); I != IE; ++I) {
 737         if (isa<InvokeInst>(I)) {
 738           InvokeInst *CI = cast<InvokeInst>(I);
 739           CI->setDoesNotThrow();
 740         }
 741       }
 742     }
 743   }
 744 }
 745
 746 extern "C" void
 747 LLVMRustSetDataLayoutFromTargetMachine(LLVMModuleRef Module,
 748                                        LLVMTargetMachineRef TMR) {
 749   TargetMachine *Target = unwrap(TMR);
 750   unwrap(Module)->setDataLayout(Target->createDataLayout());
 751 }
 752
 753 extern "C" void LLVMRustSetModulePICLevel(LLVMModuleRef M) {
 754   unwrap(M)->setPICLevel(PICLevel::Level::BigPIC);
 755 }
 756
 757 extern "C" void LLVMRustSetModulePIELevel(LLVMModuleRef M) {
 758   unwrap(M)->setPIELevel(PIELevel::Level::Large);
 759 }
 760
 761 // Here you'll find an implementation of ThinLTO as used by the Rust compiler
 762 // right now. This ThinLTO support is only enabled on "recent ish" versions of
 763 // LLVM, and otherwise it's just blanket rejected from other compilers.
 764 //
 765 // Most of this implementation is straight copied from LLVM. At the time of
 766 // this writing it wasn't *quite* suitable to reuse more code from upstream
 767 // for our purposes, but we should strive to upstream this support once it's
 768 // ready to go! I figure we may want a bit of testing locally first before
 769 // sending this upstream to LLVM. I hear though they're quite eager to receive
 770 // feedback like this!
 771 //
 772 // If you're reading this code and wondering "what in the world" or you're
 773 // working "good lord by LLVM upgrade is *still* failing due to these bindings"
 774 // then fear not! (ok maybe fear a little). All code here is mostly based
 775 // on `lib/LTO/ThinLTOCodeGenerator.cpp` in LLVM.
 776 //
 777 // You'll find that the general layout here roughly corresponds to the `run`
 778 // method in that file as well as `ProcessThinLTOModule`. Functions are
 779 // specifically commented below as well, but if you're updating this code
 780 // or otherwise trying to understand it, the LLVM source will be useful in
 781 // interpreting the mysteries within.
 782 //
 783 // Otherwise I'll apologize in advance, it probably requires a relatively
 784 // significant investment on your part to "truly understand" what's going on
 785 // here. Not saying I do myself, but it took me awhile staring at LLVM's source
 786 // and various online resources about ThinLTO to make heads or tails of all
 787 // this.
 788
 789 // This is a shared data structure which *must* be threadsafe to share
 790 // read-only amongst threads. This also corresponds basically to the arguments
 791 // of the `ProcessThinLTOModule` function in the LLVM source.
 792 struct LLVMRustThinLTOData {
 793   // The combined index that is the global analysis over all modules we're
 794   // performing ThinLTO for. This is mostly managed by LLVM.
 795   ModuleSummaryIndex Index;
 796
 797   // All modules we may look at, stored as in-memory serialized versions. This
 798   // is later used when inlining to ensure we can extract any module to inline
 799   // from.
 800   StringMap<MemoryBufferRef> ModuleMap;
 801
 802   // A set that we manage of everything we *don't* want internalized. Note that
 803   // this includes all transitive references right now as well, but it may not
 804   // always!
 805   DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
 806
 807   // Not 100% sure what these are, but they impact what's internalized and
 808   // what's inlined across modules, I believe.
 809   StringMap<FunctionImporter::ImportMapTy> ImportLists;
 810   StringMap<FunctionImporter::ExportSetTy> ExportLists;
 811   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
 812
 813 #if LLVM_VERSION_GE(7, 0)
 814   LLVMRustThinLTOData() : Index(/* HaveGVs = */ false) {}
 815 #endif
 816 };
 817
 818 // Just an argument to the `LLVMRustCreateThinLTOData` function below.
 819 struct LLVMRustThinLTOModule {
 820   const char *identifier;
 821   const char *data;
 822   size_t len;
 823 };
 824
 825 // This is copied from `lib/LTO/ThinLTOCodeGenerator.cpp`, not sure what it
 826 // does.
 827 static const GlobalValueSummary *
 828 getFirstDefinitionForLinker(const GlobalValueSummaryList &GVSummaryList) {
 829   auto StrongDefForLinker = llvm::find_if(
 830       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
 831         auto Linkage = Summary->linkage();
 832         return !GlobalValue::isAvailableExternallyLinkage(Linkage) &&
 833                !GlobalValue::isWeakForLinker(Linkage);
 834       });
 835   if (StrongDefForLinker != GVSummaryList.end())
 836     return StrongDefForLinker->get();
 837
 838   auto FirstDefForLinker = llvm::find_if(
 839       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
 840         auto Linkage = Summary->linkage();
 841         return !GlobalValue::isAvailableExternallyLinkage(Linkage);
 842       });
 843   if (FirstDefForLinker == GVSummaryList.end())
 844     return nullptr;
 845   return FirstDefForLinker->get();
 846 }
 847
 848 // The main entry point for creating the global ThinLTO analysis. The structure
 849 // here is basically the same as before threads are spawned in the `run`
 850 // function of `lib/LTO/ThinLTOCodeGenerator.cpp`.
 851 extern "C" LLVMRustThinLTOData*
 852 LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
 853                           int num_modules,
 854                           const char **preserved_symbols,
 855                           int num_symbols) {
 856   auto Ret = llvm::make_unique<LLVMRustThinLTOData>();
 857
 858   // Load each module's summary and merge it into one combined index
 859   for (int i = 0; i < num_modules; i++) {
 860     auto module = &modules[i];
 861     StringRef buffer(module->data, module->len);
 862     MemoryBufferRef mem_buffer(buffer, module->identifier);
 863
 864     Ret->ModuleMap[module->identifier] = mem_buffer;
 865
 866     if (Error Err = readModuleSummaryIndex(mem_buffer, Ret->Index, i)) {
 867       LLVMRustSetLastError(toString(std::move(Err)).c_str());
 868       return nullptr;
 869     }
 870   }
 871
 872   // Collect for each module the list of function it defines (GUID -> Summary)
 873   Ret->Index.collectDefinedGVSummariesPerModule(Ret->ModuleToDefinedGVSummaries);
 874
 875   // Convert the preserved symbols set from string to GUID, this is then needed
 876   // for internalization.
 877   for (int i = 0; i < num_symbols; i++) {
 878     auto GUID = GlobalValue::getGUID(preserved_symbols[i]);
 879     Ret->GUIDPreservedSymbols.insert(GUID);
 880   }
 881
 882   // Collect the import/export lists for all modules from the call-graph in the
 883   // combined index
 884   //
 885   // This is copied from `lib/LTO/ThinLTOCodeGenerator.cpp`
 886 #if LLVM_VERSION_GE(7, 0)
 887   auto deadIsPrevailing = [&](GlobalValue::GUID G) {
 888     return PrevailingType::Unknown;
 889   };
 890 #if LLVM_VERSION_GE(8, 0)
 891   // We don't have a complete picture in our use of ThinLTO, just our immediate
 892   // crate, so we need `ImportEnabled = false` to limit internalization.
 893   // Otherwise, we sometimes lose `static` values -- see #60184.
 894   computeDeadSymbolsWithConstProp(Ret->Index, Ret->GUIDPreservedSymbols,
 895                                   deadIsPrevailing, /* ImportEnabled = */ false);
 896 #else
 897   computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols, deadIsPrevailing);
 898 #endif
 899 #else
 900   computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols);
 901 #endif
 902   ComputeCrossModuleImport(
 903     Ret->Index,
 904     Ret->ModuleToDefinedGVSummaries,
 905     Ret->ImportLists,
 906     Ret->ExportLists
 907   );
 908
 909   // Resolve LinkOnce/Weak symbols, this has to be computed early be cause it
 910   // impacts the caching.
 911   //
 912   // This is copied from `lib/LTO/ThinLTOCodeGenerator.cpp` with some of this
 913   // being lifted from `lib/LTO/LTO.cpp` as well
 914   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
 915   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
 916   for (auto &I : Ret->Index) {
 917     if (I.second.SummaryList.size() > 1)
 918       PrevailingCopy[I.first] = getFirstDefinitionForLinker(I.second.SummaryList);
 919   }
 920   auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
 921     const auto &Prevailing = PrevailingCopy.find(GUID);
 922     if (Prevailing == PrevailingCopy.end())
 923       return true;
 924     return Prevailing->second == S;
 925   };
 926   auto recordNewLinkage = [&](StringRef ModuleIdentifier,
 927                               GlobalValue::GUID GUID,
 928                               GlobalValue::LinkageTypes NewLinkage) {
 929     ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
 930   };
 931 #if LLVM_VERSION_GE(9, 0)
 932   thinLTOResolvePrevailingInIndex(Ret->Index, isPrevailing, recordNewLinkage,
 933                                   Ret->GUIDPreservedSymbols);
 934 #elif LLVM_VERSION_GE(8, 0)
 935   thinLTOResolvePrevailingInIndex(Ret->Index, isPrevailing, recordNewLinkage);
 936 #else
 937   thinLTOResolveWeakForLinkerInIndex(Ret->Index, isPrevailing, recordNewLinkage);
 938 #endif
 939
 940   // Here we calculate an `ExportedGUIDs` set for use in the `isExported`
 941   // callback below. This callback below will dictate the linkage for all
 942   // summaries in the index, and we basically just only want to ensure that dead
 943   // symbols are internalized. Otherwise everything that's already external
 944   // linkage will stay as external, and internal will stay as internal.
 945   std::set<GlobalValue::GUID> ExportedGUIDs;
 946   for (auto &List : Ret->Index) {
 947     for (auto &GVS: List.second.SummaryList) {
 948       if (GlobalValue::isLocalLinkage(GVS->linkage()))
 949         continue;
 950       auto GUID = GVS->getOriginalName();
 951       if (GVS->flags().Live)
 952         ExportedGUIDs.insert(GUID);
 953     }
 954   }
 955   auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
 956     const auto &ExportList = Ret->ExportLists.find(ModuleIdentifier);
 957     return (ExportList != Ret->ExportLists.end() &&
 958       ExportList->second.count(GUID)) ||
 959       ExportedGUIDs.count(GUID);
 960   };
 961   thinLTOInternalizeAndPromoteInIndex(Ret->Index, isExported);
 962
 963   return Ret.release();
 964 }
 965
 966 extern "C" void
 967 LLVMRustFreeThinLTOData(LLVMRustThinLTOData *Data) {
 968   delete Data;
 969 }
 970
 971 // Below are the various passes that happen *per module* when doing ThinLTO.
 972 //
 973 // In other words, these are the functions that are all run concurrently
 974 // with one another, one per module. The passes here correspond to the analysis
 975 // passes in `lib/LTO/ThinLTOCodeGenerator.cpp`, currently found in the
 976 // `ProcessThinLTOModule` function. Here they're split up into separate steps
 977 // so rustc can save off the intermediate bytecode between each step.
 978
 979 extern "C" bool
 980 LLVMRustPrepareThinLTORename(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
 981   Module &Mod = *unwrap(M);
 982   if (renameModuleForThinLTO(Mod, Data->Index)) {
 983     LLVMRustSetLastError("renameModuleForThinLTO failed");
 984     return false;
 985   }
 986   return true;
 987 }
 988
 989 extern "C" bool
 990 LLVMRustPrepareThinLTOResolveWeak(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
 991   Module &Mod = *unwrap(M);
 992   const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
 993 #if LLVM_VERSION_GE(8, 0)
 994   thinLTOResolvePrevailingInModule(Mod, DefinedGlobals);
 995 #else
 996   thinLTOResolveWeakForLinkerModule(Mod, DefinedGlobals);
 997 #endif
 998   return true;
 999 }
1000
1001 extern "C" bool
1002 LLVMRustPrepareThinLTOInternalize(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
1003   Module &Mod = *unwrap(M);
1004   const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
1005   thinLTOInternalizeModule(Mod, DefinedGlobals);
1006   return true;
1007 }
1008
1009 extern "C" bool
1010 LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
1011   Module &Mod = *unwrap(M);
1012
1013   const auto &ImportList = Data->ImportLists.lookup(Mod.getModuleIdentifier());
1014   auto Loader = [&](StringRef Identifier) {
1015     const auto &Memory = Data->ModuleMap.lookup(Identifier);
1016     auto &Context = Mod.getContext();
1017     auto MOrErr = getLazyBitcodeModule(Memory, Context, true, true);
1018
1019     if (!MOrErr)
1020       return MOrErr;
1021
1022     // The rest of this closure is a workaround for
1023     // https://bugs.llvm.org/show_bug.cgi?id=38184 where during ThinLTO imports
1024     // we accidentally import wasm custom sections into different modules,
1025     // duplicating them by in the final output artifact.
1026     //
1027     // The issue is worked around here by manually removing the
1028     // `wasm.custom_sections` named metadata node from any imported module. This
1029     // we know isn't used by any optimization pass so there's no need for it to
1030     // be imported.
1031     //
1032     // Note that the metadata is currently lazily loaded, so we materialize it
1033     // here before looking up if there's metadata inside. The `FunctionImporter`
1034     // will immediately materialize metadata anyway after an import, so this
1035     // shouldn't be a perf hit.
1036     if (Error Err = (*MOrErr)->materializeMetadata()) {
1037       Expected<std::unique_ptr<Module>> Ret(std::move(Err));
1038       return Ret;
1039     }
1040
1041     auto *WasmCustomSections = (*MOrErr)->getNamedMetadata("wasm.custom_sections");
1042     if (WasmCustomSections)
1043       WasmCustomSections->eraseFromParent();
1044
1045     return MOrErr;
1046   };
1047   FunctionImporter Importer(Data->Index, Loader);
1048   Expected<bool> Result = Importer.importFunctions(Mod, ImportList);
1049   if (!Result) {
1050     LLVMRustSetLastError(toString(Result.takeError()).c_str());
1051     return false;
1052   }
1053   return true;
1054 }
1055
1056 extern "C" typedef void (*LLVMRustModuleNameCallback)(void*, // payload
1057                                                       const char*, // importing module name
1058                                                       const char*); // imported module name
1059
1060 // Calls `module_name_callback` for each module import done by ThinLTO.
1061 // The callback is provided with regular null-terminated C strings.
1062 extern "C" void
1063 LLVMRustGetThinLTOModuleImports(const LLVMRustThinLTOData *data,
1064                                 LLVMRustModuleNameCallback module_name_callback,
1065                                 void* callback_payload) {
1066   for (const auto& importing_module : data->ImportLists) {
1067     const std::string importing_module_id = importing_module.getKey().str();
1068     const auto& imports = importing_module.getValue();
1069     for (const auto& imported_module : imports) {
1070       const std::string imported_module_id = imported_module.getKey().str();
1071       module_name_callback(callback_payload,
1072                            importing_module_id.c_str(),
1073                            imported_module_id.c_str());
1074     }
1075   }
1076 }
1077
1078 // This struct and various functions are sort of a hack right now, but the
1079 // problem is that we've got in-memory LLVM modules after we generate and
1080 // optimize all codegen-units for one compilation in rustc. To be compatible
1081 // with the LTO support above we need to serialize the modules plus their
1082 // ThinLTO summary into memory.
1083 //
1084 // This structure is basically an owned version of a serialize module, with
1085 // a ThinLTO summary attached.
1086 struct LLVMRustThinLTOBuffer {
1087   std::string data;
1088 };
1089
1090 extern "C" LLVMRustThinLTOBuffer*
1091 LLVMRustThinLTOBufferCreate(LLVMModuleRef M) {
1092   auto Ret = llvm::make_unique<LLVMRustThinLTOBuffer>();
1093   {
1094     raw_string_ostream OS(Ret->data);
1095     {
1096       legacy::PassManager PM;
1097       PM.add(createWriteThinLTOBitcodePass(OS));
1098       PM.run(*unwrap(M));
1099     }
1100   }
1101   return Ret.release();
1102 }
1103
1104 extern "C" void
1105 LLVMRustThinLTOBufferFree(LLVMRustThinLTOBuffer *Buffer) {
1106   delete Buffer;
1107 }
1108
1109 extern "C" const void*
1110 LLVMRustThinLTOBufferPtr(const LLVMRustThinLTOBuffer *Buffer) {
1111   return Buffer->data.data();
1112 }
1113
1114 extern "C" size_t
1115 LLVMRustThinLTOBufferLen(const LLVMRustThinLTOBuffer *Buffer) {
1116   return Buffer->data.length();
1117 }
1118
1119 // This is what we used to parse upstream bitcode for actual ThinLTO
1120 // processing.  We'll call this once per module optimized through ThinLTO, and
1121 // it'll be called concurrently on many threads.
1122 extern "C" LLVMModuleRef
1123 LLVMRustParseBitcodeForLTO(LLVMContextRef Context,
1124                            const char *data,
1125                            size_t len,
1126                            const char *identifier) {
1127   StringRef Data(data, len);
1128   MemoryBufferRef Buffer(Data, identifier);
1129   unwrap(Context)->enableDebugTypeODRUniquing();
1130   Expected<std::unique_ptr<Module>> SrcOrError =
1131       parseBitcodeFile(Buffer, *unwrap(Context));
1132   if (!SrcOrError) {
1133     LLVMRustSetLastError(toString(SrcOrError.takeError()).c_str());
1134     return nullptr;
1135   }
1136   return wrap(std::move(*SrcOrError).release());
1137 }
1138
1139 // Rewrite all `DICompileUnit` pointers to the `DICompileUnit` specified. See
1140 // the comment in `back/lto.rs` for why this exists.
1141 extern "C" void
1142 LLVMRustThinLTOGetDICompileUnit(LLVMModuleRef Mod,
1143                                 DICompileUnit **A,
1144                                 DICompileUnit **B) {
1145   Module *M = unwrap(Mod);
1146   DICompileUnit **Cur = A;
1147   DICompileUnit **Next = B;
1148   for (DICompileUnit *CU : M->debug_compile_units()) {
1149     *Cur = CU;
1150     Cur = Next;
1151     Next = nullptr;
1152     if (Cur == nullptr)
1153       break;
1154   }
1155 }
1156
1157 // Rewrite all `DICompileUnit` pointers to the `DICompileUnit` specified. See
1158 // the comment in `back/lto.rs` for why this exists.
1159 extern "C" void
1160 LLVMRustThinLTOPatchDICompileUnit(LLVMModuleRef Mod, DICompileUnit *Unit) {
1161   Module *M = unwrap(Mod);
1162
1163   // If the original source module didn't have a `DICompileUnit` then try to
1164   // merge all the existing compile units. If there aren't actually any though
1165   // then there's not much for us to do so return.
1166   if (Unit == nullptr) {
1167     for (DICompileUnit *CU : M->debug_compile_units()) {
1168       Unit = CU;
1169       break;
1170     }
1171     if (Unit == nullptr)
1172       return;
1173   }
1174
1175   // Use LLVM's built-in `DebugInfoFinder` to find a bunch of debuginfo and
1176   // process it recursively. Note that we specifically iterate over instructions
1177   // to ensure we feed everything into it.
1178   DebugInfoFinder Finder;
1179   Finder.processModule(*M);
1180   for (Function &F : M->functions()) {
1181     for (auto &FI : F) {
1182       for (Instruction &BI : FI) {
1183         if (auto Loc = BI.getDebugLoc())
1184           Finder.processLocation(*M, Loc);
1185         if (auto DVI = dyn_cast<DbgValueInst>(&BI))
1186           Finder.processValue(*M, DVI);
1187         if (auto DDI = dyn_cast<DbgDeclareInst>(&BI))
1188           Finder.processDeclare(*M, DDI);
1189       }
1190     }
1191   }
1192
1193   // After we've found all our debuginfo, rewrite all subprograms to point to
1194   // the same `DICompileUnit`.
1195   for (auto &F : Finder.subprograms()) {
1196     F->replaceUnit(Unit);
1197   }
1198
1199   // Erase any other references to other `DICompileUnit` instances, the verifier
1200   // will later ensure that we don't actually have any other stale references to
1201   // worry about.
1202   auto *MD = M->getNamedMetadata("llvm.dbg.cu");
1203   MD->clearOperands();
1204   MD->addOperand(Unit);
1205 }