compiler/rustc_codegen_llvm/src/llvm/ffi.rs

   1 #![allow(non_camel_case_types)]
   2 #![allow(non_upper_case_globals)]
   3
   4 use rustc_codegen_ssa::coverageinfo::map as coverage_map;
   5
   6 use super::debuginfo::{
   7     DIArray, DIBasicType, DIBuilder, DICompositeType, DIDerivedType, DIDescriptor, DIEnumerator,
   8     DIFile, DIFlags, DIGlobalVariableExpression, DILexicalBlock, DILocation, DINameSpace,
   9     DISPFlags, DIScope, DISubprogram, DISubrange, DITemplateTypeParameter, DIType, DIVariable,
  10     DebugEmissionKind,
  11 };
  12
  13 use libc::{c_char, c_int, c_uint, size_t};
  14 use libc::{c_ulonglong, c_void};
  15
  16 use std::marker::PhantomData;
  17
  18 use super::RustString;
  19
  20 pub type Bool = c_uint;
  21
  22 pub const True: Bool = 1 as Bool;
  23 pub const False: Bool = 0 as Bool;
  24
  25 #[derive(Copy, Clone, PartialEq)]
  26 #[repr(C)]
  27 #[allow(dead_code)] // Variants constructed by C++.
  28 pub enum LLVMRustResult {
  29     Success,
  30     Failure,
  31 }
  32 // Consts for the LLVM CallConv type, pre-cast to usize.
  33
  34 /// LLVM CallingConv::ID. Should we wrap this?
  35 #[derive(Copy, Clone, PartialEq, Debug)]
  36 #[repr(C)]
  37 pub enum CallConv {
  38     CCallConv = 0,
  39     FastCallConv = 8,
  40     ColdCallConv = 9,
  41     X86StdcallCallConv = 64,
  42     X86FastcallCallConv = 65,
  43     ArmAapcsCallConv = 67,
  44     Msp430Intr = 69,
  45     X86_ThisCall = 70,
  46     PtxKernel = 71,
  47     X86_64_SysV = 78,
  48     X86_64_Win64 = 79,
  49     X86_VectorCall = 80,
  50     X86_Intr = 83,
  51     AvrNonBlockingInterrupt = 84,
  52     AvrInterrupt = 85,
  53     AmdGpuKernel = 91,
  54 }
  55
  56 /// LLVMRustLinkage
  57 #[derive(Copy, Clone, PartialEq)]
  58 #[repr(C)]
  59 pub enum Linkage {
  60     ExternalLinkage = 0,
  61     AvailableExternallyLinkage = 1,
  62     LinkOnceAnyLinkage = 2,
  63     LinkOnceODRLinkage = 3,
  64     WeakAnyLinkage = 4,
  65     WeakODRLinkage = 5,
  66     AppendingLinkage = 6,
  67     InternalLinkage = 7,
  68     PrivateLinkage = 8,
  69     ExternalWeakLinkage = 9,
  70     CommonLinkage = 10,
  71 }
  72
  73 // LLVMRustVisibility
  74 #[repr(C)]
  75 #[derive(Copy, Clone)]
  76 pub enum Visibility {
  77     Default = 0,
  78     Hidden = 1,
  79     Protected = 2,
  80 }
  81
  82 /// LLVMUnnamedAddr
  83 #[repr(C)]
  84 pub enum UnnamedAddr {
  85     No,
  86     Local,
  87     Global,
  88 }
  89
  90 /// LLVMDLLStorageClass
  91 #[derive(Copy, Clone)]
  92 #[repr(C)]
  93 pub enum DLLStorageClass {
  94     #[allow(dead_code)]
  95     Default = 0,
  96     DllImport = 1, // Function to be imported from DLL.
  97     #[allow(dead_code)]
  98     DllExport = 2, // Function to be accessible from DLL.
  99 }
 100
 101 /// Matches LLVMRustAttribute in LLVMWrapper.h
 102 /// Semantically a subset of the C++ enum llvm::Attribute::AttrKind,
 103 /// though it is not ABI compatible (since it's a C++ enum)
 104 #[repr(C)]
 105 #[derive(Copy, Clone, Debug)]
 106 pub enum Attribute {
 107     AlwaysInline = 0,
 108     ByVal = 1,
 109     Cold = 2,
 110     InlineHint = 3,
 111     MinSize = 4,
 112     Naked = 5,
 113     NoAlias = 6,
 114     NoCapture = 7,
 115     NoInline = 8,
 116     NonNull = 9,
 117     NoRedZone = 10,
 118     NoReturn = 11,
 119     NoUnwind = 12,
 120     OptimizeForSize = 13,
 121     ReadOnly = 14,
 122     SExt = 15,
 123     StructRet = 16,
 124     UWTable = 17,
 125     ZExt = 18,
 126     InReg = 19,
 127     SanitizeThread = 20,
 128     SanitizeAddress = 21,
 129     SanitizeMemory = 22,
 130     NonLazyBind = 23,
 131     OptimizeNone = 24,
 132     ReturnsTwice = 25,
 133     ReadNone = 26,
 134     InaccessibleMemOnly = 27,
 135     SanitizeHWAddress = 28,
 136     WillReturn = 29,
 137 }
 138
 139 /// LLVMIntPredicate
 140 #[derive(Copy, Clone)]
 141 #[repr(C)]
 142 pub enum IntPredicate {
 143     IntEQ = 32,
 144     IntNE = 33,
 145     IntUGT = 34,
 146     IntUGE = 35,
 147     IntULT = 36,
 148     IntULE = 37,
 149     IntSGT = 38,
 150     IntSGE = 39,
 151     IntSLT = 40,
 152     IntSLE = 41,
 153 }
 154
 155 impl IntPredicate {
 156     pub fn from_generic(intpre: rustc_codegen_ssa::common::IntPredicate) -> Self {
 157         match intpre {
 158             rustc_codegen_ssa::common::IntPredicate::IntEQ => IntPredicate::IntEQ,
 159             rustc_codegen_ssa::common::IntPredicate::IntNE => IntPredicate::IntNE,
 160             rustc_codegen_ssa::common::IntPredicate::IntUGT => IntPredicate::IntUGT,
 161             rustc_codegen_ssa::common::IntPredicate::IntUGE => IntPredicate::IntUGE,
 162             rustc_codegen_ssa::common::IntPredicate::IntULT => IntPredicate::IntULT,
 163             rustc_codegen_ssa::common::IntPredicate::IntULE => IntPredicate::IntULE,
 164             rustc_codegen_ssa::common::IntPredicate::IntSGT => IntPredicate::IntSGT,
 165             rustc_codegen_ssa::common::IntPredicate::IntSGE => IntPredicate::IntSGE,
 166             rustc_codegen_ssa::common::IntPredicate::IntSLT => IntPredicate::IntSLT,
 167             rustc_codegen_ssa::common::IntPredicate::IntSLE => IntPredicate::IntSLE,
 168         }
 169     }
 170 }
 171
 172 /// LLVMRealPredicate
 173 #[derive(Copy, Clone)]
 174 #[repr(C)]
 175 pub enum RealPredicate {
 176     RealPredicateFalse = 0,
 177     RealOEQ = 1,
 178     RealOGT = 2,
 179     RealOGE = 3,
 180     RealOLT = 4,
 181     RealOLE = 5,
 182     RealONE = 6,
 183     RealORD = 7,
 184     RealUNO = 8,
 185     RealUEQ = 9,
 186     RealUGT = 10,
 187     RealUGE = 11,
 188     RealULT = 12,
 189     RealULE = 13,
 190     RealUNE = 14,
 191     RealPredicateTrue = 15,
 192 }
 193
 194 /// LLVMTypeKind
 195 #[derive(Copy, Clone, PartialEq, Debug)]
 196 #[repr(C)]
 197 pub enum TypeKind {
 198     Void = 0,
 199     Half = 1,
 200     Float = 2,
 201     Double = 3,
 202     X86_FP80 = 4,
 203     FP128 = 5,
 204     PPC_FP128 = 6,
 205     Label = 7,
 206     Integer = 8,
 207     Function = 9,
 208     Struct = 10,
 209     Array = 11,
 210     Pointer = 12,
 211     Vector = 13,
 212     Metadata = 14,
 213     X86_MMX = 15,
 214     Token = 16,
 215     ScalableVector = 17,
 216     BFloat = 18,
 217     X86_AMX = 19,
 218 }
 219
 220 impl TypeKind {
 221     pub fn to_generic(self) -> rustc_codegen_ssa::common::TypeKind {
 222         match self {
 223             TypeKind::Void => rustc_codegen_ssa::common::TypeKind::Void,
 224             TypeKind::Half => rustc_codegen_ssa::common::TypeKind::Half,
 225             TypeKind::Float => rustc_codegen_ssa::common::TypeKind::Float,
 226             TypeKind::Double => rustc_codegen_ssa::common::TypeKind::Double,
 227             TypeKind::X86_FP80 => rustc_codegen_ssa::common::TypeKind::X86_FP80,
 228             TypeKind::FP128 => rustc_codegen_ssa::common::TypeKind::FP128,
 229             TypeKind::PPC_FP128 => rustc_codegen_ssa::common::TypeKind::PPC_FP128,
 230             TypeKind::Label => rustc_codegen_ssa::common::TypeKind::Label,
 231             TypeKind::Integer => rustc_codegen_ssa::common::TypeKind::Integer,
 232             TypeKind::Function => rustc_codegen_ssa::common::TypeKind::Function,
 233             TypeKind::Struct => rustc_codegen_ssa::common::TypeKind::Struct,
 234             TypeKind::Array => rustc_codegen_ssa::common::TypeKind::Array,
 235             TypeKind::Pointer => rustc_codegen_ssa::common::TypeKind::Pointer,
 236             TypeKind::Vector => rustc_codegen_ssa::common::TypeKind::Vector,
 237             TypeKind::Metadata => rustc_codegen_ssa::common::TypeKind::Metadata,
 238             TypeKind::X86_MMX => rustc_codegen_ssa::common::TypeKind::X86_MMX,
 239             TypeKind::Token => rustc_codegen_ssa::common::TypeKind::Token,
 240             TypeKind::ScalableVector => rustc_codegen_ssa::common::TypeKind::ScalableVector,
 241             TypeKind::BFloat => rustc_codegen_ssa::common::TypeKind::BFloat,
 242             TypeKind::X86_AMX => rustc_codegen_ssa::common::TypeKind::X86_AMX,
 243         }
 244     }
 245 }
 246
 247 /// LLVMAtomicRmwBinOp
 248 #[derive(Copy, Clone)]
 249 #[repr(C)]
 250 pub enum AtomicRmwBinOp {
 251     AtomicXchg = 0,
 252     AtomicAdd = 1,
 253     AtomicSub = 2,
 254     AtomicAnd = 3,
 255     AtomicNand = 4,
 256     AtomicOr = 5,
 257     AtomicXor = 6,
 258     AtomicMax = 7,
 259     AtomicMin = 8,
 260     AtomicUMax = 9,
 261     AtomicUMin = 10,
 262 }
 263
 264 impl AtomicRmwBinOp {
 265     pub fn from_generic(op: rustc_codegen_ssa::common::AtomicRmwBinOp) -> Self {
 266         match op {
 267             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicXchg => AtomicRmwBinOp::AtomicXchg,
 268             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicAdd => AtomicRmwBinOp::AtomicAdd,
 269             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicSub => AtomicRmwBinOp::AtomicSub,
 270             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicAnd => AtomicRmwBinOp::AtomicAnd,
 271             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicNand => AtomicRmwBinOp::AtomicNand,
 272             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicOr => AtomicRmwBinOp::AtomicOr,
 273             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicXor => AtomicRmwBinOp::AtomicXor,
 274             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicMax => AtomicRmwBinOp::AtomicMax,
 275             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicMin => AtomicRmwBinOp::AtomicMin,
 276             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicUMax => AtomicRmwBinOp::AtomicUMax,
 277             rustc_codegen_ssa::common::AtomicRmwBinOp::AtomicUMin => AtomicRmwBinOp::AtomicUMin,
 278         }
 279     }
 280 }
 281
 282 /// LLVMAtomicOrdering
 283 #[derive(Copy, Clone)]
 284 #[repr(C)]
 285 pub enum AtomicOrdering {
 286     #[allow(dead_code)]
 287     NotAtomic = 0,
 288     Unordered = 1,
 289     Monotonic = 2,
 290     // Consume = 3,  // Not specified yet.
 291     Acquire = 4,
 292     Release = 5,
 293     AcquireRelease = 6,
 294     SequentiallyConsistent = 7,
 295 }
 296
 297 impl AtomicOrdering {
 298     pub fn from_generic(ao: rustc_codegen_ssa::common::AtomicOrdering) -> Self {
 299         match ao {
 300             rustc_codegen_ssa::common::AtomicOrdering::NotAtomic => AtomicOrdering::NotAtomic,
 301             rustc_codegen_ssa::common::AtomicOrdering::Unordered => AtomicOrdering::Unordered,
 302             rustc_codegen_ssa::common::AtomicOrdering::Monotonic => AtomicOrdering::Monotonic,
 303             rustc_codegen_ssa::common::AtomicOrdering::Acquire => AtomicOrdering::Acquire,
 304             rustc_codegen_ssa::common::AtomicOrdering::Release => AtomicOrdering::Release,
 305             rustc_codegen_ssa::common::AtomicOrdering::AcquireRelease => {
 306                 AtomicOrdering::AcquireRelease
 307             }
 308             rustc_codegen_ssa::common::AtomicOrdering::SequentiallyConsistent => {
 309                 AtomicOrdering::SequentiallyConsistent
 310             }
 311         }
 312     }
 313 }
 314
 315 /// LLVMRustSynchronizationScope
 316 #[derive(Copy, Clone)]
 317 #[repr(C)]
 318 pub enum SynchronizationScope {
 319     SingleThread,
 320     CrossThread,
 321 }
 322
 323 impl SynchronizationScope {
 324     pub fn from_generic(sc: rustc_codegen_ssa::common::SynchronizationScope) -> Self {
 325         match sc {
 326             rustc_codegen_ssa::common::SynchronizationScope::SingleThread => {
 327                 SynchronizationScope::SingleThread
 328             }
 329             rustc_codegen_ssa::common::SynchronizationScope::CrossThread => {
 330                 SynchronizationScope::CrossThread
 331             }
 332         }
 333     }
 334 }
 335
 336 /// LLVMRustFileType
 337 #[derive(Copy, Clone)]
 338 #[repr(C)]
 339 pub enum FileType {
 340     AssemblyFile,
 341     ObjectFile,
 342 }
 343
 344 /// LLVMMetadataType
 345 #[derive(Copy, Clone)]
 346 #[repr(C)]
 347 pub enum MetadataType {
 348     MD_dbg = 0,
 349     MD_tbaa = 1,
 350     MD_prof = 2,
 351     MD_fpmath = 3,
 352     MD_range = 4,
 353     MD_tbaa_struct = 5,
 354     MD_invariant_load = 6,
 355     MD_alias_scope = 7,
 356     MD_noalias = 8,
 357     MD_nontemporal = 9,
 358     MD_mem_parallel_loop_access = 10,
 359     MD_nonnull = 11,
 360 }
 361
 362 /// LLVMRustAsmDialect
 363 #[derive(Copy, Clone)]
 364 #[repr(C)]
 365 pub enum AsmDialect {
 366     Att,
 367     Intel,
 368 }
 369
 370 impl AsmDialect {
 371     pub fn from_generic(asm: rustc_ast::LlvmAsmDialect) -> Self {
 372         match asm {
 373             rustc_ast::LlvmAsmDialect::Att => AsmDialect::Att,
 374             rustc_ast::LlvmAsmDialect::Intel => AsmDialect::Intel,
 375         }
 376     }
 377 }
 378
 379 /// LLVMRustCodeGenOptLevel
 380 #[derive(Copy, Clone, PartialEq)]
 381 #[repr(C)]
 382 pub enum CodeGenOptLevel {
 383     None,
 384     Less,
 385     Default,
 386     Aggressive,
 387 }
 388
 389 /// LLVMRustPassBuilderOptLevel
 390 #[repr(C)]
 391 pub enum PassBuilderOptLevel {
 392     O0,
 393     O1,
 394     O2,
 395     O3,
 396     Os,
 397     Oz,
 398 }
 399
 400 /// LLVMRustOptStage
 401 #[derive(PartialEq)]
 402 #[repr(C)]
 403 pub enum OptStage {
 404     PreLinkNoLTO,
 405     PreLinkThinLTO,
 406     PreLinkFatLTO,
 407     ThinLTO,
 408     FatLTO,
 409 }
 410
 411 /// LLVMRustSanitizerOptions
 412 #[repr(C)]
 413 pub struct SanitizerOptions {
 414     pub sanitize_address: bool,
 415     pub sanitize_address_recover: bool,
 416     pub sanitize_memory: bool,
 417     pub sanitize_memory_recover: bool,
 418     pub sanitize_memory_track_origins: c_int,
 419     pub sanitize_thread: bool,
 420     pub sanitize_hwaddress: bool,
 421     pub sanitize_hwaddress_recover: bool,
 422 }
 423
 424 /// LLVMRelocMode
 425 #[derive(Copy, Clone, PartialEq)]
 426 #[repr(C)]
 427 pub enum RelocModel {
 428     Static,
 429     PIC,
 430     DynamicNoPic,
 431     ROPI,
 432     RWPI,
 433     ROPI_RWPI,
 434 }
 435
 436 /// LLVMRustCodeModel
 437 #[derive(Copy, Clone)]
 438 #[repr(C)]
 439 pub enum CodeModel {
 440     Tiny,
 441     Small,
 442     Kernel,
 443     Medium,
 444     Large,
 445     None,
 446 }
 447
 448 /// LLVMRustDiagnosticKind
 449 #[derive(Copy, Clone)]
 450 #[repr(C)]
 451 #[allow(dead_code)] // Variants constructed by C++.
 452 pub enum DiagnosticKind {
 453     Other,
 454     InlineAsm,
 455     StackSize,
 456     DebugMetadataVersion,
 457     SampleProfile,
 458     OptimizationRemark,
 459     OptimizationRemarkMissed,
 460     OptimizationRemarkAnalysis,
 461     OptimizationRemarkAnalysisFPCommute,
 462     OptimizationRemarkAnalysisAliasing,
 463     OptimizationRemarkOther,
 464     OptimizationFailure,
 465     PGOProfile,
 466     Linker,
 467     Unsupported,
 468 }
 469
 470 /// LLVMRustDiagnosticLevel
 471 #[derive(Copy, Clone)]
 472 #[repr(C)]
 473 #[allow(dead_code)] // Variants constructed by C++.
 474 pub enum DiagnosticLevel {
 475     Error,
 476     Warning,
 477     Note,
 478     Remark,
 479 }
 480
 481 /// LLVMRustArchiveKind
 482 #[derive(Copy, Clone)]
 483 #[repr(C)]
 484 pub enum ArchiveKind {
 485     K_GNU,
 486     K_BSD,
 487     K_DARWIN,
 488     K_COFF,
 489 }
 490
 491 /// LLVMRustPassKind
 492 #[derive(Copy, Clone, PartialEq, Debug)]
 493 #[repr(C)]
 494 #[allow(dead_code)] // Variants constructed by C++.
 495 pub enum PassKind {
 496     Other,
 497     Function,
 498     Module,
 499 }
 500
 501 /// LLVMRustThinLTOData
 502 extern "C" {
 503     pub type ThinLTOData;
 504 }
 505
 506 /// LLVMRustThinLTOBuffer
 507 extern "C" {
 508     pub type ThinLTOBuffer;
 509 }
 510
 511 // LLVMRustModuleNameCallback
 512 pub type ThinLTOModuleNameCallback =
 513     unsafe extern "C" fn(*mut c_void, *const c_char, *const c_char);
 514
 515 /// LLVMRustThinLTOModule
 516 #[repr(C)]
 517 pub struct ThinLTOModule {
 518     pub identifier: *const c_char,
 519     pub data: *const u8,
 520     pub len: usize,
 521 }
 522
 523 /// LLVMThreadLocalMode
 524 #[derive(Copy, Clone)]
 525 #[repr(C)]
 526 pub enum ThreadLocalMode {
 527     NotThreadLocal,
 528     GeneralDynamic,
 529     LocalDynamic,
 530     InitialExec,
 531     LocalExec,
 532 }
 533
 534 /// LLVMRustChecksumKind
 535 #[derive(Copy, Clone)]
 536 #[repr(C)]
 537 pub enum ChecksumKind {
 538     None,
 539     MD5,
 540     SHA1,
 541     SHA256,
 542 }
 543
 544 extern "C" {
 545     type Opaque;
 546 }
 547 #[repr(C)]
 548 struct InvariantOpaque<'a> {
 549     _marker: PhantomData<&'a mut &'a ()>,
 550     _opaque: Opaque,
 551 }
 552
 553 // Opaque pointer types
 554 extern "C" {
 555     pub type Module;
 556 }
 557 extern "C" {
 558     pub type Context;
 559 }
 560 extern "C" {
 561     pub type Type;
 562 }
 563 extern "C" {
 564     pub type Value;
 565 }
 566 extern "C" {
 567     pub type ConstantInt;
 568 }
 569 extern "C" {
 570     pub type Metadata;
 571 }
 572 extern "C" {
 573     pub type BasicBlock;
 574 }
 575 #[repr(C)]
 576 pub struct Builder<'a>(InvariantOpaque<'a>);
 577 extern "C" {
 578     pub type MemoryBuffer;
 579 }
 580 #[repr(C)]
 581 pub struct PassManager<'a>(InvariantOpaque<'a>);
 582 extern "C" {
 583     pub type PassManagerBuilder;
 584 }
 585 extern "C" {
 586     pub type ObjectFile;
 587 }
 588 #[repr(C)]
 589 pub struct SectionIterator<'a>(InvariantOpaque<'a>);
 590 extern "C" {
 591     pub type Pass;
 592 }
 593 extern "C" {
 594     pub type TargetMachine;
 595 }
 596 extern "C" {
 597     pub type Archive;
 598 }
 599 #[repr(C)]
 600 pub struct ArchiveIterator<'a>(InvariantOpaque<'a>);
 601 #[repr(C)]
 602 pub struct ArchiveChild<'a>(InvariantOpaque<'a>);
 603 extern "C" {
 604     pub type Twine;
 605 }
 606 extern "C" {
 607     pub type DiagnosticInfo;
 608 }
 609 extern "C" {
 610     pub type SMDiagnostic;
 611 }
 612 #[repr(C)]
 613 pub struct RustArchiveMember<'a>(InvariantOpaque<'a>);
 614 #[repr(C)]
 615 pub struct OperandBundleDef<'a>(InvariantOpaque<'a>);
 616 #[repr(C)]
 617 pub struct Linker<'a>(InvariantOpaque<'a>);
 618
 619 pub type DiagnosticHandler = unsafe extern "C" fn(&DiagnosticInfo, *mut c_void);
 620 pub type InlineAsmDiagHandler = unsafe extern "C" fn(&SMDiagnostic, *const c_void, c_uint);
 621
 622 pub mod coverageinfo {
 623     use super::coverage_map;
 624
 625     /// Aligns with [llvm::coverage::CounterMappingRegion::RegionKind](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/include/llvm/ProfileData/Coverage/CoverageMapping.h#L206-L222)
 626     #[derive(Copy, Clone, Debug)]
 627     #[repr(C)]
 628     pub enum RegionKind {
 629         /// A CodeRegion associates some code with a counter
 630         CodeRegion = 0,
 631
 632         /// An ExpansionRegion represents a file expansion region that associates
 633         /// a source range with the expansion of a virtual source file, such as
 634         /// for a macro instantiation or #include file.
 635         ExpansionRegion = 1,
 636
 637         /// A SkippedRegion represents a source range with code that was skipped
 638         /// by a preprocessor or similar means.
 639         SkippedRegion = 2,
 640
 641         /// A GapRegion is like a CodeRegion, but its count is only set as the
 642         /// line execution count when its the only region in the line.
 643         GapRegion = 3,
 644     }
 645
 646     /// This struct provides LLVM's representation of a "CoverageMappingRegion", encoded into the
 647     /// coverage map, in accordance with the
 648     /// [LLVM Code Coverage Mapping Format](https://github.com/rust-lang/llvm-project/blob/rustc/11.0-2020-10-12/llvm/docs/CoverageMappingFormat.rst#llvm-code-coverage-mapping-format).
 649     /// The struct composes fields representing the `Counter` type and value(s) (injected counter
 650     /// ID, or expression type and operands), the source file (an indirect index into a "filenames
 651     /// array", encoded separately), and source location (start and end positions of the represented
 652     /// code region).
 653     ///
 654     /// Matches LLVMRustCounterMappingRegion.
 655     #[derive(Copy, Clone, Debug)]
 656     #[repr(C)]
 657     pub struct CounterMappingRegion {
 658         /// The counter type and type-dependent counter data, if any.
 659         counter: coverage_map::Counter,
 660
 661         /// An indirect reference to the source filename. In the LLVM Coverage Mapping Format, the
 662         /// file_id is an index into a function-specific `virtual_file_mapping` array of indexes
 663         /// that, in turn, are used to look up the filename for this region.
 664         file_id: u32,
 665
 666         /// If the `RegionKind` is an `ExpansionRegion`, the `expanded_file_id` can be used to find
 667         /// the mapping regions created as a result of macro expansion, by checking if their file id
 668         /// matches the expanded file id.
 669         expanded_file_id: u32,
 670
 671         /// 1-based starting line of the mapping region.
 672         start_line: u32,
 673
 674         /// 1-based starting column of the mapping region.
 675         start_col: u32,
 676
 677         /// 1-based ending line of the mapping region.
 678         end_line: u32,
 679
 680         /// 1-based ending column of the mapping region. If the high bit is set, the current
 681         /// mapping region is a gap area.
 682         end_col: u32,
 683
 684         kind: RegionKind,
 685     }
 686
 687     impl CounterMappingRegion {
 688         crate fn code_region(
 689             counter: coverage_map::Counter,
 690             file_id: u32,
 691             start_line: u32,
 692             start_col: u32,
 693             end_line: u32,
 694             end_col: u32,
 695         ) -> Self {
 696             Self {
 697                 counter,
 698                 file_id,
 699                 expanded_file_id: 0,
 700                 start_line,
 701                 start_col,
 702                 end_line,
 703                 end_col,
 704                 kind: RegionKind::CodeRegion,
 705             }
 706         }
 707
 708         // This function might be used in the future; the LLVM API is still evolving, as is coverage
 709         // support.
 710         #[allow(dead_code)]
 711         crate fn expansion_region(
 712             file_id: u32,
 713             expanded_file_id: u32,
 714             start_line: u32,
 715             start_col: u32,
 716             end_line: u32,
 717             end_col: u32,
 718         ) -> Self {
 719             Self {
 720                 counter: coverage_map::Counter::zero(),
 721                 file_id,
 722                 expanded_file_id,
 723                 start_line,
 724                 start_col,
 725                 end_line,
 726                 end_col,
 727                 kind: RegionKind::ExpansionRegion,
 728             }
 729         }
 730
 731         // This function might be used in the future; the LLVM API is still evolving, as is coverage
 732         // support.
 733         #[allow(dead_code)]
 734         crate fn skipped_region(
 735             file_id: u32,
 736             start_line: u32,
 737             start_col: u32,
 738             end_line: u32,
 739             end_col: u32,
 740         ) -> Self {
 741             Self {
 742                 counter: coverage_map::Counter::zero(),
 743                 file_id,
 744                 expanded_file_id: 0,
 745                 start_line,
 746                 start_col,
 747                 end_line,
 748                 end_col,
 749                 kind: RegionKind::SkippedRegion,
 750             }
 751         }
 752
 753         // This function might be used in the future; the LLVM API is still evolving, as is coverage
 754         // support.
 755         #[allow(dead_code)]
 756         crate fn gap_region(
 757             counter: coverage_map::Counter,
 758             file_id: u32,
 759             start_line: u32,
 760             start_col: u32,
 761             end_line: u32,
 762             end_col: u32,
 763         ) -> Self {
 764             Self {
 765                 counter,
 766                 file_id,
 767                 expanded_file_id: 0,
 768                 start_line,
 769                 start_col,
 770                 end_line,
 771                 end_col: ((1 as u32) << 31) | end_col,
 772                 kind: RegionKind::GapRegion,
 773             }
 774         }
 775     }
 776 }
 777
 778 pub mod debuginfo {
 779     use super::{InvariantOpaque, Metadata};
 780     use bitflags::bitflags;
 781
 782     #[repr(C)]
 783     pub struct DIBuilder<'a>(InvariantOpaque<'a>);
 784
 785     pub type DIDescriptor = Metadata;
 786     pub type DILocation = Metadata;
 787     pub type DIScope = DIDescriptor;
 788     pub type DIFile = DIScope;
 789     pub type DILexicalBlock = DIScope;
 790     pub type DISubprogram = DIScope;
 791     pub type DINameSpace = DIScope;
 792     pub type DIType = DIDescriptor;
 793     pub type DIBasicType = DIType;
 794     pub type DIDerivedType = DIType;
 795     pub type DICompositeType = DIDerivedType;
 796     pub type DIVariable = DIDescriptor;
 797     pub type DIGlobalVariableExpression = DIDescriptor;
 798     pub type DIArray = DIDescriptor;
 799     pub type DISubrange = DIDescriptor;
 800     pub type DIEnumerator = DIDescriptor;
 801     pub type DITemplateTypeParameter = DIDescriptor;
 802
 803     // These values **must** match with LLVMRustDIFlags!!
 804     bitflags! {
 805         #[repr(transparent)]
 806         #[derive(Default)]
 807         pub struct DIFlags: u32 {
 808             const FlagZero                = 0;
 809             const FlagPrivate             = 1;
 810             const FlagProtected           = 2;
 811             const FlagPublic              = 3;
 812             const FlagFwdDecl             = (1 << 2);
 813             const FlagAppleBlock          = (1 << 3);
 814             const FlagBlockByrefStruct    = (1 << 4);
 815             const FlagVirtual             = (1 << 5);
 816             const FlagArtificial          = (1 << 6);
 817             const FlagExplicit            = (1 << 7);
 818             const FlagPrototyped          = (1 << 8);
 819             const FlagObjcClassComplete   = (1 << 9);
 820             const FlagObjectPointer       = (1 << 10);
 821             const FlagVector              = (1 << 11);
 822             const FlagStaticMember        = (1 << 12);
 823             const FlagLValueReference     = (1 << 13);
 824             const FlagRValueReference     = (1 << 14);
 825             const FlagExternalTypeRef     = (1 << 15);
 826             const FlagIntroducedVirtual   = (1 << 18);
 827             const FlagBitField            = (1 << 19);
 828             const FlagNoReturn            = (1 << 20);
 829         }
 830     }
 831
 832     // These values **must** match with LLVMRustDISPFlags!!
 833     bitflags! {
 834         #[repr(transparent)]
 835         #[derive(Default)]
 836         pub struct DISPFlags: u32 {
 837             const SPFlagZero              = 0;
 838             const SPFlagVirtual           = 1;
 839             const SPFlagPureVirtual       = 2;
 840             const SPFlagLocalToUnit       = (1 << 2);
 841             const SPFlagDefinition        = (1 << 3);
 842             const SPFlagOptimized         = (1 << 4);
 843             const SPFlagMainSubprogram    = (1 << 5);
 844         }
 845     }
 846
 847     /// LLVMRustDebugEmissionKind
 848     #[derive(Copy, Clone)]
 849     #[repr(C)]
 850     pub enum DebugEmissionKind {
 851         NoDebug,
 852         FullDebug,
 853         LineTablesOnly,
 854     }
 855
 856     impl DebugEmissionKind {
 857         pub fn from_generic(kind: rustc_session::config::DebugInfo) -> Self {
 858             use rustc_session::config::DebugInfo;
 859             match kind {
 860                 DebugInfo::None => DebugEmissionKind::NoDebug,
 861                 DebugInfo::Limited => DebugEmissionKind::LineTablesOnly,
 862                 DebugInfo::Full => DebugEmissionKind::FullDebug,
 863             }
 864         }
 865     }
 866 }
 867
 868 extern "C" {
 869     pub type ModuleBuffer;
 870 }
 871
 872 pub type SelfProfileBeforePassCallback =
 873     unsafe extern "C" fn(*mut c_void, *const c_char, *const c_char);
 874 pub type SelfProfileAfterPassCallback = unsafe extern "C" fn(*mut c_void);
 875
 876 extern "C" {
 877     pub fn LLVMRustInstallFatalErrorHandler();
 878
 879     // Create and destroy contexts.
 880     pub fn LLVMRustContextCreate(shouldDiscardNames: bool) -> &'static mut Context;
 881     pub fn LLVMContextDispose(C: &'static mut Context);
 882     pub fn LLVMGetMDKindIDInContext(C: &Context, Name: *const c_char, SLen: c_uint) -> c_uint;
 883
 884     // Create modules.
 885     pub fn LLVMModuleCreateWithNameInContext(ModuleID: *const c_char, C: &Context) -> &Module;
 886     pub fn LLVMGetModuleContext(M: &Module) -> &Context;
 887     pub fn LLVMCloneModule(M: &Module) -> &Module;
 888
 889     /// Data layout. See Module::getDataLayout.
 890     pub fn LLVMGetDataLayoutStr(M: &Module) -> *const c_char;
 891     pub fn LLVMSetDataLayout(M: &Module, Triple: *const c_char);
 892
 893     /// See Module::setModuleInlineAsm.
 894     pub fn LLVMSetModuleInlineAsm2(M: &Module, Asm: *const c_char, AsmLen: size_t);
 895     pub fn LLVMRustAppendModuleInlineAsm(M: &Module, Asm: *const c_char, AsmLen: size_t);
 896
 897     /// See llvm::LLVMTypeKind::getTypeID.
 898     pub fn LLVMRustGetTypeKind(Ty: &Type) -> TypeKind;
 899
 900     // Operations on integer types
 901     pub fn LLVMInt1TypeInContext(C: &Context) -> &Type;
 902     pub fn LLVMInt8TypeInContext(C: &Context) -> &Type;
 903     pub fn LLVMInt16TypeInContext(C: &Context) -> &Type;
 904     pub fn LLVMInt32TypeInContext(C: &Context) -> &Type;
 905     pub fn LLVMInt64TypeInContext(C: &Context) -> &Type;
 906     pub fn LLVMIntTypeInContext(C: &Context, NumBits: c_uint) -> &Type;
 907
 908     pub fn LLVMGetIntTypeWidth(IntegerTy: &Type) -> c_uint;
 909
 910     // Operations on real types
 911     pub fn LLVMFloatTypeInContext(C: &Context) -> &Type;
 912     pub fn LLVMDoubleTypeInContext(C: &Context) -> &Type;
 913
 914     // Operations on function types
 915     pub fn LLVMFunctionType(
 916         ReturnType: &'a Type,
 917         ParamTypes: *const &'a Type,
 918         ParamCount: c_uint,
 919         IsVarArg: Bool,
 920     ) -> &'a Type;
 921     pub fn LLVMCountParamTypes(FunctionTy: &Type) -> c_uint;
 922     pub fn LLVMGetParamTypes(FunctionTy: &'a Type, Dest: *mut &'a Type);
 923
 924     // Operations on struct types
 925     pub fn LLVMStructTypeInContext(
 926         C: &'a Context,
 927         ElementTypes: *const &'a Type,
 928         ElementCount: c_uint,
 929         Packed: Bool,
 930     ) -> &'a Type;
 931
 932     // Operations on array, pointer, and vector types (sequence types)
 933     pub fn LLVMRustArrayType(ElementType: &Type, ElementCount: u64) -> &Type;
 934     pub fn LLVMPointerType(ElementType: &Type, AddressSpace: c_uint) -> &Type;
 935     pub fn LLVMVectorType(ElementType: &Type, ElementCount: c_uint) -> &Type;
 936
 937     pub fn LLVMGetElementType(Ty: &Type) -> &Type;
 938     pub fn LLVMGetVectorSize(VectorTy: &Type) -> c_uint;
 939
 940     // Operations on other types
 941     pub fn LLVMVoidTypeInContext(C: &Context) -> &Type;
 942     pub fn LLVMRustMetadataTypeInContext(C: &Context) -> &Type;
 943
 944     // Operations on all values
 945     pub fn LLVMTypeOf(Val: &Value) -> &Type;
 946     pub fn LLVMGetValueName2(Val: &Value, Length: *mut size_t) -> *const c_char;
 947     pub fn LLVMSetValueName2(Val: &Value, Name: *const c_char, NameLen: size_t);
 948     pub fn LLVMReplaceAllUsesWith(OldVal: &'a Value, NewVal: &'a Value);
 949     pub fn LLVMSetMetadata(Val: &'a Value, KindID: c_uint, Node: &'a Value);
 950
 951     // Operations on constants of any type
 952     pub fn LLVMConstNull(Ty: &Type) -> &Value;
 953     pub fn LLVMGetUndef(Ty: &Type) -> &Value;
 954
 955     // Operations on metadata
 956     pub fn LLVMMDStringInContext(C: &Context, Str: *const c_char, SLen: c_uint) -> &Value;
 957     pub fn LLVMMDNodeInContext(C: &'a Context, Vals: *const &'a Value, Count: c_uint) -> &'a Value;
 958     pub fn LLVMAddNamedMetadataOperand(M: &'a Module, Name: *const c_char, Val: &'a Value);
 959
 960     // Operations on scalar constants
 961     pub fn LLVMConstInt(IntTy: &Type, N: c_ulonglong, SignExtend: Bool) -> &Value;
 962     pub fn LLVMConstIntOfArbitraryPrecision(IntTy: &Type, Wn: c_uint, Ws: *const u64) -> &Value;
 963     pub fn LLVMConstReal(RealTy: &Type, N: f64) -> &Value;
 964     pub fn LLVMConstIntGetZExtValue(ConstantVal: &ConstantInt) -> c_ulonglong;
 965     pub fn LLVMRustConstInt128Get(
 966         ConstantVal: &ConstantInt,
 967         SExt: bool,
 968         high: &mut u64,
 969         low: &mut u64,
 970     ) -> bool;
 971
 972     // Operations on composite constants
 973     pub fn LLVMConstStringInContext(
 974         C: &Context,
 975         Str: *const c_char,
 976         Length: c_uint,
 977         DontNullTerminate: Bool,
 978     ) -> &Value;
 979     pub fn LLVMConstStructInContext(
 980         C: &'a Context,
 981         ConstantVals: *const &'a Value,
 982         Count: c_uint,
 983         Packed: Bool,
 984     ) -> &'a Value;
 985
 986     pub fn LLVMConstArray(
 987         ElementTy: &'a Type,
 988         ConstantVals: *const &'a Value,
 989         Length: c_uint,
 990     ) -> &'a Value;
 991     pub fn LLVMConstVector(ScalarConstantVals: *const &Value, Size: c_uint) -> &Value;
 992
 993     // Constant expressions
 994     pub fn LLVMConstInBoundsGEP(
 995         ConstantVal: &'a Value,
 996         ConstantIndices: *const &'a Value,
 997         NumIndices: c_uint,
 998     ) -> &'a Value;
 999     pub fn LLVMConstZExt(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
1000     pub fn LLVMConstPtrToInt(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
1001     pub fn LLVMConstIntToPtr(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
1002     pub fn LLVMConstBitCast(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
1003     pub fn LLVMConstPointerCast(ConstantVal: &'a Value, ToType: &'a Type) -> &'a Value;
1004     pub fn LLVMConstExtractValue(
1005         AggConstant: &Value,
1006         IdxList: *const c_uint,
1007         NumIdx: c_uint,
1008     ) -> &Value;
1009
1010     // Operations on global variables, functions, and aliases (globals)
1011     pub fn LLVMIsDeclaration(Global: &Value) -> Bool;
1012     pub fn LLVMRustGetLinkage(Global: &Value) -> Linkage;
1013     pub fn LLVMRustSetLinkage(Global: &Value, RustLinkage: Linkage);
1014     pub fn LLVMSetSection(Global: &Value, Section: *const c_char);
1015     pub fn LLVMRustGetVisibility(Global: &Value) -> Visibility;
1016     pub fn LLVMRustSetVisibility(Global: &Value, Viz: Visibility);
1017     pub fn LLVMRustSetDSOLocal(Global: &Value, is_dso_local: bool);
1018     pub fn LLVMGetAlignment(Global: &Value) -> c_uint;
1019     pub fn LLVMSetAlignment(Global: &Value, Bytes: c_uint);
1020     pub fn LLVMSetDLLStorageClass(V: &Value, C: DLLStorageClass);
1021
1022     // Operations on global variables
1023     pub fn LLVMIsAGlobalVariable(GlobalVar: &Value) -> Option<&Value>;
1024     pub fn LLVMAddGlobal(M: &'a Module, Ty: &'a Type, Name: *const c_char) -> &'a Value;
1025     pub fn LLVMGetNamedGlobal(M: &Module, Name: *const c_char) -> Option<&Value>;
1026     pub fn LLVMRustGetOrInsertGlobal(
1027         M: &'a Module,
1028         Name: *const c_char,
1029         NameLen: size_t,
1030         T: &'a Type,
1031     ) -> &'a Value;
1032     pub fn LLVMRustInsertPrivateGlobal(M: &'a Module, T: &'a Type) -> &'a Value;
1033     pub fn LLVMGetFirstGlobal(M: &Module) -> Option<&Value>;
1034     pub fn LLVMGetNextGlobal(GlobalVar: &Value) -> Option<&Value>;
1035     pub fn LLVMDeleteGlobal(GlobalVar: &Value);
1036     pub fn LLVMGetInitializer(GlobalVar: &Value) -> Option<&Value>;
1037     pub fn LLVMSetInitializer(GlobalVar: &'a Value, ConstantVal: &'a Value);
1038     pub fn LLVMSetThreadLocal(GlobalVar: &Value, IsThreadLocal: Bool);
1039     pub fn LLVMSetThreadLocalMode(GlobalVar: &Value, Mode: ThreadLocalMode);
1040     pub fn LLVMIsGlobalConstant(GlobalVar: &Value) -> Bool;
1041     pub fn LLVMSetGlobalConstant(GlobalVar: &Value, IsConstant: Bool);
1042     pub fn LLVMRustGetNamedValue(
1043         M: &Module,
1044         Name: *const c_char,
1045         NameLen: size_t,
1046     ) -> Option<&Value>;
1047     pub fn LLVMSetTailCall(CallInst: &Value, IsTailCall: Bool);
1048
1049     // Operations on functions
1050     pub fn LLVMRustGetOrInsertFunction(
1051         M: &'a Module,
1052         Name: *const c_char,
1053         NameLen: size_t,
1054         FunctionTy: &'a Type,
1055     ) -> &'a Value;
1056     pub fn LLVMSetFunctionCallConv(Fn: &Value, CC: c_uint);
1057     pub fn LLVMRustAddAlignmentAttr(Fn: &Value, index: c_uint, bytes: u32);
1058     pub fn LLVMRustAddDereferenceableAttr(Fn: &Value, index: c_uint, bytes: u64);
1059     pub fn LLVMRustAddDereferenceableOrNullAttr(Fn: &Value, index: c_uint, bytes: u64);
1060     pub fn LLVMRustAddByValAttr(Fn: &Value, index: c_uint, ty: &Type);
1061     pub fn LLVMRustAddStructRetAttr(Fn: &Value, index: c_uint, ty: &Type);
1062     pub fn LLVMRustAddFunctionAttribute(Fn: &Value, index: c_uint, attr: Attribute);
1063     pub fn LLVMRustAddFunctionAttrStringValue(
1064         Fn: &Value,
1065         index: c_uint,
1066         Name: *const c_char,
1067         Value: *const c_char,
1068     );
1069     pub fn LLVMRustRemoveFunctionAttributes(Fn: &Value, index: c_uint, attr: Attribute);
1070
1071     // Operations on parameters
1072     pub fn LLVMIsAArgument(Val: &Value) -> Option<&Value>;
1073     pub fn LLVMCountParams(Fn: &Value) -> c_uint;
1074     pub fn LLVMGetParam(Fn: &Value, Index: c_uint) -> &Value;
1075
1076     // Operations on basic blocks
1077     pub fn LLVMGetBasicBlockParent(BB: &BasicBlock) -> &Value;
1078     pub fn LLVMAppendBasicBlockInContext(
1079         C: &'a Context,
1080         Fn: &'a Value,
1081         Name: *const c_char,
1082     ) -> &'a BasicBlock;
1083
1084     // Operations on instructions
1085     pub fn LLVMIsAInstruction(Val: &Value) -> Option<&Value>;
1086     pub fn LLVMGetFirstBasicBlock(Fn: &Value) -> &BasicBlock;
1087
1088     // Operations on call sites
1089     pub fn LLVMSetInstructionCallConv(Instr: &Value, CC: c_uint);
1090     pub fn LLVMRustAddCallSiteAttribute(Instr: &Value, index: c_uint, attr: Attribute);
1091     pub fn LLVMRustAddCallSiteAttrString(Instr: &Value, index: c_uint, Name: *const c_char);
1092     pub fn LLVMRustAddAlignmentCallSiteAttr(Instr: &Value, index: c_uint, bytes: u32);
1093     pub fn LLVMRustAddDereferenceableCallSiteAttr(Instr: &Value, index: c_uint, bytes: u64);
1094     pub fn LLVMRustAddDereferenceableOrNullCallSiteAttr(Instr: &Value, index: c_uint, bytes: u64);
1095     pub fn LLVMRustAddByValCallSiteAttr(Instr: &Value, index: c_uint, ty: &Type);
1096     pub fn LLVMRustAddStructRetCallSiteAttr(Instr: &Value, index: c_uint, ty: &Type);
1097
1098     // Operations on load/store instructions (only)
1099     pub fn LLVMSetVolatile(MemoryAccessInst: &Value, volatile: Bool);
1100
1101     // Operations on phi nodes
1102     pub fn LLVMAddIncoming(
1103         PhiNode: &'a Value,
1104         IncomingValues: *const &'a Value,
1105         IncomingBlocks: *const &'a BasicBlock,
1106         Count: c_uint,
1107     );
1108
1109     // Instruction builders
1110     pub fn LLVMCreateBuilderInContext(C: &'a Context) -> &'a mut Builder<'a>;
1111     pub fn LLVMPositionBuilderAtEnd(Builder: &Builder<'a>, Block: &'a BasicBlock);
1112     pub fn LLVMGetInsertBlock(Builder: &Builder<'a>) -> &'a BasicBlock;
1113     pub fn LLVMDisposeBuilder(Builder: &'a mut Builder<'a>);
1114
1115     // Metadata
1116     pub fn LLVMSetCurrentDebugLocation(Builder: &Builder<'a>, L: &'a Value);
1117
1118     // Terminators
1119     pub fn LLVMBuildRetVoid(B: &Builder<'a>) -> &'a Value;
1120     pub fn LLVMBuildRet(B: &Builder<'a>, V: &'a Value) -> &'a Value;
1121     pub fn LLVMBuildBr(B: &Builder<'a>, Dest: &'a BasicBlock) -> &'a Value;
1122     pub fn LLVMBuildCondBr(
1123         B: &Builder<'a>,
1124         If: &'a Value,
1125         Then: &'a BasicBlock,
1126         Else: &'a BasicBlock,
1127     ) -> &'a Value;
1128     pub fn LLVMBuildSwitch(
1129         B: &Builder<'a>,
1130         V: &'a Value,
1131         Else: &'a BasicBlock,
1132         NumCases: c_uint,
1133     ) -> &'a Value;
1134     pub fn LLVMRustBuildInvoke(
1135         B: &Builder<'a>,
1136         Fn: &'a Value,
1137         Args: *const &'a Value,
1138         NumArgs: c_uint,
1139         Then: &'a BasicBlock,
1140         Catch: &'a BasicBlock,
1141         Bundle: Option<&OperandBundleDef<'a>>,
1142         Name: *const c_char,
1143     ) -> &'a Value;
1144     pub fn LLVMBuildLandingPad(
1145         B: &Builder<'a>,
1146         Ty: &'a Type,
1147         PersFn: &'a Value,
1148         NumClauses: c_uint,
1149         Name: *const c_char,
1150     ) -> &'a Value;
1151     pub fn LLVMBuildResume(B: &Builder<'a>, Exn: &'a Value) -> &'a Value;
1152     pub fn LLVMBuildUnreachable(B: &Builder<'a>) -> &'a Value;
1153
1154     pub fn LLVMRustBuildCleanupPad(
1155         B: &Builder<'a>,
1156         ParentPad: Option<&'a Value>,
1157         ArgCnt: c_uint,
1158         Args: *const &'a Value,
1159         Name: *const c_char,
1160     ) -> Option<&'a Value>;
1161     pub fn LLVMRustBuildCleanupRet(
1162         B: &Builder<'a>,
1163         CleanupPad: &'a Value,
1164         UnwindBB: Option<&'a BasicBlock>,
1165     ) -> Option<&'a Value>;
1166     pub fn LLVMRustBuildCatchPad(
1167         B: &Builder<'a>,
1168         ParentPad: &'a Value,
1169         ArgCnt: c_uint,
1170         Args: *const &'a Value,
1171         Name: *const c_char,
1172     ) -> Option<&'a Value>;
1173     pub fn LLVMRustBuildCatchRet(
1174         B: &Builder<'a>,
1175         Pad: &'a Value,
1176         BB: &'a BasicBlock,
1177     ) -> Option<&'a Value>;
1178     pub fn LLVMRustBuildCatchSwitch(
1179         Builder: &Builder<'a>,
1180         ParentPad: Option<&'a Value>,
1181         BB: Option<&'a BasicBlock>,
1182         NumHandlers: c_uint,
1183         Name: *const c_char,
1184     ) -> Option<&'a Value>;
1185     pub fn LLVMRustAddHandler(CatchSwitch: &'a Value, Handler: &'a BasicBlock);
1186     pub fn LLVMSetPersonalityFn(Func: &'a Value, Pers: &'a Value);
1187
1188     // Add a case to the switch instruction
1189     pub fn LLVMAddCase(Switch: &'a Value, OnVal: &'a Value, Dest: &'a BasicBlock);
1190
1191     // Add a clause to the landing pad instruction
1192     pub fn LLVMAddClause(LandingPad: &'a Value, ClauseVal: &'a Value);
1193
1194     // Set the cleanup on a landing pad instruction
1195     pub fn LLVMSetCleanup(LandingPad: &Value, Val: Bool);
1196
1197     // Arithmetic
1198     pub fn LLVMBuildAdd(
1199         B: &Builder<'a>,
1200         LHS: &'a Value,
1201         RHS: &'a Value,
1202         Name: *const c_char,
1203     ) -> &'a Value;
1204     pub fn LLVMBuildFAdd(
1205         B: &Builder<'a>,
1206         LHS: &'a Value,
1207         RHS: &'a Value,
1208         Name: *const c_char,
1209     ) -> &'a Value;
1210     pub fn LLVMBuildSub(
1211         B: &Builder<'a>,
1212         LHS: &'a Value,
1213         RHS: &'a Value,
1214         Name: *const c_char,
1215     ) -> &'a Value;
1216     pub fn LLVMBuildFSub(
1217         B: &Builder<'a>,
1218         LHS: &'a Value,
1219         RHS: &'a Value,
1220         Name: *const c_char,
1221     ) -> &'a Value;
1222     pub fn LLVMBuildMul(
1223         B: &Builder<'a>,
1224         LHS: &'a Value,
1225         RHS: &'a Value,
1226         Name: *const c_char,
1227     ) -> &'a Value;
1228     pub fn LLVMBuildFMul(
1229         B: &Builder<'a>,
1230         LHS: &'a Value,
1231         RHS: &'a Value,
1232         Name: *const c_char,
1233     ) -> &'a Value;
1234     pub fn LLVMBuildUDiv(
1235         B: &Builder<'a>,
1236         LHS: &'a Value,
1237         RHS: &'a Value,
1238         Name: *const c_char,
1239     ) -> &'a Value;
1240     pub fn LLVMBuildExactUDiv(
1241         B: &Builder<'a>,
1242         LHS: &'a Value,
1243         RHS: &'a Value,
1244         Name: *const c_char,
1245     ) -> &'a Value;
1246     pub fn LLVMBuildSDiv(
1247         B: &Builder<'a>,
1248         LHS: &'a Value,
1249         RHS: &'a Value,
1250         Name: *const c_char,
1251     ) -> &'a Value;
1252     pub fn LLVMBuildExactSDiv(
1253         B: &Builder<'a>,
1254         LHS: &'a Value,
1255         RHS: &'a Value,
1256         Name: *const c_char,
1257     ) -> &'a Value;
1258     pub fn LLVMBuildFDiv(
1259         B: &Builder<'a>,
1260         LHS: &'a Value,
1261         RHS: &'a Value,
1262         Name: *const c_char,
1263     ) -> &'a Value;
1264     pub fn LLVMBuildURem(
1265         B: &Builder<'a>,
1266         LHS: &'a Value,
1267         RHS: &'a Value,
1268         Name: *const c_char,
1269     ) -> &'a Value;
1270     pub fn LLVMBuildSRem(
1271         B: &Builder<'a>,
1272         LHS: &'a Value,
1273         RHS: &'a Value,
1274         Name: *const c_char,
1275     ) -> &'a Value;
1276     pub fn LLVMBuildFRem(
1277         B: &Builder<'a>,
1278         LHS: &'a Value,
1279         RHS: &'a Value,
1280         Name: *const c_char,
1281     ) -> &'a Value;
1282     pub fn LLVMBuildShl(
1283         B: &Builder<'a>,
1284         LHS: &'a Value,
1285         RHS: &'a Value,
1286         Name: *const c_char,
1287     ) -> &'a Value;
1288     pub fn LLVMBuildLShr(
1289         B: &Builder<'a>,
1290         LHS: &'a Value,
1291         RHS: &'a Value,
1292         Name: *const c_char,
1293     ) -> &'a Value;
1294     pub fn LLVMBuildAShr(
1295         B: &Builder<'a>,
1296         LHS: &'a Value,
1297         RHS: &'a Value,
1298         Name: *const c_char,
1299     ) -> &'a Value;
1300     pub fn LLVMBuildNSWAdd(
1301         B: &Builder<'a>,
1302         LHS: &'a Value,
1303         RHS: &'a Value,
1304         Name: *const c_char,
1305     ) -> &'a Value;
1306     pub fn LLVMBuildNUWAdd(
1307         B: &Builder<'a>,
1308         LHS: &'a Value,
1309         RHS: &'a Value,
1310         Name: *const c_char,
1311     ) -> &'a Value;
1312     pub fn LLVMBuildNSWSub(
1313         B: &Builder<'a>,
1314         LHS: &'a Value,
1315         RHS: &'a Value,
1316         Name: *const c_char,
1317     ) -> &'a Value;
1318     pub fn LLVMBuildNUWSub(
1319         B: &Builder<'a>,
1320         LHS: &'a Value,
1321         RHS: &'a Value,
1322         Name: *const c_char,
1323     ) -> &'a Value;
1324     pub fn LLVMBuildNSWMul(
1325         B: &Builder<'a>,
1326         LHS: &'a Value,
1327         RHS: &'a Value,
1328         Name: *const c_char,
1329     ) -> &'a Value;
1330     pub fn LLVMBuildNUWMul(
1331         B: &Builder<'a>,
1332         LHS: &'a Value,
1333         RHS: &'a Value,
1334         Name: *const c_char,
1335     ) -> &'a Value;
1336     pub fn LLVMBuildAnd(
1337         B: &Builder<'a>,
1338         LHS: &'a Value,
1339         RHS: &'a Value,
1340         Name: *const c_char,
1341     ) -> &'a Value;
1342     pub fn LLVMBuildOr(
1343         B: &Builder<'a>,
1344         LHS: &'a Value,
1345         RHS: &'a Value,
1346         Name: *const c_char,
1347     ) -> &'a Value;
1348     pub fn LLVMBuildXor(
1349         B: &Builder<'a>,
1350         LHS: &'a Value,
1351         RHS: &'a Value,
1352         Name: *const c_char,
1353     ) -> &'a Value;
1354     pub fn LLVMBuildNeg(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
1355     pub fn LLVMBuildFNeg(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
1356     pub fn LLVMBuildNot(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
1357     pub fn LLVMRustSetFastMath(Instr: &Value);
1358
1359     // Memory
1360     pub fn LLVMBuildAlloca(B: &Builder<'a>, Ty: &'a Type, Name: *const c_char) -> &'a Value;
1361     pub fn LLVMBuildArrayAlloca(
1362         B: &Builder<'a>,
1363         Ty: &'a Type,
1364         Val: &'a Value,
1365         Name: *const c_char,
1366     ) -> &'a Value;
1367     pub fn LLVMBuildLoad(B: &Builder<'a>, PointerVal: &'a Value, Name: *const c_char) -> &'a Value;
1368
1369     pub fn LLVMBuildStore(B: &Builder<'a>, Val: &'a Value, Ptr: &'a Value) -> &'a Value;
1370
1371     pub fn LLVMBuildGEP(
1372         B: &Builder<'a>,
1373         Pointer: &'a Value,
1374         Indices: *const &'a Value,
1375         NumIndices: c_uint,
1376         Name: *const c_char,
1377     ) -> &'a Value;
1378     pub fn LLVMBuildInBoundsGEP(
1379         B: &Builder<'a>,
1380         Pointer: &'a Value,
1381         Indices: *const &'a Value,
1382         NumIndices: c_uint,
1383         Name: *const c_char,
1384     ) -> &'a Value;
1385     pub fn LLVMBuildStructGEP(
1386         B: &Builder<'a>,
1387         Pointer: &'a Value,
1388         Idx: c_uint,
1389         Name: *const c_char,
1390     ) -> &'a Value;
1391
1392     // Casts
1393     pub fn LLVMBuildTrunc(
1394         B: &Builder<'a>,
1395         Val: &'a Value,
1396         DestTy: &'a Type,
1397         Name: *const c_char,
1398     ) -> &'a Value;
1399     pub fn LLVMBuildZExt(
1400         B: &Builder<'a>,
1401         Val: &'a Value,
1402         DestTy: &'a Type,
1403         Name: *const c_char,
1404     ) -> &'a Value;
1405     pub fn LLVMBuildSExt(
1406         B: &Builder<'a>,
1407         Val: &'a Value,
1408         DestTy: &'a Type,
1409         Name: *const c_char,
1410     ) -> &'a Value;
1411     pub fn LLVMBuildFPToUI(
1412         B: &Builder<'a>,
1413         Val: &'a Value,
1414         DestTy: &'a Type,
1415         Name: *const c_char,
1416     ) -> &'a Value;
1417     pub fn LLVMBuildFPToSI(
1418         B: &Builder<'a>,
1419         Val: &'a Value,
1420         DestTy: &'a Type,
1421         Name: *const c_char,
1422     ) -> &'a Value;
1423     pub fn LLVMBuildUIToFP(
1424         B: &Builder<'a>,
1425         Val: &'a Value,
1426         DestTy: &'a Type,
1427         Name: *const c_char,
1428     ) -> &'a Value;
1429     pub fn LLVMBuildSIToFP(
1430         B: &Builder<'a>,
1431         Val: &'a Value,
1432         DestTy: &'a Type,
1433         Name: *const c_char,
1434     ) -> &'a Value;
1435     pub fn LLVMBuildFPTrunc(
1436         B: &Builder<'a>,
1437         Val: &'a Value,
1438         DestTy: &'a Type,
1439         Name: *const c_char,
1440     ) -> &'a Value;
1441     pub fn LLVMBuildFPExt(
1442         B: &Builder<'a>,
1443         Val: &'a Value,
1444         DestTy: &'a Type,
1445         Name: *const c_char,
1446     ) -> &'a Value;
1447     pub fn LLVMBuildPtrToInt(
1448         B: &Builder<'a>,
1449         Val: &'a Value,
1450         DestTy: &'a Type,
1451         Name: *const c_char,
1452     ) -> &'a Value;
1453     pub fn LLVMBuildIntToPtr(
1454         B: &Builder<'a>,
1455         Val: &'a Value,
1456         DestTy: &'a Type,
1457         Name: *const c_char,
1458     ) -> &'a Value;
1459     pub fn LLVMBuildBitCast(
1460         B: &Builder<'a>,
1461         Val: &'a Value,
1462         DestTy: &'a Type,
1463         Name: *const c_char,
1464     ) -> &'a Value;
1465     pub fn LLVMBuildPointerCast(
1466         B: &Builder<'a>,
1467         Val: &'a Value,
1468         DestTy: &'a Type,
1469         Name: *const c_char,
1470     ) -> &'a Value;
1471     pub fn LLVMRustBuildIntCast(
1472         B: &Builder<'a>,
1473         Val: &'a Value,
1474         DestTy: &'a Type,
1475         IsSized: bool,
1476     ) -> &'a Value;
1477
1478     // Comparisons
1479     pub fn LLVMBuildICmp(
1480         B: &Builder<'a>,
1481         Op: c_uint,
1482         LHS: &'a Value,
1483         RHS: &'a Value,
1484         Name: *const c_char,
1485     ) -> &'a Value;
1486     pub fn LLVMBuildFCmp(
1487         B: &Builder<'a>,
1488         Op: c_uint,
1489         LHS: &'a Value,
1490         RHS: &'a Value,
1491         Name: *const c_char,
1492     ) -> &'a Value;
1493
1494     // Miscellaneous instructions
1495     pub fn LLVMBuildPhi(B: &Builder<'a>, Ty: &'a Type, Name: *const c_char) -> &'a Value;
1496     pub fn LLVMRustGetInstrProfIncrementIntrinsic(M: &Module) -> &'a Value;
1497     pub fn LLVMRustBuildCall(
1498         B: &Builder<'a>,
1499         Fn: &'a Value,
1500         Args: *const &'a Value,
1501         NumArgs: c_uint,
1502         Bundle: Option<&OperandBundleDef<'a>>,
1503     ) -> &'a Value;
1504     pub fn LLVMRustBuildMemCpy(
1505         B: &Builder<'a>,
1506         Dst: &'a Value,
1507         DstAlign: c_uint,
1508         Src: &'a Value,
1509         SrcAlign: c_uint,
1510         Size: &'a Value,
1511         IsVolatile: bool,
1512     ) -> &'a Value;
1513     pub fn LLVMRustBuildMemMove(
1514         B: &Builder<'a>,
1515         Dst: &'a Value,
1516         DstAlign: c_uint,
1517         Src: &'a Value,
1518         SrcAlign: c_uint,
1519         Size: &'a Value,
1520         IsVolatile: bool,
1521     ) -> &'a Value;
1522     pub fn LLVMRustBuildMemSet(
1523         B: &Builder<'a>,
1524         Dst: &'a Value,
1525         DstAlign: c_uint,
1526         Val: &'a Value,
1527         Size: &'a Value,
1528         IsVolatile: bool,
1529     ) -> &'a Value;
1530     pub fn LLVMBuildSelect(
1531         B: &Builder<'a>,
1532         If: &'a Value,
1533         Then: &'a Value,
1534         Else: &'a Value,
1535         Name: *const c_char,
1536     ) -> &'a Value;
1537     pub fn LLVMBuildVAArg(
1538         B: &Builder<'a>,
1539         list: &'a Value,
1540         Ty: &'a Type,
1541         Name: *const c_char,
1542     ) -> &'a Value;
1543     pub fn LLVMBuildExtractElement(
1544         B: &Builder<'a>,
1545         VecVal: &'a Value,
1546         Index: &'a Value,
1547         Name: *const c_char,
1548     ) -> &'a Value;
1549     pub fn LLVMBuildInsertElement(
1550         B: &Builder<'a>,
1551         VecVal: &'a Value,
1552         EltVal: &'a Value,
1553         Index: &'a Value,
1554         Name: *const c_char,
1555     ) -> &'a Value;
1556     pub fn LLVMBuildShuffleVector(
1557         B: &Builder<'a>,
1558         V1: &'a Value,
1559         V2: &'a Value,
1560         Mask: &'a Value,
1561         Name: *const c_char,
1562     ) -> &'a Value;
1563     pub fn LLVMBuildExtractValue(
1564         B: &Builder<'a>,
1565         AggVal: &'a Value,
1566         Index: c_uint,
1567         Name: *const c_char,
1568     ) -> &'a Value;
1569     pub fn LLVMBuildInsertValue(
1570         B: &Builder<'a>,
1571         AggVal: &'a Value,
1572         EltVal: &'a Value,
1573         Index: c_uint,
1574         Name: *const c_char,
1575     ) -> &'a Value;
1576
1577     pub fn LLVMRustBuildVectorReduceFAdd(
1578         B: &Builder<'a>,
1579         Acc: &'a Value,
1580         Src: &'a Value,
1581     ) -> &'a Value;
1582     pub fn LLVMRustBuildVectorReduceFMul(
1583         B: &Builder<'a>,
1584         Acc: &'a Value,
1585         Src: &'a Value,
1586     ) -> &'a Value;
1587     pub fn LLVMRustBuildVectorReduceAdd(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
1588     pub fn LLVMRustBuildVectorReduceMul(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
1589     pub fn LLVMRustBuildVectorReduceAnd(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
1590     pub fn LLVMRustBuildVectorReduceOr(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
1591     pub fn LLVMRustBuildVectorReduceXor(B: &Builder<'a>, Src: &'a Value) -> &'a Value;
1592     pub fn LLVMRustBuildVectorReduceMin(
1593         B: &Builder<'a>,
1594         Src: &'a Value,
1595         IsSigned: bool,
1596     ) -> &'a Value;
1597     pub fn LLVMRustBuildVectorReduceMax(
1598         B: &Builder<'a>,
1599         Src: &'a Value,
1600         IsSigned: bool,
1601     ) -> &'a Value;
1602     pub fn LLVMRustBuildVectorReduceFMin(B: &Builder<'a>, Src: &'a Value, IsNaN: bool)
1603     -> &'a Value;
1604     pub fn LLVMRustBuildVectorReduceFMax(B: &Builder<'a>, Src: &'a Value, IsNaN: bool)
1605     -> &'a Value;
1606
1607     pub fn LLVMRustBuildMinNum(B: &Builder<'a>, LHS: &'a Value, LHS: &'a Value) -> &'a Value;
1608     pub fn LLVMRustBuildMaxNum(B: &Builder<'a>, LHS: &'a Value, LHS: &'a Value) -> &'a Value;
1609
1610     // Atomic Operations
1611     pub fn LLVMRustBuildAtomicLoad(
1612         B: &Builder<'a>,
1613         PointerVal: &'a Value,
1614         Name: *const c_char,
1615         Order: AtomicOrdering,
1616     ) -> &'a Value;
1617
1618     pub fn LLVMRustBuildAtomicStore(
1619         B: &Builder<'a>,
1620         Val: &'a Value,
1621         Ptr: &'a Value,
1622         Order: AtomicOrdering,
1623     ) -> &'a Value;
1624
1625     pub fn LLVMRustBuildAtomicCmpXchg(
1626         B: &Builder<'a>,
1627         LHS: &'a Value,
1628         CMP: &'a Value,
1629         RHS: &'a Value,
1630         Order: AtomicOrdering,
1631         FailureOrder: AtomicOrdering,
1632         Weak: Bool,
1633     ) -> &'a Value;
1634
1635     pub fn LLVMBuildAtomicRMW(
1636         B: &Builder<'a>,
1637         Op: AtomicRmwBinOp,
1638         LHS: &'a Value,
1639         RHS: &'a Value,
1640         Order: AtomicOrdering,
1641         SingleThreaded: Bool,
1642     ) -> &'a Value;
1643
1644     pub fn LLVMRustBuildAtomicFence(
1645         B: &Builder<'_>,
1646         Order: AtomicOrdering,
1647         Scope: SynchronizationScope,
1648     );
1649
1650     /// Writes a module to the specified path. Returns 0 on success.
1651     pub fn LLVMWriteBitcodeToFile(M: &Module, Path: *const c_char) -> c_int;
1652
1653     /// Creates a pass manager.
1654     pub fn LLVMCreatePassManager() -> &'a mut PassManager<'a>;
1655
1656     /// Creates a function-by-function pass manager
1657     pub fn LLVMCreateFunctionPassManagerForModule(M: &'a Module) -> &'a mut PassManager<'a>;
1658
1659     /// Disposes a pass manager.
1660     pub fn LLVMDisposePassManager(PM: &'a mut PassManager<'a>);
1661
1662     /// Runs a pass manager on a module.
1663     pub fn LLVMRunPassManager(PM: &PassManager<'a>, M: &'a Module) -> Bool;
1664
1665     pub fn LLVMInitializePasses();
1666
1667     pub fn LLVMTimeTraceProfilerInitialize();
1668
1669     pub fn LLVMTimeTraceProfilerFinish(FileName: *const c_char);
1670
1671     pub fn LLVMAddAnalysisPasses(T: &'a TargetMachine, PM: &PassManager<'a>);
1672
1673     pub fn LLVMPassManagerBuilderCreate() -> &'static mut PassManagerBuilder;
1674     pub fn LLVMPassManagerBuilderDispose(PMB: &'static mut PassManagerBuilder);
1675     pub fn LLVMPassManagerBuilderSetSizeLevel(PMB: &PassManagerBuilder, Value: Bool);
1676     pub fn LLVMPassManagerBuilderSetDisableUnrollLoops(PMB: &PassManagerBuilder, Value: Bool);
1677     pub fn LLVMPassManagerBuilderUseInlinerWithThreshold(
1678         PMB: &PassManagerBuilder,
1679         threshold: c_uint,
1680     );
1681     pub fn LLVMPassManagerBuilderPopulateModulePassManager(
1682         PMB: &PassManagerBuilder,
1683         PM: &PassManager<'_>,
1684     );
1685
1686     pub fn LLVMPassManagerBuilderPopulateFunctionPassManager(
1687         PMB: &PassManagerBuilder,
1688         PM: &PassManager<'_>,
1689     );
1690     pub fn LLVMPassManagerBuilderPopulateLTOPassManager(
1691         PMB: &PassManagerBuilder,
1692         PM: &PassManager<'_>,
1693         Internalize: Bool,
1694         RunInliner: Bool,
1695     );
1696     pub fn LLVMRustPassManagerBuilderPopulateThinLTOPassManager(
1697         PMB: &PassManagerBuilder,
1698         PM: &PassManager<'_>,
1699     );
1700
1701     pub fn LLVMGetHostCPUFeatures() -> *mut c_char;
1702
1703     pub fn LLVMDisposeMessage(message: *mut c_char);
1704
1705     // Stuff that's in llvm-wrapper/ because it's not upstream yet.
1706
1707     /// Opens an object file.
1708     pub fn LLVMCreateObjectFile(
1709         MemBuf: &'static mut MemoryBuffer,
1710     ) -> Option<&'static mut ObjectFile>;
1711     /// Closes an object file.
1712     pub fn LLVMDisposeObjectFile(ObjFile: &'static mut ObjectFile);
1713
1714     /// Enumerates the sections in an object file.
1715     pub fn LLVMGetSections(ObjFile: &'a ObjectFile) -> &'a mut SectionIterator<'a>;
1716     /// Destroys a section iterator.
1717     pub fn LLVMDisposeSectionIterator(SI: &'a mut SectionIterator<'a>);
1718     /// Returns `true` if the section iterator is at the end of the section
1719     /// list:
1720     pub fn LLVMIsSectionIteratorAtEnd(ObjFile: &'a ObjectFile, SI: &SectionIterator<'a>) -> Bool;
1721     /// Moves the section iterator to point to the next section.
1722     pub fn LLVMMoveToNextSection(SI: &SectionIterator<'_>);
1723     /// Returns the current section size.
1724     pub fn LLVMGetSectionSize(SI: &SectionIterator<'_>) -> c_ulonglong;
1725     /// Returns the current section contents as a string buffer.
1726     pub fn LLVMGetSectionContents(SI: &SectionIterator<'_>) -> *const c_char;
1727
1728     /// Reads the given file and returns it as a memory buffer. Use
1729     /// LLVMDisposeMemoryBuffer() to get rid of it.
1730     pub fn LLVMRustCreateMemoryBufferWithContentsOfFile(
1731         Path: *const c_char,
1732     ) -> Option<&'static mut MemoryBuffer>;
1733
1734     pub fn LLVMStartMultithreaded() -> Bool;
1735
1736     /// Returns a string describing the last error caused by an LLVMRust* call.
1737     pub fn LLVMRustGetLastError() -> *const c_char;
1738
1739     /// Print the pass timings since static dtors aren't picking them up.
1740     pub fn LLVMRustPrintPassTimings();
1741
1742     pub fn LLVMStructCreateNamed(C: &Context, Name: *const c_char) -> &Type;
1743
1744     pub fn LLVMStructSetBody(
1745         StructTy: &'a Type,
1746         ElementTypes: *const &'a Type,
1747         ElementCount: c_uint,
1748         Packed: Bool,
1749     );
1750
1751     /// Prepares inline assembly.
1752     pub fn LLVMRustInlineAsm(
1753         Ty: &Type,
1754         AsmString: *const c_char,
1755         AsmStringLen: size_t,
1756         Constraints: *const c_char,
1757         ConstraintsLen: size_t,
1758         SideEffects: Bool,
1759         AlignStack: Bool,
1760         Dialect: AsmDialect,
1761     ) -> &Value;
1762     pub fn LLVMRustInlineAsmVerify(
1763         Ty: &Type,
1764         Constraints: *const c_char,
1765         ConstraintsLen: size_t,
1766     ) -> bool;
1767
1768     #[allow(improper_ctypes)]
1769     pub fn LLVMRustCoverageWriteFilenamesSectionToBuffer(
1770         Filenames: *const *const c_char,
1771         FilenamesLen: size_t,
1772         BufferOut: &RustString,
1773     );
1774
1775     #[allow(improper_ctypes)]
1776     pub fn LLVMRustCoverageWriteMappingToBuffer(
1777         VirtualFileMappingIDs: *const c_uint,
1778         NumVirtualFileMappingIDs: c_uint,
1779         Expressions: *const coverage_map::CounterExpression,
1780         NumExpressions: c_uint,
1781         MappingRegions: *const coverageinfo::CounterMappingRegion,
1782         NumMappingRegions: c_uint,
1783         BufferOut: &RustString,
1784     );
1785
1786     pub fn LLVMRustCoverageCreatePGOFuncNameVar(F: &'a Value, FuncName: *const c_char)
1787     -> &'a Value;
1788     pub fn LLVMRustCoverageHashCString(StrVal: *const c_char) -> u64;
1789     pub fn LLVMRustCoverageHashByteArray(Bytes: *const c_char, NumBytes: size_t) -> u64;
1790
1791     #[allow(improper_ctypes)]
1792     pub fn LLVMRustCoverageWriteMapSectionNameToString(M: &Module, Str: &RustString);
1793
1794     #[allow(improper_ctypes)]
1795     pub fn LLVMRustCoverageWriteFuncSectionNameToString(M: &Module, Str: &RustString);
1796
1797     #[allow(improper_ctypes)]
1798     pub fn LLVMRustCoverageWriteMappingVarNameToString(Str: &RustString);
1799
1800     pub fn LLVMRustCoverageMappingVersion() -> u32;
1801     pub fn LLVMRustDebugMetadataVersion() -> u32;
1802     pub fn LLVMRustVersionMajor() -> u32;
1803     pub fn LLVMRustVersionMinor() -> u32;
1804     pub fn LLVMRustVersionPatch() -> u32;
1805
1806     pub fn LLVMRustAddModuleFlag(M: &Module, name: *const c_char, value: u32);
1807
1808     pub fn LLVMRustMetadataAsValue(C: &'a Context, MD: &'a Metadata) -> &'a Value;
1809
1810     pub fn LLVMRustDIBuilderCreate(M: &'a Module) -> &'a mut DIBuilder<'a>;
1811
1812     pub fn LLVMRustDIBuilderDispose(Builder: &'a mut DIBuilder<'a>);
1813
1814     pub fn LLVMRustDIBuilderFinalize(Builder: &DIBuilder<'_>);
1815
1816     pub fn LLVMRustDIBuilderCreateCompileUnit(
1817         Builder: &DIBuilder<'a>,
1818         Lang: c_uint,
1819         File: &'a DIFile,
1820         Producer: *const c_char,
1821         ProducerLen: size_t,
1822         isOptimized: bool,
1823         Flags: *const c_char,
1824         RuntimeVer: c_uint,
1825         SplitName: *const c_char,
1826         SplitNameLen: size_t,
1827         kind: DebugEmissionKind,
1828         DWOId: u64,
1829         SplitDebugInlining: bool,
1830     ) -> &'a DIDescriptor;
1831
1832     pub fn LLVMRustDIBuilderCreateFile(
1833         Builder: &DIBuilder<'a>,
1834         Filename: *const c_char,
1835         FilenameLen: size_t,
1836         Directory: *const c_char,
1837         DirectoryLen: size_t,
1838         CSKind: ChecksumKind,
1839         Checksum: *const c_char,
1840         ChecksumLen: size_t,
1841     ) -> &'a DIFile;
1842
1843     pub fn LLVMRustDIBuilderCreateSubroutineType(
1844         Builder: &DIBuilder<'a>,
1845         ParameterTypes: &'a DIArray,
1846     ) -> &'a DICompositeType;
1847
1848     pub fn LLVMRustDIBuilderCreateFunction(
1849         Builder: &DIBuilder<'a>,
1850         Scope: &'a DIDescriptor,
1851         Name: *const c_char,
1852         NameLen: size_t,
1853         LinkageName: *const c_char,
1854         LinkageNameLen: size_t,
1855         File: &'a DIFile,
1856         LineNo: c_uint,
1857         Ty: &'a DIType,
1858         ScopeLine: c_uint,
1859         Flags: DIFlags,
1860         SPFlags: DISPFlags,
1861         MaybeFn: Option<&'a Value>,
1862         TParam: &'a DIArray,
1863         Decl: Option<&'a DIDescriptor>,
1864     ) -> &'a DISubprogram;
1865
1866     pub fn LLVMRustDIBuilderCreateBasicType(
1867         Builder: &DIBuilder<'a>,
1868         Name: *const c_char,
1869         NameLen: size_t,
1870         SizeInBits: u64,
1871         Encoding: c_uint,
1872     ) -> &'a DIBasicType;
1873
1874     pub fn LLVMRustDIBuilderCreateTypedef(
1875         Builder: &DIBuilder<'a>,
1876         Type: &'a DIBasicType,
1877         Name: *const c_char,
1878         NameLen: size_t,
1879         File: &'a DIFile,
1880         LineNo: c_uint,
1881         Scope: Option<&'a DIScope>,
1882     ) -> &'a DIDerivedType;
1883
1884     pub fn LLVMRustDIBuilderCreatePointerType(
1885         Builder: &DIBuilder<'a>,
1886         PointeeTy: &'a DIType,
1887         SizeInBits: u64,
1888         AlignInBits: u32,
1889         AddressSpace: c_uint,
1890         Name: *const c_char,
1891         NameLen: size_t,
1892     ) -> &'a DIDerivedType;
1893
1894     pub fn LLVMRustDIBuilderCreateStructType(
1895         Builder: &DIBuilder<'a>,
1896         Scope: Option<&'a DIDescriptor>,
1897         Name: *const c_char,
1898         NameLen: size_t,
1899         File: &'a DIFile,
1900         LineNumber: c_uint,
1901         SizeInBits: u64,
1902         AlignInBits: u32,
1903         Flags: DIFlags,
1904         DerivedFrom: Option<&'a DIType>,
1905         Elements: &'a DIArray,
1906         RunTimeLang: c_uint,
1907         VTableHolder: Option<&'a DIType>,
1908         UniqueId: *const c_char,
1909         UniqueIdLen: size_t,
1910     ) -> &'a DICompositeType;
1911
1912     pub fn LLVMRustDIBuilderCreateMemberType(
1913         Builder: &DIBuilder<'a>,
1914         Scope: &'a DIDescriptor,
1915         Name: *const c_char,
1916         NameLen: size_t,
1917         File: &'a DIFile,
1918         LineNo: c_uint,
1919         SizeInBits: u64,
1920         AlignInBits: u32,
1921         OffsetInBits: u64,
1922         Flags: DIFlags,
1923         Ty: &'a DIType,
1924     ) -> &'a DIDerivedType;
1925
1926     pub fn LLVMRustDIBuilderCreateVariantMemberType(
1927         Builder: &DIBuilder<'a>,
1928         Scope: &'a DIScope,
1929         Name: *const c_char,
1930         NameLen: size_t,
1931         File: &'a DIFile,
1932         LineNumber: c_uint,
1933         SizeInBits: u64,
1934         AlignInBits: u32,
1935         OffsetInBits: u64,
1936         Discriminant: Option<&'a Value>,
1937         Flags: DIFlags,
1938         Ty: &'a DIType,
1939     ) -> &'a DIType;
1940
1941     pub fn LLVMRustDIBuilderCreateLexicalBlock(
1942         Builder: &DIBuilder<'a>,
1943         Scope: &'a DIScope,
1944         File: &'a DIFile,
1945         Line: c_uint,
1946         Col: c_uint,
1947     ) -> &'a DILexicalBlock;
1948
1949     pub fn LLVMRustDIBuilderCreateLexicalBlockFile(
1950         Builder: &DIBuilder<'a>,
1951         Scope: &'a DIScope,
1952         File: &'a DIFile,
1953     ) -> &'a DILexicalBlock;
1954
1955     pub fn LLVMRustDIBuilderCreateStaticVariable(
1956         Builder: &DIBuilder<'a>,
1957         Context: Option<&'a DIScope>,
1958         Name: *const c_char,
1959         NameLen: size_t,
1960         LinkageName: *const c_char,
1961         LinkageNameLen: size_t,
1962         File: &'a DIFile,
1963         LineNo: c_uint,
1964         Ty: &'a DIType,
1965         isLocalToUnit: bool,
1966         Val: &'a Value,
1967         Decl: Option<&'a DIDescriptor>,
1968         AlignInBits: u32,
1969     ) -> &'a DIGlobalVariableExpression;
1970
1971     pub fn LLVMRustDIBuilderCreateVariable(
1972         Builder: &DIBuilder<'a>,
1973         Tag: c_uint,
1974         Scope: &'a DIDescriptor,
1975         Name: *const c_char,
1976         NameLen: size_t,
1977         File: &'a DIFile,
1978         LineNo: c_uint,
1979         Ty: &'a DIType,
1980         AlwaysPreserve: bool,
1981         Flags: DIFlags,
1982         ArgNo: c_uint,
1983         AlignInBits: u32,
1984     ) -> &'a DIVariable;
1985
1986     pub fn LLVMRustDIBuilderCreateArrayType(
1987         Builder: &DIBuilder<'a>,
1988         Size: u64,
1989         AlignInBits: u32,
1990         Ty: &'a DIType,
1991         Subscripts: &'a DIArray,
1992     ) -> &'a DIType;
1993
1994     pub fn LLVMRustDIBuilderGetOrCreateSubrange(
1995         Builder: &DIBuilder<'a>,
1996         Lo: i64,
1997         Count: i64,
1998     ) -> &'a DISubrange;
1999
2000     pub fn LLVMRustDIBuilderGetOrCreateArray(
2001         Builder: &DIBuilder<'a>,
2002         Ptr: *const Option<&'a DIDescriptor>,
2003         Count: c_uint,
2004     ) -> &'a DIArray;
2005
2006     pub fn LLVMRustDIBuilderInsertDeclareAtEnd(
2007         Builder: &DIBuilder<'a>,
2008         Val: &'a Value,
2009         VarInfo: &'a DIVariable,
2010         AddrOps: *const i64,
2011         AddrOpsCount: c_uint,
2012         DL: &'a DILocation,
2013         InsertAtEnd: &'a BasicBlock,
2014     ) -> &'a Value;
2015
2016     pub fn LLVMRustDIBuilderCreateEnumerator(
2017         Builder: &DIBuilder<'a>,
2018         Name: *const c_char,
2019         NameLen: size_t,
2020         Value: i64,
2021         IsUnsigned: bool,
2022     ) -> &'a DIEnumerator;
2023
2024     pub fn LLVMRustDIBuilderCreateEnumerationType(
2025         Builder: &DIBuilder<'a>,
2026         Scope: &'a DIScope,
2027         Name: *const c_char,
2028         NameLen: size_t,
2029         File: &'a DIFile,
2030         LineNumber: c_uint,
2031         SizeInBits: u64,
2032         AlignInBits: u32,
2033         Elements: &'a DIArray,
2034         ClassType: &'a DIType,
2035         IsScoped: bool,
2036     ) -> &'a DIType;
2037
2038     pub fn LLVMRustDIBuilderCreateUnionType(
2039         Builder: &DIBuilder<'a>,
2040         Scope: &'a DIScope,
2041         Name: *const c_char,
2042         NameLen: size_t,
2043         File: &'a DIFile,
2044         LineNumber: c_uint,
2045         SizeInBits: u64,
2046         AlignInBits: u32,
2047         Flags: DIFlags,
2048         Elements: Option<&'a DIArray>,
2049         RunTimeLang: c_uint,
2050         UniqueId: *const c_char,
2051         UniqueIdLen: size_t,
2052     ) -> &'a DIType;
2053
2054     pub fn LLVMRustDIBuilderCreateVariantPart(
2055         Builder: &DIBuilder<'a>,
2056         Scope: &'a DIScope,
2057         Name: *const c_char,
2058         NameLen: size_t,
2059         File: &'a DIFile,
2060         LineNo: c_uint,
2061         SizeInBits: u64,
2062         AlignInBits: u32,
2063         Flags: DIFlags,
2064         Discriminator: Option<&'a DIDerivedType>,
2065         Elements: &'a DIArray,
2066         UniqueId: *const c_char,
2067         UniqueIdLen: size_t,
2068     ) -> &'a DIDerivedType;
2069
2070     pub fn LLVMSetUnnamedAddress(Global: &Value, UnnamedAddr: UnnamedAddr);
2071
2072     pub fn LLVMRustDIBuilderCreateTemplateTypeParameter(
2073         Builder: &DIBuilder<'a>,
2074         Scope: Option<&'a DIScope>,
2075         Name: *const c_char,
2076         NameLen: size_t,
2077         Ty: &'a DIType,
2078     ) -> &'a DITemplateTypeParameter;
2079
2080     pub fn LLVMRustDIBuilderCreateNameSpace(
2081         Builder: &DIBuilder<'a>,
2082         Scope: Option<&'a DIScope>,
2083         Name: *const c_char,
2084         NameLen: size_t,
2085         ExportSymbols: bool,
2086     ) -> &'a DINameSpace;
2087
2088     pub fn LLVMRustDICompositeTypeReplaceArrays(
2089         Builder: &DIBuilder<'a>,
2090         CompositeType: &'a DIType,
2091         Elements: Option<&'a DIArray>,
2092         Params: Option<&'a DIArray>,
2093     );
2094
2095     pub fn LLVMRustDIBuilderCreateDebugLocation(
2096         Line: c_uint,
2097         Column: c_uint,
2098         Scope: &'a DIScope,
2099         InlinedAt: Option<&'a DILocation>,
2100     ) -> &'a DILocation;
2101     pub fn LLVMRustDIBuilderCreateOpDeref() -> i64;
2102     pub fn LLVMRustDIBuilderCreateOpPlusUconst() -> i64;
2103
2104     #[allow(improper_ctypes)]
2105     pub fn LLVMRustWriteTypeToString(Type: &Type, s: &RustString);
2106     #[allow(improper_ctypes)]
2107     pub fn LLVMRustWriteValueToString(value_ref: &Value, s: &RustString);
2108
2109     pub fn LLVMIsAConstantInt(value_ref: &Value) -> Option<&ConstantInt>;
2110
2111     pub fn LLVMRustPassKind(Pass: &Pass) -> PassKind;
2112     pub fn LLVMRustFindAndCreatePass(Pass: *const c_char) -> Option<&'static mut Pass>;
2113     pub fn LLVMRustCreateAddressSanitizerFunctionPass(Recover: bool) -> &'static mut Pass;
2114     pub fn LLVMRustCreateModuleAddressSanitizerPass(Recover: bool) -> &'static mut Pass;
2115     pub fn LLVMRustCreateMemorySanitizerPass(
2116         TrackOrigins: c_int,
2117         Recover: bool,
2118     ) -> &'static mut Pass;
2119     pub fn LLVMRustCreateThreadSanitizerPass() -> &'static mut Pass;
2120     pub fn LLVMRustCreateHWAddressSanitizerPass(Recover: bool) -> &'static mut Pass;
2121     pub fn LLVMRustAddPass(PM: &PassManager<'_>, Pass: &'static mut Pass);
2122     pub fn LLVMRustAddLastExtensionPasses(
2123         PMB: &PassManagerBuilder,
2124         Passes: *const &'static mut Pass,
2125         NumPasses: size_t,
2126     );
2127
2128     pub fn LLVMRustHasFeature(T: &TargetMachine, s: *const c_char) -> bool;
2129
2130     pub fn LLVMRustPrintTargetCPUs(T: &TargetMachine);
2131     pub fn LLVMRustGetTargetFeaturesCount(T: &TargetMachine) -> size_t;
2132     pub fn LLVMRustGetTargetFeature(
2133         T: &TargetMachine,
2134         Index: size_t,
2135         Feature: &mut *const c_char,
2136         Desc: &mut *const c_char,
2137     );
2138
2139     pub fn LLVMRustGetHostCPUName(len: *mut usize) -> *const c_char;
2140     pub fn LLVMRustCreateTargetMachine(
2141         Triple: *const c_char,
2142         CPU: *const c_char,
2143         Features: *const c_char,
2144         Abi: *const c_char,
2145         Model: CodeModel,
2146         Reloc: RelocModel,
2147         Level: CodeGenOptLevel,
2148         UseSoftFP: bool,
2149         FunctionSections: bool,
2150         DataSections: bool,
2151         TrapUnreachable: bool,
2152         Singlethread: bool,
2153         AsmComments: bool,
2154         EmitStackSizeSection: bool,
2155         RelaxELFRelocations: bool,
2156         UseInitArray: bool,
2157         SplitDwarfFile: *const c_char,
2158     ) -> Option<&'static mut TargetMachine>;
2159     pub fn LLVMRustDisposeTargetMachine(T: &'static mut TargetMachine);
2160     pub fn LLVMRustAddBuilderLibraryInfo(
2161         PMB: &'a PassManagerBuilder,
2162         M: &'a Module,
2163         DisableSimplifyLibCalls: bool,
2164     );
2165     pub fn LLVMRustConfigurePassManagerBuilder(
2166         PMB: &PassManagerBuilder,
2167         OptLevel: CodeGenOptLevel,
2168         MergeFunctions: bool,
2169         SLPVectorize: bool,
2170         LoopVectorize: bool,
2171         PrepareForThinLTO: bool,
2172         PGOGenPath: *const c_char,
2173         PGOUsePath: *const c_char,
2174     );
2175     pub fn LLVMRustAddLibraryInfo(
2176         PM: &PassManager<'a>,
2177         M: &'a Module,
2178         DisableSimplifyLibCalls: bool,
2179     );
2180     pub fn LLVMRustRunFunctionPassManager(PM: &PassManager<'a>, M: &'a Module);
2181     pub fn LLVMRustWriteOutputFile(
2182         T: &'a TargetMachine,
2183         PM: &PassManager<'a>,
2184         M: &'a Module,
2185         Output: *const c_char,
2186         DwoOutput: *const c_char,
2187         FileType: FileType,
2188     ) -> LLVMRustResult;
2189     pub fn LLVMRustOptimizeWithNewPassManager(
2190         M: &'a Module,
2191         TM: &'a TargetMachine,
2192         OptLevel: PassBuilderOptLevel,
2193         OptStage: OptStage,
2194         NoPrepopulatePasses: bool,
2195         VerifyIR: bool,
2196         UseThinLTOBuffers: bool,
2197         MergeFunctions: bool,
2198         UnrollLoops: bool,
2199         SLPVectorize: bool,
2200         LoopVectorize: bool,
2201         DisableSimplifyLibCalls: bool,
2202         EmitLifetimeMarkers: bool,
2203         SanitizerOptions: Option<&SanitizerOptions>,
2204         PGOGenPath: *const c_char,
2205         PGOUsePath: *const c_char,
2206         InstrumentCoverage: bool,
2207         InstrumentGCOV: bool,
2208         llvm_selfprofiler: *mut c_void,
2209         begin_callback: SelfProfileBeforePassCallback,
2210         end_callback: SelfProfileAfterPassCallback,
2211         ExtraPasses: *const c_char,
2212         ExtraPassesLen: size_t,
2213     ) -> LLVMRustResult;
2214     pub fn LLVMRustPrintModule(
2215         M: &'a Module,
2216         Output: *const c_char,
2217         Demangle: extern "C" fn(*const c_char, size_t, *mut c_char, size_t) -> size_t,
2218     ) -> LLVMRustResult;
2219     pub fn LLVMRustSetLLVMOptions(Argc: c_int, Argv: *const *const c_char);
2220     pub fn LLVMRustPrintPasses();
2221     pub fn LLVMRustGetInstructionCount(M: &Module) -> u32;
2222     pub fn LLVMRustSetNormalizedTarget(M: &Module, triple: *const c_char);
2223     pub fn LLVMRustAddAlwaysInlinePass(P: &PassManagerBuilder, AddLifetimes: bool);
2224     pub fn LLVMRustRunRestrictionPass(M: &Module, syms: *const *const c_char, len: size_t);
2225     pub fn LLVMRustMarkAllFunctionsNounwind(M: &Module);
2226
2227     pub fn LLVMRustOpenArchive(path: *const c_char) -> Option<&'static mut Archive>;
2228     pub fn LLVMRustArchiveIteratorNew(AR: &'a Archive) -> &'a mut ArchiveIterator<'a>;
2229     pub fn LLVMRustArchiveIteratorNext(
2230         AIR: &ArchiveIterator<'a>,
2231     ) -> Option<&'a mut ArchiveChild<'a>>;
2232     pub fn LLVMRustArchiveChildName(ACR: &ArchiveChild<'_>, size: &mut size_t) -> *const c_char;
2233     pub fn LLVMRustArchiveChildData(ACR: &ArchiveChild<'_>, size: &mut size_t) -> *const c_char;
2234     pub fn LLVMRustArchiveChildFree(ACR: &'a mut ArchiveChild<'a>);
2235     pub fn LLVMRustArchiveIteratorFree(AIR: &'a mut ArchiveIterator<'a>);
2236     pub fn LLVMRustDestroyArchive(AR: &'static mut Archive);
2237
2238     #[allow(improper_ctypes)]
2239     pub fn LLVMRustGetSectionName(
2240         SI: &SectionIterator<'_>,
2241         data: &mut Option<std::ptr::NonNull<c_char>>,
2242     ) -> size_t;
2243
2244     #[allow(improper_ctypes)]
2245     pub fn LLVMRustWriteTwineToString(T: &Twine, s: &RustString);
2246
2247     pub fn LLVMContextSetDiagnosticHandler(
2248         C: &Context,
2249         Handler: DiagnosticHandler,
2250         DiagnosticContext: *mut c_void,
2251     );
2252
2253     #[allow(improper_ctypes)]
2254     pub fn LLVMRustUnpackOptimizationDiagnostic(
2255         DI: &'a DiagnosticInfo,
2256         pass_name_out: &RustString,
2257         function_out: &mut Option<&'a Value>,
2258         loc_line_out: &mut c_uint,
2259         loc_column_out: &mut c_uint,
2260         loc_filename_out: &RustString,
2261         message_out: &RustString,
2262     );
2263
2264     pub fn LLVMRustUnpackInlineAsmDiagnostic(
2265         DI: &'a DiagnosticInfo,
2266         level_out: &mut DiagnosticLevel,
2267         cookie_out: &mut c_uint,
2268         message_out: &mut Option<&'a Twine>,
2269         instruction_out: &mut Option<&'a Value>,
2270     );
2271
2272     #[allow(improper_ctypes)]
2273     pub fn LLVMRustWriteDiagnosticInfoToString(DI: &DiagnosticInfo, s: &RustString);
2274     pub fn LLVMRustGetDiagInfoKind(DI: &DiagnosticInfo) -> DiagnosticKind;
2275
2276     pub fn LLVMRustSetInlineAsmDiagnosticHandler(
2277         C: &Context,
2278         H: InlineAsmDiagHandler,
2279         CX: *mut c_void,
2280     );
2281
2282     #[allow(improper_ctypes)]
2283     pub fn LLVMRustUnpackSMDiagnostic(
2284         d: &SMDiagnostic,
2285         message_out: &RustString,
2286         buffer_out: &RustString,
2287         level_out: &mut DiagnosticLevel,
2288         loc_out: &mut c_uint,
2289         ranges_out: *mut c_uint,
2290         num_ranges: &mut usize,
2291     ) -> bool;
2292
2293     pub fn LLVMRustWriteArchive(
2294         Dst: *const c_char,
2295         NumMembers: size_t,
2296         Members: *const &RustArchiveMember<'_>,
2297         WriteSymbtab: bool,
2298         Kind: ArchiveKind,
2299     ) -> LLVMRustResult;
2300     pub fn LLVMRustArchiveMemberNew(
2301         Filename: *const c_char,
2302         Name: *const c_char,
2303         Child: Option<&ArchiveChild<'a>>,
2304     ) -> &'a mut RustArchiveMember<'a>;
2305     pub fn LLVMRustArchiveMemberFree(Member: &'a mut RustArchiveMember<'a>);
2306
2307     pub fn LLVMRustSetDataLayoutFromTargetMachine(M: &'a Module, TM: &'a TargetMachine);
2308
2309     pub fn LLVMRustBuildOperandBundleDef(
2310         Name: *const c_char,
2311         Inputs: *const &'a Value,
2312         NumInputs: c_uint,
2313     ) -> &'a mut OperandBundleDef<'a>;
2314     pub fn LLVMRustFreeOperandBundleDef(Bundle: &'a mut OperandBundleDef<'a>);
2315
2316     pub fn LLVMRustPositionBuilderAtStart(B: &Builder<'a>, BB: &'a BasicBlock);
2317
2318     pub fn LLVMRustSetComdat(M: &'a Module, V: &'a Value, Name: *const c_char, NameLen: size_t);
2319     pub fn LLVMRustUnsetComdat(V: &Value);
2320     pub fn LLVMRustSetModulePICLevel(M: &Module);
2321     pub fn LLVMRustSetModulePIELevel(M: &Module);
2322     pub fn LLVMRustSetModuleCodeModel(M: &Module, Model: CodeModel);
2323     pub fn LLVMRustModuleBufferCreate(M: &Module) -> &'static mut ModuleBuffer;
2324     pub fn LLVMRustModuleBufferPtr(p: &ModuleBuffer) -> *const u8;
2325     pub fn LLVMRustModuleBufferLen(p: &ModuleBuffer) -> usize;
2326     pub fn LLVMRustModuleBufferFree(p: &'static mut ModuleBuffer);
2327     pub fn LLVMRustModuleCost(M: &Module) -> u64;
2328
2329     pub fn LLVMRustThinLTOBufferCreate(M: &Module) -> &'static mut ThinLTOBuffer;
2330     pub fn LLVMRustThinLTOBufferFree(M: &'static mut ThinLTOBuffer);
2331     pub fn LLVMRustThinLTOBufferPtr(M: &ThinLTOBuffer) -> *const c_char;
2332     pub fn LLVMRustThinLTOBufferLen(M: &ThinLTOBuffer) -> size_t;
2333     pub fn LLVMRustCreateThinLTOData(
2334         Modules: *const ThinLTOModule,
2335         NumModules: c_uint,
2336         PreservedSymbols: *const *const c_char,
2337         PreservedSymbolsLen: c_uint,
2338     ) -> Option<&'static mut ThinLTOData>;
2339     pub fn LLVMRustPrepareThinLTORename(
2340         Data: &ThinLTOData,
2341         Module: &Module,
2342         Target: &TargetMachine,
2343     ) -> bool;
2344     pub fn LLVMRustPrepareThinLTOResolveWeak(Data: &ThinLTOData, Module: &Module) -> bool;
2345     pub fn LLVMRustPrepareThinLTOInternalize(Data: &ThinLTOData, Module: &Module) -> bool;
2346     pub fn LLVMRustPrepareThinLTOImport(
2347         Data: &ThinLTOData,
2348         Module: &Module,
2349         Target: &TargetMachine,
2350     ) -> bool;
2351     pub fn LLVMRustGetThinLTOModuleImports(
2352         Data: *const ThinLTOData,
2353         ModuleNameCallback: ThinLTOModuleNameCallback,
2354         CallbackPayload: *mut c_void,
2355     );
2356     pub fn LLVMRustFreeThinLTOData(Data: &'static mut ThinLTOData);
2357     pub fn LLVMRustParseBitcodeForLTO(
2358         Context: &Context,
2359         Data: *const u8,
2360         len: usize,
2361         Identifier: *const c_char,
2362     ) -> Option<&Module>;
2363     pub fn LLVMRustGetBitcodeSliceFromObjectData(
2364         Data: *const u8,
2365         len: usize,
2366         out_len: &mut usize,
2367     ) -> *const u8;
2368     pub fn LLVMRustThinLTOGetDICompileUnit(
2369         M: &Module,
2370         CU1: &mut *mut c_void,
2371         CU2: &mut *mut c_void,
2372     );
2373     pub fn LLVMRustThinLTOPatchDICompileUnit(M: &Module, CU: *mut c_void);
2374
2375     pub fn LLVMRustLinkerNew(M: &'a Module) -> &'a mut Linker<'a>;
2376     pub fn LLVMRustLinkerAdd(
2377         linker: &Linker<'_>,
2378         bytecode: *const c_char,
2379         bytecode_len: usize,
2380     ) -> bool;
2381     pub fn LLVMRustLinkerFree(linker: &'a mut Linker<'a>);
2382     #[allow(improper_ctypes)]
2383     pub fn LLVMRustComputeLTOCacheKey(
2384         key_out: &RustString,
2385         mod_id: *const c_char,
2386         data: &ThinLTOData,
2387     );
2388 }