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