src/rustllvm/RustWrapper.cpp

   1 #include "rustllvm.h"
   2 #include "llvm/IR/CallSite.h"
   3 #include "llvm/IR/DebugInfoMetadata.h"
   4 #include "llvm/IR/DiagnosticInfo.h"
   5 #include "llvm/IR/DiagnosticPrinter.h"
   6 #include "llvm/IR/GlobalVariable.h"
   7 #include "llvm/IR/Instructions.h"
   8 #include "llvm/Object/Archive.h"
   9 #include "llvm/Object/ObjectFile.h"
  10 #include "llvm/Bitcode/BitcodeWriterPass.h"
  11 #include "llvm/Support/Signals.h"
  12 #include "llvm/ADT/Optional.h"
  13
  14 #include <iostream>
  15
  16 //===----------------------------------------------------------------------===
  17 //
  18 // This file defines alternate interfaces to core functions that are more
  19 // readily callable by Rust's FFI.
  20 //
  21 //===----------------------------------------------------------------------===
  22
  23 using namespace llvm;
  24 using namespace llvm::sys;
  25 using namespace llvm::object;
  26
  27 // LLVMAtomicOrdering is already an enum - don't create another
  28 // one.
  29 static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
  30   switch (Ordering) {
  31   case LLVMAtomicOrderingNotAtomic:
  32     return AtomicOrdering::NotAtomic;
  33   case LLVMAtomicOrderingUnordered:
  34     return AtomicOrdering::Unordered;
  35   case LLVMAtomicOrderingMonotonic:
  36     return AtomicOrdering::Monotonic;
  37   case LLVMAtomicOrderingAcquire:
  38     return AtomicOrdering::Acquire;
  39   case LLVMAtomicOrderingRelease:
  40     return AtomicOrdering::Release;
  41   case LLVMAtomicOrderingAcquireRelease:
  42     return AtomicOrdering::AcquireRelease;
  43   case LLVMAtomicOrderingSequentiallyConsistent:
  44     return AtomicOrdering::SequentiallyConsistent;
  45   }
  46
  47   report_fatal_error("Invalid LLVMAtomicOrdering value!");
  48 }
  49
  50 static LLVM_THREAD_LOCAL char *LastError;
  51
  52 // Custom error handler for fatal LLVM errors.
  53 //
  54 // Notably it exits the process with code 101, unlike LLVM's default of 1.
  55 static void FatalErrorHandler(void *UserData,
  56                               const std::string& Reason,
  57                               bool GenCrashDiag) {
  58   // Do the same thing that the default error handler does.
  59   std::cerr << "LLVM ERROR: " << Reason << std::endl;
  60
  61   // Since this error handler exits the process, we have to run any cleanup that
  62   // LLVM would run after handling the error. This might change with an LLVM
  63   // upgrade.
  64   sys::RunInterruptHandlers();
  65
  66   exit(101);
  67 }
  68
  69 extern "C" void LLVMRustInstallFatalErrorHandler() {
  70   install_fatal_error_handler(FatalErrorHandler);
  71 }
  72
  73 extern "C" LLVMMemoryBufferRef
  74 LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) {
  75   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOr =
  76       MemoryBuffer::getFile(Path, -1, false);
  77   if (!BufOr) {
  78     LLVMRustSetLastError(BufOr.getError().message().c_str());
  79     return nullptr;
  80   }
  81   return wrap(BufOr.get().release());
  82 }
  83
  84 extern "C" char *LLVMRustGetLastError(void) {
  85   char *Ret = LastError;
  86   LastError = nullptr;
  87   return Ret;
  88 }
  89
  90 extern "C" void LLVMRustSetLastError(const char *Err) {
  91   free((void *)LastError);
  92   LastError = strdup(Err);
  93 }
  94
  95 extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) {
  96   auto ctx = new LLVMContext();
  97   ctx->setDiscardValueNames(shouldDiscardNames);
  98   return wrap(ctx);
  99 }
 100
 101 extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M,
 102                                             const char *Triple) {
 103   unwrap(M)->setTargetTriple(Triple::normalize(Triple));
 104 }
 105
 106 extern "C" void LLVMRustPrintPassTimings() {
 107   raw_fd_ostream OS(2, false); // stderr.
 108   TimerGroup::printAll(OS);
 109 }
 110
 111 extern "C" LLVMValueRef LLVMRustGetNamedValue(LLVMModuleRef M,
 112                                               const char *Name) {
 113   return wrap(unwrap(M)->getNamedValue(Name));
 114 }
 115
 116 extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M,
 117                                                     const char *Name,
 118                                                     LLVMTypeRef FunctionTy) {
 119   return wrap(
 120       unwrap(M)->getOrInsertFunction(Name, unwrap<FunctionType>(FunctionTy))
 121 #if LLVM_VERSION_GE(9, 0)
 122       .getCallee()
 123 #endif
 124       );
 125 }
 126
 127 extern "C" LLVMValueRef
 128 LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, LLVMTypeRef Ty) {
 129   return wrap(unwrap(M)->getOrInsertGlobal(Name, unwrap(Ty)));
 130 }
 131
 132 extern "C" LLVMValueRef
 133 LLVMRustInsertPrivateGlobal(LLVMModuleRef M, LLVMTypeRef Ty) {
 134   return wrap(new GlobalVariable(*unwrap(M),
 135                                  unwrap(Ty),
 136                                  false,
 137                                  GlobalValue::PrivateLinkage,
 138                                  nullptr));
 139 }
 140
 141 extern "C" LLVMTypeRef LLVMRustMetadataTypeInContext(LLVMContextRef C) {
 142   return wrap(Type::getMetadataTy(*unwrap(C)));
 143 }
 144
 145 static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
 146   switch (Kind) {
 147   case AlwaysInline:
 148     return Attribute::AlwaysInline;
 149   case ByVal:
 150     return Attribute::ByVal;
 151   case Cold:
 152     return Attribute::Cold;
 153   case InlineHint:
 154     return Attribute::InlineHint;
 155   case MinSize:
 156     return Attribute::MinSize;
 157   case Naked:
 158     return Attribute::Naked;
 159   case NoAlias:
 160     return Attribute::NoAlias;
 161   case NoCapture:
 162     return Attribute::NoCapture;
 163   case NoInline:
 164     return Attribute::NoInline;
 165   case NonNull:
 166     return Attribute::NonNull;
 167   case NoRedZone:
 168     return Attribute::NoRedZone;
 169   case NoReturn:
 170     return Attribute::NoReturn;
 171   case NoUnwind:
 172     return Attribute::NoUnwind;
 173   case OptimizeForSize:
 174     return Attribute::OptimizeForSize;
 175   case ReadOnly:
 176     return Attribute::ReadOnly;
 177   case SExt:
 178     return Attribute::SExt;
 179   case StructRet:
 180     return Attribute::StructRet;
 181   case UWTable:
 182     return Attribute::UWTable;
 183   case ZExt:
 184     return Attribute::ZExt;
 185   case InReg:
 186     return Attribute::InReg;
 187   case SanitizeThread:
 188     return Attribute::SanitizeThread;
 189   case SanitizeAddress:
 190     return Attribute::SanitizeAddress;
 191   case SanitizeMemory:
 192     return Attribute::SanitizeMemory;
 193   case NonLazyBind:
 194     return Attribute::NonLazyBind;
 195   case OptimizeNone:
 196     return Attribute::OptimizeNone;
 197   case ReturnsTwice:
 198     return Attribute::ReturnsTwice;
 199   }
 200   report_fatal_error("bad AttributeKind");
 201 }
 202
 203 extern "C" void LLVMRustAddCallSiteAttribute(LLVMValueRef Instr, unsigned Index,
 204                                              LLVMRustAttribute RustAttr) {
 205   CallSite Call = CallSite(unwrap<Instruction>(Instr));
 206   Attribute Attr = Attribute::get(Call->getContext(), fromRust(RustAttr));
 207   Call.addAttribute(Index, Attr);
 208 }
 209
 210 extern "C" void LLVMRustAddAlignmentCallSiteAttr(LLVMValueRef Instr,
 211                                                  unsigned Index,
 212                                                  uint32_t Bytes) {
 213   CallSite Call = CallSite(unwrap<Instruction>(Instr));
 214   AttrBuilder B;
 215   B.addAlignmentAttr(Bytes);
 216   Call.setAttributes(Call.getAttributes().addAttributes(
 217       Call->getContext(), Index, B));
 218 }
 219
 220 extern "C" void LLVMRustAddDereferenceableCallSiteAttr(LLVMValueRef Instr,
 221                                                        unsigned Index,
 222                                                        uint64_t Bytes) {
 223   CallSite Call = CallSite(unwrap<Instruction>(Instr));
 224   AttrBuilder B;
 225   B.addDereferenceableAttr(Bytes);
 226   Call.setAttributes(Call.getAttributes().addAttributes(
 227       Call->getContext(), Index, B));
 228 }
 229
 230 extern "C" void LLVMRustAddDereferenceableOrNullCallSiteAttr(LLVMValueRef Instr,
 231                                                              unsigned Index,
 232                                                              uint64_t Bytes) {
 233   CallSite Call = CallSite(unwrap<Instruction>(Instr));
 234   AttrBuilder B;
 235   B.addDereferenceableOrNullAttr(Bytes);
 236   Call.setAttributes(Call.getAttributes().addAttributes(
 237       Call->getContext(), Index, B));
 238 }
 239
 240 extern "C" void LLVMRustAddByValCallSiteAttr(LLVMValueRef Instr, unsigned Index,
 241                                              LLVMTypeRef Ty) {
 242   CallSite Call = CallSite(unwrap<Instruction>(Instr));
 243 #if LLVM_VERSION_GE(9, 0)
 244   Attribute Attr = Attribute::getWithByValType(Call->getContext(), unwrap(Ty));
 245 #else
 246   Attribute Attr = Attribute::get(Call->getContext(), Attribute::ByVal);
 247 #endif
 248   Call.addAttribute(Index, Attr);
 249 }
 250
 251 extern "C" void LLVMRustAddFunctionAttribute(LLVMValueRef Fn, unsigned Index,
 252                                              LLVMRustAttribute RustAttr) {
 253   Function *A = unwrap<Function>(Fn);
 254   Attribute Attr = Attribute::get(A->getContext(), fromRust(RustAttr));
 255   AttrBuilder B(Attr);
 256   A->addAttributes(Index, B);
 257 }
 258
 259 extern "C" void LLVMRustAddAlignmentAttr(LLVMValueRef Fn,
 260                                          unsigned Index,
 261                                          uint32_t Bytes) {
 262   Function *A = unwrap<Function>(Fn);
 263   AttrBuilder B;
 264   B.addAlignmentAttr(Bytes);
 265   A->addAttributes(Index, B);
 266 }
 267
 268 extern "C" void LLVMRustAddDereferenceableAttr(LLVMValueRef Fn, unsigned Index,
 269                                                uint64_t Bytes) {
 270   Function *A = unwrap<Function>(Fn);
 271   AttrBuilder B;
 272   B.addDereferenceableAttr(Bytes);
 273   A->addAttributes(Index, B);
 274 }
 275
 276 extern "C" void LLVMRustAddDereferenceableOrNullAttr(LLVMValueRef Fn,
 277                                                      unsigned Index,
 278                                                      uint64_t Bytes) {
 279   Function *A = unwrap<Function>(Fn);
 280   AttrBuilder B;
 281   B.addDereferenceableOrNullAttr(Bytes);
 282   A->addAttributes(Index, B);
 283 }
 284
 285 extern "C" void LLVMRustAddByValAttr(LLVMValueRef Fn, unsigned Index,
 286                                      LLVMTypeRef Ty) {
 287   Function *F = unwrap<Function>(Fn);
 288 #if LLVM_VERSION_GE(9, 0)
 289   Attribute Attr = Attribute::getWithByValType(F->getContext(), unwrap(Ty));
 290 #else
 291   Attribute Attr = Attribute::get(F->getContext(), Attribute::ByVal);
 292 #endif
 293   F->addAttribute(Index, Attr);
 294 }
 295
 296 extern "C" void LLVMRustAddFunctionAttrStringValue(LLVMValueRef Fn,
 297                                                    unsigned Index,
 298                                                    const char *Name,
 299                                                    const char *Value) {
 300   Function *F = unwrap<Function>(Fn);
 301   AttrBuilder B;
 302   B.addAttribute(Name, Value);
 303   F->addAttributes(Index, B);
 304 }
 305
 306 extern "C" void LLVMRustRemoveFunctionAttributes(LLVMValueRef Fn,
 307                                                  unsigned Index,
 308                                                  LLVMRustAttribute RustAttr) {
 309   Function *F = unwrap<Function>(Fn);
 310   Attribute Attr = Attribute::get(F->getContext(), fromRust(RustAttr));
 311   AttrBuilder B(Attr);
 312   auto PAL = F->getAttributes();
 313   auto PALNew = PAL.removeAttributes(F->getContext(), Index, B);
 314   F->setAttributes(PALNew);
 315 }
 316
 317 // enable fpmath flag UnsafeAlgebra
 318 extern "C" void LLVMRustSetHasUnsafeAlgebra(LLVMValueRef V) {
 319   if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) {
 320     I->setFast(true);
 321   }
 322 }
 323
 324 extern "C" LLVMValueRef
 325 LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMValueRef Source, const char *Name,
 326                         LLVMAtomicOrdering Order) {
 327   LoadInst *LI = new LoadInst(unwrap(Source));
 328   LI->setAtomic(fromRust(Order));
 329   return wrap(unwrap(B)->Insert(LI, Name));
 330 }
 331
 332 extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B,
 333                                                  LLVMValueRef V,
 334                                                  LLVMValueRef Target,
 335                                                  LLVMAtomicOrdering Order) {
 336   StoreInst *SI = new StoreInst(unwrap(V), unwrap(Target));
 337   SI->setAtomic(fromRust(Order));
 338   return wrap(unwrap(B)->Insert(SI));
 339 }
 340
 341 extern "C" LLVMValueRef
 342 LLVMRustBuildAtomicCmpXchg(LLVMBuilderRef B, LLVMValueRef Target,
 343                            LLVMValueRef Old, LLVMValueRef Source,
 344                            LLVMAtomicOrdering Order,
 345                            LLVMAtomicOrdering FailureOrder, LLVMBool Weak) {
 346   AtomicCmpXchgInst *ACXI = unwrap(B)->CreateAtomicCmpXchg(
 347       unwrap(Target), unwrap(Old), unwrap(Source), fromRust(Order),
 348       fromRust(FailureOrder));
 349   ACXI->setWeak(Weak);
 350   return wrap(ACXI);
 351 }
 352
 353 enum class LLVMRustSynchronizationScope {
 354   Other,
 355   SingleThread,
 356   CrossThread,
 357 };
 358
 359 static SyncScope::ID fromRust(LLVMRustSynchronizationScope Scope) {
 360   switch (Scope) {
 361   case LLVMRustSynchronizationScope::SingleThread:
 362     return SyncScope::SingleThread;
 363   case LLVMRustSynchronizationScope::CrossThread:
 364     return SyncScope::System;
 365   default:
 366     report_fatal_error("bad SynchronizationScope.");
 367   }
 368 }
 369
 370 extern "C" LLVMValueRef
 371 LLVMRustBuildAtomicFence(LLVMBuilderRef B, LLVMAtomicOrdering Order,
 372                          LLVMRustSynchronizationScope Scope) {
 373   return wrap(unwrap(B)->CreateFence(fromRust(Order), fromRust(Scope)));
 374 }
 375
 376 enum class LLVMRustAsmDialect {
 377   Other,
 378   Att,
 379   Intel,
 380 };
 381
 382 static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
 383   switch (Dialect) {
 384   case LLVMRustAsmDialect::Att:
 385     return InlineAsm::AD_ATT;
 386   case LLVMRustAsmDialect::Intel:
 387     return InlineAsm::AD_Intel;
 388   default:
 389     report_fatal_error("bad AsmDialect.");
 390   }
 391 }
 392
 393 extern "C" LLVMValueRef LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString,
 394                                           char *Constraints,
 395                                           LLVMBool HasSideEffects,
 396                                           LLVMBool IsAlignStack,
 397                                           LLVMRustAsmDialect Dialect) {
 398   return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), AsmString, Constraints,
 399                              HasSideEffects, IsAlignStack, fromRust(Dialect)));
 400 }
 401
 402 extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty,
 403                                           char *Constraints) {
 404   return InlineAsm::Verify(unwrap<FunctionType>(Ty), Constraints);
 405 }
 406
 407 extern "C" void LLVMRustAppendModuleInlineAsm(LLVMModuleRef M, const char *Asm) {
 408   unwrap(M)->appendModuleInlineAsm(StringRef(Asm));
 409 }
 410
 411 typedef DIBuilder *LLVMRustDIBuilderRef;
 412
 413 template <typename DIT> DIT *unwrapDIPtr(LLVMMetadataRef Ref) {
 414   return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr);
 415 }
 416
 417 #define DIDescriptor DIScope
 418 #define DIArray DINodeArray
 419 #define unwrapDI unwrapDIPtr
 420
 421 // These values **must** match debuginfo::DIFlags! They also *happen*
 422 // to match LLVM, but that isn't required as we do giant sets of
 423 // matching below. The value shouldn't be directly passed to LLVM.
 424 enum class LLVMRustDIFlags : uint32_t {
 425   FlagZero = 0,
 426   FlagPrivate = 1,
 427   FlagProtected = 2,
 428   FlagPublic = 3,
 429   FlagFwdDecl = (1 << 2),
 430   FlagAppleBlock = (1 << 3),
 431   FlagBlockByrefStruct = (1 << 4),
 432   FlagVirtual = (1 << 5),
 433   FlagArtificial = (1 << 6),
 434   FlagExplicit = (1 << 7),
 435   FlagPrototyped = (1 << 8),
 436   FlagObjcClassComplete = (1 << 9),
 437   FlagObjectPointer = (1 << 10),
 438   FlagVector = (1 << 11),
 439   FlagStaticMember = (1 << 12),
 440   FlagLValueReference = (1 << 13),
 441   FlagRValueReference = (1 << 14),
 442   FlagExternalTypeRef = (1 << 15),
 443   FlagIntroducedVirtual = (1 << 18),
 444   FlagBitField = (1 << 19),
 445   FlagNoReturn = (1 << 20),
 446   // Do not add values that are not supported by the minimum LLVM
 447   // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
 448 };
 449
 450 inline LLVMRustDIFlags operator&(LLVMRustDIFlags A, LLVMRustDIFlags B) {
 451   return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) &
 452                                       static_cast<uint32_t>(B));
 453 }
 454
 455 inline LLVMRustDIFlags operator|(LLVMRustDIFlags A, LLVMRustDIFlags B) {
 456   return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) |
 457                                       static_cast<uint32_t>(B));
 458 }
 459
 460 inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &A, LLVMRustDIFlags B) {
 461   return A = A | B;
 462 }
 463
 464 inline bool isSet(LLVMRustDIFlags F) { return F != LLVMRustDIFlags::FlagZero; }
 465
 466 inline LLVMRustDIFlags visibility(LLVMRustDIFlags F) {
 467   return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(F) & 0x3);
 468 }
 469
 470 static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) {
 471   DINode::DIFlags Result = DINode::DIFlags::FlagZero;
 472
 473   switch (visibility(Flags)) {
 474   case LLVMRustDIFlags::FlagPrivate:
 475     Result |= DINode::DIFlags::FlagPrivate;
 476     break;
 477   case LLVMRustDIFlags::FlagProtected:
 478     Result |= DINode::DIFlags::FlagProtected;
 479     break;
 480   case LLVMRustDIFlags::FlagPublic:
 481     Result |= DINode::DIFlags::FlagPublic;
 482     break;
 483   default:
 484     // The rest are handled below
 485     break;
 486   }
 487
 488   if (isSet(Flags & LLVMRustDIFlags::FlagFwdDecl)) {
 489     Result |= DINode::DIFlags::FlagFwdDecl;
 490   }
 491   if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) {
 492     Result |= DINode::DIFlags::FlagAppleBlock;
 493   }
 494   if (isSet(Flags & LLVMRustDIFlags::FlagBlockByrefStruct)) {
 495     Result |= DINode::DIFlags::FlagBlockByrefStruct;
 496   }
 497   if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) {
 498     Result |= DINode::DIFlags::FlagVirtual;
 499   }
 500   if (isSet(Flags & LLVMRustDIFlags::FlagArtificial)) {
 501     Result |= DINode::DIFlags::FlagArtificial;
 502   }
 503   if (isSet(Flags & LLVMRustDIFlags::FlagExplicit)) {
 504     Result |= DINode::DIFlags::FlagExplicit;
 505   }
 506   if (isSet(Flags & LLVMRustDIFlags::FlagPrototyped)) {
 507     Result |= DINode::DIFlags::FlagPrototyped;
 508   }
 509   if (isSet(Flags & LLVMRustDIFlags::FlagObjcClassComplete)) {
 510     Result |= DINode::DIFlags::FlagObjcClassComplete;
 511   }
 512   if (isSet(Flags & LLVMRustDIFlags::FlagObjectPointer)) {
 513     Result |= DINode::DIFlags::FlagObjectPointer;
 514   }
 515   if (isSet(Flags & LLVMRustDIFlags::FlagVector)) {
 516     Result |= DINode::DIFlags::FlagVector;
 517   }
 518   if (isSet(Flags & LLVMRustDIFlags::FlagStaticMember)) {
 519     Result |= DINode::DIFlags::FlagStaticMember;
 520   }
 521   if (isSet(Flags & LLVMRustDIFlags::FlagLValueReference)) {
 522     Result |= DINode::DIFlags::FlagLValueReference;
 523   }
 524   if (isSet(Flags & LLVMRustDIFlags::FlagRValueReference)) {
 525     Result |= DINode::DIFlags::FlagRValueReference;
 526   }
 527   if (isSet(Flags & LLVMRustDIFlags::FlagIntroducedVirtual)) {
 528     Result |= DINode::DIFlags::FlagIntroducedVirtual;
 529   }
 530   if (isSet(Flags & LLVMRustDIFlags::FlagBitField)) {
 531     Result |= DINode::DIFlags::FlagBitField;
 532   }
 533   if (isSet(Flags & LLVMRustDIFlags::FlagNoReturn)) {
 534     Result |= DINode::DIFlags::FlagNoReturn;
 535   }
 536
 537   return Result;
 538 }
 539
 540 // These values **must** match debuginfo::DISPFlags! They also *happen*
 541 // to match LLVM, but that isn't required as we do giant sets of
 542 // matching below. The value shouldn't be directly passed to LLVM.
 543 enum class LLVMRustDISPFlags : uint32_t {
 544   SPFlagZero = 0,
 545   SPFlagVirtual = 1,
 546   SPFlagPureVirtual = 2,
 547   SPFlagLocalToUnit = (1 << 2),
 548   SPFlagDefinition = (1 << 3),
 549   SPFlagOptimized = (1 << 4),
 550   SPFlagMainSubprogram = (1 << 5),
 551   // Do not add values that are not supported by the minimum LLVM
 552   // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def
 553   // (In LLVM < 8, createFunction supported these as separate bool arguments.)
 554 };
 555
 556 inline LLVMRustDISPFlags operator&(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
 557   return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) &
 558                                       static_cast<uint32_t>(B));
 559 }
 560
 561 inline LLVMRustDISPFlags operator|(LLVMRustDISPFlags A, LLVMRustDISPFlags B) {
 562   return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) |
 563                                       static_cast<uint32_t>(B));
 564 }
 565
 566 inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A, LLVMRustDISPFlags B) {
 567   return A = A | B;
 568 }
 569
 570 inline bool isSet(LLVMRustDISPFlags F) { return F != LLVMRustDISPFlags::SPFlagZero; }
 571
 572 inline LLVMRustDISPFlags virtuality(LLVMRustDISPFlags F) {
 573   return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(F) & 0x3);
 574 }
 575
 576 #if LLVM_VERSION_GE(8, 0)
 577 static DISubprogram::DISPFlags fromRust(LLVMRustDISPFlags SPFlags) {
 578   DISubprogram::DISPFlags Result = DISubprogram::DISPFlags::SPFlagZero;
 579
 580   switch (virtuality(SPFlags)) {
 581   case LLVMRustDISPFlags::SPFlagVirtual:
 582     Result |= DISubprogram::DISPFlags::SPFlagVirtual;
 583     break;
 584   case LLVMRustDISPFlags::SPFlagPureVirtual:
 585     Result |= DISubprogram::DISPFlags::SPFlagPureVirtual;
 586     break;
 587   default:
 588     // The rest are handled below
 589     break;
 590   }
 591
 592   if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit)) {
 593     Result |= DISubprogram::DISPFlags::SPFlagLocalToUnit;
 594   }
 595   if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition)) {
 596     Result |= DISubprogram::DISPFlags::SPFlagDefinition;
 597   }
 598   if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized)) {
 599     Result |= DISubprogram::DISPFlags::SPFlagOptimized;
 600   }
 601 #if LLVM_VERSION_GE(9, 0)
 602   if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram)) {
 603     Result |= DISubprogram::DISPFlags::SPFlagMainSubprogram;
 604   }
 605 #endif
 606
 607   return Result;
 608 }
 609 #endif
 610
 611 enum class LLVMRustDebugEmissionKind {
 612   NoDebug,
 613   FullDebug,
 614   LineTablesOnly,
 615 };
 616
 617 static DICompileUnit::DebugEmissionKind fromRust(LLVMRustDebugEmissionKind Kind) {
 618   switch (Kind) {
 619   case LLVMRustDebugEmissionKind::NoDebug:
 620     return DICompileUnit::DebugEmissionKind::NoDebug;
 621   case LLVMRustDebugEmissionKind::FullDebug:
 622     return DICompileUnit::DebugEmissionKind::FullDebug;
 623   case LLVMRustDebugEmissionKind::LineTablesOnly:
 624     return DICompileUnit::DebugEmissionKind::LineTablesOnly;
 625   default:
 626     report_fatal_error("bad DebugEmissionKind.");
 627   }
 628 }
 629
 630 extern "C" uint32_t LLVMRustDebugMetadataVersion() {
 631   return DEBUG_METADATA_VERSION;
 632 }
 633
 634 extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; }
 635
 636 extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; }
 637
 638 extern "C" void LLVMRustAddModuleFlag(LLVMModuleRef M, const char *Name,
 639                                       uint32_t Value) {
 640   unwrap(M)->addModuleFlag(Module::Warning, Name, Value);
 641 }
 642
 643 extern "C" LLVMValueRef LLVMRustMetadataAsValue(LLVMContextRef C, LLVMMetadataRef MD) {
 644   return wrap(MetadataAsValue::get(*unwrap(C), unwrap(MD)));
 645 }
 646
 647 extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) {
 648   return new DIBuilder(*unwrap(M));
 649 }
 650
 651 extern "C" void LLVMRustDIBuilderDispose(LLVMRustDIBuilderRef Builder) {
 652   delete Builder;
 653 }
 654
 655 extern "C" void LLVMRustDIBuilderFinalize(LLVMRustDIBuilderRef Builder) {
 656   Builder->finalize();
 657 }
 658
 659 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit(
 660     LLVMRustDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef,
 661     const char *Producer, bool isOptimized, const char *Flags,
 662     unsigned RuntimeVer, const char *SplitName,
 663     LLVMRustDebugEmissionKind Kind) {
 664   auto *File = unwrapDI<DIFile>(FileRef);
 665
 666   return wrap(Builder->createCompileUnit(Lang, File, Producer, isOptimized,
 667                                          Flags, RuntimeVer, SplitName,
 668                                          fromRust(Kind)));
 669 }
 670
 671 extern "C" LLVMMetadataRef
 672 LLVMRustDIBuilderCreateFile(LLVMRustDIBuilderRef Builder, const char *Filename,
 673                             const char *Directory) {
 674   return wrap(Builder->createFile(Filename, Directory));
 675 }
 676
 677 extern "C" LLVMMetadataRef
 678 LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder,
 679                                       LLVMMetadataRef File,
 680                                       LLVMMetadataRef ParameterTypes) {
 681   return wrap(Builder->createSubroutineType(
 682       DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
 683 }
 684
 685 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction(
 686     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
 687     const char *LinkageName, LLVMMetadataRef File, unsigned LineNo,
 688     LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags,
 689     LLVMRustDISPFlags SPFlags, LLVMValueRef Fn, LLVMMetadataRef TParam,
 690     LLVMMetadataRef Decl) {
 691   DITemplateParameterArray TParams =
 692       DITemplateParameterArray(unwrap<MDTuple>(TParam));
 693 #if LLVM_VERSION_GE(8, 0)
 694   DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags);
 695   DINode::DIFlags llvmFlags = fromRust(Flags);
 696 #if LLVM_VERSION_LT(9, 0)
 697   if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram))
 698     llvmFlags |= DINode::DIFlags::FlagMainSubprogram;
 699 #endif
 700   DISubprogram *Sub = Builder->createFunction(
 701       unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
 702       LineNo, unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags,
 703       llvmSPFlags, TParams, unwrapDIPtr<DISubprogram>(Decl));
 704 #else
 705   bool IsLocalToUnit = isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit);
 706   bool IsDefinition = isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition);
 707   bool IsOptimized = isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized);
 708   DINode::DIFlags llvmFlags = fromRust(Flags);
 709   if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram))
 710     llvmFlags |= DINode::DIFlags::FlagMainSubprogram;
 711   DISubprogram *Sub = Builder->createFunction(
 712       unwrapDI<DIScope>(Scope), Name, LinkageName, unwrapDI<DIFile>(File),
 713       LineNo, unwrapDI<DISubroutineType>(Ty), IsLocalToUnit, IsDefinition,
 714       ScopeLine, llvmFlags, IsOptimized, TParams,
 715       unwrapDIPtr<DISubprogram>(Decl));
 716 #endif
 717   unwrap<Function>(Fn)->setSubprogram(Sub);
 718   return wrap(Sub);
 719 }
 720
 721 extern "C" LLVMMetadataRef
 722 LLVMRustDIBuilderCreateBasicType(LLVMRustDIBuilderRef Builder, const char *Name,
 723                                  uint64_t SizeInBits, uint32_t AlignInBits,
 724                                  unsigned Encoding) {
 725   return wrap(Builder->createBasicType(Name, SizeInBits, Encoding));
 726 }
 727
 728 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType(
 729     LLVMRustDIBuilderRef Builder, LLVMMetadataRef PointeeTy,
 730     uint64_t SizeInBits, uint32_t AlignInBits, const char *Name) {
 731   return wrap(Builder->createPointerType(unwrapDI<DIType>(PointeeTy),
 732                                          SizeInBits, AlignInBits,
 733                                          /* DWARFAddressSpace */ None,
 734                                          Name));
 735 }
 736
 737 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType(
 738     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
 739     LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
 740     uint32_t AlignInBits, LLVMRustDIFlags Flags,
 741     LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements,
 742     unsigned RunTimeLang, LLVMMetadataRef VTableHolder,
 743     const char *UniqueId) {
 744   return wrap(Builder->createStructType(
 745       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
 746       SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom),
 747       DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang,
 748       unwrapDI<DIType>(VTableHolder), UniqueId));
 749 }
 750
 751 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart(
 752     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
 753     LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
 754     uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Discriminator,
 755     LLVMMetadataRef Elements, const char *UniqueId) {
 756 #if LLVM_VERSION_GE(7, 0)
 757   return wrap(Builder->createVariantPart(
 758       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
 759       SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator),
 760       DINodeArray(unwrapDI<MDTuple>(Elements)), UniqueId));
 761 #else
 762   abort();
 763 #endif
 764 }
 765
 766 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType(
 767     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
 768     LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
 769     uint32_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags,
 770     LLVMMetadataRef Ty) {
 771   return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope), Name,
 772                                         unwrapDI<DIFile>(File), LineNo,
 773                                         SizeInBits, AlignInBits, OffsetInBits,
 774                                         fromRust(Flags), unwrapDI<DIType>(Ty)));
 775 }
 776
 777 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType(
 778     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
 779     const char *Name, LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits,
 780     uint32_t AlignInBits, uint64_t OffsetInBits, LLVMValueRef Discriminant,
 781     LLVMRustDIFlags Flags, LLVMMetadataRef Ty) {
 782 #if LLVM_VERSION_GE(7, 0)
 783   llvm::ConstantInt* D = nullptr;
 784   if (Discriminant) {
 785     D = unwrap<llvm::ConstantInt>(Discriminant);
 786   }
 787   return wrap(Builder->createVariantMemberType(unwrapDI<DIDescriptor>(Scope), Name,
 788                                                unwrapDI<DIFile>(File), LineNo,
 789                                                SizeInBits, AlignInBits, OffsetInBits, D,
 790                                                fromRust(Flags), unwrapDI<DIType>(Ty)));
 791 #else
 792   return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope), Name,
 793                                         unwrapDI<DIFile>(File), LineNo,
 794                                         SizeInBits, AlignInBits, OffsetInBits,
 795                                         fromRust(Flags), unwrapDI<DIType>(Ty)));
 796 #endif
 797 }
 798
 799 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlock(
 800     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope,
 801     LLVMMetadataRef File, unsigned Line, unsigned Col) {
 802   return wrap(Builder->createLexicalBlock(unwrapDI<DIDescriptor>(Scope),
 803                                           unwrapDI<DIFile>(File), Line, Col));
 804 }
 805
 806 extern "C" LLVMMetadataRef
 807 LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder,
 808                                         LLVMMetadataRef Scope,
 809                                         LLVMMetadataRef File) {
 810   return wrap(Builder->createLexicalBlockFile(unwrapDI<DIDescriptor>(Scope),
 811                                               unwrapDI<DIFile>(File)));
 812 }
 813
 814 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable(
 815     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Context, const char *Name,
 816     const char *LinkageName, LLVMMetadataRef File, unsigned LineNo,
 817     LLVMMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V,
 818     LLVMMetadataRef Decl = nullptr, uint32_t AlignInBits = 0) {
 819   llvm::GlobalVariable *InitVal = cast<llvm::GlobalVariable>(unwrap(V));
 820
 821   llvm::DIExpression *InitExpr = nullptr;
 822   if (llvm::ConstantInt *IntVal = llvm::dyn_cast<llvm::ConstantInt>(InitVal)) {
 823     InitExpr = Builder->createConstantValueExpression(
 824         IntVal->getValue().getSExtValue());
 825   } else if (llvm::ConstantFP *FPVal =
 826                  llvm::dyn_cast<llvm::ConstantFP>(InitVal)) {
 827     InitExpr = Builder->createConstantValueExpression(
 828         FPVal->getValueAPF().bitcastToAPInt().getZExtValue());
 829   }
 830
 831   llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression(
 832       unwrapDI<DIDescriptor>(Context), Name, LinkageName,
 833       unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit,
 834       InitExpr, unwrapDIPtr<MDNode>(Decl),
 835 #if LLVM_VERSION_GE(8, 0)
 836       /* templateParams */ nullptr,
 837 #endif
 838       AlignInBits);
 839
 840   InitVal->setMetadata("dbg", VarExpr);
 841
 842   return wrap(VarExpr);
 843 }
 844
 845 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
 846     LLVMRustDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope,
 847     const char *Name, LLVMMetadataRef File, unsigned LineNo,
 848     LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMRustDIFlags Flags,
 849     unsigned ArgNo, uint32_t AlignInBits) {
 850   if (Tag == 0x100) { // DW_TAG_auto_variable
 851     return wrap(Builder->createAutoVariable(
 852         unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNo,
 853         unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), AlignInBits));
 854   } else {
 855     return wrap(Builder->createParameterVariable(
 856         unwrapDI<DIDescriptor>(Scope), Name, ArgNo, unwrapDI<DIFile>(File),
 857         LineNo, unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)));
 858   }
 859 }
 860
 861 extern "C" LLVMMetadataRef
 862 LLVMRustDIBuilderCreateArrayType(LLVMRustDIBuilderRef Builder, uint64_t Size,
 863                                  uint32_t AlignInBits, LLVMMetadataRef Ty,
 864                                  LLVMMetadataRef Subscripts) {
 865   return wrap(
 866       Builder->createArrayType(Size, AlignInBits, unwrapDI<DIType>(Ty),
 867                                DINodeArray(unwrapDI<MDTuple>(Subscripts))));
 868 }
 869
 870 extern "C" LLVMMetadataRef
 871 LLVMRustDIBuilderGetOrCreateSubrange(LLVMRustDIBuilderRef Builder, int64_t Lo,
 872                                      int64_t Count) {
 873   return wrap(Builder->getOrCreateSubrange(Lo, Count));
 874 }
 875
 876 extern "C" LLVMMetadataRef
 877 LLVMRustDIBuilderGetOrCreateArray(LLVMRustDIBuilderRef Builder,
 878                                   LLVMMetadataRef *Ptr, unsigned Count) {
 879   Metadata **DataValue = unwrap(Ptr);
 880   return wrap(
 881       Builder->getOrCreateArray(ArrayRef<Metadata *>(DataValue, Count)).get());
 882 }
 883
 884 extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd(
 885     LLVMRustDIBuilderRef Builder, LLVMValueRef V, LLVMMetadataRef VarInfo,
 886     int64_t *AddrOps, unsigned AddrOpsCount, LLVMValueRef DL,
 887     LLVMBasicBlockRef InsertAtEnd) {
 888   return wrap(Builder->insertDeclare(
 889       unwrap(V), unwrap<DILocalVariable>(VarInfo),
 890       Builder->createExpression(llvm::ArrayRef<int64_t>(AddrOps, AddrOpsCount)),
 891       DebugLoc(cast<MDNode>(unwrap<MetadataAsValue>(DL)->getMetadata())),
 892       unwrap(InsertAtEnd)));
 893 }
 894
 895 extern "C" LLVMMetadataRef
 896 LLVMRustDIBuilderCreateEnumerator(LLVMRustDIBuilderRef Builder,
 897                                   const char *Name, uint64_t Val) {
 898   return wrap(Builder->createEnumerator(Name, Val));
 899 }
 900
 901 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType(
 902     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
 903     LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
 904     uint32_t AlignInBits, LLVMMetadataRef Elements,
 905     LLVMMetadataRef ClassTy, bool IsScoped) {
 906 #if LLVM_VERSION_GE(7, 0)
 907   return wrap(Builder->createEnumerationType(
 908       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
 909       SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
 910       unwrapDI<DIType>(ClassTy), "", IsScoped));
 911 #else
 912   // Ignore IsScoped on older LLVM.
 913   return wrap(Builder->createEnumerationType(
 914       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
 915       SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)),
 916       unwrapDI<DIType>(ClassTy), ""));
 917 #endif
 918 }
 919
 920 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType(
 921     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
 922     LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits,
 923     uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Elements,
 924     unsigned RunTimeLang, const char *UniqueId) {
 925   return wrap(Builder->createUnionType(
 926       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIFile>(File), LineNumber,
 927       SizeInBits, AlignInBits, fromRust(Flags),
 928       DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang, UniqueId));
 929 }
 930
 931 extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter(
 932     LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name,
 933     LLVMMetadataRef Ty, LLVMMetadataRef File, unsigned LineNo,
 934     unsigned ColumnNo) {
 935   return wrap(Builder->createTemplateTypeParameter(
 936       unwrapDI<DIDescriptor>(Scope), Name, unwrapDI<DIType>(Ty)));
 937 }
 938
 939 extern "C" LLVMMetadataRef
 940 LLVMRustDIBuilderCreateNameSpace(LLVMRustDIBuilderRef Builder,
 941                                  LLVMMetadataRef Scope, const char *Name,
 942                                  LLVMMetadataRef File, unsigned LineNo) {
 943   return wrap(Builder->createNameSpace(
 944       unwrapDI<DIDescriptor>(Scope), Name,
 945       false // ExportSymbols (only relevant for C++ anonymous namespaces)
 946       ));
 947 }
 948
 949 extern "C" void
 950 LLVMRustDICompositeTypeReplaceArrays(LLVMRustDIBuilderRef Builder,
 951                                      LLVMMetadataRef CompositeTy,
 952                                      LLVMMetadataRef Elements,
 953                                      LLVMMetadataRef Params) {
 954   DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy);
 955   Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(Elements)),
 956                          DINodeArray(unwrap<MDTuple>(Params)));
 957 }
 958
 959 extern "C" LLVMValueRef
 960 LLVMRustDIBuilderCreateDebugLocation(LLVMContextRef ContextRef, unsigned Line,
 961                                      unsigned Column, LLVMMetadataRef Scope,
 962                                      LLVMMetadataRef InlinedAt) {
 963   LLVMContext &Context = *unwrap(ContextRef);
 964
 965   DebugLoc debug_loc = DebugLoc::get(Line, Column, unwrapDIPtr<MDNode>(Scope),
 966                                      unwrapDIPtr<MDNode>(InlinedAt));
 967
 968   return wrap(MetadataAsValue::get(Context, debug_loc.getAsMDNode()));
 969 }
 970
 971 extern "C" int64_t LLVMRustDIBuilderCreateOpDeref() {
 972   return dwarf::DW_OP_deref;
 973 }
 974
 975 extern "C" int64_t LLVMRustDIBuilderCreateOpPlusUconst() {
 976   return dwarf::DW_OP_plus_uconst;
 977 }
 978
 979 extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Ty, RustStringRef Str) {
 980   RawRustStringOstream OS(Str);
 981   unwrap<llvm::Type>(Ty)->print(OS);
 982 }
 983
 984 extern "C" void LLVMRustWriteValueToString(LLVMValueRef V,
 985                                            RustStringRef Str) {
 986   RawRustStringOstream OS(Str);
 987   if (!V) {
 988     OS << "(null)";
 989   } else {
 990     OS << "(";
 991     unwrap<llvm::Value>(V)->getType()->print(OS);
 992     OS << ":";
 993     unwrap<llvm::Value>(V)->print(OS);
 994     OS << ")";
 995   }
 996 }
 997
 998 // Note that the two following functions look quite similar to the
 999 // LLVMGetSectionName function. Sadly, it appears that this function only
1000 // returns a char* pointer, which isn't guaranteed to be null-terminated. The
1001 // function provided by LLVM doesn't return the length, so we've created our own
1002 // function which returns the length as well as the data pointer.
1003 //
1004 // For an example of this not returning a null terminated string, see
1005 // lib/Object/COFFObjectFile.cpp in the getSectionName function. One of the
1006 // branches explicitly creates a StringRef without a null terminator, and then
1007 // that's returned.
1008
1009 inline section_iterator *unwrap(LLVMSectionIteratorRef SI) {
1010   return reinterpret_cast<section_iterator *>(SI);
1011 }
1012
1013 extern "C" size_t LLVMRustGetSectionName(LLVMSectionIteratorRef SI,
1014                                          const char **Ptr) {
1015   StringRef Ret;
1016   if (std::error_code EC = (*unwrap(SI))->getName(Ret))
1017     report_fatal_error(EC.message());
1018   *Ptr = Ret.data();
1019   return Ret.size();
1020 }
1021
1022 // LLVMArrayType function does not support 64-bit ElementCount
1023 extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy,
1024                                          uint64_t ElementCount) {
1025   return wrap(ArrayType::get(unwrap(ElementTy), ElementCount));
1026 }
1027
1028 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef)
1029
1030 extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) {
1031   RawRustStringOstream OS(Str);
1032   unwrap(T)->print(OS);
1033 }
1034
1035 extern "C" void LLVMRustUnpackOptimizationDiagnostic(
1036     LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut,
1037     LLVMValueRef *FunctionOut, unsigned* Line, unsigned* Column,
1038     RustStringRef FilenameOut, RustStringRef MessageOut) {
1039   // Undefined to call this not on an optimization diagnostic!
1040   llvm::DiagnosticInfoOptimizationBase *Opt =
1041       static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(DI));
1042
1043   RawRustStringOstream PassNameOS(PassNameOut);
1044   PassNameOS << Opt->getPassName();
1045   *FunctionOut = wrap(&Opt->getFunction());
1046
1047   RawRustStringOstream FilenameOS(FilenameOut);
1048   DiagnosticLocation loc = Opt->getLocation();
1049   if (loc.isValid()) {
1050     *Line = loc.getLine();
1051     *Column = loc.getColumn();
1052 #if LLVM_VERSION_GE(8, 0)
1053     FilenameOS << loc.getAbsolutePath();
1054 #else
1055     FilenameOS << loc.getFilename();
1056 #endif
1057   }
1058
1059   RawRustStringOstream MessageOS(MessageOut);
1060   MessageOS << Opt->getMsg();
1061 }
1062
1063 extern "C" void
1064 LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI, unsigned *CookieOut,
1065                                   LLVMTwineRef *MessageOut,
1066                                   LLVMValueRef *InstructionOut) {
1067   // Undefined to call this not on an inline assembly diagnostic!
1068   llvm::DiagnosticInfoInlineAsm *IA =
1069       static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI));
1070
1071   *CookieOut = IA->getLocCookie();
1072   *MessageOut = wrap(&IA->getMsgStr());
1073   *InstructionOut = wrap(IA->getInstruction());
1074 }
1075
1076 extern "C" void LLVMRustWriteDiagnosticInfoToString(LLVMDiagnosticInfoRef DI,
1077                                                     RustStringRef Str) {
1078   RawRustStringOstream OS(Str);
1079   DiagnosticPrinterRawOStream DP(OS);
1080   unwrap(DI)->print(DP);
1081 }
1082
1083 enum class LLVMRustDiagnosticKind {
1084   Other,
1085   InlineAsm,
1086   StackSize,
1087   DebugMetadataVersion,
1088   SampleProfile,
1089   OptimizationRemark,
1090   OptimizationRemarkMissed,
1091   OptimizationRemarkAnalysis,
1092   OptimizationRemarkAnalysisFPCommute,
1093   OptimizationRemarkAnalysisAliasing,
1094   OptimizationRemarkOther,
1095   OptimizationFailure,
1096   PGOProfile,
1097   Linker,
1098 };
1099
1100 static LLVMRustDiagnosticKind toRust(DiagnosticKind Kind) {
1101   switch (Kind) {
1102   case DK_InlineAsm:
1103     return LLVMRustDiagnosticKind::InlineAsm;
1104   case DK_StackSize:
1105     return LLVMRustDiagnosticKind::StackSize;
1106   case DK_DebugMetadataVersion:
1107     return LLVMRustDiagnosticKind::DebugMetadataVersion;
1108   case DK_SampleProfile:
1109     return LLVMRustDiagnosticKind::SampleProfile;
1110   case DK_OptimizationRemark:
1111     return LLVMRustDiagnosticKind::OptimizationRemark;
1112   case DK_OptimizationRemarkMissed:
1113     return LLVMRustDiagnosticKind::OptimizationRemarkMissed;
1114   case DK_OptimizationRemarkAnalysis:
1115     return LLVMRustDiagnosticKind::OptimizationRemarkAnalysis;
1116   case DK_OptimizationRemarkAnalysisFPCommute:
1117     return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisFPCommute;
1118   case DK_OptimizationRemarkAnalysisAliasing:
1119     return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisAliasing;
1120   case DK_PGOProfile:
1121     return LLVMRustDiagnosticKind::PGOProfile;
1122   case DK_Linker:
1123     return LLVMRustDiagnosticKind::Linker;
1124   default:
1125     return (Kind >= DK_FirstRemark && Kind <= DK_LastRemark)
1126                ? LLVMRustDiagnosticKind::OptimizationRemarkOther
1127                : LLVMRustDiagnosticKind::Other;
1128   }
1129 }
1130
1131 extern "C" LLVMRustDiagnosticKind
1132 LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef DI) {
1133   return toRust((DiagnosticKind)unwrap(DI)->getKind());
1134 }
1135 // This is kept distinct from LLVMGetTypeKind, because when
1136 // a new type kind is added, the Rust-side enum must be
1137 // updated or UB will result.
1138 extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
1139   switch (unwrap(Ty)->getTypeID()) {
1140   case Type::VoidTyID:
1141     return LLVMVoidTypeKind;
1142   case Type::HalfTyID:
1143     return LLVMHalfTypeKind;
1144   case Type::FloatTyID:
1145     return LLVMFloatTypeKind;
1146   case Type::DoubleTyID:
1147     return LLVMDoubleTypeKind;
1148   case Type::X86_FP80TyID:
1149     return LLVMX86_FP80TypeKind;
1150   case Type::FP128TyID:
1151     return LLVMFP128TypeKind;
1152   case Type::PPC_FP128TyID:
1153     return LLVMPPC_FP128TypeKind;
1154   case Type::LabelTyID:
1155     return LLVMLabelTypeKind;
1156   case Type::MetadataTyID:
1157     return LLVMMetadataTypeKind;
1158   case Type::IntegerTyID:
1159     return LLVMIntegerTypeKind;
1160   case Type::FunctionTyID:
1161     return LLVMFunctionTypeKind;
1162   case Type::StructTyID:
1163     return LLVMStructTypeKind;
1164   case Type::ArrayTyID:
1165     return LLVMArrayTypeKind;
1166   case Type::PointerTyID:
1167     return LLVMPointerTypeKind;
1168   case Type::VectorTyID:
1169     return LLVMVectorTypeKind;
1170   case Type::X86_MMXTyID:
1171     return LLVMX86_MMXTypeKind;
1172   case Type::TokenTyID:
1173     return LLVMTokenTypeKind;
1174   }
1175   report_fatal_error("Unhandled TypeID.");
1176 }
1177
1178 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef)
1179
1180 extern "C" void LLVMRustSetInlineAsmDiagnosticHandler(
1181     LLVMContextRef C, LLVMContext::InlineAsmDiagHandlerTy H, void *CX) {
1182   unwrap(C)->setInlineAsmDiagnosticHandler(H, CX);
1183 }
1184
1185 extern "C" void LLVMRustWriteSMDiagnosticToString(LLVMSMDiagnosticRef D,
1186                                                   RustStringRef Str) {
1187   RawRustStringOstream OS(Str);
1188   unwrap(D)->print("", OS);
1189 }
1190
1191 extern "C" LLVMValueRef LLVMRustBuildCleanupPad(LLVMBuilderRef B,
1192                                                 LLVMValueRef ParentPad,
1193                                                 unsigned ArgCount,
1194                                                 LLVMValueRef *LLArgs,
1195                                                 const char *Name) {
1196   Value **Args = unwrap(LLArgs);
1197   if (ParentPad == nullptr) {
1198     Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
1199     ParentPad = wrap(Constant::getNullValue(Ty));
1200   }
1201   return wrap(unwrap(B)->CreateCleanupPad(
1202       unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
1203 }
1204
1205 extern "C" LLVMValueRef LLVMRustBuildCleanupRet(LLVMBuilderRef B,
1206                                                 LLVMValueRef CleanupPad,
1207                                                 LLVMBasicBlockRef UnwindBB) {
1208   CleanupPadInst *Inst = cast<CleanupPadInst>(unwrap(CleanupPad));
1209   return wrap(unwrap(B)->CreateCleanupRet(Inst, unwrap(UnwindBB)));
1210 }
1211
1212 extern "C" LLVMValueRef
1213 LLVMRustBuildCatchPad(LLVMBuilderRef B, LLVMValueRef ParentPad,
1214                       unsigned ArgCount, LLVMValueRef *LLArgs, const char *Name) {
1215   Value **Args = unwrap(LLArgs);
1216   return wrap(unwrap(B)->CreateCatchPad(
1217       unwrap(ParentPad), ArrayRef<Value *>(Args, ArgCount), Name));
1218 }
1219
1220 extern "C" LLVMValueRef LLVMRustBuildCatchRet(LLVMBuilderRef B,
1221                                               LLVMValueRef Pad,
1222                                               LLVMBasicBlockRef BB) {
1223   return wrap(unwrap(B)->CreateCatchRet(cast<CatchPadInst>(unwrap(Pad)),
1224                                               unwrap(BB)));
1225 }
1226
1227 extern "C" LLVMValueRef LLVMRustBuildCatchSwitch(LLVMBuilderRef B,
1228                                                  LLVMValueRef ParentPad,
1229                                                  LLVMBasicBlockRef BB,
1230                                                  unsigned NumHandlers,
1231                                                  const char *Name) {
1232   if (ParentPad == nullptr) {
1233     Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
1234     ParentPad = wrap(Constant::getNullValue(Ty));
1235   }
1236   return wrap(unwrap(B)->CreateCatchSwitch(unwrap(ParentPad), unwrap(BB),
1237                                                  NumHandlers, Name));
1238 }
1239
1240 extern "C" void LLVMRustAddHandler(LLVMValueRef CatchSwitchRef,
1241                                    LLVMBasicBlockRef Handler) {
1242   Value *CatchSwitch = unwrap(CatchSwitchRef);
1243   cast<CatchSwitchInst>(CatchSwitch)->addHandler(unwrap(Handler));
1244 }
1245
1246 extern "C" OperandBundleDef *LLVMRustBuildOperandBundleDef(const char *Name,
1247                                                            LLVMValueRef *Inputs,
1248                                                            unsigned NumInputs) {
1249   return new OperandBundleDef(Name, makeArrayRef(unwrap(Inputs), NumInputs));
1250 }
1251
1252 extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) {
1253   delete Bundle;
1254 }
1255
1256 extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMValueRef Fn,
1257                                           LLVMValueRef *Args, unsigned NumArgs,
1258                                           OperandBundleDef *Bundle,
1259                                           const char *Name) {
1260   unsigned Len = Bundle ? 1 : 0;
1261   ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
1262   return wrap(unwrap(B)->CreateCall(
1263       unwrap(Fn), makeArrayRef(unwrap(Args), NumArgs), Bundles, Name));
1264 }
1265
1266 extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B,
1267                                             LLVMValueRef Dst, unsigned DstAlign,
1268                                             LLVMValueRef Src, unsigned SrcAlign,
1269                                             LLVMValueRef Size, bool IsVolatile) {
1270 #if LLVM_VERSION_GE(7, 0)
1271   return wrap(unwrap(B)->CreateMemCpy(
1272       unwrap(Dst), DstAlign,
1273       unwrap(Src), SrcAlign,
1274       unwrap(Size), IsVolatile));
1275 #else
1276   unsigned Align = std::min(DstAlign, SrcAlign);
1277   return wrap(unwrap(B)->CreateMemCpy(
1278       unwrap(Dst), unwrap(Src),
1279       unwrap(Size), Align, IsVolatile));
1280 #endif
1281 }
1282
1283 extern "C" LLVMValueRef LLVMRustBuildMemMove(LLVMBuilderRef B,
1284                                              LLVMValueRef Dst, unsigned DstAlign,
1285                                              LLVMValueRef Src, unsigned SrcAlign,
1286                                              LLVMValueRef Size, bool IsVolatile) {
1287 #if LLVM_VERSION_GE(7, 0)
1288   return wrap(unwrap(B)->CreateMemMove(
1289       unwrap(Dst), DstAlign,
1290       unwrap(Src), SrcAlign,
1291       unwrap(Size), IsVolatile));
1292 #else
1293   unsigned Align = std::min(DstAlign, SrcAlign);
1294   return wrap(unwrap(B)->CreateMemMove(
1295       unwrap(Dst), unwrap(Src),
1296       unwrap(Size), Align, IsVolatile));
1297 #endif
1298 }
1299
1300 extern "C" LLVMValueRef
1301 LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMValueRef Fn, LLVMValueRef *Args,
1302                     unsigned NumArgs, LLVMBasicBlockRef Then,
1303                     LLVMBasicBlockRef Catch, OperandBundleDef *Bundle,
1304                     const char *Name) {
1305   unsigned Len = Bundle ? 1 : 0;
1306   ArrayRef<OperandBundleDef> Bundles = makeArrayRef(Bundle, Len);
1307   return wrap(unwrap(B)->CreateInvoke(unwrap(Fn), unwrap(Then), unwrap(Catch),
1308                                       makeArrayRef(unwrap(Args), NumArgs),
1309                                       Bundles, Name));
1310 }
1311
1312 extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B,
1313                                                LLVMBasicBlockRef BB) {
1314   auto Point = unwrap(BB)->getFirstInsertionPt();
1315   unwrap(B)->SetInsertPoint(unwrap(BB), Point);
1316 }
1317
1318 extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V,
1319                                   const char *Name) {
1320   Triple TargetTriple(unwrap(M)->getTargetTriple());
1321   GlobalObject *GV = unwrap<GlobalObject>(V);
1322   if (!TargetTriple.isOSBinFormatMachO()) {
1323     GV->setComdat(unwrap(M)->getOrInsertComdat(Name));
1324   }
1325 }
1326
1327 extern "C" void LLVMRustUnsetComdat(LLVMValueRef V) {
1328   GlobalObject *GV = unwrap<GlobalObject>(V);
1329   GV->setComdat(nullptr);
1330 }
1331
1332 enum class LLVMRustLinkage {
1333   ExternalLinkage = 0,
1334   AvailableExternallyLinkage = 1,
1335   LinkOnceAnyLinkage = 2,
1336   LinkOnceODRLinkage = 3,
1337   WeakAnyLinkage = 4,
1338   WeakODRLinkage = 5,
1339   AppendingLinkage = 6,
1340   InternalLinkage = 7,
1341   PrivateLinkage = 8,
1342   ExternalWeakLinkage = 9,
1343   CommonLinkage = 10,
1344 };
1345
1346 static LLVMRustLinkage toRust(LLVMLinkage Linkage) {
1347   switch (Linkage) {
1348   case LLVMExternalLinkage:
1349     return LLVMRustLinkage::ExternalLinkage;
1350   case LLVMAvailableExternallyLinkage:
1351     return LLVMRustLinkage::AvailableExternallyLinkage;
1352   case LLVMLinkOnceAnyLinkage:
1353     return LLVMRustLinkage::LinkOnceAnyLinkage;
1354   case LLVMLinkOnceODRLinkage:
1355     return LLVMRustLinkage::LinkOnceODRLinkage;
1356   case LLVMWeakAnyLinkage:
1357     return LLVMRustLinkage::WeakAnyLinkage;
1358   case LLVMWeakODRLinkage:
1359     return LLVMRustLinkage::WeakODRLinkage;
1360   case LLVMAppendingLinkage:
1361     return LLVMRustLinkage::AppendingLinkage;
1362   case LLVMInternalLinkage:
1363     return LLVMRustLinkage::InternalLinkage;
1364   case LLVMPrivateLinkage:
1365     return LLVMRustLinkage::PrivateLinkage;
1366   case LLVMExternalWeakLinkage:
1367     return LLVMRustLinkage::ExternalWeakLinkage;
1368   case LLVMCommonLinkage:
1369     return LLVMRustLinkage::CommonLinkage;
1370   default:
1371     report_fatal_error("Invalid LLVMRustLinkage value!");
1372   }
1373 }
1374
1375 static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {
1376   switch (Linkage) {
1377   case LLVMRustLinkage::ExternalLinkage:
1378     return LLVMExternalLinkage;
1379   case LLVMRustLinkage::AvailableExternallyLinkage:
1380     return LLVMAvailableExternallyLinkage;
1381   case LLVMRustLinkage::LinkOnceAnyLinkage:
1382     return LLVMLinkOnceAnyLinkage;
1383   case LLVMRustLinkage::LinkOnceODRLinkage:
1384     return LLVMLinkOnceODRLinkage;
1385   case LLVMRustLinkage::WeakAnyLinkage:
1386     return LLVMWeakAnyLinkage;
1387   case LLVMRustLinkage::WeakODRLinkage:
1388     return LLVMWeakODRLinkage;
1389   case LLVMRustLinkage::AppendingLinkage:
1390     return LLVMAppendingLinkage;
1391   case LLVMRustLinkage::InternalLinkage:
1392     return LLVMInternalLinkage;
1393   case LLVMRustLinkage::PrivateLinkage:
1394     return LLVMPrivateLinkage;
1395   case LLVMRustLinkage::ExternalWeakLinkage:
1396     return LLVMExternalWeakLinkage;
1397   case LLVMRustLinkage::CommonLinkage:
1398     return LLVMCommonLinkage;
1399   }
1400   report_fatal_error("Invalid LLVMRustLinkage value!");
1401 }
1402
1403 extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {
1404   return toRust(LLVMGetLinkage(V));
1405 }
1406
1407 extern "C" void LLVMRustSetLinkage(LLVMValueRef V,
1408                                    LLVMRustLinkage RustLinkage) {
1409   LLVMSetLinkage(V, fromRust(RustLinkage));
1410 }
1411
1412 // Returns true if both high and low were successfully set. Fails in case constant wasn’t any of
1413 // the common sizes (1, 8, 16, 32, 64, 128 bits)
1414 extern "C" bool LLVMRustConstInt128Get(LLVMValueRef CV, bool sext, uint64_t *high, uint64_t *low)
1415 {
1416     auto C = unwrap<llvm::ConstantInt>(CV);
1417     if (C->getBitWidth() > 128) { return false; }
1418     APInt AP;
1419     if (sext) {
1420         AP = C->getValue().sextOrSelf(128);
1421     } else {
1422         AP = C->getValue().zextOrSelf(128);
1423     }
1424     *low = AP.getLoBits(64).getZExtValue();
1425     *high = AP.getHiBits(64).getZExtValue();
1426     return true;
1427 }
1428
1429 enum class LLVMRustVisibility {
1430   Default = 0,
1431   Hidden = 1,
1432   Protected = 2,
1433 };
1434
1435 static LLVMRustVisibility toRust(LLVMVisibility Vis) {
1436   switch (Vis) {
1437   case LLVMDefaultVisibility:
1438     return LLVMRustVisibility::Default;
1439   case LLVMHiddenVisibility:
1440     return LLVMRustVisibility::Hidden;
1441   case LLVMProtectedVisibility:
1442     return LLVMRustVisibility::Protected;
1443   }
1444   report_fatal_error("Invalid LLVMRustVisibility value!");
1445 }
1446
1447 static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
1448   switch (Vis) {
1449   case LLVMRustVisibility::Default:
1450     return LLVMDefaultVisibility;
1451   case LLVMRustVisibility::Hidden:
1452     return LLVMHiddenVisibility;
1453   case LLVMRustVisibility::Protected:
1454     return LLVMProtectedVisibility;
1455   }
1456   report_fatal_error("Invalid LLVMRustVisibility value!");
1457 }
1458
1459 extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {
1460   return toRust(LLVMGetVisibility(V));
1461 }
1462
1463 // Oh hey, a binding that makes sense for once? (because LLVM’s own do not)
1464 extern "C" LLVMValueRef LLVMRustBuildIntCast(LLVMBuilderRef B, LLVMValueRef Val,
1465                                              LLVMTypeRef DestTy, bool isSigned) {
1466   return wrap(unwrap(B)->CreateIntCast(unwrap(Val), unwrap(DestTy), isSigned, ""));
1467 }
1468
1469 extern "C" void LLVMRustSetVisibility(LLVMValueRef V,
1470                                       LLVMRustVisibility RustVisibility) {
1471   LLVMSetVisibility(V, fromRust(RustVisibility));
1472 }
1473
1474 struct LLVMRustModuleBuffer {
1475   std::string data;
1476 };
1477
1478 extern "C" LLVMRustModuleBuffer*
1479 LLVMRustModuleBufferCreate(LLVMModuleRef M) {
1480   auto Ret = llvm::make_unique<LLVMRustModuleBuffer>();
1481   {
1482     raw_string_ostream OS(Ret->data);
1483     {
1484       legacy::PassManager PM;
1485       PM.add(createBitcodeWriterPass(OS));
1486       PM.run(*unwrap(M));
1487     }
1488   }
1489   return Ret.release();
1490 }
1491
1492 extern "C" void
1493 LLVMRustModuleBufferFree(LLVMRustModuleBuffer *Buffer) {
1494   delete Buffer;
1495 }
1496
1497 extern "C" const void*
1498 LLVMRustModuleBufferPtr(const LLVMRustModuleBuffer *Buffer) {
1499   return Buffer->data.data();
1500 }
1501
1502 extern "C" size_t
1503 LLVMRustModuleBufferLen(const LLVMRustModuleBuffer *Buffer) {
1504   return Buffer->data.length();
1505 }
1506
1507 extern "C" uint64_t
1508 LLVMRustModuleCost(LLVMModuleRef M) {
1509   auto f = unwrap(M)->functions();
1510   return std::distance(std::begin(f), std::end(f));
1511 }
1512
1513 // Vector reductions:
1514 extern "C" LLVMValueRef
1515 LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
1516     return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc),unwrap(Src)));
1517 }
1518 extern "C" LLVMValueRef
1519 LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) {
1520     return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc),unwrap(Src)));
1521 }
1522 extern "C" LLVMValueRef
1523 LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B, LLVMValueRef Src) {
1524     return wrap(unwrap(B)->CreateAddReduce(unwrap(Src)));
1525 }
1526 extern "C" LLVMValueRef
1527 LLVMRustBuildVectorReduceMul(LLVMBuilderRef B, LLVMValueRef Src) {
1528     return wrap(unwrap(B)->CreateMulReduce(unwrap(Src)));
1529 }
1530 extern "C" LLVMValueRef
1531 LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B, LLVMValueRef Src) {
1532     return wrap(unwrap(B)->CreateAndReduce(unwrap(Src)));
1533 }
1534 extern "C" LLVMValueRef
1535 LLVMRustBuildVectorReduceOr(LLVMBuilderRef B, LLVMValueRef Src) {
1536     return wrap(unwrap(B)->CreateOrReduce(unwrap(Src)));
1537 }
1538 extern "C" LLVMValueRef
1539 LLVMRustBuildVectorReduceXor(LLVMBuilderRef B, LLVMValueRef Src) {
1540     return wrap(unwrap(B)->CreateXorReduce(unwrap(Src)));
1541 }
1542 extern "C" LLVMValueRef
1543 LLVMRustBuildVectorReduceMin(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
1544     return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned));
1545 }
1546 extern "C" LLVMValueRef
1547 LLVMRustBuildVectorReduceMax(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) {
1548     return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned));
1549 }
1550 extern "C" LLVMValueRef
1551 LLVMRustBuildVectorReduceFMin(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
1552    return wrap(unwrap(B)->CreateFPMinReduce(unwrap(Src), NoNaN));
1553 }
1554 extern "C" LLVMValueRef
1555 LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) {
1556   return wrap(unwrap(B)->CreateFPMaxReduce(unwrap(Src), NoNaN));
1557 }
1558
1559 extern "C" LLVMValueRef
1560 LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
1561     return wrap(unwrap(B)->CreateMinNum(unwrap(LHS),unwrap(RHS)));
1562 }
1563 extern "C" LLVMValueRef
1564 LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) {
1565     return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS),unwrap(RHS)));
1566 }