| // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT |
| // file at the top-level directory of this distribution and at |
| // http://rust-lang.org/COPYRIGHT. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| use debuginfo::{DIBuilderRef, DIDescriptor, |
| DIFile, DILexicalBlock, DISubprogram, DIType, |
| DIBasicType, DIDerivedType, DICompositeType, DIScope, |
| DIVariable, DIGlobalVariable, DIArray, DISubrange, |
| DITemplateTypeParameter, DIEnumerator, DINameSpace}; |
| |
| use libc::{c_uint, c_int, size_t, c_char}; |
| use libc::{c_longlong, c_ulonglong, c_void}; |
| |
| use RustStringRef; |
| |
| pub type Opcode = u32; |
| pub type Bool = c_uint; |
| |
| pub const True: Bool = 1 as Bool; |
| pub const False: Bool = 0 as Bool; |
| |
| #[derive(Copy, Clone, PartialEq)] |
| #[repr(C)] |
| pub enum LLVMRustResult { |
| Success, |
| Failure, |
| } |
| // Consts for the LLVM CallConv type, pre-cast to usize. |
| |
| /// LLVM CallingConv::ID. Should we wrap this? |
| #[derive(Copy, Clone, PartialEq)] |
| #[repr(C)] |
| pub enum CallConv { |
| CCallConv = 0, |
| FastCallConv = 8, |
| ColdCallConv = 9, |
| X86StdcallCallConv = 64, |
| X86FastcallCallConv = 65, |
| X86_64_Win64 = 79, |
| X86_VectorCall = 80 |
| } |
| |
| /// LLVMLinkage |
| /// |
| /// This enum omits the obsolete (and no-op) linkage types DLLImportLinkage, |
| /// DLLExportLinkage, GhostLinkage and LinkOnceODRAutoHideLinkage. |
| /// LinkerPrivateLinkage and LinkerPrivateWeakLinkage are not included either; |
| /// they've been removed in upstream LLVM commit r203866. |
| #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] |
| #[repr(C)] |
| pub enum Linkage { |
| ExternalLinkage = 0, |
| AvailableExternallyLinkage = 1, |
| LinkOnceAnyLinkage = 2, |
| LinkOnceODRLinkage = 3, |
| WeakAnyLinkage = 5, |
| WeakODRLinkage = 6, |
| AppendingLinkage = 7, |
| InternalLinkage = 8, |
| PrivateLinkage = 9, |
| ExternalWeakLinkage = 12, |
| CommonLinkage = 14, |
| } |
| |
| /// LLVMDiagnosticSeverity |
| #[derive(Copy, Clone, Debug)] |
| #[repr(C)] |
| pub enum DiagnosticSeverity { |
| Error = 0, |
| Warning = 1, |
| Remark = 2, |
| Note = 3, |
| } |
| |
| /// LLVMDLLStorageClass |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum DLLStorageClass { |
| Default = 0, |
| DllImport = 1, /* Function to be imported from DLL. */ |
| DllExport = 2, /* Function to be accessible from DLL. */ |
| } |
| |
| bitflags! { |
| #[derive(Default, Debug)] |
| flags Attribute : u64 { |
| const ZExt = 1 << 0, |
| const SExt = 1 << 1, |
| const NoReturn = 1 << 2, |
| const InReg = 1 << 3, |
| const StructRet = 1 << 4, |
| const NoUnwind = 1 << 5, |
| const NoAlias = 1 << 6, |
| const ByVal = 1 << 7, |
| const Nest = 1 << 8, |
| const ReadNone = 1 << 9, |
| const ReadOnly = 1 << 10, |
| const NoInline = 1 << 11, |
| const AlwaysInline = 1 << 12, |
| const OptimizeForSize = 1 << 13, |
| const StackProtect = 1 << 14, |
| const StackProtectReq = 1 << 15, |
| const NoCapture = 1 << 21, |
| const NoRedZone = 1 << 22, |
| const NoImplicitFloat = 1 << 23, |
| const Naked = 1 << 24, |
| const InlineHint = 1 << 25, |
| const ReturnsTwice = 1 << 29, |
| const UWTable = 1 << 30, |
| const NonLazyBind = 1 << 31, |
| |
| // Some of these are missing from the LLVM C API, the rest are |
| // present, but commented out, and preceded by the following warning: |
| // FIXME: These attributes are currently not included in the C API as |
| // a temporary measure until the API/ABI impact to the C API is understood |
| // and the path forward agreed upon. |
| const SanitizeAddress = 1 << 32, |
| const MinSize = 1 << 33, |
| const NoDuplicate = 1 << 34, |
| const StackProtectStrong = 1 << 35, |
| const SanitizeThread = 1 << 36, |
| const SanitizeMemory = 1 << 37, |
| const NoBuiltin = 1 << 38, |
| const Returned = 1 << 39, |
| const Cold = 1 << 40, |
| const Builtin = 1 << 41, |
| const OptimizeNone = 1 << 42, |
| const InAlloca = 1 << 43, |
| const NonNull = 1 << 44, |
| const JumpTable = 1 << 45, |
| const Convergent = 1 << 46, |
| const SafeStack = 1 << 47, |
| const NoRecurse = 1 << 48, |
| const InaccessibleMemOnly = 1 << 49, |
| const InaccessibleMemOrArgMemOnly = 1 << 50, |
| } |
| } |
| |
| /// LLVMIntPredicate |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum IntPredicate { |
| IntEQ = 32, |
| IntNE = 33, |
| IntUGT = 34, |
| IntUGE = 35, |
| IntULT = 36, |
| IntULE = 37, |
| IntSGT = 38, |
| IntSGE = 39, |
| IntSLT = 40, |
| IntSLE = 41, |
| } |
| |
| /// LLVMRealPredicate |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum RealPredicate { |
| RealPredicateFalse = 0, |
| RealOEQ = 1, |
| RealOGT = 2, |
| RealOGE = 3, |
| RealOLT = 4, |
| RealOLE = 5, |
| RealONE = 6, |
| RealORD = 7, |
| RealUNO = 8, |
| RealUEQ = 9, |
| RealUGT = 10, |
| RealUGE = 11, |
| RealULT = 12, |
| RealULE = 13, |
| RealUNE = 14, |
| RealPredicateTrue = 15, |
| } |
| |
| /// LLVMTypeKind |
| #[derive(Copy, Clone, PartialEq, Debug)] |
| #[repr(C)] |
| pub enum TypeKind { |
| Void = 0, |
| Half = 1, |
| Float = 2, |
| Double = 3, |
| X86_FP80 = 4, |
| FP128 = 5, |
| PPC_FP128 = 6, |
| Label = 7, |
| Integer = 8, |
| Function = 9, |
| Struct = 10, |
| Array = 11, |
| Pointer = 12, |
| Vector = 13, |
| Metadata = 14, |
| X86_MMX = 15, |
| Token = 16, |
| } |
| |
| /// LLVMAtomicRmwBinOp |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum AtomicRmwBinOp { |
| AtomicXchg = 0, |
| AtomicAdd = 1, |
| AtomicSub = 2, |
| AtomicAnd = 3, |
| AtomicNand = 4, |
| AtomicOr = 5, |
| AtomicXor = 6, |
| AtomicMax = 7, |
| AtomicMin = 8, |
| AtomicUMax = 9, |
| AtomicUMin = 10, |
| } |
| |
| /// LLVMAtomicOrdering |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum AtomicOrdering { |
| NotAtomic = 0, |
| Unordered = 1, |
| Monotonic = 2, |
| // Consume = 3, // Not specified yet. |
| Acquire = 4, |
| Release = 5, |
| AcquireRelease = 6, |
| SequentiallyConsistent = 7 |
| } |
| |
| /// LLVMRustSynchronizationScope |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum SynchronizationScope { |
| Other, |
| SingleThread, |
| CrossThread, |
| } |
| |
| /// LLVMRustFileType |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum FileType { |
| Other, |
| AssemblyFile, |
| ObjectFile, |
| } |
| |
| /// Enum pinned in LLVMContext, used in |
| /// LLVMSetMetadata so ABI-stable. |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum MetadataType { |
| MD_dbg = 0, |
| MD_tbaa = 1, |
| MD_prof = 2, |
| MD_fpmath = 3, |
| MD_range = 4, |
| MD_tbaa_struct = 5, |
| MD_invariant_load = 6, |
| MD_alias_scope = 7, |
| MD_noalias = 8, |
| MD_nontemporal = 9, |
| MD_mem_parallel_loop_access = 10, |
| MD_nonnull = 11, |
| } |
| |
| /// LLVMRustAsmDialect |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum AsmDialect { |
| Other, |
| Att, |
| Intel, |
| } |
| |
| /// LLVMRustCodeGenOptLevel |
| #[derive(Copy, Clone, PartialEq)] |
| #[repr(C)] |
| pub enum CodeGenOptLevel { |
| Other, |
| None, |
| Less, |
| Default, |
| Aggressive, |
| } |
| |
| /// LLVMRelocMode |
| #[derive(Copy, Clone, PartialEq)] |
| #[repr(C)] |
| pub enum RelocMode { |
| Default = 0, |
| Static = 1, |
| PIC = 2, |
| DynamicNoPic = 3, |
| } |
| |
| /// LLVMRustCodeModel |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum CodeModel { |
| Other, |
| Default, |
| JITDefault, |
| Small, |
| Kernel, |
| Medium, |
| Large, |
| } |
| |
| /// LLVMRustDiagnosticKind |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum DiagnosticKind { |
| Other, |
| InlineAsm, |
| StackSize, |
| DebugMetadataVersion, |
| SampleProfile, |
| OptimizationRemark, |
| OptimizationRemarkMissed, |
| OptimizationRemarkAnalysis, |
| OptimizationRemarkAnalysisFPCommute, |
| OptimizationRemarkAnalysisAliasing, |
| OptimizationRemarkOther, |
| OptimizationFailure, |
| } |
| |
| /// LLVMRustArchiveKind |
| #[derive(Copy, Clone)] |
| #[repr(C)] |
| pub enum ArchiveKind { |
| Other, |
| K_GNU, |
| K_MIPS64, |
| K_BSD, |
| K_COFF, |
| } |
| |
| /// LLVMRustPassKind |
| #[derive(Copy, Clone, PartialEq, Debug)] |
| #[repr(C)] |
| pub enum PassKind { |
| Other, |
| Function, |
| Module, |
| } |
| |
| // Opaque pointer types |
| #[allow(missing_copy_implementations)] |
| pub enum Module_opaque {} |
| pub type ModuleRef = *mut Module_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Context_opaque {} |
| pub type ContextRef = *mut Context_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Type_opaque {} |
| pub type TypeRef = *mut Type_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Value_opaque {} |
| pub type ValueRef = *mut Value_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Metadata_opaque {} |
| pub type MetadataRef = *mut Metadata_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum BasicBlock_opaque {} |
| pub type BasicBlockRef = *mut BasicBlock_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Builder_opaque {} |
| pub type BuilderRef = *mut Builder_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum ExecutionEngine_opaque {} |
| pub type ExecutionEngineRef = *mut ExecutionEngine_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum MemoryBuffer_opaque {} |
| pub type MemoryBufferRef = *mut MemoryBuffer_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum PassManager_opaque {} |
| pub type PassManagerRef = *mut PassManager_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum PassManagerBuilder_opaque {} |
| pub type PassManagerBuilderRef = *mut PassManagerBuilder_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Use_opaque {} |
| pub type UseRef = *mut Use_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum TargetData_opaque {} |
| pub type TargetDataRef = *mut TargetData_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum ObjectFile_opaque {} |
| pub type ObjectFileRef = *mut ObjectFile_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum SectionIterator_opaque {} |
| pub type SectionIteratorRef = *mut SectionIterator_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Pass_opaque {} |
| pub type PassRef = *mut Pass_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum TargetMachine_opaque {} |
| pub type TargetMachineRef = *mut TargetMachine_opaque; |
| pub enum Archive_opaque {} |
| pub type ArchiveRef = *mut Archive_opaque; |
| pub enum ArchiveIterator_opaque {} |
| pub type ArchiveIteratorRef = *mut ArchiveIterator_opaque; |
| pub enum ArchiveChild_opaque {} |
| pub type ArchiveChildRef = *mut ArchiveChild_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum Twine_opaque {} |
| pub type TwineRef = *mut Twine_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum DiagnosticInfo_opaque {} |
| pub type DiagnosticInfoRef = *mut DiagnosticInfo_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum DebugLoc_opaque {} |
| pub type DebugLocRef = *mut DebugLoc_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum SMDiagnostic_opaque {} |
| pub type SMDiagnosticRef = *mut SMDiagnostic_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum RustArchiveMember_opaque {} |
| pub type RustArchiveMemberRef = *mut RustArchiveMember_opaque; |
| #[allow(missing_copy_implementations)] |
| pub enum OperandBundleDef_opaque {} |
| pub type OperandBundleDefRef = *mut OperandBundleDef_opaque; |
| |
| pub type DiagnosticHandler = unsafe extern "C" fn(DiagnosticInfoRef, *mut c_void); |
| pub type InlineAsmDiagHandler = unsafe extern "C" fn(SMDiagnosticRef, *const c_void, c_uint); |
| |
| pub mod debuginfo { |
| pub use self::DIDescriptorFlags::*; |
| use super::{MetadataRef}; |
| |
| #[allow(missing_copy_implementations)] |
| pub enum DIBuilder_opaque {} |
| pub type DIBuilderRef = *mut DIBuilder_opaque; |
| |
| pub type DIDescriptor = MetadataRef; |
| pub type DIScope = DIDescriptor; |
| pub type DILocation = DIDescriptor; |
| pub type DIFile = DIScope; |
| pub type DILexicalBlock = DIScope; |
| pub type DISubprogram = DIScope; |
| pub type DINameSpace = DIScope; |
| pub type DIType = DIDescriptor; |
| pub type DIBasicType = DIType; |
| pub type DIDerivedType = DIType; |
| pub type DICompositeType = DIDerivedType; |
| pub type DIVariable = DIDescriptor; |
| pub type DIGlobalVariable = DIDescriptor; |
| pub type DIArray = DIDescriptor; |
| pub type DISubrange = DIDescriptor; |
| pub type DIEnumerator = DIDescriptor; |
| pub type DITemplateTypeParameter = DIDescriptor; |
| |
| #[derive(Copy, Clone)] |
| pub enum DIDescriptorFlags { |
| FlagPrivate = 1 << 0, |
| FlagProtected = 1 << 1, |
| FlagFwdDecl = 1 << 2, |
| FlagAppleBlock = 1 << 3, |
| FlagBlockByrefStruct = 1 << 4, |
| FlagVirtual = 1 << 5, |
| FlagArtificial = 1 << 6, |
| FlagExplicit = 1 << 7, |
| FlagPrototyped = 1 << 8, |
| FlagObjcClassComplete = 1 << 9, |
| FlagObjectPointer = 1 << 10, |
| FlagVector = 1 << 11, |
| FlagStaticMember = 1 << 12, |
| FlagIndirectVariable = 1 << 13, |
| FlagLValueReference = 1 << 14, |
| FlagRValueReference = 1 << 15 |
| } |
| } |
| |
| |
| // Link to our native llvm bindings (things that we need to use the C++ api |
| // for) and because llvm is written in C++ we need to link against libstdc++ |
| // |
| // You'll probably notice that there is an omission of all LLVM libraries |
| // from this location. This is because the set of LLVM libraries that we |
| // link to is mostly defined by LLVM, and the `llvm-config` tool is used to |
| // figure out the exact set of libraries. To do this, the build system |
| // generates an llvmdeps.rs file next to this one which will be |
| // automatically updated whenever LLVM is updated to include an up-to-date |
| // set of the libraries we need to link to LLVM for. |
| #[link(name = "rustllvm", kind = "static")] |
| #[cfg(not(cargobuild))] |
| extern {} |
| |
| #[linked_from = "rustllvm"] // not quite true but good enough |
| extern { |
| /* Create and destroy contexts. */ |
| pub fn LLVMContextCreate() -> ContextRef; |
| pub fn LLVMContextDispose(C: ContextRef); |
| pub fn LLVMGetMDKindIDInContext(C: ContextRef, |
| Name: *const c_char, |
| SLen: c_uint) |
| -> c_uint; |
| |
| /* Create and destroy modules. */ |
| pub fn LLVMModuleCreateWithNameInContext(ModuleID: *const c_char, |
| C: ContextRef) |
| -> ModuleRef; |
| pub fn LLVMGetModuleContext(M: ModuleRef) -> ContextRef; |
| pub fn LLVMCloneModule(M: ModuleRef) -> ModuleRef; |
| pub fn LLVMDisposeModule(M: ModuleRef); |
| |
| /// Data layout. See Module::getDataLayout. |
| pub fn LLVMGetDataLayout(M: ModuleRef) -> *const c_char; |
| pub fn LLVMSetDataLayout(M: ModuleRef, Triple: *const c_char); |
| |
| /// Target triple. See Module::getTargetTriple. |
| pub fn LLVMGetTarget(M: ModuleRef) -> *const c_char; |
| pub fn LLVMSetTarget(M: ModuleRef, Triple: *const c_char); |
| |
| /// See Module::dump. |
| pub fn LLVMDumpModule(M: ModuleRef); |
| |
| /// See Module::setModuleInlineAsm. |
| pub fn LLVMSetModuleInlineAsm(M: ModuleRef, Asm: *const c_char); |
| |
| /// See llvm::LLVMTypeKind::getTypeID. |
| pub fn LLVMRustGetTypeKind(Ty: TypeRef) -> TypeKind; |
| |
| /// See llvm::LLVMType::getContext. |
| pub fn LLVMGetTypeContext(Ty: TypeRef) -> ContextRef; |
| |
| /* Operations on integer types */ |
| pub fn LLVMInt1TypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMInt8TypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMInt16TypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMInt32TypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMInt64TypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMIntTypeInContext(C: ContextRef, NumBits: c_uint) |
| -> TypeRef; |
| |
| pub fn LLVMGetIntTypeWidth(IntegerTy: TypeRef) -> c_uint; |
| |
| /* Operations on real types */ |
| pub fn LLVMFloatTypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMDoubleTypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMX86FP80TypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMFP128TypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMPPCFP128TypeInContext(C: ContextRef) -> TypeRef; |
| |
| /* Operations on function types */ |
| pub fn LLVMFunctionType(ReturnType: TypeRef, |
| ParamTypes: *const TypeRef, |
| ParamCount: c_uint, |
| IsVarArg: Bool) |
| -> TypeRef; |
| pub fn LLVMIsFunctionVarArg(FunctionTy: TypeRef) -> Bool; |
| pub fn LLVMGetReturnType(FunctionTy: TypeRef) -> TypeRef; |
| pub fn LLVMCountParamTypes(FunctionTy: TypeRef) -> c_uint; |
| pub fn LLVMGetParamTypes(FunctionTy: TypeRef, Dest: *mut TypeRef); |
| |
| /* Operations on struct types */ |
| pub fn LLVMStructTypeInContext(C: ContextRef, |
| ElementTypes: *const TypeRef, |
| ElementCount: c_uint, |
| Packed: Bool) |
| -> TypeRef; |
| pub fn LLVMCountStructElementTypes(StructTy: TypeRef) -> c_uint; |
| pub fn LLVMGetStructElementTypes(StructTy: TypeRef, |
| Dest: *mut TypeRef); |
| pub fn LLVMIsPackedStruct(StructTy: TypeRef) -> Bool; |
| |
| /* Operations on array, pointer, and vector types (sequence types) */ |
| pub fn LLVMRustArrayType(ElementType: TypeRef, ElementCount: u64) -> TypeRef; |
| pub fn LLVMPointerType(ElementType: TypeRef, AddressSpace: c_uint) |
| -> TypeRef; |
| pub fn LLVMVectorType(ElementType: TypeRef, ElementCount: c_uint) |
| -> TypeRef; |
| |
| pub fn LLVMGetElementType(Ty: TypeRef) -> TypeRef; |
| pub fn LLVMGetArrayLength(ArrayTy: TypeRef) -> c_uint; |
| pub fn LLVMGetPointerAddressSpace(PointerTy: TypeRef) -> c_uint; |
| pub fn LLVMGetPointerToGlobal(EE: ExecutionEngineRef, V: ValueRef) |
| -> *const c_void; |
| pub fn LLVMGetVectorSize(VectorTy: TypeRef) -> c_uint; |
| |
| /* Operations on other types */ |
| pub fn LLVMVoidTypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMLabelTypeInContext(C: ContextRef) -> TypeRef; |
| pub fn LLVMRustMetadataTypeInContext(C: ContextRef) -> TypeRef; |
| |
| /* Operations on all values */ |
| pub fn LLVMTypeOf(Val: ValueRef) -> TypeRef; |
| pub fn LLVMGetValueName(Val: ValueRef) -> *const c_char; |
| pub fn LLVMSetValueName(Val: ValueRef, Name: *const c_char); |
| pub fn LLVMDumpValue(Val: ValueRef); |
| pub fn LLVMReplaceAllUsesWith(OldVal: ValueRef, NewVal: ValueRef); |
| pub fn LLVMSetMetadata(Val: ValueRef, KindID: c_uint, Node: ValueRef); |
| |
| /* Operations on Uses */ |
| pub fn LLVMGetFirstUse(Val: ValueRef) -> UseRef; |
| pub fn LLVMGetNextUse(U: UseRef) -> UseRef; |
| pub fn LLVMGetUser(U: UseRef) -> ValueRef; |
| pub fn LLVMGetUsedValue(U: UseRef) -> ValueRef; |
| |
| /* Operations on Users */ |
| pub fn LLVMGetNumOperands(Val: ValueRef) -> c_int; |
| pub fn LLVMGetOperand(Val: ValueRef, Index: c_uint) -> ValueRef; |
| pub fn LLVMSetOperand(Val: ValueRef, Index: c_uint, Op: ValueRef); |
| |
| /* Operations on constants of any type */ |
| pub fn LLVMConstNull(Ty: TypeRef) -> ValueRef; |
| /* all zeroes */ |
| pub fn LLVMConstAllOnes(Ty: TypeRef) -> ValueRef; |
| pub fn LLVMConstICmp(Pred: IntPredicate, V1: ValueRef, V2: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstFCmp(Pred: RealPredicate, V1: ValueRef, V2: ValueRef) |
| -> ValueRef; |
| /* only for isize/vector */ |
| pub fn LLVMGetUndef(Ty: TypeRef) -> ValueRef; |
| pub fn LLVMIsConstant(Val: ValueRef) -> Bool; |
| pub fn LLVMIsNull(Val: ValueRef) -> Bool; |
| pub fn LLVMIsUndef(Val: ValueRef) -> Bool; |
| pub fn LLVMConstPointerNull(Ty: TypeRef) -> ValueRef; |
| |
| /* Operations on metadata */ |
| pub fn LLVMMDStringInContext(C: ContextRef, |
| Str: *const c_char, |
| SLen: c_uint) |
| -> ValueRef; |
| pub fn LLVMMDNodeInContext(C: ContextRef, |
| Vals: *const ValueRef, |
| Count: c_uint) |
| -> ValueRef; |
| pub fn LLVMAddNamedMetadataOperand(M: ModuleRef, |
| Str: *const c_char, |
| Val: ValueRef); |
| |
| /* Operations on scalar constants */ |
| pub fn LLVMConstInt(IntTy: TypeRef, N: c_ulonglong, SignExtend: Bool) |
| -> ValueRef; |
| pub fn LLVMConstIntOfString(IntTy: TypeRef, Text: *const c_char, Radix: u8) |
| -> ValueRef; |
| pub fn LLVMConstIntOfStringAndSize(IntTy: TypeRef, |
| Text: *const c_char, |
| SLen: c_uint, |
| Radix: u8) |
| -> ValueRef; |
| pub fn LLVMConstReal(RealTy: TypeRef, N: f64) -> ValueRef; |
| pub fn LLVMConstRealOfString(RealTy: TypeRef, Text: *const c_char) |
| -> ValueRef; |
| pub fn LLVMConstRealOfStringAndSize(RealTy: TypeRef, |
| Text: *const c_char, |
| SLen: c_uint) |
| -> ValueRef; |
| pub fn LLVMConstIntGetZExtValue(ConstantVal: ValueRef) -> c_ulonglong; |
| pub fn LLVMConstIntGetSExtValue(ConstantVal: ValueRef) -> c_longlong; |
| |
| |
| /* Operations on composite constants */ |
| pub fn LLVMConstStringInContext(C: ContextRef, |
| Str: *const c_char, |
| Length: c_uint, |
| DontNullTerminate: Bool) |
| -> ValueRef; |
| pub fn LLVMConstStructInContext(C: ContextRef, |
| ConstantVals: *const ValueRef, |
| Count: c_uint, |
| Packed: Bool) |
| -> ValueRef; |
| |
| pub fn LLVMConstArray(ElementTy: TypeRef, |
| ConstantVals: *const ValueRef, |
| Length: c_uint) |
| -> ValueRef; |
| pub fn LLVMConstVector(ScalarConstantVals: *const ValueRef, Size: c_uint) |
| -> ValueRef; |
| |
| /* Constant expressions */ |
| pub fn LLVMAlignOf(Ty: TypeRef) -> ValueRef; |
| pub fn LLVMSizeOf(Ty: TypeRef) -> ValueRef; |
| pub fn LLVMConstNeg(ConstantVal: ValueRef) -> ValueRef; |
| pub fn LLVMConstNSWNeg(ConstantVal: ValueRef) -> ValueRef; |
| pub fn LLVMConstNUWNeg(ConstantVal: ValueRef) -> ValueRef; |
| pub fn LLVMConstFNeg(ConstantVal: ValueRef) -> ValueRef; |
| pub fn LLVMConstNot(ConstantVal: ValueRef) -> ValueRef; |
| pub fn LLVMConstAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstNSWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstNUWAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstFAdd(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstSub(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstNSWSub(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstNUWSub(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstFSub(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstMul(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstNSWMul(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstNUWMul(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstFMul(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstUDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstSDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstExactSDiv(LHSConstant: ValueRef, |
| RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstFDiv(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstURem(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstSRem(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstFRem(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstAnd(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstOr(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstXor(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstShl(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstLShr(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstAShr(LHSConstant: ValueRef, RHSConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstGEP(ConstantVal: ValueRef, |
| ConstantIndices: *const ValueRef, |
| NumIndices: c_uint) |
| -> ValueRef; |
| pub fn LLVMConstInBoundsGEP(ConstantVal: ValueRef, |
| ConstantIndices: *const ValueRef, |
| NumIndices: c_uint) |
| -> ValueRef; |
| pub fn LLVMConstTrunc(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstSExt(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstZExt(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstFPTrunc(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstFPExt(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstUIToFP(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstSIToFP(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstFPToUI(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstFPToSI(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstPtrToInt(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstIntToPtr(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstBitCast(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstZExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstSExtOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstTruncOrBitCast(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstPointerCast(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstIntCast(ConstantVal: ValueRef, |
| ToType: TypeRef, |
| isSigned: Bool) |
| -> ValueRef; |
| pub fn LLVMConstFPCast(ConstantVal: ValueRef, ToType: TypeRef) |
| -> ValueRef; |
| pub fn LLVMConstSelect(ConstantCondition: ValueRef, |
| ConstantIfTrue: ValueRef, |
| ConstantIfFalse: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstExtractElement(VectorConstant: ValueRef, |
| IndexConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstInsertElement(VectorConstant: ValueRef, |
| ElementValueConstant: ValueRef, |
| IndexConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstShuffleVector(VectorAConstant: ValueRef, |
| VectorBConstant: ValueRef, |
| MaskConstant: ValueRef) |
| -> ValueRef; |
| pub fn LLVMConstExtractValue(AggConstant: ValueRef, |
| IdxList: *const c_uint, |
| NumIdx: c_uint) |
| -> ValueRef; |
| pub fn LLVMConstInsertValue(AggConstant: ValueRef, |
| ElementValueConstant: ValueRef, |
| IdxList: *const c_uint, |
| NumIdx: c_uint) |
| -> ValueRef; |
| pub fn LLVMConstInlineAsm(Ty: TypeRef, |
| AsmString: *const c_char, |
| Constraints: *const c_char, |
| HasSideEffects: Bool, |
| IsAlignStack: Bool) |
| -> ValueRef; |
| pub fn LLVMBlockAddress(F: ValueRef, BB: BasicBlockRef) -> ValueRef; |
| |
| |
| |
| /* Operations on global variables, functions, and aliases (globals) */ |
| pub fn LLVMGetGlobalParent(Global: ValueRef) -> ModuleRef; |
| pub fn LLVMIsDeclaration(Global: ValueRef) -> Bool; |
| pub fn LLVMGetLinkage(Global: ValueRef) -> c_uint; |
| pub fn LLVMSetLinkage(Global: ValueRef, Link: Linkage); |
| pub fn LLVMGetSection(Global: ValueRef) -> *const c_char; |
| pub fn LLVMSetSection(Global: ValueRef, Section: *const c_char); |
| pub fn LLVMGetVisibility(Global: ValueRef) -> c_uint; |
| pub fn LLVMSetVisibility(Global: ValueRef, Viz: c_uint); |
| pub fn LLVMGetAlignment(Global: ValueRef) -> c_uint; |
| pub fn LLVMSetAlignment(Global: ValueRef, Bytes: c_uint); |
| pub fn LLVMSetDLLStorageClass(V: ValueRef, |
| C: DLLStorageClass); |
| |
| |
| /* Operations on global variables */ |
| pub fn LLVMIsAGlobalVariable(GlobalVar: ValueRef) -> ValueRef; |
| pub fn LLVMAddGlobal(M: ModuleRef, Ty: TypeRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMAddGlobalInAddressSpace(M: ModuleRef, |
| Ty: TypeRef, |
| Name: *const c_char, |
| AddressSpace: c_uint) |
| -> ValueRef; |
| pub fn LLVMGetNamedGlobal(M: ModuleRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMRustGetOrInsertGlobal(M: ModuleRef, |
| Name: *const c_char, |
| T: TypeRef) |
| -> ValueRef; |
| pub fn LLVMGetFirstGlobal(M: ModuleRef) -> ValueRef; |
| pub fn LLVMGetLastGlobal(M: ModuleRef) -> ValueRef; |
| pub fn LLVMGetNextGlobal(GlobalVar: ValueRef) -> ValueRef; |
| pub fn LLVMGetPreviousGlobal(GlobalVar: ValueRef) -> ValueRef; |
| pub fn LLVMDeleteGlobal(GlobalVar: ValueRef); |
| pub fn LLVMGetInitializer(GlobalVar: ValueRef) -> ValueRef; |
| pub fn LLVMSetInitializer(GlobalVar: ValueRef, |
| ConstantVal: ValueRef); |
| pub fn LLVMIsThreadLocal(GlobalVar: ValueRef) -> Bool; |
| pub fn LLVMSetThreadLocal(GlobalVar: ValueRef, IsThreadLocal: Bool); |
| pub fn LLVMIsGlobalConstant(GlobalVar: ValueRef) -> Bool; |
| pub fn LLVMSetGlobalConstant(GlobalVar: ValueRef, IsConstant: Bool); |
| pub fn LLVMRustGetNamedValue(M: ModuleRef, Name: *const c_char) -> ValueRef; |
| |
| /* Operations on aliases */ |
| pub fn LLVMAddAlias(M: ModuleRef, |
| Ty: TypeRef, |
| Aliasee: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| |
| /* Operations on functions */ |
| pub fn LLVMAddFunction(M: ModuleRef, |
| Name: *const c_char, |
| FunctionTy: TypeRef) |
| -> ValueRef; |
| pub fn LLVMGetNamedFunction(M: ModuleRef, Name: *const c_char) -> ValueRef; |
| pub fn LLVMGetFirstFunction(M: ModuleRef) -> ValueRef; |
| pub fn LLVMGetLastFunction(M: ModuleRef) -> ValueRef; |
| pub fn LLVMGetNextFunction(Fn: ValueRef) -> ValueRef; |
| pub fn LLVMGetPreviousFunction(Fn: ValueRef) -> ValueRef; |
| pub fn LLVMDeleteFunction(Fn: ValueRef); |
| pub fn LLVMRustGetOrInsertFunction(M: ModuleRef, |
| Name: *const c_char, |
| FunctionTy: TypeRef) |
| -> ValueRef; |
| pub fn LLVMGetIntrinsicID(Fn: ValueRef) -> c_uint; |
| pub fn LLVMGetFunctionCallConv(Fn: ValueRef) -> c_uint; |
| pub fn LLVMSetFunctionCallConv(Fn: ValueRef, CC: c_uint); |
| pub fn LLVMGetGC(Fn: ValueRef) -> *const c_char; |
| pub fn LLVMSetGC(Fn: ValueRef, Name: *const c_char); |
| pub fn LLVMRustAddDereferenceableAttr(Fn: ValueRef, index: c_uint, bytes: u64); |
| pub fn LLVMRustAddFunctionAttribute(Fn: ValueRef, index: c_uint, PA: u64); |
| pub fn LLVMRustAddFunctionAttrString(Fn: ValueRef, index: c_uint, Name: *const c_char); |
| pub fn LLVMRustAddFunctionAttrStringValue(Fn: ValueRef, index: c_uint, |
| Name: *const c_char, |
| Value: *const c_char); |
| pub fn LLVMRustRemoveFunctionAttributes(Fn: ValueRef, |
| index: c_uint, |
| attr: u64); |
| pub fn LLVMRustRemoveFunctionAttrString(Fn: ValueRef, |
| index: c_uint, |
| Name: *const c_char); |
| pub fn LLVMGetFunctionAttr(Fn: ValueRef) -> c_uint; |
| pub fn LLVMRemoveFunctionAttr(Fn: ValueRef, val: c_uint); |
| |
| /* Operations on parameters */ |
| pub fn LLVMCountParams(Fn: ValueRef) -> c_uint; |
| pub fn LLVMGetParams(Fn: ValueRef, Params: *const ValueRef); |
| pub fn LLVMGetParam(Fn: ValueRef, Index: c_uint) -> ValueRef; |
| pub fn LLVMGetParamParent(Inst: ValueRef) -> ValueRef; |
| pub fn LLVMGetFirstParam(Fn: ValueRef) -> ValueRef; |
| pub fn LLVMGetLastParam(Fn: ValueRef) -> ValueRef; |
| pub fn LLVMGetNextParam(Arg: ValueRef) -> ValueRef; |
| pub fn LLVMGetPreviousParam(Arg: ValueRef) -> ValueRef; |
| pub fn LLVMAddAttribute(Arg: ValueRef, PA: c_uint); |
| pub fn LLVMRemoveAttribute(Arg: ValueRef, PA: c_uint); |
| pub fn LLVMGetAttribute(Arg: ValueRef) -> c_uint; |
| pub fn LLVMSetParamAlignment(Arg: ValueRef, align: c_uint); |
| |
| /* Operations on basic blocks */ |
| pub fn LLVMBasicBlockAsValue(BB: BasicBlockRef) -> ValueRef; |
| pub fn LLVMValueIsBasicBlock(Val: ValueRef) -> Bool; |
| pub fn LLVMValueAsBasicBlock(Val: ValueRef) -> BasicBlockRef; |
| pub fn LLVMGetBasicBlockParent(BB: BasicBlockRef) -> ValueRef; |
| pub fn LLVMCountBasicBlocks(Fn: ValueRef) -> c_uint; |
| pub fn LLVMGetBasicBlocks(Fn: ValueRef, BasicBlocks: *const ValueRef); |
| pub fn LLVMGetFirstBasicBlock(Fn: ValueRef) -> BasicBlockRef; |
| pub fn LLVMGetLastBasicBlock(Fn: ValueRef) -> BasicBlockRef; |
| pub fn LLVMGetNextBasicBlock(BB: BasicBlockRef) -> BasicBlockRef; |
| pub fn LLVMGetPreviousBasicBlock(BB: BasicBlockRef) -> BasicBlockRef; |
| pub fn LLVMGetEntryBasicBlock(Fn: ValueRef) -> BasicBlockRef; |
| |
| pub fn LLVMAppendBasicBlockInContext(C: ContextRef, |
| Fn: ValueRef, |
| Name: *const c_char) |
| -> BasicBlockRef; |
| pub fn LLVMInsertBasicBlockInContext(C: ContextRef, |
| BB: BasicBlockRef, |
| Name: *const c_char) |
| -> BasicBlockRef; |
| pub fn LLVMDeleteBasicBlock(BB: BasicBlockRef); |
| |
| pub fn LLVMMoveBasicBlockAfter(BB: BasicBlockRef, |
| MoveAfter: BasicBlockRef); |
| |
| pub fn LLVMMoveBasicBlockBefore(BB: BasicBlockRef, |
| MoveBefore: BasicBlockRef); |
| |
| /* Operations on instructions */ |
| pub fn LLVMGetInstructionParent(Inst: ValueRef) -> BasicBlockRef; |
| pub fn LLVMGetFirstInstruction(BB: BasicBlockRef) -> ValueRef; |
| pub fn LLVMGetLastInstruction(BB: BasicBlockRef) -> ValueRef; |
| pub fn LLVMGetNextInstruction(Inst: ValueRef) -> ValueRef; |
| pub fn LLVMGetPreviousInstruction(Inst: ValueRef) -> ValueRef; |
| pub fn LLVMInstructionEraseFromParent(Inst: ValueRef); |
| |
| /* Operations on call sites */ |
| pub fn LLVMSetInstructionCallConv(Instr: ValueRef, CC: c_uint); |
| pub fn LLVMGetInstructionCallConv(Instr: ValueRef) -> c_uint; |
| pub fn LLVMAddInstrAttribute(Instr: ValueRef, |
| index: c_uint, |
| IA: c_uint); |
| pub fn LLVMRemoveInstrAttribute(Instr: ValueRef, |
| index: c_uint, |
| IA: c_uint); |
| pub fn LLVMSetInstrParamAlignment(Instr: ValueRef, |
| index: c_uint, |
| align: c_uint); |
| pub fn LLVMRustAddCallSiteAttribute(Instr: ValueRef, |
| index: c_uint, |
| Val: u64); |
| pub fn LLVMRustAddDereferenceableCallSiteAttr(Instr: ValueRef, |
| index: c_uint, |
| bytes: u64); |
| |
| /* Operations on call instructions (only) */ |
| pub fn LLVMIsTailCall(CallInst: ValueRef) -> Bool; |
| pub fn LLVMSetTailCall(CallInst: ValueRef, IsTailCall: Bool); |
| |
| /* Operations on load/store instructions (only) */ |
| pub fn LLVMGetVolatile(MemoryAccessInst: ValueRef) -> Bool; |
| pub fn LLVMSetVolatile(MemoryAccessInst: ValueRef, volatile: Bool); |
| |
| /* Operations on phi nodes */ |
| pub fn LLVMAddIncoming(PhiNode: ValueRef, |
| IncomingValues: *const ValueRef, |
| IncomingBlocks: *const BasicBlockRef, |
| Count: c_uint); |
| pub fn LLVMCountIncoming(PhiNode: ValueRef) -> c_uint; |
| pub fn LLVMGetIncomingValue(PhiNode: ValueRef, Index: c_uint) |
| -> ValueRef; |
| pub fn LLVMGetIncomingBlock(PhiNode: ValueRef, Index: c_uint) |
| -> BasicBlockRef; |
| |
| /* Instruction builders */ |
| pub fn LLVMCreateBuilderInContext(C: ContextRef) -> BuilderRef; |
| pub fn LLVMPositionBuilder(Builder: BuilderRef, |
| Block: BasicBlockRef, |
| Instr: ValueRef); |
| pub fn LLVMPositionBuilderBefore(Builder: BuilderRef, |
| Instr: ValueRef); |
| pub fn LLVMPositionBuilderAtEnd(Builder: BuilderRef, |
| Block: BasicBlockRef); |
| pub fn LLVMGetInsertBlock(Builder: BuilderRef) -> BasicBlockRef; |
| pub fn LLVMClearInsertionPosition(Builder: BuilderRef); |
| pub fn LLVMInsertIntoBuilder(Builder: BuilderRef, Instr: ValueRef); |
| pub fn LLVMInsertIntoBuilderWithName(Builder: BuilderRef, |
| Instr: ValueRef, |
| Name: *const c_char); |
| pub fn LLVMDisposeBuilder(Builder: BuilderRef); |
| |
| /* Metadata */ |
| pub fn LLVMSetCurrentDebugLocation(Builder: BuilderRef, L: ValueRef); |
| pub fn LLVMGetCurrentDebugLocation(Builder: BuilderRef) -> ValueRef; |
| pub fn LLVMSetInstDebugLocation(Builder: BuilderRef, Inst: ValueRef); |
| |
| /* Terminators */ |
| pub fn LLVMBuildRetVoid(B: BuilderRef) -> ValueRef; |
| pub fn LLVMBuildRet(B: BuilderRef, V: ValueRef) -> ValueRef; |
| pub fn LLVMBuildAggregateRet(B: BuilderRef, |
| RetVals: *const ValueRef, |
| N: c_uint) |
| -> ValueRef; |
| pub fn LLVMBuildBr(B: BuilderRef, Dest: BasicBlockRef) -> ValueRef; |
| pub fn LLVMBuildCondBr(B: BuilderRef, |
| If: ValueRef, |
| Then: BasicBlockRef, |
| Else: BasicBlockRef) |
| -> ValueRef; |
| pub fn LLVMBuildSwitch(B: BuilderRef, |
| V: ValueRef, |
| Else: BasicBlockRef, |
| NumCases: c_uint) |
| -> ValueRef; |
| pub fn LLVMBuildIndirectBr(B: BuilderRef, |
| Addr: ValueRef, |
| NumDests: c_uint) |
| -> ValueRef; |
| pub fn LLVMRustBuildInvoke(B: BuilderRef, |
| Fn: ValueRef, |
| Args: *const ValueRef, |
| NumArgs: c_uint, |
| Then: BasicBlockRef, |
| Catch: BasicBlockRef, |
| Bundle: OperandBundleDefRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMRustBuildLandingPad(B: BuilderRef, |
| Ty: TypeRef, |
| PersFn: ValueRef, |
| NumClauses: c_uint, |
| Name: *const c_char, |
| F: ValueRef) |
| -> ValueRef; |
| pub fn LLVMBuildResume(B: BuilderRef, Exn: ValueRef) -> ValueRef; |
| pub fn LLVMBuildUnreachable(B: BuilderRef) -> ValueRef; |
| |
| pub fn LLVMRustBuildCleanupPad(B: BuilderRef, |
| ParentPad: ValueRef, |
| ArgCnt: c_uint, |
| Args: *const ValueRef, |
| Name: *const c_char) -> ValueRef; |
| pub fn LLVMRustBuildCleanupRet(B: BuilderRef, |
| CleanupPad: ValueRef, |
| UnwindBB: BasicBlockRef) -> ValueRef; |
| pub fn LLVMRustBuildCatchPad(B: BuilderRef, |
| ParentPad: ValueRef, |
| ArgCnt: c_uint, |
| Args: *const ValueRef, |
| Name: *const c_char) -> ValueRef; |
| pub fn LLVMRustBuildCatchRet(B: BuilderRef, |
| Pad: ValueRef, |
| BB: BasicBlockRef) -> ValueRef; |
| pub fn LLVMRustBuildCatchSwitch(Builder: BuilderRef, |
| ParentPad: ValueRef, |
| BB: BasicBlockRef, |
| NumHandlers: c_uint, |
| Name: *const c_char) -> ValueRef; |
| pub fn LLVMRustAddHandler(CatchSwitch: ValueRef, |
| Handler: BasicBlockRef); |
| pub fn LLVMRustSetPersonalityFn(B: BuilderRef, Pers: ValueRef); |
| |
| /* Add a case to the switch instruction */ |
| pub fn LLVMAddCase(Switch: ValueRef, |
| OnVal: ValueRef, |
| Dest: BasicBlockRef); |
| |
| /* Add a destination to the indirectbr instruction */ |
| pub fn LLVMAddDestination(IndirectBr: ValueRef, Dest: BasicBlockRef); |
| |
| /* Add a clause to the landing pad instruction */ |
| pub fn LLVMAddClause(LandingPad: ValueRef, ClauseVal: ValueRef); |
| |
| /* Set the cleanup on a landing pad instruction */ |
| pub fn LLVMSetCleanup(LandingPad: ValueRef, Val: Bool); |
| |
| /* Arithmetic */ |
| pub fn LLVMBuildAdd(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNSWAdd(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNUWAdd(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFAdd(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildSub(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNSWSub(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNUWSub(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFSub(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildMul(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNSWMul(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNUWMul(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFMul(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildUDiv(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildSDiv(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildExactSDiv(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFDiv(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildURem(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildSRem(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFRem(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildShl(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildLShr(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildAShr(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildAnd(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildOr(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildXor(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildBinOp(B: BuilderRef, |
| Op: Opcode, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNSWNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNUWNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFNeg(B: BuilderRef, V: ValueRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildNot(B: BuilderRef, V: ValueRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMRustSetHasUnsafeAlgebra(Instr: ValueRef); |
| |
| /* Memory */ |
| pub fn LLVMBuildAlloca(B: BuilderRef, Ty: TypeRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFree(B: BuilderRef, PointerVal: ValueRef) -> ValueRef; |
| pub fn LLVMBuildLoad(B: BuilderRef, |
| PointerVal: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| |
| pub fn LLVMBuildStore(B: BuilderRef, Val: ValueRef, Ptr: ValueRef) |
| -> ValueRef; |
| |
| pub fn LLVMBuildGEP(B: BuilderRef, |
| Pointer: ValueRef, |
| Indices: *const ValueRef, |
| NumIndices: c_uint, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildInBoundsGEP(B: BuilderRef, |
| Pointer: ValueRef, |
| Indices: *const ValueRef, |
| NumIndices: c_uint, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildStructGEP(B: BuilderRef, |
| Pointer: ValueRef, |
| Idx: c_uint, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildGlobalString(B: BuilderRef, |
| Str: *const c_char, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildGlobalStringPtr(B: BuilderRef, |
| Str: *const c_char, |
| Name: *const c_char) |
| -> ValueRef; |
| |
| /* Casts */ |
| pub fn LLVMBuildTrunc(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildZExt(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildSExt(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFPToUI(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFPToSI(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildUIToFP(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildSIToFP(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFPTrunc(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFPExt(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildPtrToInt(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildIntToPtr(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildBitCast(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildZExtOrBitCast(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildSExtOrBitCast(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildTruncOrBitCast(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildCast(B: BuilderRef, |
| Op: Opcode, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) -> ValueRef; |
| pub fn LLVMBuildPointerCast(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildIntCast(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFPCast(B: BuilderRef, |
| Val: ValueRef, |
| DestTy: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| |
| /* Comparisons */ |
| pub fn LLVMBuildICmp(B: BuilderRef, |
| Op: c_uint, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildFCmp(B: BuilderRef, |
| Op: c_uint, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| |
| /* Miscellaneous instructions */ |
| pub fn LLVMBuildPhi(B: BuilderRef, Ty: TypeRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMRustBuildCall(B: BuilderRef, |
| Fn: ValueRef, |
| Args: *const ValueRef, |
| NumArgs: c_uint, |
| Bundle: OperandBundleDefRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildSelect(B: BuilderRef, |
| If: ValueRef, |
| Then: ValueRef, |
| Else: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildVAArg(B: BuilderRef, |
| list: ValueRef, |
| Ty: TypeRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildExtractElement(B: BuilderRef, |
| VecVal: ValueRef, |
| Index: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildInsertElement(B: BuilderRef, |
| VecVal: ValueRef, |
| EltVal: ValueRef, |
| Index: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildShuffleVector(B: BuilderRef, |
| V1: ValueRef, |
| V2: ValueRef, |
| Mask: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildExtractValue(B: BuilderRef, |
| AggVal: ValueRef, |
| Index: c_uint, |
| Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildInsertValue(B: BuilderRef, |
| AggVal: ValueRef, |
| EltVal: ValueRef, |
| Index: c_uint, |
| Name: *const c_char) |
| -> ValueRef; |
| |
| pub fn LLVMBuildIsNull(B: BuilderRef, Val: ValueRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildIsNotNull(B: BuilderRef, Val: ValueRef, Name: *const c_char) |
| -> ValueRef; |
| pub fn LLVMBuildPtrDiff(B: BuilderRef, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Name: *const c_char) |
| -> ValueRef; |
| |
| /* Atomic Operations */ |
| pub fn LLVMRustBuildAtomicLoad(B: BuilderRef, |
| PointerVal: ValueRef, |
| Name: *const c_char, |
| Order: AtomicOrdering, |
| Alignment: c_uint) |
| -> ValueRef; |
| |
| pub fn LLVMRustBuildAtomicStore(B: BuilderRef, |
| Val: ValueRef, |
| Ptr: ValueRef, |
| Order: AtomicOrdering, |
| Alignment: c_uint) |
| -> ValueRef; |
| |
| pub fn LLVMRustBuildAtomicCmpXchg(B: BuilderRef, |
| LHS: ValueRef, |
| CMP: ValueRef, |
| RHS: ValueRef, |
| Order: AtomicOrdering, |
| FailureOrder: AtomicOrdering, |
| Weak: Bool) |
| -> ValueRef; |
| |
| pub fn LLVMBuildAtomicRMW(B: BuilderRef, |
| Op: AtomicRmwBinOp, |
| LHS: ValueRef, |
| RHS: ValueRef, |
| Order: AtomicOrdering, |
| SingleThreaded: Bool) |
| -> ValueRef; |
| |
| pub fn LLVMRustBuildAtomicFence(B: BuilderRef, |
| Order: AtomicOrdering, |
| Scope: SynchronizationScope); |
| |
| |
| /* Selected entries from the downcasts. */ |
| pub fn LLVMIsATerminatorInst(Inst: ValueRef) -> ValueRef; |
| pub fn LLVMIsAStoreInst(Inst: ValueRef) -> ValueRef; |
| |
| /// Writes a module to the specified path. Returns 0 on success. |
| pub fn LLVMWriteBitcodeToFile(M: ModuleRef, Path: *const c_char) -> c_int; |
| |
| /// Creates target data from a target layout string. |
| pub fn LLVMCreateTargetData(StringRep: *const c_char) -> TargetDataRef; |
| /// Number of bytes clobbered when doing a Store to *T. |
| pub fn LLVMStoreSizeOfType(TD: TargetDataRef, Ty: TypeRef) |
| -> c_ulonglong; |
| |
| /// Number of bytes clobbered when doing a Store to *T. |
| pub fn LLVMSizeOfTypeInBits(TD: TargetDataRef, Ty: TypeRef) |
| -> c_ulonglong; |
| |
| /// Distance between successive elements in an array of T. Includes ABI padding. |
| pub fn LLVMABISizeOfType(TD: TargetDataRef, Ty: TypeRef) -> c_ulonglong; |
| |
| /// Returns the preferred alignment of a type. |
| pub fn LLVMPreferredAlignmentOfType(TD: TargetDataRef, Ty: TypeRef) |
| -> c_uint; |
| /// Returns the minimum alignment of a type. |
| pub fn LLVMABIAlignmentOfType(TD: TargetDataRef, Ty: TypeRef) |
| -> c_uint; |
| |
| /// Computes the byte offset of the indexed struct element for a |
| /// target. |
| pub fn LLVMOffsetOfElement(TD: TargetDataRef, |
| StructTy: TypeRef, |
| Element: c_uint) |
| -> c_ulonglong; |
| |
| /// Returns the minimum alignment of a type when part of a call frame. |
| pub fn LLVMCallFrameAlignmentOfType(TD: TargetDataRef, Ty: TypeRef) |
| -> c_uint; |
| |
| /// Disposes target data. |
| pub fn LLVMDisposeTargetData(TD: TargetDataRef); |
| |
| /// Creates a pass manager. |
| pub fn LLVMCreatePassManager() -> PassManagerRef; |
| |
| /// Creates a function-by-function pass manager |
| pub fn LLVMCreateFunctionPassManagerForModule(M: ModuleRef) |
| -> PassManagerRef; |
| |
| /// Disposes a pass manager. |
| pub fn LLVMDisposePassManager(PM: PassManagerRef); |
| |
| /// Runs a pass manager on a module. |
| pub fn LLVMRunPassManager(PM: PassManagerRef, M: ModuleRef) -> Bool; |
| |
| /// Runs the function passes on the provided function. |
| pub fn LLVMRunFunctionPassManager(FPM: PassManagerRef, F: ValueRef) |
| -> Bool; |
| |
| /// Initializes all the function passes scheduled in the manager |
| pub fn LLVMInitializeFunctionPassManager(FPM: PassManagerRef) -> Bool; |
| |
| /// Finalizes all the function passes scheduled in the manager |
| pub fn LLVMFinalizeFunctionPassManager(FPM: PassManagerRef) -> Bool; |
| |
| pub fn LLVMInitializePasses(); |
| |
| /// Adds a verification pass. |
| pub fn LLVMAddVerifierPass(PM: PassManagerRef); |
| |
| pub fn LLVMAddGlobalOptimizerPass(PM: PassManagerRef); |
| pub fn LLVMAddIPSCCPPass(PM: PassManagerRef); |
| pub fn LLVMAddDeadArgEliminationPass(PM: PassManagerRef); |
| pub fn LLVMAddInstructionCombiningPass(PM: PassManagerRef); |
| pub fn LLVMAddCFGSimplificationPass(PM: PassManagerRef); |
| pub fn LLVMAddFunctionInliningPass(PM: PassManagerRef); |
| pub fn LLVMAddFunctionAttrsPass(PM: PassManagerRef); |
| pub fn LLVMAddScalarReplAggregatesPass(PM: PassManagerRef); |
| pub fn LLVMAddScalarReplAggregatesPassSSA(PM: PassManagerRef); |
| pub fn LLVMAddJumpThreadingPass(PM: PassManagerRef); |
| pub fn LLVMAddConstantPropagationPass(PM: PassManagerRef); |
| pub fn LLVMAddReassociatePass(PM: PassManagerRef); |
| pub fn LLVMAddLoopRotatePass(PM: PassManagerRef); |
| pub fn LLVMAddLICMPass(PM: PassManagerRef); |
| pub fn LLVMAddLoopUnswitchPass(PM: PassManagerRef); |
| pub fn LLVMAddLoopDeletionPass(PM: PassManagerRef); |
| pub fn LLVMAddLoopUnrollPass(PM: PassManagerRef); |
| pub fn LLVMAddGVNPass(PM: PassManagerRef); |
| pub fn LLVMAddMemCpyOptPass(PM: PassManagerRef); |
| pub fn LLVMAddSCCPPass(PM: PassManagerRef); |
| pub fn LLVMAddDeadStoreEliminationPass(PM: PassManagerRef); |
| pub fn LLVMAddStripDeadPrototypesPass(PM: PassManagerRef); |
| pub fn LLVMAddConstantMergePass(PM: PassManagerRef); |
| pub fn LLVMAddArgumentPromotionPass(PM: PassManagerRef); |
| pub fn LLVMAddTailCallEliminationPass(PM: PassManagerRef); |
| pub fn LLVMAddIndVarSimplifyPass(PM: PassManagerRef); |
| pub fn LLVMAddAggressiveDCEPass(PM: PassManagerRef); |
| pub fn LLVMAddGlobalDCEPass(PM: PassManagerRef); |
| pub fn LLVMAddCorrelatedValuePropagationPass(PM: PassManagerRef); |
| pub fn LLVMAddPruneEHPass(PM: PassManagerRef); |
| pub fn LLVMAddSimplifyLibCallsPass(PM: PassManagerRef); |
| pub fn LLVMAddLoopIdiomPass(PM: PassManagerRef); |
| pub fn LLVMAddEarlyCSEPass(PM: PassManagerRef); |
| pub fn LLVMAddTypeBasedAliasAnalysisPass(PM: PassManagerRef); |
| pub fn LLVMAddBasicAliasAnalysisPass(PM: PassManagerRef); |
| |
| pub fn LLVMPassManagerBuilderCreate() -> PassManagerBuilderRef; |
| pub fn LLVMPassManagerBuilderDispose(PMB: PassManagerBuilderRef); |
| pub fn LLVMPassManagerBuilderSetOptLevel(PMB: PassManagerBuilderRef, |
| OptimizationLevel: c_uint); |
| pub fn LLVMPassManagerBuilderSetSizeLevel(PMB: PassManagerBuilderRef, |
| Value: Bool); |
| pub fn LLVMPassManagerBuilderSetDisableUnitAtATime( |
| PMB: PassManagerBuilderRef, |
| Value: Bool); |
| pub fn LLVMPassManagerBuilderSetDisableUnrollLoops( |
| PMB: PassManagerBuilderRef, |
| Value: Bool); |
| pub fn LLVMPassManagerBuilderSetDisableSimplifyLibCalls( |
| PMB: PassManagerBuilderRef, |
| Value: Bool); |
| pub fn LLVMPassManagerBuilderUseInlinerWithThreshold( |
| PMB: PassManagerBuilderRef, |
| threshold: c_uint); |
| pub fn LLVMPassManagerBuilderPopulateModulePassManager( |
| PMB: PassManagerBuilderRef, |
| PM: PassManagerRef); |
| |
| pub fn LLVMPassManagerBuilderPopulateFunctionPassManager( |
| PMB: PassManagerBuilderRef, |
| PM: PassManagerRef); |
| pub fn LLVMPassManagerBuilderPopulateLTOPassManager( |
| PMB: PassManagerBuilderRef, |
| PM: PassManagerRef, |
| Internalize: Bool, |
| RunInliner: Bool); |
| |
| /// Destroys a memory buffer. |
| pub fn LLVMDisposeMemoryBuffer(MemBuf: MemoryBufferRef); |
| |
| |
| /* Stuff that's in rustllvm/ because it's not upstream yet. */ |
| |
| /// Opens an object file. |
| pub fn LLVMCreateObjectFile(MemBuf: MemoryBufferRef) -> ObjectFileRef; |
| /// Closes an object file. |
| pub fn LLVMDisposeObjectFile(ObjFile: ObjectFileRef); |
| |
| /// Enumerates the sections in an object file. |
| pub fn LLVMGetSections(ObjFile: ObjectFileRef) -> SectionIteratorRef; |
| /// Destroys a section iterator. |
| pub fn LLVMDisposeSectionIterator(SI: SectionIteratorRef); |
| /// Returns true if the section iterator is at the end of the section |
| /// list: |
| pub fn LLVMIsSectionIteratorAtEnd(ObjFile: ObjectFileRef, |
| SI: SectionIteratorRef) |
| -> Bool; |
| /// Moves the section iterator to point to the next section. |
| pub fn LLVMMoveToNextSection(SI: SectionIteratorRef); |
| /// Returns the current section size. |
| pub fn LLVMGetSectionSize(SI: SectionIteratorRef) -> c_ulonglong; |
| /// Returns the current section contents as a string buffer. |
| pub fn LLVMGetSectionContents(SI: SectionIteratorRef) -> *const c_char; |
| |
| /// Reads the given file and returns it as a memory buffer. Use |
| /// LLVMDisposeMemoryBuffer() to get rid of it. |
| pub fn LLVMRustCreateMemoryBufferWithContentsOfFile(Path: *const c_char) |
| -> MemoryBufferRef; |
| /// Borrows the contents of the memory buffer (doesn't copy it) |
| pub fn LLVMCreateMemoryBufferWithMemoryRange(InputData: *const c_char, |
| InputDataLength: size_t, |
| BufferName: *const c_char, |
| RequiresNull: Bool) |
| -> MemoryBufferRef; |
| pub fn LLVMCreateMemoryBufferWithMemoryRangeCopy(InputData: *const c_char, |
| InputDataLength: size_t, |
| BufferName: *const c_char) |
| -> MemoryBufferRef; |
| |
| pub fn LLVMIsMultithreaded() -> Bool; |
| pub fn LLVMStartMultithreaded() -> Bool; |
| |
| /// Returns a string describing the last error caused by an LLVMRust* call. |
| pub fn LLVMRustGetLastError() -> *const c_char; |
| |
| /// Print the pass timings since static dtors aren't picking them up. |
| pub fn LLVMRustPrintPassTimings(); |
| |
| pub fn LLVMStructCreateNamed(C: ContextRef, Name: *const c_char) -> TypeRef; |
| |
| pub fn LLVMStructSetBody(StructTy: TypeRef, |
| ElementTypes: *const TypeRef, |
| ElementCount: c_uint, |
| Packed: Bool); |
| |
| pub fn LLVMConstNamedStruct(S: TypeRef, |
| ConstantVals: *const ValueRef, |
| Count: c_uint) |
| -> ValueRef; |
| |
| /// Enables LLVM debug output. |
| pub fn LLVMRustSetDebug(Enabled: c_int); |
| |
| /// Prepares inline assembly. |
| pub fn LLVMRustInlineAsm(Ty: TypeRef, |
| AsmString: *const c_char, |
| Constraints: *const c_char, |
| SideEffects: Bool, |
| AlignStack: Bool, |
| Dialect: AsmDialect) |
| -> ValueRef; |
| |
| pub fn LLVMRustDebugMetadataVersion() -> u32; |
| pub fn LLVMRustVersionMajor() -> u32; |
| pub fn LLVMRustVersionMinor() -> u32; |
| |
| pub fn LLVMRustAddModuleFlag(M: ModuleRef, |
| name: *const c_char, |
| value: u32); |
| |
| pub fn LLVMRustDIBuilderCreate(M: ModuleRef) -> DIBuilderRef; |
| |
| pub fn LLVMRustDIBuilderDispose(Builder: DIBuilderRef); |
| |
| pub fn LLVMRustDIBuilderFinalize(Builder: DIBuilderRef); |
| |
| pub fn LLVMRustDIBuilderCreateCompileUnit(Builder: DIBuilderRef, |
| Lang: c_uint, |
| File: *const c_char, |
| Dir: *const c_char, |
| Producer: *const c_char, |
| isOptimized: bool, |
| Flags: *const c_char, |
| RuntimeVer: c_uint, |
| SplitName: *const c_char) |
| -> DIDescriptor; |
| |
| pub fn LLVMRustDIBuilderCreateFile(Builder: DIBuilderRef, |
| Filename: *const c_char, |
| Directory: *const c_char) |
| -> DIFile; |
| |
| pub fn LLVMRustDIBuilderCreateSubroutineType(Builder: DIBuilderRef, |
| File: DIFile, |
| ParameterTypes: DIArray) |
| -> DICompositeType; |
| |
| pub fn LLVMRustDIBuilderCreateFunction(Builder: DIBuilderRef, |
| Scope: DIDescriptor, |
| Name: *const c_char, |
| LinkageName: *const c_char, |
| File: DIFile, |
| LineNo: c_uint, |
| Ty: DIType, |
| isLocalToUnit: bool, |
| isDefinition: bool, |
| ScopeLine: c_uint, |
| Flags: c_uint, |
| isOptimized: bool, |
| Fn: ValueRef, |
| TParam: DIArray, |
| Decl: DIDescriptor) |
| -> DISubprogram; |
| |
| pub fn LLVMRustDIBuilderCreateBasicType(Builder: DIBuilderRef, |
| Name: *const c_char, |
| SizeInBits: u64, |
| AlignInBits: u64, |
| Encoding: c_uint) |
| -> DIBasicType; |
| |
| pub fn LLVMRustDIBuilderCreatePointerType(Builder: DIBuilderRef, |
| PointeeTy: DIType, |
| SizeInBits: u64, |
| AlignInBits: u64, |
| Name: *const c_char) |
| -> DIDerivedType; |
| |
| pub fn LLVMRustDIBuilderCreateStructType(Builder: DIBuilderRef, |
| Scope: DIDescriptor, |
| Name: *const c_char, |
| File: DIFile, |
| LineNumber: c_uint, |
| SizeInBits: u64, |
| AlignInBits: u64, |
| Flags: c_uint, |
| DerivedFrom: DIType, |
| Elements: DIArray, |
| RunTimeLang: c_uint, |
| VTableHolder: DIType, |
| UniqueId: *const c_char) |
| -> DICompositeType; |
| |
| pub fn LLVMRustDIBuilderCreateMemberType(Builder: DIBuilderRef, |
| Scope: DIDescriptor, |
| Name: *const c_char, |
| File: DIFile, |
| LineNo: c_uint, |
| SizeInBits: u64, |
| AlignInBits: u64, |
| OffsetInBits: u64, |
| Flags: c_uint, |
| Ty: DIType) |
| -> DIDerivedType; |
| |
| pub fn LLVMRustDIBuilderCreateLexicalBlock(Builder: DIBuilderRef, |
| Scope: DIScope, |
| File: DIFile, |
| Line: c_uint, |
| Col: c_uint) |
| -> DILexicalBlock; |
| |
| pub fn LLVMRustDIBuilderCreateStaticVariable(Builder: DIBuilderRef, |
| Context: DIScope, |
| Name: *const c_char, |
| LinkageName: *const c_char, |
| File: DIFile, |
| LineNo: c_uint, |
| Ty: DIType, |
| isLocalToUnit: bool, |
| Val: ValueRef, |
| Decl: DIDescriptor) |
| -> DIGlobalVariable; |
| |
| pub fn LLVMRustDIBuilderCreateVariable(Builder: DIBuilderRef, |
| Tag: c_uint, |
| Scope: DIDescriptor, |
| Name: *const c_char, |
| File: DIFile, |
| LineNo: c_uint, |
| Ty: DIType, |
| AlwaysPreserve: bool, |
| Flags: c_uint, |
| AddrOps: *const i64, |
| AddrOpsCount: c_uint, |
| ArgNo: c_uint) |
| -> DIVariable; |
| |
| pub fn LLVMRustDIBuilderCreateArrayType(Builder: DIBuilderRef, |
| Size: u64, |
| AlignInBits: u64, |
| Ty: DIType, |
| Subscripts: DIArray) |
| -> DIType; |
| |
| pub fn LLVMRustDIBuilderCreateVectorType(Builder: DIBuilderRef, |
| Size: u64, |
| AlignInBits: u64, |
| Ty: DIType, |
| Subscripts: DIArray) |
| -> DIType; |
| |
| pub fn LLVMRustDIBuilderGetOrCreateSubrange(Builder: DIBuilderRef, |
| Lo: i64, |
| Count: i64) |
| -> DISubrange; |
| |
| pub fn LLVMRustDIBuilderGetOrCreateArray(Builder: DIBuilderRef, |
| Ptr: *const DIDescriptor, |
| Count: c_uint) |
| -> DIArray; |
| |
| pub fn LLVMRustDIBuilderInsertDeclareAtEnd(Builder: DIBuilderRef, |
| Val: ValueRef, |
| VarInfo: DIVariable, |
| AddrOps: *const i64, |
| AddrOpsCount: c_uint, |
| DL: ValueRef, |
| InsertAtEnd: BasicBlockRef) |
| -> ValueRef; |
| |
| pub fn LLVMRustDIBuilderInsertDeclareBefore(Builder: DIBuilderRef, |
| Val: ValueRef, |
| VarInfo: DIVariable, |
| AddrOps: *const i64, |
| AddrOpsCount: c_uint, |
| DL: ValueRef, |
| InsertBefore: ValueRef) |
| -> ValueRef; |
| |
| pub fn LLVMRustDIBuilderCreateEnumerator(Builder: DIBuilderRef, |
| Name: *const c_char, |
| Val: u64) |
| -> DIEnumerator; |
| |
| pub fn LLVMRustDIBuilderCreateEnumerationType(Builder: DIBuilderRef, |
| Scope: DIScope, |
| Name: *const c_char, |
| File: DIFile, |
| LineNumber: c_uint, |
| SizeInBits: u64, |
| AlignInBits: u64, |
| Elements: DIArray, |
| ClassType: DIType) |
| -> DIType; |
| |
| pub fn LLVMRustDIBuilderCreateUnionType(Builder: DIBuilderRef, |
| Scope: DIScope, |
| Name: *const c_char, |
| File: DIFile, |
| LineNumber: c_uint, |
| SizeInBits: u64, |
| AlignInBits: u64, |
| Flags: c_uint, |
| Elements: DIArray, |
| RunTimeLang: c_uint, |
| UniqueId: *const c_char) |
| -> DIType; |
| |
| pub fn LLVMSetUnnamedAddr(GlobalVar: ValueRef, UnnamedAddr: Bool); |
| |
| pub fn LLVMRustDIBuilderCreateTemplateTypeParameter(Builder: DIBuilderRef, |
| Scope: DIScope, |
| Name: *const c_char, |
| Ty: DIType, |
| File: DIFile, |
| LineNo: c_uint, |
| ColumnNo: c_uint) |
| -> DITemplateTypeParameter; |
| |
| |
| pub fn LLVMRustDIBuilderCreateNameSpace(Builder: DIBuilderRef, |
| Scope: DIScope, |
| Name: *const c_char, |
| File: DIFile, |
| LineNo: c_uint) |
| -> DINameSpace; |
| pub fn LLVMRustDICompositeTypeSetTypeArray(Builder: DIBuilderRef, |
| CompositeType: DIType, |
| TypeArray: DIArray); |
| |
| |
| pub fn LLVMRustDIBuilderCreateDebugLocation(Context: ContextRef, |
| Line: c_uint, |
| Column: c_uint, |
| Scope: DIScope, |
| InlinedAt: MetadataRef) |
| -> ValueRef; |
| pub fn LLVMRustDIBuilderCreateOpDeref() -> i64; |
| pub fn LLVMRustDIBuilderCreateOpPlus() -> i64; |
| |
| pub fn LLVMRustWriteTypeToString(Type: TypeRef, s: RustStringRef); |
| pub fn LLVMRustWriteValueToString(value_ref: ValueRef, s: RustStringRef); |
| |
| pub fn LLVMIsAArgument(value_ref: ValueRef) -> ValueRef; |
| |
| pub fn LLVMIsAAllocaInst(value_ref: ValueRef) -> ValueRef; |
| pub fn LLVMIsAConstantInt(value_ref: ValueRef) -> ValueRef; |
| |
| pub fn LLVMRustPassKind(Pass: PassRef) -> PassKind; |
| pub fn LLVMRustFindAndCreatePass(Pass: *const c_char) -> PassRef; |
| pub fn LLVMRustAddPass(PM: PassManagerRef, Pass: PassRef); |
| |
| pub fn LLVMRustHasFeature(T: TargetMachineRef, |
| s: *const c_char) -> bool; |
| |
| pub fn LLVMRustCreateTargetMachine(Triple: *const c_char, |
| CPU: *const c_char, |
| Features: *const c_char, |
| Model: CodeModel, |
| Reloc: RelocMode, |
| Level: CodeGenOptLevel, |
| UseSoftFP: bool, |
| PositionIndependentExecutable: bool, |
| FunctionSections: bool, |
| DataSections: bool) -> TargetMachineRef; |
| pub fn LLVMRustDisposeTargetMachine(T: TargetMachineRef); |
| pub fn LLVMRustAddAnalysisPasses(T: TargetMachineRef, |
| PM: PassManagerRef, |
| M: ModuleRef); |
| pub fn LLVMRustAddBuilderLibraryInfo(PMB: PassManagerBuilderRef, |
| M: ModuleRef, |
| DisableSimplifyLibCalls: bool); |
| pub fn LLVMRustConfigurePassManagerBuilder(PMB: PassManagerBuilderRef, |
| OptLevel: CodeGenOptLevel, |
| MergeFunctions: bool, |
| SLPVectorize: bool, |
| LoopVectorize: bool); |
| pub fn LLVMRustAddLibraryInfo(PM: PassManagerRef, M: ModuleRef, |
| DisableSimplifyLibCalls: bool); |
| pub fn LLVMRustRunFunctionPassManager(PM: PassManagerRef, M: ModuleRef); |
| pub fn LLVMRustWriteOutputFile(T: TargetMachineRef, |
| PM: PassManagerRef, |
| M: ModuleRef, |
| Output: *const c_char, |
| FileType: FileType) |
| -> LLVMRustResult; |
| pub fn LLVMRustPrintModule(PM: PassManagerRef, |
| M: ModuleRef, |
| Output: *const c_char); |
| pub fn LLVMRustSetLLVMOptions(Argc: c_int, Argv: *const *const c_char); |
| pub fn LLVMRustPrintPasses(); |
| pub fn LLVMRustSetNormalizedTarget(M: ModuleRef, triple: *const c_char); |
| pub fn LLVMRustAddAlwaysInlinePass(P: PassManagerBuilderRef, |
| AddLifetimes: bool); |
| pub fn LLVMRustLinkInExternalBitcode(M: ModuleRef, |
| bc: *const c_char, |
| len: size_t) -> bool; |
| pub fn LLVMRustRunRestrictionPass(M: ModuleRef, |
| syms: *const *const c_char, |
| len: size_t); |
| pub fn LLVMRustMarkAllFunctionsNounwind(M: ModuleRef); |
| |
| pub fn LLVMRustOpenArchive(path: *const c_char) -> ArchiveRef; |
| pub fn LLVMRustArchiveIteratorNew(AR: ArchiveRef) -> ArchiveIteratorRef; |
| pub fn LLVMRustArchiveIteratorNext(AIR: ArchiveIteratorRef) -> ArchiveChildRef; |
| pub fn LLVMRustArchiveChildName(ACR: ArchiveChildRef, |
| size: *mut size_t) -> *const c_char; |
| pub fn LLVMRustArchiveChildData(ACR: ArchiveChildRef, |
| size: *mut size_t) -> *const c_char; |
| pub fn LLVMRustArchiveChildFree(ACR: ArchiveChildRef); |
| pub fn LLVMRustArchiveIteratorFree(AIR: ArchiveIteratorRef); |
| pub fn LLVMRustDestroyArchive(AR: ArchiveRef); |
| |
| pub fn LLVMRustGetSectionName(SI: SectionIteratorRef, |
| data: *mut *const c_char) -> size_t; |
| |
| pub fn LLVMRustWriteTwineToString(T: TwineRef, s: RustStringRef); |
| |
| pub fn LLVMContextSetDiagnosticHandler(C: ContextRef, |
| Handler: DiagnosticHandler, |
| DiagnosticContext: *mut c_void); |
| |
| pub fn LLVMRustUnpackOptimizationDiagnostic(DI: DiagnosticInfoRef, |
| pass_name_out: *mut *const c_char, |
| function_out: *mut ValueRef, |
| debugloc_out: *mut DebugLocRef, |
| message_out: *mut TwineRef); |
| pub fn LLVMRustUnpackInlineAsmDiagnostic(DI: DiagnosticInfoRef, |
| cookie_out: *mut c_uint, |
| message_out: *mut TwineRef, |
| instruction_out: *mut ValueRef); |
| |
| pub fn LLVMRustWriteDiagnosticInfoToString(DI: DiagnosticInfoRef, |
| s: RustStringRef); |
| pub fn LLVMGetDiagInfoSeverity(DI: DiagnosticInfoRef) -> DiagnosticSeverity; |
| pub fn LLVMRustGetDiagInfoKind(DI: DiagnosticInfoRef) -> DiagnosticKind; |
| |
| pub fn LLVMRustWriteDebugLocToString(C: ContextRef, |
| DL: DebugLocRef, |
| s: RustStringRef); |
| |
| pub fn LLVMRustSetInlineAsmDiagnosticHandler(C: ContextRef, |
| H: InlineAsmDiagHandler, |
| CX: *mut c_void); |
| |
| pub fn LLVMRustWriteSMDiagnosticToString(d: SMDiagnosticRef, s: RustStringRef); |
| |
| pub fn LLVMRustWriteArchive(Dst: *const c_char, |
| NumMembers: size_t, |
| Members: *const RustArchiveMemberRef, |
| WriteSymbtab: bool, |
| Kind: ArchiveKind) -> |
| LLVMRustResult; |
| pub fn LLVMRustArchiveMemberNew(Filename: *const c_char, |
| Name: *const c_char, |
| Child: ArchiveChildRef) -> RustArchiveMemberRef; |
| pub fn LLVMRustArchiveMemberFree(Member: RustArchiveMemberRef); |
| |
| pub fn LLVMRustSetDataLayoutFromTargetMachine(M: ModuleRef, |
| TM: TargetMachineRef); |
| pub fn LLVMRustGetModuleDataLayout(M: ModuleRef) -> TargetDataRef; |
| |
| pub fn LLVMRustBuildOperandBundleDef(Name: *const c_char, |
| Inputs: *const ValueRef, |
| NumInputs: c_uint) |
| -> OperandBundleDefRef; |
| pub fn LLVMRustFreeOperandBundleDef(Bundle: OperandBundleDefRef); |
| |
| pub fn LLVMRustPositionBuilderAtStart(B: BuilderRef, BB: BasicBlockRef); |
| |
| pub fn LLVMRustSetComdat(M: ModuleRef, V: ValueRef, Name: *const c_char); |
| pub fn LLVMRustUnsetComdat(V: ValueRef); |
| pub fn LLVMRustSetModulePIELevel(M: ModuleRef); |
| } |
| |
| |
| // LLVM requires symbols from this library, but apparently they're not printed |
| // during llvm-config? |
| #[cfg(windows)] |
| #[link(name = "ole32")] |
| extern {} |
