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