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