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 class RustPrintModulePass : public ModulePass {
 664   raw_ostream* OS;
 665   DemangleFn Demangle;
 666 public:
 667   static char ID;
 668   RustPrintModulePass() : ModulePass(ID), OS(nullptr), Demangle(nullptr) {}
 669   RustPrintModulePass(raw_ostream &OS, DemangleFn Demangle)
 670       : ModulePass(ID), OS(&OS), Demangle(Demangle) {}
 671
 672   bool runOnModule(Module &M) override {
 673     RustAssemblyAnnotationWriter AW(Demangle);
 674
 675     M.print(*OS, &AW, false);
 676
 677     return false;
 678   }
 679
 680   void getAnalysisUsage(AnalysisUsage &AU) const override {
 681     AU.setPreservesAll();
 682   }
 683
 684   static StringRef name() { return "RustPrintModulePass"; }
 685 };
 686
 687 } // namespace
 688
 689 namespace llvm {
 690   void initializeRustPrintModulePassPass(PassRegistry&);
 691 }
 692
 693 char RustPrintModulePass::ID = 0;
 694 INITIALIZE_PASS(RustPrintModulePass, "print-rust-module",
 695                 "Print rust module to stderr", false, false)
 696
 697 extern "C" LLVMRustResult
 698 LLVMRustPrintModule(LLVMPassManagerRef PMR, LLVMModuleRef M,
 699                     const char *Path, DemangleFn Demangle) {
 700   llvm::legacy::PassManager *PM = unwrap<llvm::legacy::PassManager>(PMR);
 701   std::string ErrorInfo;
 702
 703   std::error_code EC;
 704   raw_fd_ostream OS(Path, EC, sys::fs::F_None);
 705   if (EC)
 706     ErrorInfo = EC.message();
 707   if (ErrorInfo != "") {
 708     LLVMRustSetLastError(ErrorInfo.c_str());
 709     return LLVMRustResult::Failure;
 710   }
 711
 712   formatted_raw_ostream FOS(OS);
 713
 714   PM->add(new RustPrintModulePass(FOS, Demangle));
 715
 716   PM->run(*unwrap(M));
 717
 718   return LLVMRustResult::Success;
 719 }
 720
 721 extern "C" void LLVMRustPrintPasses() {
 722   LLVMInitializePasses();
 723   struct MyListener : PassRegistrationListener {
 724     void passEnumerate(const PassInfo *Info) {
 725       StringRef PassArg = Info->getPassArgument();
 726       StringRef PassName = Info->getPassName();
 727       if (!PassArg.empty()) {
 728         // These unsigned->signed casts could theoretically overflow, but
 729         // realistically never will (and even if, the result is implementation
 730         // defined rather plain UB).
 731         printf("%15.*s - %.*s\n", (int)PassArg.size(), PassArg.data(),
 732                (int)PassName.size(), PassName.data());
 733       }
 734     }
 735   } Listener;
 736
 737   PassRegistry *PR = PassRegistry::getPassRegistry();
 738   PR->enumerateWith(&Listener);
 739 }
 740
 741 extern "C" void LLVMRustAddAlwaysInlinePass(LLVMPassManagerBuilderRef PMBR,
 742                                             bool AddLifetimes) {
 743   unwrap(PMBR)->Inliner = llvm::createAlwaysInlinerLegacyPass(AddLifetimes);
 744 }
 745
 746 extern "C" void LLVMRustRunRestrictionPass(LLVMModuleRef M, char **Symbols,
 747                                            size_t Len) {
 748   llvm::legacy::PassManager passes;
 749
 750   auto PreserveFunctions = [=](const GlobalValue &GV) {
 751     for (size_t I = 0; I < Len; I++) {
 752       if (GV.getName() == Symbols[I]) {
 753         return true;
 754       }
 755     }
 756     return false;
 757   };
 758
 759   passes.add(llvm::createInternalizePass(PreserveFunctions));
 760
 761   passes.run(*unwrap(M));
 762 }
 763
 764 extern "C" void LLVMRustMarkAllFunctionsNounwind(LLVMModuleRef M) {
 765   for (Module::iterator GV = unwrap(M)->begin(), E = unwrap(M)->end(); GV != E;
 766        ++GV) {
 767     GV->setDoesNotThrow();
 768     Function *F = dyn_cast<Function>(GV);
 769     if (F == nullptr)
 770       continue;
 771
 772     for (Function::iterator B = F->begin(), BE = F->end(); B != BE; ++B) {
 773       for (BasicBlock::iterator I = B->begin(), IE = B->end(); I != IE; ++I) {
 774         if (isa<InvokeInst>(I)) {
 775           InvokeInst *CI = cast<InvokeInst>(I);
 776           CI->setDoesNotThrow();
 777         }
 778       }
 779     }
 780   }
 781 }
 782
 783 extern "C" void
 784 LLVMRustSetDataLayoutFromTargetMachine(LLVMModuleRef Module,
 785                                        LLVMTargetMachineRef TMR) {
 786   TargetMachine *Target = unwrap(TMR);
 787   unwrap(Module)->setDataLayout(Target->createDataLayout());
 788 }
 789
 790 extern "C" void LLVMRustSetModulePICLevel(LLVMModuleRef M) {
 791   unwrap(M)->setPICLevel(PICLevel::Level::BigPIC);
 792 }
 793
 794 extern "C" void LLVMRustSetModulePIELevel(LLVMModuleRef M) {
 795   unwrap(M)->setPIELevel(PIELevel::Level::Large);
 796 }
 797
 798 // Here you'll find an implementation of ThinLTO as used by the Rust compiler
 799 // right now. This ThinLTO support is only enabled on "recent ish" versions of
 800 // LLVM, and otherwise it's just blanket rejected from other compilers.
 801 //
 802 // Most of this implementation is straight copied from LLVM. At the time of
 803 // this writing it wasn't *quite* suitable to reuse more code from upstream
 804 // for our purposes, but we should strive to upstream this support once it's
 805 // ready to go! I figure we may want a bit of testing locally first before
 806 // sending this upstream to LLVM. I hear though they're quite eager to receive
 807 // feedback like this!
 808 //
 809 // If you're reading this code and wondering "what in the world" or you're
 810 // working "good lord by LLVM upgrade is *still* failing due to these bindings"
 811 // then fear not! (ok maybe fear a little). All code here is mostly based
 812 // on `lib/LTO/ThinLTOCodeGenerator.cpp` in LLVM.
 813 //
 814 // You'll find that the general layout here roughly corresponds to the `run`
 815 // method in that file as well as `ProcessThinLTOModule`. Functions are
 816 // specifically commented below as well, but if you're updating this code
 817 // or otherwise trying to understand it, the LLVM source will be useful in
 818 // interpreting the mysteries within.
 819 //
 820 // Otherwise I'll apologize in advance, it probably requires a relatively
 821 // significant investment on your part to "truly understand" what's going on
 822 // here. Not saying I do myself, but it took me awhile staring at LLVM's source
 823 // and various online resources about ThinLTO to make heads or tails of all
 824 // this.
 825
 826 // This is a shared data structure which *must* be threadsafe to share
 827 // read-only amongst threads. This also corresponds basically to the arguments
 828 // of the `ProcessThinLTOModule` function in the LLVM source.
 829 struct LLVMRustThinLTOData {
 830   // The combined index that is the global analysis over all modules we're
 831   // performing ThinLTO for. This is mostly managed by LLVM.
 832   ModuleSummaryIndex Index;
 833
 834   // All modules we may look at, stored as in-memory serialized versions. This
 835   // is later used when inlining to ensure we can extract any module to inline
 836   // from.
 837   StringMap<MemoryBufferRef> ModuleMap;
 838
 839   // A set that we manage of everything we *don't* want internalized. Note that
 840   // this includes all transitive references right now as well, but it may not
 841   // always!
 842   DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
 843
 844   // Not 100% sure what these are, but they impact what's internalized and
 845   // what's inlined across modules, I believe.
 846   StringMap<FunctionImporter::ImportMapTy> ImportLists;
 847   StringMap<FunctionImporter::ExportSetTy> ExportLists;
 848   StringMap<GVSummaryMapTy> ModuleToDefinedGVSummaries;
 849
 850 #if LLVM_VERSION_GE(7, 0)
 851   LLVMRustThinLTOData() : Index(/* HaveGVs = */ false) {}
 852 #endif
 853 };
 854
 855 // Just an argument to the `LLVMRustCreateThinLTOData` function below.
 856 struct LLVMRustThinLTOModule {
 857   const char *identifier;
 858   const char *data;
 859   size_t len;
 860 };
 861
 862 // This is copied from `lib/LTO/ThinLTOCodeGenerator.cpp`, not sure what it
 863 // does.
 864 static const GlobalValueSummary *
 865 getFirstDefinitionForLinker(const GlobalValueSummaryList &GVSummaryList) {
 866   auto StrongDefForLinker = llvm::find_if(
 867       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
 868         auto Linkage = Summary->linkage();
 869         return !GlobalValue::isAvailableExternallyLinkage(Linkage) &&
 870                !GlobalValue::isWeakForLinker(Linkage);
 871       });
 872   if (StrongDefForLinker != GVSummaryList.end())
 873     return StrongDefForLinker->get();
 874
 875   auto FirstDefForLinker = llvm::find_if(
 876       GVSummaryList, [](const std::unique_ptr<GlobalValueSummary> &Summary) {
 877         auto Linkage = Summary->linkage();
 878         return !GlobalValue::isAvailableExternallyLinkage(Linkage);
 879       });
 880   if (FirstDefForLinker == GVSummaryList.end())
 881     return nullptr;
 882   return FirstDefForLinker->get();
 883 }
 884
 885 // The main entry point for creating the global ThinLTO analysis. The structure
 886 // here is basically the same as before threads are spawned in the `run`
 887 // function of `lib/LTO/ThinLTOCodeGenerator.cpp`.
 888 extern "C" LLVMRustThinLTOData*
 889 LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
 890                           int num_modules,
 891                           const char **preserved_symbols,
 892                           int num_symbols) {
 893   auto Ret = llvm::make_unique<LLVMRustThinLTOData>();
 894
 895   // Load each module's summary and merge it into one combined index
 896   for (int i = 0; i < num_modules; i++) {
 897     auto module = &modules[i];
 898     StringRef buffer(module->data, module->len);
 899     MemoryBufferRef mem_buffer(buffer, module->identifier);
 900
 901     Ret->ModuleMap[module->identifier] = mem_buffer;
 902
 903     if (Error Err = readModuleSummaryIndex(mem_buffer, Ret->Index, i)) {
 904       LLVMRustSetLastError(toString(std::move(Err)).c_str());
 905       return nullptr;
 906     }
 907   }
 908
 909   // Collect for each module the list of function it defines (GUID -> Summary)
 910   Ret->Index.collectDefinedGVSummariesPerModule(Ret->ModuleToDefinedGVSummaries);
 911
 912   // Convert the preserved symbols set from string to GUID, this is then needed
 913   // for internalization.
 914   for (int i = 0; i < num_symbols; i++) {
 915     auto GUID = GlobalValue::getGUID(preserved_symbols[i]);
 916     Ret->GUIDPreservedSymbols.insert(GUID);
 917   }
 918
 919   // Collect the import/export lists for all modules from the call-graph in the
 920   // combined index
 921   //
 922   // This is copied from `lib/LTO/ThinLTOCodeGenerator.cpp`
 923 #if LLVM_VERSION_GE(7, 0)
 924   auto deadIsPrevailing = [&](GlobalValue::GUID G) {
 925     return PrevailingType::Unknown;
 926   };
 927 #if LLVM_VERSION_GE(8, 0)
 928   // We don't have a complete picture in our use of ThinLTO, just our immediate
 929   // crate, so we need `ImportEnabled = false` to limit internalization.
 930   // Otherwise, we sometimes lose `static` values -- see #60184.
 931   computeDeadSymbolsWithConstProp(Ret->Index, Ret->GUIDPreservedSymbols,
 932                                   deadIsPrevailing, /* ImportEnabled = */ false);
 933 #else
 934   computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols, deadIsPrevailing);
 935 #endif
 936 #else
 937   computeDeadSymbols(Ret->Index, Ret->GUIDPreservedSymbols);
 938 #endif
 939   ComputeCrossModuleImport(
 940     Ret->Index,
 941     Ret->ModuleToDefinedGVSummaries,
 942     Ret->ImportLists,
 943     Ret->ExportLists
 944   );
 945
 946   // Resolve LinkOnce/Weak symbols, this has to be computed early be cause it
 947   // impacts the caching.
 948   //
 949   // This is copied from `lib/LTO/ThinLTOCodeGenerator.cpp` with some of this
 950   // being lifted from `lib/LTO/LTO.cpp` as well
 951   StringMap<std::map<GlobalValue::GUID, GlobalValue::LinkageTypes>> ResolvedODR;
 952   DenseMap<GlobalValue::GUID, const GlobalValueSummary *> PrevailingCopy;
 953   for (auto &I : Ret->Index) {
 954     if (I.second.SummaryList.size() > 1)
 955       PrevailingCopy[I.first] = getFirstDefinitionForLinker(I.second.SummaryList);
 956   }
 957   auto isPrevailing = [&](GlobalValue::GUID GUID, const GlobalValueSummary *S) {
 958     const auto &Prevailing = PrevailingCopy.find(GUID);
 959     if (Prevailing == PrevailingCopy.end())
 960       return true;
 961     return Prevailing->second == S;
 962   };
 963   auto recordNewLinkage = [&](StringRef ModuleIdentifier,
 964                               GlobalValue::GUID GUID,
 965                               GlobalValue::LinkageTypes NewLinkage) {
 966     ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
 967   };
 968 #if LLVM_VERSION_GE(9, 0)
 969   thinLTOResolvePrevailingInIndex(Ret->Index, isPrevailing, recordNewLinkage,
 970                                   Ret->GUIDPreservedSymbols);
 971 #elif LLVM_VERSION_GE(8, 0)
 972   thinLTOResolvePrevailingInIndex(Ret->Index, isPrevailing, recordNewLinkage);
 973 #else
 974   thinLTOResolveWeakForLinkerInIndex(Ret->Index, isPrevailing, recordNewLinkage);
 975 #endif
 976
 977   // Here we calculate an `ExportedGUIDs` set for use in the `isExported`
 978   // callback below. This callback below will dictate the linkage for all
 979   // summaries in the index, and we basically just only want to ensure that dead
 980   // symbols are internalized. Otherwise everything that's already external
 981   // linkage will stay as external, and internal will stay as internal.
 982   std::set<GlobalValue::GUID> ExportedGUIDs;
 983   for (auto &List : Ret->Index) {
 984     for (auto &GVS: List.second.SummaryList) {
 985       if (GlobalValue::isLocalLinkage(GVS->linkage()))
 986         continue;
 987       auto GUID = GVS->getOriginalName();
 988       if (GVS->flags().Live)
 989         ExportedGUIDs.insert(GUID);
 990     }
 991   }
 992   auto isExported = [&](StringRef ModuleIdentifier, GlobalValue::GUID GUID) {
 993     const auto &ExportList = Ret->ExportLists.find(ModuleIdentifier);
 994     return (ExportList != Ret->ExportLists.end() &&
 995       ExportList->second.count(GUID)) ||
 996       ExportedGUIDs.count(GUID);
 997   };
 998   thinLTOInternalizeAndPromoteInIndex(Ret->Index, isExported);
 999
1000   return Ret.release();
1001 }
1002
1003 extern "C" void
1004 LLVMRustFreeThinLTOData(LLVMRustThinLTOData *Data) {
1005   delete Data;
1006 }
1007
1008 // Below are the various passes that happen *per module* when doing ThinLTO.
1009 //
1010 // In other words, these are the functions that are all run concurrently
1011 // with one another, one per module. The passes here correspond to the analysis
1012 // passes in `lib/LTO/ThinLTOCodeGenerator.cpp`, currently found in the
1013 // `ProcessThinLTOModule` function. Here they're split up into separate steps
1014 // so rustc can save off the intermediate bytecode between each step.
1015
1016 extern "C" bool
1017 LLVMRustPrepareThinLTORename(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
1018   Module &Mod = *unwrap(M);
1019   if (renameModuleForThinLTO(Mod, Data->Index)) {
1020     LLVMRustSetLastError("renameModuleForThinLTO failed");
1021     return false;
1022   }
1023   return true;
1024 }
1025
1026 extern "C" bool
1027 LLVMRustPrepareThinLTOResolveWeak(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
1028   Module &Mod = *unwrap(M);
1029   const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
1030 #if LLVM_VERSION_GE(8, 0)
1031   thinLTOResolvePrevailingInModule(Mod, DefinedGlobals);
1032 #else
1033   thinLTOResolveWeakForLinkerModule(Mod, DefinedGlobals);
1034 #endif
1035   return true;
1036 }
1037
1038 extern "C" bool
1039 LLVMRustPrepareThinLTOInternalize(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
1040   Module &Mod = *unwrap(M);
1041   const auto &DefinedGlobals = Data->ModuleToDefinedGVSummaries.lookup(Mod.getModuleIdentifier());
1042   thinLTOInternalizeModule(Mod, DefinedGlobals);
1043   return true;
1044 }
1045
1046 extern "C" bool
1047 LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
1048   Module &Mod = *unwrap(M);
1049
1050   const auto &ImportList = Data->ImportLists.lookup(Mod.getModuleIdentifier());
1051   auto Loader = [&](StringRef Identifier) {
1052     const auto &Memory = Data->ModuleMap.lookup(Identifier);
1053     auto &Context = Mod.getContext();
1054     auto MOrErr = getLazyBitcodeModule(Memory, Context, true, true);
1055
1056     if (!MOrErr)
1057       return MOrErr;
1058
1059     // The rest of this closure is a workaround for
1060     // https://bugs.llvm.org/show_bug.cgi?id=38184 where during ThinLTO imports
1061     // we accidentally import wasm custom sections into different modules,
1062     // duplicating them by in the final output artifact.
1063     //
1064     // The issue is worked around here by manually removing the
1065     // `wasm.custom_sections` named metadata node from any imported module. This
1066     // we know isn't used by any optimization pass so there's no need for it to
1067     // be imported.
1068     //
1069     // Note that the metadata is currently lazily loaded, so we materialize it
1070     // here before looking up if there's metadata inside. The `FunctionImporter`
1071     // will immediately materialize metadata anyway after an import, so this
1072     // shouldn't be a perf hit.
1073     if (Error Err = (*MOrErr)->materializeMetadata()) {
1074       Expected<std::unique_ptr<Module>> Ret(std::move(Err));
1075       return Ret;
1076     }
1077
1078     auto *WasmCustomSections = (*MOrErr)->getNamedMetadata("wasm.custom_sections");
1079     if (WasmCustomSections)
1080       WasmCustomSections->eraseFromParent();
1081
1082     return MOrErr;
1083   };
1084   FunctionImporter Importer(Data->Index, Loader);
1085   Expected<bool> Result = Importer.importFunctions(Mod, ImportList);
1086   if (!Result) {
1087     LLVMRustSetLastError(toString(Result.takeError()).c_str());
1088     return false;
1089   }
1090   return true;
1091 }
1092
1093 extern "C" typedef void (*LLVMRustModuleNameCallback)(void*, // payload
1094                                                       const char*, // importing module name
1095                                                       const char*); // imported module name
1096
1097 // Calls `module_name_callback` for each module import done by ThinLTO.
1098 // The callback is provided with regular null-terminated C strings.
1099 extern "C" void
1100 LLVMRustGetThinLTOModuleImports(const LLVMRustThinLTOData *data,
1101                                 LLVMRustModuleNameCallback module_name_callback,
1102                                 void* callback_payload) {
1103   for (const auto& importing_module : data->ImportLists) {
1104     const std::string importing_module_id = importing_module.getKey().str();
1105     const auto& imports = importing_module.getValue();
1106     for (const auto& imported_module : imports) {
1107       const std::string imported_module_id = imported_module.getKey().str();
1108       module_name_callback(callback_payload,
1109                            importing_module_id.c_str(),
1110                            imported_module_id.c_str());
1111     }
1112   }
1113 }
1114
1115 // This struct and various functions are sort of a hack right now, but the
1116 // problem is that we've got in-memory LLVM modules after we generate and
1117 // optimize all codegen-units for one compilation in rustc. To be compatible
1118 // with the LTO support above we need to serialize the modules plus their
1119 // ThinLTO summary into memory.
1120 //
1121 // This structure is basically an owned version of a serialize module, with
1122 // a ThinLTO summary attached.
1123 struct LLVMRustThinLTOBuffer {
1124   std::string data;
1125 };
1126
1127 extern "C" LLVMRustThinLTOBuffer*
1128 LLVMRustThinLTOBufferCreate(LLVMModuleRef M) {
1129   auto Ret = llvm::make_unique<LLVMRustThinLTOBuffer>();
1130   {
1131     raw_string_ostream OS(Ret->data);
1132     {
1133       legacy::PassManager PM;
1134       PM.add(createWriteThinLTOBitcodePass(OS));
1135       PM.run(*unwrap(M));
1136     }
1137   }
1138   return Ret.release();
1139 }
1140
1141 extern "C" void
1142 LLVMRustThinLTOBufferFree(LLVMRustThinLTOBuffer *Buffer) {
1143   delete Buffer;
1144 }
1145
1146 extern "C" const void*
1147 LLVMRustThinLTOBufferPtr(const LLVMRustThinLTOBuffer *Buffer) {
1148   return Buffer->data.data();
1149 }
1150
1151 extern "C" size_t
1152 LLVMRustThinLTOBufferLen(const LLVMRustThinLTOBuffer *Buffer) {
1153   return Buffer->data.length();
1154 }
1155
1156 // This is what we used to parse upstream bitcode for actual ThinLTO
1157 // processing.  We'll call this once per module optimized through ThinLTO, and
1158 // it'll be called concurrently on many threads.
1159 extern "C" LLVMModuleRef
1160 LLVMRustParseBitcodeForLTO(LLVMContextRef Context,
1161                            const char *data,
1162                            size_t len,
1163                            const char *identifier) {
1164   StringRef Data(data, len);
1165   MemoryBufferRef Buffer(Data, identifier);
1166   unwrap(Context)->enableDebugTypeODRUniquing();
1167   Expected<std::unique_ptr<Module>> SrcOrError =
1168       parseBitcodeFile(Buffer, *unwrap(Context));
1169   if (!SrcOrError) {
1170     LLVMRustSetLastError(toString(SrcOrError.takeError()).c_str());
1171     return nullptr;
1172   }
1173   return wrap(std::move(*SrcOrError).release());
1174 }
1175
1176 // Rewrite all `DICompileUnit` pointers to the `DICompileUnit` specified. See
1177 // the comment in `back/lto.rs` for why this exists.
1178 extern "C" void
1179 LLVMRustThinLTOGetDICompileUnit(LLVMModuleRef Mod,
1180                                 DICompileUnit **A,
1181                                 DICompileUnit **B) {
1182   Module *M = unwrap(Mod);
1183   DICompileUnit **Cur = A;
1184   DICompileUnit **Next = B;
1185   for (DICompileUnit *CU : M->debug_compile_units()) {
1186     *Cur = CU;
1187     Cur = Next;
1188     Next = nullptr;
1189     if (Cur == nullptr)
1190       break;
1191   }
1192 }
1193
1194 // Rewrite all `DICompileUnit` pointers to the `DICompileUnit` specified. See
1195 // the comment in `back/lto.rs` for why this exists.
1196 extern "C" void
1197 LLVMRustThinLTOPatchDICompileUnit(LLVMModuleRef Mod, DICompileUnit *Unit) {
1198   Module *M = unwrap(Mod);
1199
1200   // If the original source module didn't have a `DICompileUnit` then try to
1201   // merge all the existing compile units. If there aren't actually any though
1202   // then there's not much for us to do so return.
1203   if (Unit == nullptr) {
1204     for (DICompileUnit *CU : M->debug_compile_units()) {
1205       Unit = CU;
1206       break;
1207     }
1208     if (Unit == nullptr)
1209       return;
1210   }
1211
1212   // Use LLVM's built-in `DebugInfoFinder` to find a bunch of debuginfo and
1213   // process it recursively. Note that we specifically iterate over instructions
1214   // to ensure we feed everything into it.
1215   DebugInfoFinder Finder;
1216   Finder.processModule(*M);
1217   for (Function &F : M->functions()) {
1218     for (auto &FI : F) {
1219       for (Instruction &BI : FI) {
1220         if (auto Loc = BI.getDebugLoc())
1221           Finder.processLocation(*M, Loc);
1222         if (auto DVI = dyn_cast<DbgValueInst>(&BI))
1223           Finder.processValue(*M, DVI);
1224         if (auto DDI = dyn_cast<DbgDeclareInst>(&BI))
1225           Finder.processDeclare(*M, DDI);
1226       }
1227     }
1228   }
1229
1230   // After we've found all our debuginfo, rewrite all subprograms to point to
1231   // the same `DICompileUnit`.
1232   for (auto &F : Finder.subprograms()) {
1233     F->replaceUnit(Unit);
1234   }
1235
1236   // Erase any other references to other `DICompileUnit` instances, the verifier
1237   // will later ensure that we don't actually have any other stale references to
1238   // worry about.
1239   auto *MD = M->getNamedMetadata("llvm.dbg.cu");
1240   MD->clearOperands();
1241   MD->addOperand(Unit);
1242 }