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