fork/rust
git clone https://git.julia.blue/fork/rust
3bcad65fbf6
master
1#include "LLVMWrapper.h" 2#include "llvm/ADT/Statistic.h" 3#include "llvm/IR/DebugInfoMetadata.h" 4#include "llvm/IR/DiagnosticHandler.h" 5#include "llvm/IR/DiagnosticInfo.h" 6#include "llvm/IR/DiagnosticPrinter.h" 7#include "llvm/IR/GlobalVariable.h" 8#include "llvm/IR/Instructions.h" 9#include "llvm/IR/Intrinsics.h" 10#include "llvm/IR/IntrinsicsARM.h" 11#include "llvm/IR/LLVMRemarkStreamer.h" 12#include "llvm/IR/Mangler.h" 13#include "llvm/Remarks/RemarkStreamer.h" 14#include "llvm/Remarks/RemarkSerializer.h" 15#include "llvm/Remarks/RemarkFormat.h" 16#include "llvm/Support/ToolOutputFile.h" 17#if LLVM_VERSION_GE(16, 0) 18#include "llvm/Support/ModRef.h" 19#endif 20#include "llvm/Object/Archive.h" 21#include "llvm/Object/COFFImportFile.h" 22#include "llvm/Object/ObjectFile.h" 23#include "llvm/Pass.h" 24#include "llvm/Bitcode/BitcodeWriter.h" 25#include "llvm/Support/Signals.h" 26#if LLVM_VERSION_LT(16, 0) 27#include "llvm/ADT/Optional.h" 28#endif 29 30#include <iostream> 31 32//===----------------------------------------------------------------------=== 33// 34// This file defines alternate interfaces to core functions that are more 35// readily callable by Rust's FFI. 36// 37//===----------------------------------------------------------------------=== 38 39using namespace llvm; 40using namespace llvm::sys; 41using namespace llvm::object; 42 43// LLVMAtomicOrdering is already an enum - don't create another 44// one. 45static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) { 46 switch (Ordering) { 47 case LLVMAtomicOrderingNotAtomic: 48 return AtomicOrdering::NotAtomic; 49 case LLVMAtomicOrderingUnordered: 50 return AtomicOrdering::Unordered; 51 case LLVMAtomicOrderingMonotonic: 52 return AtomicOrdering::Monotonic; 53 case LLVMAtomicOrderingAcquire: 54 return AtomicOrdering::Acquire; 55 case LLVMAtomicOrderingRelease: 56 return AtomicOrdering::Release; 57 case LLVMAtomicOrderingAcquireRelease: 58 return AtomicOrdering::AcquireRelease; 59 case LLVMAtomicOrderingSequentiallyConsistent: 60 return AtomicOrdering::SequentiallyConsistent; 61 } 62 63 report_fatal_error("Invalid LLVMAtomicOrdering value!"); 64} 65 66static LLVM_THREAD_LOCAL char *LastError; 67 68// Custom error handler for fatal LLVM errors. 69// 70// Notably it exits the process with code 101, unlike LLVM's default of 1. 71static void FatalErrorHandler(void *UserData, 72 const char* Reason, 73 bool GenCrashDiag) { 74 // Do the same thing that the default error handler does. 75 std::cerr << "LLVM ERROR: " << Reason << std::endl; 76 77 // Since this error handler exits the process, we have to run any cleanup that 78 // LLVM would run after handling the error. This might change with an LLVM 79 // upgrade. 80 sys::RunInterruptHandlers(); 81 82 exit(101); 83} 84 85extern "C" void LLVMRustInstallFatalErrorHandler() { 86 install_fatal_error_handler(FatalErrorHandler); 87} 88 89extern "C" void LLVMRustDisableSystemDialogsOnCrash() { 90 sys::DisableSystemDialogsOnCrash(); 91} 92 93extern "C" char *LLVMRustGetLastError(void) { 94 char *Ret = LastError; 95 LastError = nullptr; 96 return Ret; 97} 98 99extern "C" void LLVMRustSetLastError(const char *Err) { 100 free((void *)LastError); 101 LastError = strdup(Err); 102} 103 104extern "C" LLVMContextRef LLVMRustContextCreate(bool shouldDiscardNames) { 105 auto ctx = new LLVMContext(); 106 ctx->setDiscardValueNames(shouldDiscardNames); 107 return wrap(ctx); 108} 109 110extern "C" void LLVMRustSetNormalizedTarget(LLVMModuleRef M, 111 const char *Triple) { 112 unwrap(M)->setTargetTriple(Triple::normalize(Triple)); 113} 114 115extern "C" const char *LLVMRustPrintPassTimings(size_t *Len) { 116 std::string buf; 117 raw_string_ostream SS(buf); 118 TimerGroup::printAll(SS); 119 SS.flush(); 120 *Len = buf.length(); 121 char *CStr = (char *)malloc(*Len); 122 memcpy(CStr, buf.c_str(), *Len); 123 return CStr; 124} 125 126extern "C" const char *LLVMRustPrintStatistics(size_t *Len) { 127 std::string buf; 128 raw_string_ostream SS(buf); 129 llvm::PrintStatistics(SS); 130 SS.flush(); 131 *Len = buf.length(); 132 char *CStr = (char *)malloc(*Len); 133 memcpy(CStr, buf.c_str(), *Len); 134 return CStr; 135} 136 137extern "C" LLVMValueRef LLVMRustGetNamedValue(LLVMModuleRef M, const char *Name, 138 size_t NameLen) { 139 return wrap(unwrap(M)->getNamedValue(StringRef(Name, NameLen))); 140} 141 142enum class LLVMRustTailCallKind { 143 None, 144 Tail, 145 MustTail, 146 NoTail, 147}; 148 149static CallInst::TailCallKind fromRust(LLVMRustTailCallKind Kind) { 150 switch (Kind) { 151 case LLVMRustTailCallKind::None: 152 return CallInst::TailCallKind::TCK_None; 153 case LLVMRustTailCallKind::Tail: 154 return CallInst::TailCallKind::TCK_Tail; 155 case LLVMRustTailCallKind::MustTail: 156 return CallInst::TailCallKind::TCK_MustTail; 157 case LLVMRustTailCallKind::NoTail: 158 return CallInst::TailCallKind::TCK_NoTail; 159 default: 160 report_fatal_error("bad CallInst::TailCallKind."); 161 } 162} 163 164extern "C" void LLVMRustSetTailCallKind(LLVMValueRef Call, LLVMRustTailCallKind TCK) { 165 unwrap<CallInst>(Call)->setTailCallKind(fromRust(TCK)); 166} 167 168extern "C" LLVMValueRef LLVMRustGetOrInsertFunction(LLVMModuleRef M, 169 const char *Name, 170 size_t NameLen, 171 LLVMTypeRef FunctionTy) { 172 return wrap(unwrap(M) 173 ->getOrInsertFunction(StringRef(Name, NameLen), 174 unwrap<FunctionType>(FunctionTy)) 175 .getCallee() 176 ); 177} 178 179extern "C" LLVMValueRef 180LLVMRustGetOrInsertGlobal(LLVMModuleRef M, const char *Name, size_t NameLen, LLVMTypeRef Ty) { 181 Module *Mod = unwrap(M); 182 StringRef NameRef(Name, NameLen); 183 184 // We don't use Module::getOrInsertGlobal because that returns a Constant*, 185 // which may either be the real GlobalVariable*, or a constant bitcast of it 186 // if our type doesn't match the original declaration. We always want the 187 // GlobalVariable* so we can access linkage, visibility, etc. 188 GlobalVariable *GV = Mod->getGlobalVariable(NameRef, true); 189 if (!GV) 190 GV = new GlobalVariable(*Mod, unwrap(Ty), false, 191 GlobalValue::ExternalLinkage, nullptr, NameRef); 192 return wrap(GV); 193} 194 195extern "C" LLVMValueRef 196LLVMRustInsertPrivateGlobal(LLVMModuleRef M, LLVMTypeRef Ty) { 197 return wrap(new GlobalVariable(*unwrap(M), 198 unwrap(Ty), 199 false, 200 GlobalValue::PrivateLinkage, 201 nullptr)); 202} 203 204static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) { 205 switch (Kind) { 206 case AlwaysInline: 207 return Attribute::AlwaysInline; 208 case ByVal: 209 return Attribute::ByVal; 210 case Cold: 211 return Attribute::Cold; 212 case InlineHint: 213 return Attribute::InlineHint; 214 case MinSize: 215 return Attribute::MinSize; 216 case Naked: 217 return Attribute::Naked; 218 case NoAlias: 219 return Attribute::NoAlias; 220 case NoCapture: 221 return Attribute::NoCapture; 222 case NoCfCheck: 223 return Attribute::NoCfCheck; 224 case NoInline: 225 return Attribute::NoInline; 226 case NonNull: 227 return Attribute::NonNull; 228 case NoRedZone: 229 return Attribute::NoRedZone; 230 case NoReturn: 231 return Attribute::NoReturn; 232 case NoUnwind: 233 return Attribute::NoUnwind; 234 case OptimizeForSize: 235 return Attribute::OptimizeForSize; 236 case ReadOnly: 237 return Attribute::ReadOnly; 238 case SExt: 239 return Attribute::SExt; 240 case StructRet: 241 return Attribute::StructRet; 242 case UWTable: 243 return Attribute::UWTable; 244 case ZExt: 245 return Attribute::ZExt; 246 case InReg: 247 return Attribute::InReg; 248 case SanitizeThread: 249 return Attribute::SanitizeThread; 250 case SanitizeAddress: 251 return Attribute::SanitizeAddress; 252 case SanitizeMemory: 253 return Attribute::SanitizeMemory; 254 case NonLazyBind: 255 return Attribute::NonLazyBind; 256 case OptimizeNone: 257 return Attribute::OptimizeNone; 258 case ReturnsTwice: 259 return Attribute::ReturnsTwice; 260 case ReadNone: 261 return Attribute::ReadNone; 262 case SanitizeHWAddress: 263 return Attribute::SanitizeHWAddress; 264 case WillReturn: 265 return Attribute::WillReturn; 266 case StackProtectReq: 267 return Attribute::StackProtectReq; 268 case StackProtectStrong: 269 return Attribute::StackProtectStrong; 270 case StackProtect: 271 return Attribute::StackProtect; 272 case NoUndef: 273 return Attribute::NoUndef; 274 case SanitizeMemTag: 275 return Attribute::SanitizeMemTag; 276 case ShadowCallStack: 277 return Attribute::ShadowCallStack; 278 case AllocSize: 279 return Attribute::AllocSize; 280 case AllocatedPointer: 281 return Attribute::AllocatedPointer; 282 case AllocAlign: 283 return Attribute::AllocAlign; 284 case SanitizeSafeStack: 285 return Attribute::SafeStack; 286 } 287 report_fatal_error("bad AttributeKind"); 288} 289 290template<typename T> static inline void AddAttributes(T *t, unsigned Index, 291 LLVMAttributeRef *Attrs, size_t AttrsLen) { 292 AttributeList PAL = t->getAttributes(); 293 AttrBuilder B(t->getContext()); 294 for (LLVMAttributeRef Attr : ArrayRef<LLVMAttributeRef>(Attrs, AttrsLen)) 295 B.addAttribute(unwrap(Attr)); 296 AttributeList PALNew = PAL.addAttributesAtIndex(t->getContext(), Index, B); 297 t->setAttributes(PALNew); 298} 299 300extern "C" void LLVMRustAddFunctionAttributes(LLVMValueRef Fn, unsigned Index, 301 LLVMAttributeRef *Attrs, size_t AttrsLen) { 302 Function *F = unwrap<Function>(Fn); 303 AddAttributes(F, Index, Attrs, AttrsLen); 304} 305 306extern "C" void LLVMRustAddCallSiteAttributes(LLVMValueRef Instr, unsigned Index, 307 LLVMAttributeRef *Attrs, size_t AttrsLen) { 308 CallBase *Call = unwrap<CallBase>(Instr); 309 AddAttributes(Call, Index, Attrs, AttrsLen); 310} 311 312extern "C" LLVMAttributeRef LLVMRustCreateAttrNoValue(LLVMContextRef C, 313 LLVMRustAttribute RustAttr) { 314 return wrap(Attribute::get(*unwrap(C), fromRust(RustAttr))); 315} 316 317extern "C" LLVMAttributeRef LLVMRustCreateAlignmentAttr(LLVMContextRef C, 318 uint64_t Bytes) { 319 return wrap(Attribute::getWithAlignment(*unwrap(C), llvm::Align(Bytes))); 320} 321 322extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableAttr(LLVMContextRef C, 323 uint64_t Bytes) { 324 return wrap(Attribute::getWithDereferenceableBytes(*unwrap(C), Bytes)); 325} 326 327extern "C" LLVMAttributeRef LLVMRustCreateDereferenceableOrNullAttr(LLVMContextRef C, 328 uint64_t Bytes) { 329 return wrap(Attribute::getWithDereferenceableOrNullBytes(*unwrap(C), Bytes)); 330} 331 332extern "C" LLVMAttributeRef LLVMRustCreateByValAttr(LLVMContextRef C, LLVMTypeRef Ty) { 333 return wrap(Attribute::getWithByValType(*unwrap(C), unwrap(Ty))); 334} 335 336extern "C" LLVMAttributeRef LLVMRustCreateStructRetAttr(LLVMContextRef C, LLVMTypeRef Ty) { 337 return wrap(Attribute::getWithStructRetType(*unwrap(C), unwrap(Ty))); 338} 339 340extern "C" LLVMAttributeRef LLVMRustCreateElementTypeAttr(LLVMContextRef C, LLVMTypeRef Ty) { 341 return wrap(Attribute::get(*unwrap(C), Attribute::ElementType, unwrap(Ty))); 342} 343 344extern "C" LLVMAttributeRef LLVMRustCreateUWTableAttr(LLVMContextRef C, bool Async) { 345 return wrap(Attribute::getWithUWTableKind( 346 *unwrap(C), Async ? UWTableKind::Async : UWTableKind::Sync)); 347} 348 349extern "C" LLVMAttributeRef LLVMRustCreateAllocSizeAttr(LLVMContextRef C, uint32_t ElementSizeArg) { 350 return wrap(Attribute::getWithAllocSizeArgs(*unwrap(C), ElementSizeArg, 351#if LLVM_VERSION_LT(16, 0) 352 None 353#else 354 std::nullopt 355#endif 356 )); 357} 358 359// These values **must** match ffi::AllocKindFlags. 360// It _happens_ to match the LLVM values of llvm::AllocFnKind, 361// but that's happenstance and we do explicit conversions before 362// passing them to LLVM. 363enum class LLVMRustAllocKindFlags : uint64_t { 364 Unknown = 0, 365 Alloc = 1, 366 Realloc = 1 << 1, 367 Free = 1 << 2, 368 Uninitialized = 1 << 3, 369 Zeroed = 1 << 4, 370 Aligned = 1 << 5, 371}; 372 373static LLVMRustAllocKindFlags operator&(LLVMRustAllocKindFlags A, LLVMRustAllocKindFlags B) { 374 return static_cast<LLVMRustAllocKindFlags>(static_cast<uint64_t>(A) & 375 static_cast<uint64_t>(B)); 376} 377 378static bool isSet(LLVMRustAllocKindFlags F) { return F != LLVMRustAllocKindFlags::Unknown; } 379 380static llvm::AllocFnKind allocKindFromRust(LLVMRustAllocKindFlags F) { 381 llvm::AllocFnKind AFK = llvm::AllocFnKind::Unknown; 382 if (isSet(F & LLVMRustAllocKindFlags::Alloc)) { 383 AFK |= llvm::AllocFnKind::Alloc; 384 } 385 if (isSet(F & LLVMRustAllocKindFlags::Realloc)) { 386 AFK |= llvm::AllocFnKind::Realloc; 387 } 388 if (isSet(F & LLVMRustAllocKindFlags::Free)) { 389 AFK |= llvm::AllocFnKind::Free; 390 } 391 if (isSet(F & LLVMRustAllocKindFlags::Uninitialized)) { 392 AFK |= llvm::AllocFnKind::Uninitialized; 393 } 394 if (isSet(F & LLVMRustAllocKindFlags::Zeroed)) { 395 AFK |= llvm::AllocFnKind::Zeroed; 396 } 397 if (isSet(F & LLVMRustAllocKindFlags::Aligned)) { 398 AFK |= llvm::AllocFnKind::Aligned; 399 } 400 return AFK; 401} 402 403extern "C" LLVMAttributeRef LLVMRustCreateAllocKindAttr(LLVMContextRef C, uint64_t AllocKindArg) { 404 return wrap(Attribute::get(*unwrap(C), Attribute::AllocKind, 405 static_cast<uint64_t>(allocKindFromRust(static_cast<LLVMRustAllocKindFlags>(AllocKindArg))))); 406} 407 408// Simplified representation of `MemoryEffects` across the FFI boundary. 409// 410// Each variant corresponds to one of the static factory methods on `MemoryEffects`. 411enum class LLVMRustMemoryEffects { 412 None, 413 ReadOnly, 414 InaccessibleMemOnly, 415}; 416 417extern "C" LLVMAttributeRef LLVMRustCreateMemoryEffectsAttr(LLVMContextRef C, 418 LLVMRustMemoryEffects Effects) { 419#if LLVM_VERSION_GE(16, 0) 420 switch (Effects) { 421 case LLVMRustMemoryEffects::None: 422 return wrap(Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::none())); 423 case LLVMRustMemoryEffects::ReadOnly: 424 return wrap(Attribute::getWithMemoryEffects(*unwrap(C), MemoryEffects::readOnly())); 425 case LLVMRustMemoryEffects::InaccessibleMemOnly: 426 return wrap(Attribute::getWithMemoryEffects(*unwrap(C), 427 MemoryEffects::inaccessibleMemOnly())); 428 default: 429 report_fatal_error("bad MemoryEffects."); 430 } 431#else 432 switch (Effects) { 433 case LLVMRustMemoryEffects::None: 434 return wrap(Attribute::get(*unwrap(C), Attribute::ReadNone)); 435 case LLVMRustMemoryEffects::ReadOnly: 436 return wrap(Attribute::get(*unwrap(C), Attribute::ReadOnly)); 437 case LLVMRustMemoryEffects::InaccessibleMemOnly: 438 return wrap(Attribute::get(*unwrap(C), Attribute::InaccessibleMemOnly)); 439 default: 440 report_fatal_error("bad MemoryEffects."); 441 } 442#endif 443} 444 445// Enable a fast-math flag 446// 447// https://llvm.org/docs/LangRef.html#fast-math-flags 448extern "C" void LLVMRustSetFastMath(LLVMValueRef V) { 449 if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) { 450 I->setFast(true); 451 } 452} 453 454extern "C" LLVMValueRef 455LLVMRustBuildAtomicLoad(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Source, 456 const char *Name, LLVMAtomicOrdering Order) { 457 Value *Ptr = unwrap(Source); 458 LoadInst *LI = unwrap(B)->CreateLoad(unwrap(Ty), Ptr, Name); 459 LI->setAtomic(fromRust(Order)); 460 return wrap(LI); 461} 462 463extern "C" LLVMValueRef LLVMRustBuildAtomicStore(LLVMBuilderRef B, 464 LLVMValueRef V, 465 LLVMValueRef Target, 466 LLVMAtomicOrdering Order) { 467 StoreInst *SI = unwrap(B)->CreateStore(unwrap(V), unwrap(Target)); 468 SI->setAtomic(fromRust(Order)); 469 return wrap(SI); 470} 471 472enum class LLVMRustAsmDialect { 473 Att, 474 Intel, 475}; 476 477static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) { 478 switch (Dialect) { 479 case LLVMRustAsmDialect::Att: 480 return InlineAsm::AD_ATT; 481 case LLVMRustAsmDialect::Intel: 482 return InlineAsm::AD_Intel; 483 default: 484 report_fatal_error("bad AsmDialect."); 485 } 486} 487 488extern "C" LLVMValueRef 489LLVMRustInlineAsm(LLVMTypeRef Ty, char *AsmString, size_t AsmStringLen, 490 char *Constraints, size_t ConstraintsLen, 491 LLVMBool HasSideEffects, LLVMBool IsAlignStack, 492 LLVMRustAsmDialect Dialect, LLVMBool CanThrow) { 493 return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), 494 StringRef(AsmString, AsmStringLen), 495 StringRef(Constraints, ConstraintsLen), 496 HasSideEffects, IsAlignStack, 497 fromRust(Dialect), CanThrow)); 498} 499 500extern "C" bool LLVMRustInlineAsmVerify(LLVMTypeRef Ty, char *Constraints, 501 size_t ConstraintsLen) { 502 // llvm::Error converts to true if it is an error. 503 return !llvm::errorToBool(InlineAsm::verify( 504 unwrap<FunctionType>(Ty), StringRef(Constraints, ConstraintsLen))); 505} 506 507typedef DIBuilder *LLVMRustDIBuilderRef; 508 509template <typename DIT> DIT *unwrapDIPtr(LLVMMetadataRef Ref) { 510 return (DIT *)(Ref ? unwrap<MDNode>(Ref) : nullptr); 511} 512 513#define DIDescriptor DIScope 514#define DIArray DINodeArray 515#define unwrapDI unwrapDIPtr 516 517// These values **must** match debuginfo::DIFlags! They also *happen* 518// to match LLVM, but that isn't required as we do giant sets of 519// matching below. The value shouldn't be directly passed to LLVM. 520enum class LLVMRustDIFlags : uint32_t { 521 FlagZero = 0, 522 FlagPrivate = 1, 523 FlagProtected = 2, 524 FlagPublic = 3, 525 FlagFwdDecl = (1 << 2), 526 FlagAppleBlock = (1 << 3), 527 FlagBlockByrefStruct = (1 << 4), 528 FlagVirtual = (1 << 5), 529 FlagArtificial = (1 << 6), 530 FlagExplicit = (1 << 7), 531 FlagPrototyped = (1 << 8), 532 FlagObjcClassComplete = (1 << 9), 533 FlagObjectPointer = (1 << 10), 534 FlagVector = (1 << 11), 535 FlagStaticMember = (1 << 12), 536 FlagLValueReference = (1 << 13), 537 FlagRValueReference = (1 << 14), 538 FlagExternalTypeRef = (1 << 15), 539 FlagIntroducedVirtual = (1 << 18), 540 FlagBitField = (1 << 19), 541 FlagNoReturn = (1 << 20), 542 // Do not add values that are not supported by the minimum LLVM 543 // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def 544}; 545 546inline LLVMRustDIFlags operator&(LLVMRustDIFlags A, LLVMRustDIFlags B) { 547 return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) & 548 static_cast<uint32_t>(B)); 549} 550 551inline LLVMRustDIFlags operator|(LLVMRustDIFlags A, LLVMRustDIFlags B) { 552 return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(A) | 553 static_cast<uint32_t>(B)); 554} 555 556inline LLVMRustDIFlags &operator|=(LLVMRustDIFlags &A, LLVMRustDIFlags B) { 557 return A = A | B; 558} 559 560inline bool isSet(LLVMRustDIFlags F) { return F != LLVMRustDIFlags::FlagZero; } 561 562inline LLVMRustDIFlags visibility(LLVMRustDIFlags F) { 563 return static_cast<LLVMRustDIFlags>(static_cast<uint32_t>(F) & 0x3); 564} 565 566static DINode::DIFlags fromRust(LLVMRustDIFlags Flags) { 567 DINode::DIFlags Result = DINode::DIFlags::FlagZero; 568 569 switch (visibility(Flags)) { 570 case LLVMRustDIFlags::FlagPrivate: 571 Result |= DINode::DIFlags::FlagPrivate; 572 break; 573 case LLVMRustDIFlags::FlagProtected: 574 Result |= DINode::DIFlags::FlagProtected; 575 break; 576 case LLVMRustDIFlags::FlagPublic: 577 Result |= DINode::DIFlags::FlagPublic; 578 break; 579 default: 580 // The rest are handled below 581 break; 582 } 583 584 if (isSet(Flags & LLVMRustDIFlags::FlagFwdDecl)) { 585 Result |= DINode::DIFlags::FlagFwdDecl; 586 } 587 if (isSet(Flags & LLVMRustDIFlags::FlagAppleBlock)) { 588 Result |= DINode::DIFlags::FlagAppleBlock; 589 } 590 if (isSet(Flags & LLVMRustDIFlags::FlagVirtual)) { 591 Result |= DINode::DIFlags::FlagVirtual; 592 } 593 if (isSet(Flags & LLVMRustDIFlags::FlagArtificial)) { 594 Result |= DINode::DIFlags::FlagArtificial; 595 } 596 if (isSet(Flags & LLVMRustDIFlags::FlagExplicit)) { 597 Result |= DINode::DIFlags::FlagExplicit; 598 } 599 if (isSet(Flags & LLVMRustDIFlags::FlagPrototyped)) { 600 Result |= DINode::DIFlags::FlagPrototyped; 601 } 602 if (isSet(Flags & LLVMRustDIFlags::FlagObjcClassComplete)) { 603 Result |= DINode::DIFlags::FlagObjcClassComplete; 604 } 605 if (isSet(Flags & LLVMRustDIFlags::FlagObjectPointer)) { 606 Result |= DINode::DIFlags::FlagObjectPointer; 607 } 608 if (isSet(Flags & LLVMRustDIFlags::FlagVector)) { 609 Result |= DINode::DIFlags::FlagVector; 610 } 611 if (isSet(Flags & LLVMRustDIFlags::FlagStaticMember)) { 612 Result |= DINode::DIFlags::FlagStaticMember; 613 } 614 if (isSet(Flags & LLVMRustDIFlags::FlagLValueReference)) { 615 Result |= DINode::DIFlags::FlagLValueReference; 616 } 617 if (isSet(Flags & LLVMRustDIFlags::FlagRValueReference)) { 618 Result |= DINode::DIFlags::FlagRValueReference; 619 } 620 if (isSet(Flags & LLVMRustDIFlags::FlagIntroducedVirtual)) { 621 Result |= DINode::DIFlags::FlagIntroducedVirtual; 622 } 623 if (isSet(Flags & LLVMRustDIFlags::FlagBitField)) { 624 Result |= DINode::DIFlags::FlagBitField; 625 } 626 if (isSet(Flags & LLVMRustDIFlags::FlagNoReturn)) { 627 Result |= DINode::DIFlags::FlagNoReturn; 628 } 629 630 return Result; 631} 632 633// These values **must** match debuginfo::DISPFlags! They also *happen* 634// to match LLVM, but that isn't required as we do giant sets of 635// matching below. The value shouldn't be directly passed to LLVM. 636enum class LLVMRustDISPFlags : uint32_t { 637 SPFlagZero = 0, 638 SPFlagVirtual = 1, 639 SPFlagPureVirtual = 2, 640 SPFlagLocalToUnit = (1 << 2), 641 SPFlagDefinition = (1 << 3), 642 SPFlagOptimized = (1 << 4), 643 SPFlagMainSubprogram = (1 << 5), 644 // Do not add values that are not supported by the minimum LLVM 645 // version we support! see llvm/include/llvm/IR/DebugInfoFlags.def 646 // (In LLVM < 8, createFunction supported these as separate bool arguments.) 647}; 648 649inline LLVMRustDISPFlags operator&(LLVMRustDISPFlags A, LLVMRustDISPFlags B) { 650 return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) & 651 static_cast<uint32_t>(B)); 652} 653 654inline LLVMRustDISPFlags operator|(LLVMRustDISPFlags A, LLVMRustDISPFlags B) { 655 return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(A) | 656 static_cast<uint32_t>(B)); 657} 658 659inline LLVMRustDISPFlags &operator|=(LLVMRustDISPFlags &A, LLVMRustDISPFlags B) { 660 return A = A | B; 661} 662 663inline bool isSet(LLVMRustDISPFlags F) { return F != LLVMRustDISPFlags::SPFlagZero; } 664 665inline LLVMRustDISPFlags virtuality(LLVMRustDISPFlags F) { 666 return static_cast<LLVMRustDISPFlags>(static_cast<uint32_t>(F) & 0x3); 667} 668 669static DISubprogram::DISPFlags fromRust(LLVMRustDISPFlags SPFlags) { 670 DISubprogram::DISPFlags Result = DISubprogram::DISPFlags::SPFlagZero; 671 672 switch (virtuality(SPFlags)) { 673 case LLVMRustDISPFlags::SPFlagVirtual: 674 Result |= DISubprogram::DISPFlags::SPFlagVirtual; 675 break; 676 case LLVMRustDISPFlags::SPFlagPureVirtual: 677 Result |= DISubprogram::DISPFlags::SPFlagPureVirtual; 678 break; 679 default: 680 // The rest are handled below 681 break; 682 } 683 684 if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagLocalToUnit)) { 685 Result |= DISubprogram::DISPFlags::SPFlagLocalToUnit; 686 } 687 if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagDefinition)) { 688 Result |= DISubprogram::DISPFlags::SPFlagDefinition; 689 } 690 if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagOptimized)) { 691 Result |= DISubprogram::DISPFlags::SPFlagOptimized; 692 } 693 if (isSet(SPFlags & LLVMRustDISPFlags::SPFlagMainSubprogram)) { 694 Result |= DISubprogram::DISPFlags::SPFlagMainSubprogram; 695 } 696 697 return Result; 698} 699 700enum class LLVMRustDebugEmissionKind { 701 NoDebug, 702 FullDebug, 703 LineTablesOnly, 704 DebugDirectivesOnly, 705}; 706 707static DICompileUnit::DebugEmissionKind fromRust(LLVMRustDebugEmissionKind Kind) { 708 switch (Kind) { 709 case LLVMRustDebugEmissionKind::NoDebug: 710 return DICompileUnit::DebugEmissionKind::NoDebug; 711 case LLVMRustDebugEmissionKind::FullDebug: 712 return DICompileUnit::DebugEmissionKind::FullDebug; 713 case LLVMRustDebugEmissionKind::LineTablesOnly: 714 return DICompileUnit::DebugEmissionKind::LineTablesOnly; 715 case LLVMRustDebugEmissionKind::DebugDirectivesOnly: 716 return DICompileUnit::DebugEmissionKind::DebugDirectivesOnly; 717 default: 718 report_fatal_error("bad DebugEmissionKind."); 719 } 720} 721 722enum class LLVMRustChecksumKind { 723 None, 724 MD5, 725 SHA1, 726 SHA256, 727}; 728 729#if LLVM_VERSION_LT(16, 0) 730static Optional<DIFile::ChecksumKind> fromRust(LLVMRustChecksumKind Kind) { 731#else 732static std::optional<DIFile::ChecksumKind> fromRust(LLVMRustChecksumKind Kind) { 733#endif 734 switch (Kind) { 735 case LLVMRustChecksumKind::None: 736#if LLVM_VERSION_LT(16, 0) 737 return None; 738#else 739 return std::nullopt; 740#endif 741 case LLVMRustChecksumKind::MD5: 742 return DIFile::ChecksumKind::CSK_MD5; 743 case LLVMRustChecksumKind::SHA1: 744 return DIFile::ChecksumKind::CSK_SHA1; 745 case LLVMRustChecksumKind::SHA256: 746 return DIFile::ChecksumKind::CSK_SHA256; 747 default: 748 report_fatal_error("bad ChecksumKind."); 749 } 750} 751 752extern "C" uint32_t LLVMRustDebugMetadataVersion() { 753 return DEBUG_METADATA_VERSION; 754} 755 756extern "C" uint32_t LLVMRustVersionPatch() { return LLVM_VERSION_PATCH; } 757 758extern "C" uint32_t LLVMRustVersionMinor() { return LLVM_VERSION_MINOR; } 759 760extern "C" uint32_t LLVMRustVersionMajor() { return LLVM_VERSION_MAJOR; } 761 762extern "C" void LLVMRustAddModuleFlag( 763 LLVMModuleRef M, 764 Module::ModFlagBehavior MergeBehavior, 765 const char *Name, 766 uint32_t Value) { 767 unwrap(M)->addModuleFlag(MergeBehavior, Name, Value); 768} 769 770extern "C" bool LLVMRustHasModuleFlag(LLVMModuleRef M, const char *Name, 771 size_t Len) { 772 return unwrap(M)->getModuleFlag(StringRef(Name, Len)) != nullptr; 773} 774 775extern "C" void LLVMRustGlobalAddMetadata( 776 LLVMValueRef Global, unsigned Kind, LLVMMetadataRef MD) { 777 unwrap<GlobalObject>(Global)->addMetadata(Kind, *unwrap<MDNode>(MD)); 778} 779 780extern "C" LLVMRustDIBuilderRef LLVMRustDIBuilderCreate(LLVMModuleRef M) { 781 return new DIBuilder(*unwrap(M)); 782} 783 784extern "C" void LLVMRustDIBuilderDispose(LLVMRustDIBuilderRef Builder) { 785 delete Builder; 786} 787 788extern "C" void LLVMRustDIBuilderFinalize(LLVMRustDIBuilderRef Builder) { 789 Builder->finalize(); 790} 791 792extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateCompileUnit( 793 LLVMRustDIBuilderRef Builder, unsigned Lang, LLVMMetadataRef FileRef, 794 const char *Producer, size_t ProducerLen, bool isOptimized, 795 const char *Flags, unsigned RuntimeVer, 796 const char *SplitName, size_t SplitNameLen, 797 LLVMRustDebugEmissionKind Kind, 798 uint64_t DWOId, bool SplitDebugInlining) { 799 auto *File = unwrapDI<DIFile>(FileRef); 800 801 return wrap(Builder->createCompileUnit(Lang, File, StringRef(Producer, ProducerLen), 802 isOptimized, Flags, RuntimeVer, 803 StringRef(SplitName, SplitNameLen), 804 fromRust(Kind), DWOId, SplitDebugInlining)); 805} 806 807extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFile( 808 LLVMRustDIBuilderRef Builder, 809 const char *Filename, size_t FilenameLen, 810 const char *Directory, size_t DirectoryLen, LLVMRustChecksumKind CSKind, 811 const char *Checksum, size_t ChecksumLen) { 812 813#if LLVM_VERSION_LT(16, 0) 814 Optional<DIFile::ChecksumKind> llvmCSKind = fromRust(CSKind); 815#else 816 std::optional<DIFile::ChecksumKind> llvmCSKind = fromRust(CSKind); 817#endif 818 819#if LLVM_VERSION_LT(16, 0) 820 Optional<DIFile::ChecksumInfo<StringRef>> CSInfo{}; 821#else 822 std::optional<DIFile::ChecksumInfo<StringRef>> CSInfo{}; 823#endif 824 if (llvmCSKind) 825 CSInfo.emplace(*llvmCSKind, StringRef{Checksum, ChecksumLen}); 826 return wrap(Builder->createFile(StringRef(Filename, FilenameLen), 827 StringRef(Directory, DirectoryLen), 828 CSInfo)); 829} 830 831extern "C" LLVMMetadataRef 832LLVMRustDIBuilderCreateSubroutineType(LLVMRustDIBuilderRef Builder, 833 LLVMMetadataRef ParameterTypes) { 834 return wrap(Builder->createSubroutineType( 835 DITypeRefArray(unwrap<MDTuple>(ParameterTypes)))); 836} 837 838extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateFunction( 839 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 840 const char *Name, size_t NameLen, 841 const char *LinkageName, size_t LinkageNameLen, 842 LLVMMetadataRef File, unsigned LineNo, 843 LLVMMetadataRef Ty, unsigned ScopeLine, LLVMRustDIFlags Flags, 844 LLVMRustDISPFlags SPFlags, LLVMValueRef MaybeFn, LLVMMetadataRef TParam, 845 LLVMMetadataRef Decl) { 846 DITemplateParameterArray TParams = 847 DITemplateParameterArray(unwrap<MDTuple>(TParam)); 848 DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags); 849 DINode::DIFlags llvmFlags = fromRust(Flags); 850 DISubprogram *Sub = Builder->createFunction( 851 unwrapDI<DIScope>(Scope), 852 StringRef(Name, NameLen), 853 StringRef(LinkageName, LinkageNameLen), 854 unwrapDI<DIFile>(File), LineNo, 855 unwrapDI<DISubroutineType>(Ty), ScopeLine, llvmFlags, 856 llvmSPFlags, TParams, unwrapDIPtr<DISubprogram>(Decl)); 857 if (MaybeFn) 858 unwrap<Function>(MaybeFn)->setSubprogram(Sub); 859 return wrap(Sub); 860} 861 862extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMethod( 863 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 864 const char *Name, size_t NameLen, 865 const char *LinkageName, size_t LinkageNameLen, 866 LLVMMetadataRef File, unsigned LineNo, 867 LLVMMetadataRef Ty, LLVMRustDIFlags Flags, 868 LLVMRustDISPFlags SPFlags, LLVMMetadataRef TParam) { 869 DITemplateParameterArray TParams = 870 DITemplateParameterArray(unwrap<MDTuple>(TParam)); 871 DISubprogram::DISPFlags llvmSPFlags = fromRust(SPFlags); 872 DINode::DIFlags llvmFlags = fromRust(Flags); 873 DISubprogram *Sub = Builder->createMethod( 874 unwrapDI<DIScope>(Scope), 875 StringRef(Name, NameLen), 876 StringRef(LinkageName, LinkageNameLen), 877 unwrapDI<DIFile>(File), LineNo, 878 unwrapDI<DISubroutineType>(Ty), 879 0, 0, nullptr, // VTable params aren't used 880 llvmFlags, llvmSPFlags, TParams); 881 return wrap(Sub); 882} 883 884extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateBasicType( 885 LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen, 886 uint64_t SizeInBits, unsigned Encoding) { 887 return wrap(Builder->createBasicType(StringRef(Name, NameLen), SizeInBits, Encoding)); 888} 889 890extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTypedef( 891 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Type, const char *Name, size_t NameLen, 892 LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Scope) { 893 return wrap(Builder->createTypedef( 894 unwrap<DIType>(Type), StringRef(Name, NameLen), unwrap<DIFile>(File), 895 LineNo, unwrapDIPtr<DIScope>(Scope))); 896} 897 898extern "C" LLVMMetadataRef LLVMRustDIBuilderCreatePointerType( 899 LLVMRustDIBuilderRef Builder, LLVMMetadataRef PointeeTy, 900 uint64_t SizeInBits, uint32_t AlignInBits, unsigned AddressSpace, 901 const char *Name, size_t NameLen) { 902 return wrap(Builder->createPointerType(unwrapDI<DIType>(PointeeTy), 903 SizeInBits, AlignInBits, 904 AddressSpace, 905 StringRef(Name, NameLen))); 906} 907 908extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStructType( 909 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 910 const char *Name, size_t NameLen, 911 LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, 912 uint32_t AlignInBits, LLVMRustDIFlags Flags, 913 LLVMMetadataRef DerivedFrom, LLVMMetadataRef Elements, 914 unsigned RunTimeLang, LLVMMetadataRef VTableHolder, 915 const char *UniqueId, size_t UniqueIdLen) { 916 return wrap(Builder->createStructType( 917 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), 918 unwrapDI<DIFile>(File), LineNumber, 919 SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIType>(DerivedFrom), 920 DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang, 921 unwrapDI<DIType>(VTableHolder), StringRef(UniqueId, UniqueIdLen))); 922} 923 924extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantPart( 925 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 926 const char *Name, size_t NameLen, 927 LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, 928 uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Discriminator, 929 LLVMMetadataRef Elements, const char *UniqueId, size_t UniqueIdLen) { 930 return wrap(Builder->createVariantPart( 931 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), 932 unwrapDI<DIFile>(File), LineNumber, 933 SizeInBits, AlignInBits, fromRust(Flags), unwrapDI<DIDerivedType>(Discriminator), 934 DINodeArray(unwrapDI<MDTuple>(Elements)), StringRef(UniqueId, UniqueIdLen))); 935} 936 937extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateMemberType( 938 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 939 const char *Name, size_t NameLen, 940 LLVMMetadataRef File, unsigned LineNo, uint64_t SizeInBits, 941 uint32_t AlignInBits, uint64_t OffsetInBits, LLVMRustDIFlags Flags, 942 LLVMMetadataRef Ty) { 943 return wrap(Builder->createMemberType(unwrapDI<DIDescriptor>(Scope), 944 StringRef(Name, NameLen), 945 unwrapDI<DIFile>(File), LineNo, 946 SizeInBits, AlignInBits, OffsetInBits, 947 fromRust(Flags), unwrapDI<DIType>(Ty))); 948} 949 950extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariantMemberType( 951 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 952 const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, 953 uint64_t SizeInBits, uint32_t AlignInBits, uint64_t OffsetInBits, LLVMValueRef Discriminant, 954 LLVMRustDIFlags Flags, LLVMMetadataRef Ty) { 955 llvm::ConstantInt* D = nullptr; 956 if (Discriminant) { 957 D = unwrap<llvm::ConstantInt>(Discriminant); 958 } 959 return wrap(Builder->createVariantMemberType(unwrapDI<DIDescriptor>(Scope), 960 StringRef(Name, NameLen), 961 unwrapDI<DIFile>(File), LineNo, 962 SizeInBits, AlignInBits, OffsetInBits, D, 963 fromRust(Flags), unwrapDI<DIType>(Ty))); 964} 965 966extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticMemberType( 967 LLVMRustDIBuilderRef Builder, 968 LLVMMetadataRef Scope, 969 const char *Name, 970 size_t NameLen, 971 LLVMMetadataRef File, 972 unsigned LineNo, 973 LLVMMetadataRef Ty, 974 LLVMRustDIFlags Flags, 975 LLVMValueRef val, 976 uint32_t AlignInBits 977) { 978 return wrap(Builder->createStaticMemberType( 979 unwrapDI<DIDescriptor>(Scope), 980 StringRef(Name, NameLen), 981 unwrapDI<DIFile>(File), 982 LineNo, 983 unwrapDI<DIType>(Ty), 984 fromRust(Flags), 985 unwrap<llvm::ConstantInt>(val), 986 AlignInBits 987 )); 988} 989 990extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateLexicalBlock( 991 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 992 LLVMMetadataRef File, unsigned Line, unsigned Col) { 993 return wrap(Builder->createLexicalBlock(unwrapDI<DIDescriptor>(Scope), 994 unwrapDI<DIFile>(File), Line, Col)); 995} 996 997extern "C" LLVMMetadataRef 998LLVMRustDIBuilderCreateLexicalBlockFile(LLVMRustDIBuilderRef Builder, 999 LLVMMetadataRef Scope, 1000 LLVMMetadataRef File) { 1001 return wrap(Builder->createLexicalBlockFile(unwrapDI<DIDescriptor>(Scope), 1002 unwrapDI<DIFile>(File))); 1003} 1004 1005extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateStaticVariable( 1006 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Context, 1007 const char *Name, size_t NameLen, 1008 const char *LinkageName, size_t LinkageNameLen, 1009 LLVMMetadataRef File, unsigned LineNo, 1010 LLVMMetadataRef Ty, bool IsLocalToUnit, LLVMValueRef V, 1011 LLVMMetadataRef Decl = nullptr, uint32_t AlignInBits = 0) { 1012 llvm::GlobalVariable *InitVal = cast<llvm::GlobalVariable>(unwrap(V)); 1013 1014 llvm::DIExpression *InitExpr = nullptr; 1015 if (llvm::ConstantInt *IntVal = llvm::dyn_cast<llvm::ConstantInt>(InitVal)) { 1016 InitExpr = Builder->createConstantValueExpression( 1017 IntVal->getValue().getSExtValue()); 1018 } else if (llvm::ConstantFP *FPVal = 1019 llvm::dyn_cast<llvm::ConstantFP>(InitVal)) { 1020 InitExpr = Builder->createConstantValueExpression( 1021 FPVal->getValueAPF().bitcastToAPInt().getZExtValue()); 1022 } 1023 1024 llvm::DIGlobalVariableExpression *VarExpr = Builder->createGlobalVariableExpression( 1025 unwrapDI<DIDescriptor>(Context), StringRef(Name, NameLen), 1026 StringRef(LinkageName, LinkageNameLen), 1027 unwrapDI<DIFile>(File), LineNo, unwrapDI<DIType>(Ty), IsLocalToUnit, 1028 /* isDefined */ true, 1029 InitExpr, unwrapDIPtr<MDNode>(Decl), 1030 /* templateParams */ nullptr, 1031 AlignInBits); 1032 1033 InitVal->setMetadata("dbg", VarExpr); 1034 1035 return wrap(VarExpr); 1036} 1037 1038extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable( 1039 LLVMRustDIBuilderRef Builder, unsigned Tag, LLVMMetadataRef Scope, 1040 const char *Name, size_t NameLen, 1041 LLVMMetadataRef File, unsigned LineNo, 1042 LLVMMetadataRef Ty, bool AlwaysPreserve, LLVMRustDIFlags Flags, 1043 unsigned ArgNo, uint32_t AlignInBits) { 1044 if (Tag == 0x100) { // DW_TAG_auto_variable 1045 return wrap(Builder->createAutoVariable( 1046 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), 1047 unwrapDI<DIFile>(File), LineNo, 1048 unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags), AlignInBits)); 1049 } else { 1050 return wrap(Builder->createParameterVariable( 1051 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ArgNo, 1052 unwrapDI<DIFile>(File), LineNo, 1053 unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags))); 1054 } 1055} 1056 1057extern "C" LLVMMetadataRef 1058LLVMRustDIBuilderCreateArrayType(LLVMRustDIBuilderRef Builder, uint64_t Size, 1059 uint32_t AlignInBits, LLVMMetadataRef Ty, 1060 LLVMMetadataRef Subscripts) { 1061 return wrap( 1062 Builder->createArrayType(Size, AlignInBits, unwrapDI<DIType>(Ty), 1063 DINodeArray(unwrapDI<MDTuple>(Subscripts)))); 1064} 1065 1066extern "C" LLVMMetadataRef 1067LLVMRustDIBuilderGetOrCreateSubrange(LLVMRustDIBuilderRef Builder, int64_t Lo, 1068 int64_t Count) { 1069 return wrap(Builder->getOrCreateSubrange(Lo, Count)); 1070} 1071 1072extern "C" LLVMMetadataRef 1073LLVMRustDIBuilderGetOrCreateArray(LLVMRustDIBuilderRef Builder, 1074 LLVMMetadataRef *Ptr, unsigned Count) { 1075 Metadata **DataValue = unwrap(Ptr); 1076 return wrap( 1077 Builder->getOrCreateArray(ArrayRef<Metadata *>(DataValue, Count)).get()); 1078} 1079 1080extern "C" LLVMValueRef LLVMRustDIBuilderInsertDeclareAtEnd( 1081 LLVMRustDIBuilderRef Builder, LLVMValueRef V, LLVMMetadataRef VarInfo, 1082 uint64_t *AddrOps, unsigned AddrOpsCount, LLVMMetadataRef DL, 1083 LLVMBasicBlockRef InsertAtEnd) { 1084 return wrap(Builder->insertDeclare( 1085 unwrap(V), unwrap<DILocalVariable>(VarInfo), 1086 Builder->createExpression(llvm::ArrayRef<uint64_t>(AddrOps, AddrOpsCount)), 1087 DebugLoc(cast<MDNode>(unwrap(DL))), 1088 unwrap(InsertAtEnd))); 1089} 1090 1091extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerator( 1092 LLVMRustDIBuilderRef Builder, const char *Name, size_t NameLen, 1093 const uint64_t Value[2], unsigned SizeInBits, bool IsUnsigned) { 1094 return wrap(Builder->createEnumerator(StringRef(Name, NameLen), 1095 APSInt(APInt(SizeInBits, ArrayRef<uint64_t>(Value, 2)), IsUnsigned))); 1096} 1097 1098extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateEnumerationType( 1099 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 1100 const char *Name, size_t NameLen, 1101 LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, 1102 uint32_t AlignInBits, LLVMMetadataRef Elements, 1103 LLVMMetadataRef ClassTy, bool IsScoped) { 1104 return wrap(Builder->createEnumerationType( 1105 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), 1106 unwrapDI<DIFile>(File), LineNumber, 1107 SizeInBits, AlignInBits, DINodeArray(unwrapDI<MDTuple>(Elements)), 1108 unwrapDI<DIType>(ClassTy), "", IsScoped)); 1109} 1110 1111extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateUnionType( 1112 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 1113 const char *Name, size_t NameLen, 1114 LLVMMetadataRef File, unsigned LineNumber, uint64_t SizeInBits, 1115 uint32_t AlignInBits, LLVMRustDIFlags Flags, LLVMMetadataRef Elements, 1116 unsigned RunTimeLang, const char *UniqueId, size_t UniqueIdLen) { 1117 return wrap(Builder->createUnionType( 1118 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIFile>(File), 1119 LineNumber, SizeInBits, AlignInBits, fromRust(Flags), 1120 DINodeArray(unwrapDI<MDTuple>(Elements)), RunTimeLang, 1121 StringRef(UniqueId, UniqueIdLen))); 1122} 1123 1124extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateTemplateTypeParameter( 1125 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 1126 const char *Name, size_t NameLen, LLVMMetadataRef Ty) { 1127 bool IsDefault = false; // FIXME: should we ever set this true? 1128 return wrap(Builder->createTemplateTypeParameter( 1129 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), unwrapDI<DIType>(Ty), IsDefault)); 1130} 1131 1132extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateNameSpace( 1133 LLVMRustDIBuilderRef Builder, LLVMMetadataRef Scope, 1134 const char *Name, size_t NameLen, bool ExportSymbols) { 1135 return wrap(Builder->createNameSpace( 1136 unwrapDI<DIDescriptor>(Scope), StringRef(Name, NameLen), ExportSymbols 1137 )); 1138} 1139 1140extern "C" void 1141LLVMRustDICompositeTypeReplaceArrays(LLVMRustDIBuilderRef Builder, 1142 LLVMMetadataRef CompositeTy, 1143 LLVMMetadataRef Elements, 1144 LLVMMetadataRef Params) { 1145 DICompositeType *Tmp = unwrapDI<DICompositeType>(CompositeTy); 1146 Builder->replaceArrays(Tmp, DINodeArray(unwrap<MDTuple>(Elements)), 1147 DINodeArray(unwrap<MDTuple>(Params))); 1148} 1149 1150extern "C" LLVMMetadataRef 1151LLVMRustDIBuilderCreateDebugLocation(unsigned Line, unsigned Column, 1152 LLVMMetadataRef ScopeRef, 1153 LLVMMetadataRef InlinedAt) { 1154 MDNode *Scope = unwrapDIPtr<MDNode>(ScopeRef); 1155 DILocation *Loc = DILocation::get( 1156 Scope->getContext(), Line, Column, Scope, 1157 unwrapDIPtr<MDNode>(InlinedAt)); 1158 return wrap(Loc); 1159} 1160 1161extern "C" uint64_t LLVMRustDIBuilderCreateOpDeref() { 1162 return dwarf::DW_OP_deref; 1163} 1164 1165extern "C" uint64_t LLVMRustDIBuilderCreateOpPlusUconst() { 1166 return dwarf::DW_OP_plus_uconst; 1167} 1168 1169extern "C" int64_t LLVMRustDIBuilderCreateOpLLVMFragment() { 1170 return dwarf::DW_OP_LLVM_fragment; 1171} 1172 1173extern "C" void LLVMRustWriteTypeToString(LLVMTypeRef Ty, RustStringRef Str) { 1174 RawRustStringOstream OS(Str); 1175 unwrap<llvm::Type>(Ty)->print(OS); 1176} 1177 1178extern "C" void LLVMRustWriteValueToString(LLVMValueRef V, 1179 RustStringRef Str) { 1180 RawRustStringOstream OS(Str); 1181 if (!V) { 1182 OS << "(null)"; 1183 } else { 1184 OS << "("; 1185 unwrap<llvm::Value>(V)->getType()->print(OS); 1186 OS << ":"; 1187 unwrap<llvm::Value>(V)->print(OS); 1188 OS << ")"; 1189 } 1190} 1191 1192// LLVMArrayType function does not support 64-bit ElementCount 1193// FIXME: replace with LLVMArrayType2 when bumped minimal version to llvm-17 1194// https://github.com/llvm/llvm-project/commit/35276f16e5a2cae0dfb49c0fbf874d4d2f177acc 1195extern "C" LLVMTypeRef LLVMRustArrayType(LLVMTypeRef ElementTy, 1196 uint64_t ElementCount) { 1197 return wrap(ArrayType::get(unwrap(ElementTy), ElementCount)); 1198} 1199 1200DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Twine, LLVMTwineRef) 1201 1202extern "C" void LLVMRustWriteTwineToString(LLVMTwineRef T, RustStringRef Str) { 1203 RawRustStringOstream OS(Str); 1204 unwrap(T)->print(OS); 1205} 1206 1207extern "C" void LLVMRustUnpackOptimizationDiagnostic( 1208 LLVMDiagnosticInfoRef DI, RustStringRef PassNameOut, 1209 LLVMValueRef *FunctionOut, unsigned* Line, unsigned* Column, 1210 RustStringRef FilenameOut, RustStringRef MessageOut) { 1211 // Undefined to call this not on an optimization diagnostic! 1212 llvm::DiagnosticInfoOptimizationBase *Opt = 1213 static_cast<llvm::DiagnosticInfoOptimizationBase *>(unwrap(DI)); 1214 1215 RawRustStringOstream PassNameOS(PassNameOut); 1216 PassNameOS << Opt->getPassName(); 1217 *FunctionOut = wrap(&Opt->getFunction()); 1218 1219 RawRustStringOstream FilenameOS(FilenameOut); 1220 DiagnosticLocation loc = Opt->getLocation(); 1221 if (loc.isValid()) { 1222 *Line = loc.getLine(); 1223 *Column = loc.getColumn(); 1224 FilenameOS << loc.getAbsolutePath(); 1225 } 1226 1227 RawRustStringOstream MessageOS(MessageOut); 1228 MessageOS << Opt->getMsg(); 1229} 1230 1231enum class LLVMRustDiagnosticLevel { 1232 Error, 1233 Warning, 1234 Note, 1235 Remark, 1236}; 1237 1238extern "C" void 1239LLVMRustUnpackInlineAsmDiagnostic(LLVMDiagnosticInfoRef DI, 1240 LLVMRustDiagnosticLevel *LevelOut, 1241 unsigned *CookieOut, 1242 LLVMTwineRef *MessageOut) { 1243 // Undefined to call this not on an inline assembly diagnostic! 1244 llvm::DiagnosticInfoInlineAsm *IA = 1245 static_cast<llvm::DiagnosticInfoInlineAsm *>(unwrap(DI)); 1246 1247 *CookieOut = IA->getLocCookie(); 1248 *MessageOut = wrap(&IA->getMsgStr()); 1249 1250 switch (IA->getSeverity()) { 1251 case DS_Error: 1252 *LevelOut = LLVMRustDiagnosticLevel::Error; 1253 break; 1254 case DS_Warning: 1255 *LevelOut = LLVMRustDiagnosticLevel::Warning; 1256 break; 1257 case DS_Note: 1258 *LevelOut = LLVMRustDiagnosticLevel::Note; 1259 break; 1260 case DS_Remark: 1261 *LevelOut = LLVMRustDiagnosticLevel::Remark; 1262 break; 1263 default: 1264 report_fatal_error("Invalid LLVMRustDiagnosticLevel value!"); 1265 } 1266} 1267 1268extern "C" void LLVMRustWriteDiagnosticInfoToString(LLVMDiagnosticInfoRef DI, 1269 RustStringRef Str) { 1270 RawRustStringOstream OS(Str); 1271 DiagnosticPrinterRawOStream DP(OS); 1272 unwrap(DI)->print(DP); 1273} 1274 1275enum class LLVMRustDiagnosticKind { 1276 Other, 1277 InlineAsm, 1278 StackSize, 1279 DebugMetadataVersion, 1280 SampleProfile, 1281 OptimizationRemark, 1282 OptimizationRemarkMissed, 1283 OptimizationRemarkAnalysis, 1284 OptimizationRemarkAnalysisFPCommute, 1285 OptimizationRemarkAnalysisAliasing, 1286 OptimizationRemarkOther, 1287 OptimizationFailure, 1288 PGOProfile, 1289 Linker, 1290 Unsupported, 1291 SrcMgr, 1292}; 1293 1294static LLVMRustDiagnosticKind toRust(DiagnosticKind Kind) { 1295 switch (Kind) { 1296 case DK_InlineAsm: 1297 return LLVMRustDiagnosticKind::InlineAsm; 1298 case DK_StackSize: 1299 return LLVMRustDiagnosticKind::StackSize; 1300 case DK_DebugMetadataVersion: 1301 return LLVMRustDiagnosticKind::DebugMetadataVersion; 1302 case DK_SampleProfile: 1303 return LLVMRustDiagnosticKind::SampleProfile; 1304 case DK_OptimizationRemark: 1305 case DK_MachineOptimizationRemark: 1306 return LLVMRustDiagnosticKind::OptimizationRemark; 1307 case DK_OptimizationRemarkMissed: 1308 case DK_MachineOptimizationRemarkMissed: 1309 return LLVMRustDiagnosticKind::OptimizationRemarkMissed; 1310 case DK_OptimizationRemarkAnalysis: 1311 case DK_MachineOptimizationRemarkAnalysis: 1312 return LLVMRustDiagnosticKind::OptimizationRemarkAnalysis; 1313 case DK_OptimizationRemarkAnalysisFPCommute: 1314 return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisFPCommute; 1315 case DK_OptimizationRemarkAnalysisAliasing: 1316 return LLVMRustDiagnosticKind::OptimizationRemarkAnalysisAliasing; 1317 case DK_PGOProfile: 1318 return LLVMRustDiagnosticKind::PGOProfile; 1319 case DK_Linker: 1320 return LLVMRustDiagnosticKind::Linker; 1321 case DK_Unsupported: 1322 return LLVMRustDiagnosticKind::Unsupported; 1323 case DK_SrcMgr: 1324 return LLVMRustDiagnosticKind::SrcMgr; 1325 default: 1326 return (Kind >= DK_FirstRemark && Kind <= DK_LastRemark) 1327 ? LLVMRustDiagnosticKind::OptimizationRemarkOther 1328 : LLVMRustDiagnosticKind::Other; 1329 } 1330} 1331 1332extern "C" LLVMRustDiagnosticKind 1333LLVMRustGetDiagInfoKind(LLVMDiagnosticInfoRef DI) { 1334 return toRust((DiagnosticKind)unwrap(DI)->getKind()); 1335} 1336 1337// This is kept distinct from LLVMGetTypeKind, because when 1338// a new type kind is added, the Rust-side enum must be 1339// updated or UB will result. 1340extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) { 1341 switch (unwrap(Ty)->getTypeID()) { 1342 case Type::VoidTyID: 1343 return LLVMVoidTypeKind; 1344 case Type::HalfTyID: 1345 return LLVMHalfTypeKind; 1346 case Type::FloatTyID: 1347 return LLVMFloatTypeKind; 1348 case Type::DoubleTyID: 1349 return LLVMDoubleTypeKind; 1350 case Type::X86_FP80TyID: 1351 return LLVMX86_FP80TypeKind; 1352 case Type::FP128TyID: 1353 return LLVMFP128TypeKind; 1354 case Type::PPC_FP128TyID: 1355 return LLVMPPC_FP128TypeKind; 1356 case Type::LabelTyID: 1357 return LLVMLabelTypeKind; 1358 case Type::MetadataTyID: 1359 return LLVMMetadataTypeKind; 1360 case Type::IntegerTyID: 1361 return LLVMIntegerTypeKind; 1362 case Type::FunctionTyID: 1363 return LLVMFunctionTypeKind; 1364 case Type::StructTyID: 1365 return LLVMStructTypeKind; 1366 case Type::ArrayTyID: 1367 return LLVMArrayTypeKind; 1368 case Type::PointerTyID: 1369 return LLVMPointerTypeKind; 1370 case Type::FixedVectorTyID: 1371 return LLVMVectorTypeKind; 1372 case Type::X86_MMXTyID: 1373 return LLVMX86_MMXTypeKind; 1374 case Type::TokenTyID: 1375 return LLVMTokenTypeKind; 1376 case Type::ScalableVectorTyID: 1377 return LLVMScalableVectorTypeKind; 1378 case Type::BFloatTyID: 1379 return LLVMBFloatTypeKind; 1380 case Type::X86_AMXTyID: 1381 return LLVMX86_AMXTypeKind; 1382 default: 1383 { 1384 std::string error; 1385 llvm::raw_string_ostream stream(error); 1386 stream << "Rust does not support the TypeID: " << unwrap(Ty)->getTypeID() 1387 << " for the type: " << *unwrap(Ty); 1388 stream.flush(); 1389 report_fatal_error(error.c_str()); 1390 } 1391 } 1392} 1393 1394DEFINE_SIMPLE_CONVERSION_FUNCTIONS(SMDiagnostic, LLVMSMDiagnosticRef) 1395 1396extern "C" LLVMSMDiagnosticRef LLVMRustGetSMDiagnostic( 1397 LLVMDiagnosticInfoRef DI, unsigned *Cookie) { 1398 llvm::DiagnosticInfoSrcMgr *SM = static_cast<llvm::DiagnosticInfoSrcMgr *>(unwrap(DI)); 1399 *Cookie = SM->getLocCookie(); 1400 return wrap(&SM->getSMDiag()); 1401} 1402 1403extern "C" bool LLVMRustUnpackSMDiagnostic(LLVMSMDiagnosticRef DRef, 1404 RustStringRef MessageOut, 1405 RustStringRef BufferOut, 1406 LLVMRustDiagnosticLevel* LevelOut, 1407 unsigned* LocOut, 1408 unsigned* RangesOut, 1409 size_t* NumRanges) { 1410 SMDiagnostic& D = *unwrap(DRef); 1411 RawRustStringOstream MessageOS(MessageOut); 1412 MessageOS << D.getMessage(); 1413 1414 switch (D.getKind()) { 1415 case SourceMgr::DK_Error: 1416 *LevelOut = LLVMRustDiagnosticLevel::Error; 1417 break; 1418 case SourceMgr::DK_Warning: 1419 *LevelOut = LLVMRustDiagnosticLevel::Warning; 1420 break; 1421 case SourceMgr::DK_Note: 1422 *LevelOut = LLVMRustDiagnosticLevel::Note; 1423 break; 1424 case SourceMgr::DK_Remark: 1425 *LevelOut = LLVMRustDiagnosticLevel::Remark; 1426 break; 1427 default: 1428 report_fatal_error("Invalid LLVMRustDiagnosticLevel value!"); 1429 } 1430 1431 if (D.getLoc() == SMLoc()) 1432 return false; 1433 1434 const SourceMgr &LSM = *D.getSourceMgr(); 1435 const MemoryBuffer *LBuf = LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc())); 1436 LLVMRustStringWriteImpl(BufferOut, LBuf->getBufferStart(), LBuf->getBufferSize()); 1437 1438 *LocOut = D.getLoc().getPointer() - LBuf->getBufferStart(); 1439 1440 *NumRanges = std::min(*NumRanges, D.getRanges().size()); 1441 size_t LineStart = *LocOut - (size_t)D.getColumnNo(); 1442 for (size_t i = 0; i < *NumRanges; i++) { 1443 RangesOut[i * 2] = LineStart + D.getRanges()[i].first; 1444 RangesOut[i * 2 + 1] = LineStart + D.getRanges()[i].second; 1445 } 1446 1447 return true; 1448} 1449 1450extern "C" OperandBundleDef *LLVMRustBuildOperandBundleDef(const char *Name, 1451 LLVMValueRef *Inputs, 1452 unsigned NumInputs) { 1453 return new OperandBundleDef(Name, ArrayRef<Value*>(unwrap(Inputs), NumInputs)); 1454} 1455 1456extern "C" void LLVMRustFreeOperandBundleDef(OperandBundleDef *Bundle) { 1457 delete Bundle; 1458} 1459 1460extern "C" LLVMValueRef LLVMRustBuildCall(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn, 1461 LLVMValueRef *Args, unsigned NumArgs, 1462 OperandBundleDef **OpBundles, 1463 unsigned NumOpBundles) { 1464 Value *Callee = unwrap(Fn); 1465 FunctionType *FTy = unwrap<FunctionType>(Ty); 1466 return wrap(unwrap(B)->CreateCall( 1467 FTy, Callee, ArrayRef<Value*>(unwrap(Args), NumArgs), 1468 ArrayRef<OperandBundleDef>(*OpBundles, NumOpBundles))); 1469} 1470 1471extern "C" LLVMValueRef LLVMRustGetInstrProfIncrementIntrinsic(LLVMModuleRef M) { 1472 return wrap(llvm::Intrinsic::getDeclaration(unwrap(M), 1473 (llvm::Intrinsic::ID)llvm::Intrinsic::instrprof_increment)); 1474} 1475 1476extern "C" LLVMValueRef LLVMRustBuildMemCpy(LLVMBuilderRef B, 1477 LLVMValueRef Dst, unsigned DstAlign, 1478 LLVMValueRef Src, unsigned SrcAlign, 1479 LLVMValueRef Size, bool IsVolatile) { 1480 return wrap(unwrap(B)->CreateMemCpy( 1481 unwrap(Dst), MaybeAlign(DstAlign), 1482 unwrap(Src), MaybeAlign(SrcAlign), 1483 unwrap(Size), IsVolatile)); 1484} 1485 1486extern "C" LLVMValueRef LLVMRustBuildMemMove(LLVMBuilderRef B, 1487 LLVMValueRef Dst, unsigned DstAlign, 1488 LLVMValueRef Src, unsigned SrcAlign, 1489 LLVMValueRef Size, bool IsVolatile) { 1490 return wrap(unwrap(B)->CreateMemMove( 1491 unwrap(Dst), MaybeAlign(DstAlign), 1492 unwrap(Src), MaybeAlign(SrcAlign), 1493 unwrap(Size), IsVolatile)); 1494} 1495 1496extern "C" LLVMValueRef LLVMRustBuildMemSet(LLVMBuilderRef B, 1497 LLVMValueRef Dst, unsigned DstAlign, 1498 LLVMValueRef Val, 1499 LLVMValueRef Size, bool IsVolatile) { 1500 return wrap(unwrap(B)->CreateMemSet( 1501 unwrap(Dst), unwrap(Val), unwrap(Size), MaybeAlign(DstAlign), IsVolatile)); 1502} 1503 1504extern "C" LLVMValueRef 1505LLVMRustBuildInvoke(LLVMBuilderRef B, LLVMTypeRef Ty, LLVMValueRef Fn, 1506 LLVMValueRef *Args, unsigned NumArgs, 1507 LLVMBasicBlockRef Then, LLVMBasicBlockRef Catch, 1508 OperandBundleDef **OpBundles, unsigned NumOpBundles, 1509 const char *Name) { 1510 Value *Callee = unwrap(Fn); 1511 FunctionType *FTy = unwrap<FunctionType>(Ty); 1512 return wrap(unwrap(B)->CreateInvoke(FTy, Callee, unwrap(Then), unwrap(Catch), 1513 ArrayRef<Value*>(unwrap(Args), NumArgs), 1514 ArrayRef<OperandBundleDef>(*OpBundles, NumOpBundles), 1515 Name)); 1516} 1517 1518extern "C" void LLVMRustPositionBuilderAtStart(LLVMBuilderRef B, 1519 LLVMBasicBlockRef BB) { 1520 auto Point = unwrap(BB)->getFirstInsertionPt(); 1521 unwrap(B)->SetInsertPoint(unwrap(BB), Point); 1522} 1523 1524extern "C" void LLVMRustSetComdat(LLVMModuleRef M, LLVMValueRef V, 1525 const char *Name, size_t NameLen) { 1526 Triple TargetTriple(unwrap(M)->getTargetTriple()); 1527 GlobalObject *GV = unwrap<GlobalObject>(V); 1528 if (TargetTriple.supportsCOMDAT()) { 1529 StringRef NameRef(Name, NameLen); 1530 GV->setComdat(unwrap(M)->getOrInsertComdat(NameRef)); 1531 } 1532} 1533 1534enum class LLVMRustLinkage { 1535 ExternalLinkage = 0, 1536 AvailableExternallyLinkage = 1, 1537 LinkOnceAnyLinkage = 2, 1538 LinkOnceODRLinkage = 3, 1539 WeakAnyLinkage = 4, 1540 WeakODRLinkage = 5, 1541 AppendingLinkage = 6, 1542 InternalLinkage = 7, 1543 PrivateLinkage = 8, 1544 ExternalWeakLinkage = 9, 1545 CommonLinkage = 10, 1546}; 1547 1548static LLVMRustLinkage toRust(LLVMLinkage Linkage) { 1549 switch (Linkage) { 1550 case LLVMExternalLinkage: 1551 return LLVMRustLinkage::ExternalLinkage; 1552 case LLVMAvailableExternallyLinkage: 1553 return LLVMRustLinkage::AvailableExternallyLinkage; 1554 case LLVMLinkOnceAnyLinkage: 1555 return LLVMRustLinkage::LinkOnceAnyLinkage; 1556 case LLVMLinkOnceODRLinkage: 1557 return LLVMRustLinkage::LinkOnceODRLinkage; 1558 case LLVMWeakAnyLinkage: 1559 return LLVMRustLinkage::WeakAnyLinkage; 1560 case LLVMWeakODRLinkage: 1561 return LLVMRustLinkage::WeakODRLinkage; 1562 case LLVMAppendingLinkage: 1563 return LLVMRustLinkage::AppendingLinkage; 1564 case LLVMInternalLinkage: 1565 return LLVMRustLinkage::InternalLinkage; 1566 case LLVMPrivateLinkage: 1567 return LLVMRustLinkage::PrivateLinkage; 1568 case LLVMExternalWeakLinkage: 1569 return LLVMRustLinkage::ExternalWeakLinkage; 1570 case LLVMCommonLinkage: 1571 return LLVMRustLinkage::CommonLinkage; 1572 default: 1573 report_fatal_error("Invalid LLVMRustLinkage value!"); 1574 } 1575} 1576 1577static LLVMLinkage fromRust(LLVMRustLinkage Linkage) { 1578 switch (Linkage) { 1579 case LLVMRustLinkage::ExternalLinkage: 1580 return LLVMExternalLinkage; 1581 case LLVMRustLinkage::AvailableExternallyLinkage: 1582 return LLVMAvailableExternallyLinkage; 1583 case LLVMRustLinkage::LinkOnceAnyLinkage: 1584 return LLVMLinkOnceAnyLinkage; 1585 case LLVMRustLinkage::LinkOnceODRLinkage: 1586 return LLVMLinkOnceODRLinkage; 1587 case LLVMRustLinkage::WeakAnyLinkage: 1588 return LLVMWeakAnyLinkage; 1589 case LLVMRustLinkage::WeakODRLinkage: 1590 return LLVMWeakODRLinkage; 1591 case LLVMRustLinkage::AppendingLinkage: 1592 return LLVMAppendingLinkage; 1593 case LLVMRustLinkage::InternalLinkage: 1594 return LLVMInternalLinkage; 1595 case LLVMRustLinkage::PrivateLinkage: 1596 return LLVMPrivateLinkage; 1597 case LLVMRustLinkage::ExternalWeakLinkage: 1598 return LLVMExternalWeakLinkage; 1599 case LLVMRustLinkage::CommonLinkage: 1600 return LLVMCommonLinkage; 1601 } 1602 report_fatal_error("Invalid LLVMRustLinkage value!"); 1603} 1604 1605extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) { 1606 return toRust(LLVMGetLinkage(V)); 1607} 1608 1609extern "C" void LLVMRustSetLinkage(LLVMValueRef V, 1610 LLVMRustLinkage RustLinkage) { 1611 LLVMSetLinkage(V, fromRust(RustLinkage)); 1612} 1613 1614extern "C" bool LLVMRustConstIntGetZExtValue(LLVMValueRef CV, uint64_t *value) { 1615 auto C = unwrap<llvm::ConstantInt>(CV); 1616 if (C->getBitWidth() > 64) 1617 return false; 1618 *value = C->getZExtValue(); 1619 return true; 1620} 1621 1622// Returns true if both high and low were successfully set. Fails in case constant wasn’t any of 1623// the common sizes (1, 8, 16, 32, 64, 128 bits) 1624extern "C" bool LLVMRustConstInt128Get(LLVMValueRef CV, bool sext, uint64_t *high, uint64_t *low) 1625{ 1626 auto C = unwrap<llvm::ConstantInt>(CV); 1627 if (C->getBitWidth() > 128) { return false; } 1628 APInt AP; 1629 if (sext) { 1630 AP = C->getValue().sext(128); 1631 } else { 1632 AP = C->getValue().zext(128); 1633 } 1634 *low = AP.getLoBits(64).getZExtValue(); 1635 *high = AP.getHiBits(64).getZExtValue(); 1636 return true; 1637} 1638 1639enum class LLVMRustVisibility { 1640 Default = 0, 1641 Hidden = 1, 1642 Protected = 2, 1643}; 1644 1645static LLVMRustVisibility toRust(LLVMVisibility Vis) { 1646 switch (Vis) { 1647 case LLVMDefaultVisibility: 1648 return LLVMRustVisibility::Default; 1649 case LLVMHiddenVisibility: 1650 return LLVMRustVisibility::Hidden; 1651 case LLVMProtectedVisibility: 1652 return LLVMRustVisibility::Protected; 1653 } 1654 report_fatal_error("Invalid LLVMRustVisibility value!"); 1655} 1656 1657static LLVMVisibility fromRust(LLVMRustVisibility Vis) { 1658 switch (Vis) { 1659 case LLVMRustVisibility::Default: 1660 return LLVMDefaultVisibility; 1661 case LLVMRustVisibility::Hidden: 1662 return LLVMHiddenVisibility; 1663 case LLVMRustVisibility::Protected: 1664 return LLVMProtectedVisibility; 1665 } 1666 report_fatal_error("Invalid LLVMRustVisibility value!"); 1667} 1668 1669extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) { 1670 return toRust(LLVMGetVisibility(V)); 1671} 1672 1673extern "C" void LLVMRustSetVisibility(LLVMValueRef V, 1674 LLVMRustVisibility RustVisibility) { 1675 LLVMSetVisibility(V, fromRust(RustVisibility)); 1676} 1677 1678extern "C" void LLVMRustSetDSOLocal(LLVMValueRef Global, bool is_dso_local) { 1679 unwrap<GlobalValue>(Global)->setDSOLocal(is_dso_local); 1680} 1681 1682struct LLVMRustModuleBuffer { 1683 std::string data; 1684}; 1685 1686extern "C" LLVMRustModuleBuffer* 1687LLVMRustModuleBufferCreate(LLVMModuleRef M) { 1688 auto Ret = std::make_unique<LLVMRustModuleBuffer>(); 1689 { 1690 raw_string_ostream OS(Ret->data); 1691 WriteBitcodeToFile(*unwrap(M), OS); 1692 } 1693 return Ret.release(); 1694} 1695 1696extern "C" void 1697LLVMRustModuleBufferFree(LLVMRustModuleBuffer *Buffer) { 1698 delete Buffer; 1699} 1700 1701extern "C" const void* 1702LLVMRustModuleBufferPtr(const LLVMRustModuleBuffer *Buffer) { 1703 return Buffer->data.data(); 1704} 1705 1706extern "C" size_t 1707LLVMRustModuleBufferLen(const LLVMRustModuleBuffer *Buffer) { 1708 return Buffer->data.length(); 1709} 1710 1711extern "C" uint64_t 1712LLVMRustModuleCost(LLVMModuleRef M) { 1713 auto f = unwrap(M)->functions(); 1714 return std::distance(std::begin(f), std::end(f)); 1715} 1716 1717extern "C" void 1718LLVMRustModuleInstructionStats(LLVMModuleRef M, RustStringRef Str) 1719{ 1720 RawRustStringOstream OS(Str); 1721 llvm::json::OStream JOS(OS); 1722 auto Module = unwrap(M); 1723 1724 JOS.object([&] { 1725 JOS.attribute("module", Module->getName()); 1726 JOS.attribute("total", Module->getInstructionCount()); 1727 }); 1728} 1729 1730// Vector reductions: 1731extern "C" LLVMValueRef 1732LLVMRustBuildVectorReduceFAdd(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) { 1733 return wrap(unwrap(B)->CreateFAddReduce(unwrap(Acc),unwrap(Src))); 1734} 1735extern "C" LLVMValueRef 1736LLVMRustBuildVectorReduceFMul(LLVMBuilderRef B, LLVMValueRef Acc, LLVMValueRef Src) { 1737 return wrap(unwrap(B)->CreateFMulReduce(unwrap(Acc),unwrap(Src))); 1738} 1739extern "C" LLVMValueRef 1740LLVMRustBuildVectorReduceAdd(LLVMBuilderRef B, LLVMValueRef Src) { 1741 return wrap(unwrap(B)->CreateAddReduce(unwrap(Src))); 1742} 1743extern "C" LLVMValueRef 1744LLVMRustBuildVectorReduceMul(LLVMBuilderRef B, LLVMValueRef Src) { 1745 return wrap(unwrap(B)->CreateMulReduce(unwrap(Src))); 1746} 1747extern "C" LLVMValueRef 1748LLVMRustBuildVectorReduceAnd(LLVMBuilderRef B, LLVMValueRef Src) { 1749 return wrap(unwrap(B)->CreateAndReduce(unwrap(Src))); 1750} 1751extern "C" LLVMValueRef 1752LLVMRustBuildVectorReduceOr(LLVMBuilderRef B, LLVMValueRef Src) { 1753 return wrap(unwrap(B)->CreateOrReduce(unwrap(Src))); 1754} 1755extern "C" LLVMValueRef 1756LLVMRustBuildVectorReduceXor(LLVMBuilderRef B, LLVMValueRef Src) { 1757 return wrap(unwrap(B)->CreateXorReduce(unwrap(Src))); 1758} 1759extern "C" LLVMValueRef 1760LLVMRustBuildVectorReduceMin(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) { 1761 return wrap(unwrap(B)->CreateIntMinReduce(unwrap(Src), IsSigned)); 1762} 1763extern "C" LLVMValueRef 1764LLVMRustBuildVectorReduceMax(LLVMBuilderRef B, LLVMValueRef Src, bool IsSigned) { 1765 return wrap(unwrap(B)->CreateIntMaxReduce(unwrap(Src), IsSigned)); 1766} 1767extern "C" LLVMValueRef 1768LLVMRustBuildVectorReduceFMin(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) { 1769 Instruction *I = unwrap(B)->CreateFPMinReduce(unwrap(Src)); 1770 I->setHasNoNaNs(NoNaN); 1771 return wrap(I); 1772} 1773extern "C" LLVMValueRef 1774LLVMRustBuildVectorReduceFMax(LLVMBuilderRef B, LLVMValueRef Src, bool NoNaN) { 1775 Instruction *I = unwrap(B)->CreateFPMaxReduce(unwrap(Src)); 1776 I->setHasNoNaNs(NoNaN); 1777 return wrap(I); 1778} 1779 1780extern "C" LLVMValueRef 1781LLVMRustBuildMinNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) { 1782 return wrap(unwrap(B)->CreateMinNum(unwrap(LHS),unwrap(RHS))); 1783} 1784extern "C" LLVMValueRef 1785LLVMRustBuildMaxNum(LLVMBuilderRef B, LLVMValueRef LHS, LLVMValueRef RHS) { 1786 return wrap(unwrap(B)->CreateMaxNum(unwrap(LHS),unwrap(RHS))); 1787} 1788 1789// This struct contains all necessary info about a symbol exported from a DLL. 1790struct LLVMRustCOFFShortExport { 1791 const char* name; 1792 bool ordinal_present; 1793 // The value of `ordinal` is only meaningful if `ordinal_present` is true. 1794 uint16_t ordinal; 1795}; 1796 1797// Machine must be a COFF machine type, as defined in PE specs. 1798extern "C" LLVMRustResult LLVMRustWriteImportLibrary( 1799 const char* ImportName, 1800 const char* Path, 1801 const LLVMRustCOFFShortExport* Exports, 1802 size_t NumExports, 1803 uint16_t Machine, 1804 bool MinGW) 1805{ 1806 std::vector<llvm::object::COFFShortExport> ConvertedExports; 1807 ConvertedExports.reserve(NumExports); 1808 1809 for (size_t i = 0; i < NumExports; ++i) { 1810 bool ordinal_present = Exports[i].ordinal_present; 1811 uint16_t ordinal = ordinal_present ? Exports[i].ordinal : 0; 1812 ConvertedExports.push_back(llvm::object::COFFShortExport{ 1813 Exports[i].name, // Name 1814 std::string{}, // ExtName 1815 std::string{}, // SymbolName 1816 std::string{}, // AliasTarget 1817 ordinal, // Ordinal 1818 ordinal_present, // Noname 1819 false, // Data 1820 false, // Private 1821 false // Constant 1822 }); 1823 } 1824 1825 auto Error = llvm::object::writeImportLibrary( 1826 ImportName, 1827 Path, 1828 ConvertedExports, 1829 static_cast<llvm::COFF::MachineTypes>(Machine), 1830 MinGW); 1831 if (Error) { 1832 std::string errorString; 1833 llvm::raw_string_ostream stream(errorString); 1834 stream << Error; 1835 stream.flush(); 1836 LLVMRustSetLastError(errorString.c_str()); 1837 return LLVMRustResult::Failure; 1838 } else { 1839 return LLVMRustResult::Success; 1840 } 1841} 1842 1843// Transfers ownership of DiagnosticHandler unique_ptr to the caller. 1844extern "C" DiagnosticHandler * 1845LLVMRustContextGetDiagnosticHandler(LLVMContextRef C) { 1846 std::unique_ptr<DiagnosticHandler> DH = unwrap(C)->getDiagnosticHandler(); 1847 return DH.release(); 1848} 1849 1850// Sets unique_ptr to object of DiagnosticHandler to provide custom diagnostic 1851// handling. Ownership of the handler is moved to the LLVMContext. 1852extern "C" void LLVMRustContextSetDiagnosticHandler(LLVMContextRef C, 1853 DiagnosticHandler *DH) { 1854 unwrap(C)->setDiagnosticHandler(std::unique_ptr<DiagnosticHandler>(DH)); 1855} 1856 1857using LLVMDiagnosticHandlerTy = DiagnosticHandler::DiagnosticHandlerTy; 1858 1859// Configures a diagnostic handler that invokes provided callback when a 1860// backend needs to emit a diagnostic. 1861// 1862// When RemarkAllPasses is true, remarks are enabled for all passes. Otherwise 1863// the RemarkPasses array specifies individual passes for which remarks will be 1864// enabled. 1865// 1866// If RemarkFilePath is not NULL, optimization remarks will be streamed directly into this file, 1867// bypassing the diagnostics handler. 1868extern "C" void LLVMRustContextConfigureDiagnosticHandler( 1869 LLVMContextRef C, LLVMDiagnosticHandlerTy DiagnosticHandlerCallback, 1870 void *DiagnosticHandlerContext, bool RemarkAllPasses, 1871 const char * const * RemarkPasses, size_t RemarkPassesLen, 1872 const char * RemarkFilePath, 1873 bool PGOAvailable 1874) { 1875 1876 class RustDiagnosticHandler final : public DiagnosticHandler { 1877 public: 1878 RustDiagnosticHandler( 1879 LLVMDiagnosticHandlerTy DiagnosticHandlerCallback, 1880 void *DiagnosticHandlerContext, 1881 bool RemarkAllPasses, 1882 std::vector<std::string> RemarkPasses, 1883 std::unique_ptr<ToolOutputFile> RemarksFile, 1884 std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer, 1885 std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer 1886 ) 1887 : DiagnosticHandlerCallback(DiagnosticHandlerCallback), 1888 DiagnosticHandlerContext(DiagnosticHandlerContext), 1889 RemarkAllPasses(RemarkAllPasses), 1890 RemarkPasses(std::move(RemarkPasses)), 1891 RemarksFile(std::move(RemarksFile)), 1892 RemarkStreamer(std::move(RemarkStreamer)), 1893 LlvmRemarkStreamer(std::move(LlvmRemarkStreamer)) {} 1894 1895 virtual bool handleDiagnostics(const DiagnosticInfo &DI) override { 1896 // If this diagnostic is one of the optimization remark kinds, we can check if it's enabled 1897 // before emitting it. This can avoid many short-lived allocations when unpacking the 1898 // diagnostic and converting its various C++ strings into rust strings. 1899 // FIXME: some diagnostic infos still allocate before we get here, and avoiding that would be 1900 // good in the future. That will require changing a few call sites in LLVM. 1901 if (auto *OptDiagBase = dyn_cast<DiagnosticInfoOptimizationBase>(&DI)) { 1902 if (OptDiagBase->isEnabled()) { 1903 if (this->LlvmRemarkStreamer) { 1904 this->LlvmRemarkStreamer->emit(*OptDiagBase); 1905 return true; 1906 } 1907 } else { 1908 return true; 1909 } 1910 } 1911 if (DiagnosticHandlerCallback) { 1912 DiagnosticHandlerCallback(DI, DiagnosticHandlerContext); 1913 return true; 1914 } 1915 return false; 1916 } 1917 1918 bool isAnalysisRemarkEnabled(StringRef PassName) const override { 1919 return isRemarkEnabled(PassName); 1920 } 1921 1922 bool isMissedOptRemarkEnabled(StringRef PassName) const override { 1923 return isRemarkEnabled(PassName); 1924 } 1925 1926 bool isPassedOptRemarkEnabled(StringRef PassName) const override { 1927 return isRemarkEnabled(PassName); 1928 } 1929 1930 bool isAnyRemarkEnabled() const override { 1931 return RemarkAllPasses || !RemarkPasses.empty(); 1932 } 1933 1934 private: 1935 bool isRemarkEnabled(StringRef PassName) const { 1936 if (RemarkAllPasses) 1937 return true; 1938 1939 for (auto &Pass : RemarkPasses) 1940 if (Pass == PassName) 1941 return true; 1942 1943 return false; 1944 } 1945 1946 LLVMDiagnosticHandlerTy DiagnosticHandlerCallback = nullptr; 1947 void *DiagnosticHandlerContext = nullptr; 1948 1949 bool RemarkAllPasses = false; 1950 std::vector<std::string> RemarkPasses; 1951 1952 // Since LlvmRemarkStreamer contains a pointer to RemarkStreamer, the ordering of the three 1953 // members below is important. 1954 std::unique_ptr<ToolOutputFile> RemarksFile; 1955 std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer; 1956 std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer; 1957 }; 1958 1959 std::vector<std::string> Passes; 1960 for (size_t I = 0; I != RemarkPassesLen; ++I) 1961 { 1962 Passes.push_back(RemarkPasses[I]); 1963 } 1964 1965 // We need to hold onto both the streamers and the opened file 1966 std::unique_ptr<ToolOutputFile> RemarkFile; 1967 std::unique_ptr<llvm::remarks::RemarkStreamer> RemarkStreamer; 1968 std::unique_ptr<LLVMRemarkStreamer> LlvmRemarkStreamer; 1969 1970 if (RemarkFilePath != nullptr) { 1971 if (PGOAvailable) { 1972 // Enable PGO hotness data for remarks, if available 1973 unwrap(C)->setDiagnosticsHotnessRequested(true); 1974 } 1975 1976 std::error_code EC; 1977 RemarkFile = std::make_unique<ToolOutputFile>( 1978 RemarkFilePath, 1979 EC, 1980 llvm::sys::fs::OF_TextWithCRLF 1981 ); 1982 if (EC) { 1983 std::string Error = std::string("Cannot create remark file: ") + 1984 toString(errorCodeToError(EC)); 1985 report_fatal_error(Twine(Error)); 1986 } 1987 1988 // Do not delete the file after we gather remarks 1989 RemarkFile->keep(); 1990 1991 auto RemarkSerializer = remarks::createRemarkSerializer( 1992 llvm::remarks::Format::YAML, 1993 remarks::SerializerMode::Separate, 1994 RemarkFile->os() 1995 ); 1996 if (Error E = RemarkSerializer.takeError()) 1997 { 1998 std::string Error = std::string("Cannot create remark serializer: ") + toString(std::move(E)); 1999 report_fatal_error(Twine(Error)); 2000 } 2001 RemarkStreamer = std::make_unique<llvm::remarks::RemarkStreamer>(std::move(*RemarkSerializer)); 2002 LlvmRemarkStreamer = std::make_unique<LLVMRemarkStreamer>(*RemarkStreamer); 2003 } 2004 2005 unwrap(C)->setDiagnosticHandler(std::make_unique<RustDiagnosticHandler>( 2006 DiagnosticHandlerCallback, 2007 DiagnosticHandlerContext, 2008 RemarkAllPasses, 2009 Passes, 2010 std::move(RemarkFile), 2011 std::move(RemarkStreamer), 2012 std::move(LlvmRemarkStreamer) 2013 )); 2014} 2015 2016extern "C" void LLVMRustGetMangledName(LLVMValueRef V, RustStringRef Str) { 2017 RawRustStringOstream OS(Str); 2018 GlobalValue *GV = unwrap<GlobalValue>(V); 2019 Mangler().getNameWithPrefix(OS, GV, true); 2020} 2021 2022extern "C" int32_t LLVMRustGetElementTypeArgIndex(LLVMValueRef CallSite) { 2023 auto *CB = unwrap<CallBase>(CallSite); 2024 switch (CB->getIntrinsicID()) { 2025 case Intrinsic::arm_ldrex: 2026 return 0; 2027 case Intrinsic::arm_strex: 2028 return 1; 2029 } 2030 return -1; 2031} 2032 2033extern "C" bool LLVMRustIsBitcode(char *ptr, size_t len) { 2034 return identify_magic(StringRef(ptr, len)) == file_magic::bitcode; 2035} 2036 2037extern "C" bool LLVMRustIsNonGVFunctionPointerTy(LLVMValueRef V) { 2038 if (unwrap<Value>(V)->getType()->isPointerTy()) { 2039 if (auto *GV = dyn_cast<GlobalValue>(unwrap<Value>(V))) { 2040 if (GV->getValueType()->isFunctionTy()) 2041 return false; 2042 } 2043 return true; 2044 } 2045 return false; 2046} 2047 2048extern "C" bool LLVMRustLLVMHasZlibCompressionForDebugSymbols() { 2049#if LLVM_VERSION_GE(16, 0) 2050 return llvm::compression::zlib::isAvailable(); 2051#else 2052 return false; 2053#endif 2054} 2055 2056extern "C" bool LLVMRustLLVMHasZstdCompressionForDebugSymbols() { 2057#if LLVM_VERSION_GE(16, 0) 2058 return llvm::compression::zstd::isAvailable(); 2059#else 2060 return false; 2061#endif 2062}