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