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