#![allow(dead_code)]
#![crate_name = "rustc_llvm"]
-#![unstable]
-#![staged_api]
+#![unstable(feature = "rustc_private", issue = "27812")]
#![crate_type = "dylib"]
#![crate_type = "rlib"]
-#![doc(html_logo_url = "http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
- html_favicon_url = "http://www.rust-lang.org/favicon.ico",
- html_root_url = "http://doc.rust-lang.org/nightly/")]
+#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
+ html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
+ html_root_url = "https://doc.rust-lang.org/nightly/")]
+#![deny(warnings)]
-#![allow(unknown_features)]
-#![feature(link_args)]
+#![feature(associated_consts)]
#![feature(box_syntax)]
-#![allow(unknown_features)] #![feature(int_uint)]
+#![feature(concat_idents)]
+#![feature(libc)]
+#![feature(link_args)]
+#![feature(staged_api)]
+#![feature(rustc_private)]
extern crate libc;
+#[macro_use]
+#[no_link]
+extern crate rustc_bitflags;
-pub use self::OtherAttribute::*;
-pub use self::SpecialAttribute::*;
-pub use self::AttributeSet::*;
pub use self::IntPredicate::*;
pub use self::RealPredicate::*;
pub use self::TypeKind::*;
-pub use self::AtomicBinOp::*;
-pub use self::AtomicOrdering::*;
-pub use self::FileType::*;
+pub use self::AtomicRmwBinOp::*;
pub use self::MetadataType::*;
-pub use self::AsmDialect::*;
-pub use self::CodeGenOptLevel::*;
-pub use self::RelocMode::*;
-pub use self::CodeGenModel::*;
+pub use self::CodeGenOptSize::*;
pub use self::DiagnosticKind::*;
pub use self::CallConv::*;
-pub use self::Visibility::*;
pub use self::DiagnosticSeverity::*;
pub use self::Linkage::*;
-use std::ffi::CString;
+use std::str::FromStr;
+use std::slice;
+use std::ffi::{CString, CStr};
use std::cell::RefCell;
-use std::{raw, mem};
-use libc::{c_uint, c_ushort, uint64_t, c_int, size_t, c_char};
-use libc::{c_longlong, c_ulonglong, c_void};
-use debuginfo::{DIBuilderRef, DIDescriptor,
- DIFile, DILexicalBlock, DISubprogram, DIType,
- DIBasicType, DIDerivedType, DICompositeType,
- DIVariable, DIGlobalVariable, DIArray, DISubrange};
+use libc::{c_uint, c_char, size_t};
pub mod archive_ro;
pub mod diagnostic;
+pub mod ffi;
-pub type Opcode = u32;
-pub type Bool = c_uint;
-
-pub const True: Bool = 1 as Bool;
-pub const False: Bool = 0 as Bool;
-
-// Consts for the LLVM CallConv type, pre-cast to uint.
-
-#[derive(Copy, PartialEq)]
-pub enum CallConv {
- CCallConv = 0,
- FastCallConv = 8,
- ColdCallConv = 9,
- X86StdcallCallConv = 64,
- X86FastcallCallConv = 65,
- X86_64_Win64 = 79,
-}
-
-#[derive(Copy)]
-pub enum Visibility {
- LLVMDefaultVisibility = 0,
- HiddenVisibility = 1,
- ProtectedVisibility = 2,
-}
-
-// 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)]
-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,
-}
-
-#[repr(C)]
-#[derive(Copy, Show)]
-pub enum DiagnosticSeverity {
- Error,
- Warning,
- Remark,
- Note,
-}
-
-bitflags! {
- flags Attribute : u32 {
- const ZExtAttribute = 1 << 0,
- const SExtAttribute = 1 << 1,
- const NoReturnAttribute = 1 << 2,
- const InRegAttribute = 1 << 3,
- const StructRetAttribute = 1 << 4,
- const NoUnwindAttribute = 1 << 5,
- const NoAliasAttribute = 1 << 6,
- const ByValAttribute = 1 << 7,
- const NestAttribute = 1 << 8,
- const ReadNoneAttribute = 1 << 9,
- const ReadOnlyAttribute = 1 << 10,
- const NoInlineAttribute = 1 << 11,
- const AlwaysInlineAttribute = 1 << 12,
- const OptimizeForSizeAttribute = 1 << 13,
- const StackProtectAttribute = 1 << 14,
- const StackProtectReqAttribute = 1 << 15,
- const AlignmentAttribute = 31 << 16,
- const NoCaptureAttribute = 1 << 21,
- const NoRedZoneAttribute = 1 << 22,
- const NoImplicitFloatAttribute = 1 << 23,
- const NakedAttribute = 1 << 24,
- const InlineHintAttribute = 1 << 25,
- const StackAttribute = 7 << 26,
- const ReturnsTwiceAttribute = 1 << 29,
- const UWTableAttribute = 1 << 30,
- const NonLazyBindAttribute = 1 << 31,
- }
-}
-
+pub use ffi::*;
-#[repr(u64)]
-#[derive(Copy)]
-pub enum OtherAttribute {
- // The following are not really exposed in
- // the LLVM c api so instead to add these
- // we call a wrapper function in RustWrapper
- // that uses the C++ api.
- SanitizeAddressAttribute = 1 << 32,
- MinSizeAttribute = 1 << 33,
- NoDuplicateAttribute = 1 << 34,
- StackProtectStrongAttribute = 1 << 35,
- SanitizeThreadAttribute = 1 << 36,
- SanitizeMemoryAttribute = 1 << 37,
- NoBuiltinAttribute = 1 << 38,
- ReturnedAttribute = 1 << 39,
- ColdAttribute = 1 << 40,
- BuiltinAttribute = 1 << 41,
- OptimizeNoneAttribute = 1 << 42,
- InAllocaAttribute = 1 << 43,
- NonNullAttribute = 1 << 44,
-}
-
-#[derive(Copy)]
-pub enum SpecialAttribute {
- DereferenceableAttribute(u64)
-}
-
-#[repr(C)]
-#[derive(Copy)]
-pub enum AttributeSet {
- ReturnIndex = 0,
- FunctionIndex = !0
-}
-
-pub trait AttrHelper {
- fn apply_llfn(&self, idx: c_uint, llfn: ValueRef);
- fn apply_callsite(&self, idx: c_uint, callsite: ValueRef);
-}
-
-impl AttrHelper for Attribute {
- fn apply_llfn(&self, idx: c_uint, llfn: ValueRef) {
- unsafe {
- LLVMAddFunctionAttribute(llfn, idx, self.bits() as uint64_t);
- }
- }
-
- fn apply_callsite(&self, idx: c_uint, callsite: ValueRef) {
- unsafe {
- LLVMAddCallSiteAttribute(callsite, idx, self.bits() as uint64_t);
+impl LLVMRustResult {
+ pub fn into_result(self) -> Result<(), ()> {
+ match self {
+ LLVMRustResult::Success => Ok(()),
+ LLVMRustResult::Failure => Err(()),
}
}
}
-impl AttrHelper for OtherAttribute {
- fn apply_llfn(&self, idx: c_uint, llfn: ValueRef) {
- unsafe {
- LLVMAddFunctionAttribute(llfn, idx, *self as uint64_t);
- }
- }
-
- fn apply_callsite(&self, idx: c_uint, callsite: ValueRef) {
- unsafe {
- LLVMAddCallSiteAttribute(callsite, idx, *self as uint64_t);
- }
- }
-}
-
-impl AttrHelper for SpecialAttribute {
- fn apply_llfn(&self, idx: c_uint, llfn: ValueRef) {
- match *self {
- DereferenceableAttribute(bytes) => unsafe {
- LLVMAddDereferenceableAttr(llfn, idx, bytes as uint64_t);
- }
- }
- }
-
- fn apply_callsite(&self, idx: c_uint, callsite: ValueRef) {
- match *self {
- DereferenceableAttribute(bytes) => unsafe {
- LLVMAddDereferenceableCallSiteAttr(callsite, idx, bytes as uint64_t);
- }
- }
+pub fn AddFunctionAttrStringValue(llfn: ValueRef,
+ idx: AttributePlace,
+ attr: &CStr,
+ value: &CStr) {
+ unsafe {
+ LLVMRustAddFunctionAttrStringValue(llfn,
+ idx.as_uint(),
+ attr.as_ptr(),
+ value.as_ptr())
}
}
-pub struct AttrBuilder {
- attrs: Vec<(uint, Box<AttrHelper+'static>)>
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub enum AttributePlace {
+ Argument(u32),
+ Function,
}
-impl AttrBuilder {
- pub fn new() -> AttrBuilder {
- AttrBuilder {
- attrs: Vec::new()
- }
+impl AttributePlace {
+ pub fn ReturnValue() -> Self {
+ AttributePlace::Argument(0)
}
- pub fn arg<'a, T: AttrHelper + 'static>(&'a mut self, idx: uint, a: T) -> &'a mut AttrBuilder {
- self.attrs.push((idx, box a as Box<AttrHelper+'static>));
- self
- }
-
- pub fn ret<'a, T: AttrHelper + 'static>(&'a mut self, a: T) -> &'a mut AttrBuilder {
- self.attrs.push((ReturnIndex as uint, box a as Box<AttrHelper+'static>));
- self
- }
-
- pub fn apply_llfn(&self, llfn: ValueRef) {
- for &(idx, ref attr) in self.attrs.iter() {
- attr.apply_llfn(idx as c_uint, llfn);
+ pub fn as_uint(self) -> c_uint {
+ match self {
+ AttributePlace::Function => !0,
+ AttributePlace::Argument(i) => i,
}
}
-
- pub fn apply_callsite(&self, callsite: ValueRef) {
- for &(idx, ref attr) in self.attrs.iter() {
- attr.apply_callsite(idx as c_uint, callsite);
- }
- }
-}
-
-// enum for the LLVM IntPredicate type
-#[derive(Copy)]
-pub enum IntPredicate {
- IntEQ = 32,
- IntNE = 33,
- IntUGT = 34,
- IntUGE = 35,
- IntULT = 36,
- IntULE = 37,
- IntSGT = 38,
- IntSGE = 39,
- IntSLT = 40,
- IntSLE = 41,
-}
-
-// enum for the LLVM RealPredicate type
-#[derive(Copy)]
-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,
-}
-
-// The LLVM TypeKind type - must stay in sync with the def of
-// LLVMTypeKind in llvm/include/llvm-c/Core.h
-#[derive(Copy, PartialEq)]
-#[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,
-}
-
-#[repr(C)]
-#[derive(Copy)]
-pub enum AtomicBinOp {
- AtomicXchg = 0,
- AtomicAdd = 1,
- AtomicSub = 2,
- AtomicAnd = 3,
- AtomicNand = 4,
- AtomicOr = 5,
- AtomicXor = 6,
- AtomicMax = 7,
- AtomicMin = 8,
- AtomicUMax = 9,
- AtomicUMin = 10,
-}
-
-#[repr(C)]
-#[derive(Copy)]
-pub enum AtomicOrdering {
- NotAtomic = 0,
- Unordered = 1,
- Monotonic = 2,
- // Consume = 3, // Not specified yet.
- Acquire = 4,
- Release = 5,
- AcquireRelease = 6,
- SequentiallyConsistent = 7
-}
-
-// Consts for the LLVMCodeGenFileType type (in include/llvm/c/TargetMachine.h)
-#[repr(C)]
-#[derive(Copy)]
-pub enum FileType {
- AssemblyFileType = 0,
- ObjectFileType = 1
-}
-
-#[derive(Copy)]
-pub enum MetadataType {
- MD_dbg = 0,
- MD_tbaa = 1,
- MD_prof = 2,
- MD_fpmath = 3,
- MD_range = 4,
- MD_tbaa_struct = 5
-}
-
-// Inline Asm Dialect
-#[derive(Copy)]
-pub enum AsmDialect {
- AD_ATT = 0,
- AD_Intel = 1
-}
-
-#[derive(Copy, PartialEq, Clone)]
-#[repr(C)]
-pub enum CodeGenOptLevel {
- CodeGenLevelNone = 0,
- CodeGenLevelLess = 1,
- CodeGenLevelDefault = 2,
- CodeGenLevelAggressive = 3,
-}
-
-#[derive(Copy, PartialEq)]
-#[repr(C)]
-pub enum RelocMode {
- RelocDefault = 0,
- RelocStatic = 1,
- RelocPIC = 2,
- RelocDynamicNoPic = 3,
}
+#[derive(Copy, Clone, PartialEq)]
#[repr(C)]
-#[derive(Copy)]
-pub enum CodeGenModel {
- CodeModelDefault = 0,
- CodeModelJITDefault = 1,
- CodeModelSmall = 2,
- CodeModelKernel = 3,
- CodeModelMedium = 4,
- CodeModelLarge = 5,
-}
-
-#[repr(C)]
-#[derive(Copy)]
-pub enum DiagnosticKind {
- DK_InlineAsm = 0,
- DK_StackSize,
- DK_DebugMetadataVersion,
- DK_SampleProfile,
- DK_OptimizationRemark,
- DK_OptimizationRemarkMissed,
- DK_OptimizationRemarkAnalysis,
- DK_OptimizationFailure,
-}
-
-// 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 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 RustJITMemoryManager_opaque {}
-pub type RustJITMemoryManagerRef = *mut RustJITMemoryManager_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;
-#[allow(missing_copy_implementations)]
-pub enum Archive_opaque {}
-pub type ArchiveRef = *mut Archive_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;
-
-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::{ValueRef};
-
- #[allow(missing_copy_implementations)]
- pub enum DIBuilder_opaque {}
- pub type DIBuilderRef = *mut DIBuilder_opaque;
-
- pub type DIDescriptor = ValueRef;
- pub type DIScope = DIDescriptor;
- pub type DILocation = DIDescriptor;
- pub type DIFile = DIScope;
- pub type DILexicalBlock = DIScope;
- pub type DISubprogram = 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;
-
- #[derive(Copy)]
- 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
+pub enum CodeGenOptSize {
+ CodeGenOptSizeNone = 0,
+ CodeGenOptSizeDefault = 1,
+ CodeGenOptSizeAggressive = 2,
+}
+
+impl FromStr for ArchiveKind {
+ type Err = ();
+
+ fn from_str(s: &str) -> Result<Self, Self::Err> {
+ match s {
+ "gnu" => Ok(ArchiveKind::K_GNU),
+ "mips64" => Ok(ArchiveKind::K_MIPS64),
+ "bsd" => Ok(ArchiveKind::K_BSD),
+ "coff" => Ok(ArchiveKind::K_COFF),
+ _ => Err(()),
+ }
}
}
+#[allow(missing_copy_implementations)]
+pub enum RustString_opaque {}
+pub type RustStringRef = *mut RustString_opaque;
+type RustStringRepr = *mut RefCell<Vec<u8>>;
-// 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")]
-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 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 LLVMGetTypeKind(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 ();
- 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 LLVMMetadataTypeInContext(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 LLVMHasMetadata(Val: ValueRef) -> c_int;
- pub fn LLVMGetMetadata(Val: ValueRef, KindID: c_uint) -> 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: c_ushort, V1: ValueRef, V2: ValueRef)
- -> ValueRef;
- pub fn LLVMConstFCmp(Pred: c_ushort, V1: ValueRef, V2: ValueRef)
- -> ValueRef;
- /* only for int/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: c_uint);
- 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);
-
-
- /* Operations on global variables */
- 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 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);
-
- /* 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 LLVMGetOrInsertFunction(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 LLVMAddDereferenceableAttr(Fn: ValueRef, index: c_uint, bytes: uint64_t);
- pub fn LLVMAddFunctionAttribute(Fn: ValueRef, index: c_uint, PA: uint64_t);
- pub fn LLVMAddFunctionAttrString(Fn: ValueRef, index: c_uint, Name: *const c_char);
- pub fn LLVMRemoveFunctionAttrString(Fn: ValueRef, index: c_uint, Name: *const c_char);
- pub fn LLVMGetFunctionAttr(Fn: ValueRef) -> c_ulonglong;
-
- /* 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 LLVMAddCallSiteAttribute(Instr: ValueRef,
- index: c_uint,
- Val: uint64_t);
- pub fn LLVMAddDereferenceableCallSiteAttr(Instr: ValueRef,
- index: c_uint,
- bytes: uint64_t);
-
- /* 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);
-
- /* Execution engine */
- pub fn LLVMRustCreateJITMemoryManager(morestack: *const ())
- -> RustJITMemoryManagerRef;
- pub fn LLVMBuildExecutionEngine(Mod: ModuleRef,
- MM: RustJITMemoryManagerRef) -> ExecutionEngineRef;
- pub fn LLVMDisposeExecutionEngine(EE: ExecutionEngineRef);
- pub fn LLVMExecutionEngineFinalizeObject(EE: ExecutionEngineRef);
- pub fn LLVMRustLoadDynamicLibrary(path: *const c_char) -> Bool;
- pub fn LLVMExecutionEngineAddModule(EE: ExecutionEngineRef, M: ModuleRef);
- pub fn LLVMExecutionEngineRemoveModule(EE: ExecutionEngineRef, M: ModuleRef)
- -> Bool;
-
- /* 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 LLVMBuildInvoke(B: BuilderRef,
- Fn: ValueRef,
- Args: *const ValueRef,
- NumArgs: c_uint,
- Then: BasicBlockRef,
- Catch: BasicBlockRef,
- Name: *const c_char)
- -> ValueRef;
- pub fn LLVMBuildLandingPad(B: BuilderRef,
- Ty: TypeRef,
- PersFn: ValueRef,
- NumClauses: c_uint,
- Name: *const c_char)
- -> ValueRef;
- pub fn LLVMBuildResume(B: BuilderRef, Exn: ValueRef) -> ValueRef;
- pub fn LLVMBuildUnreachable(B: BuilderRef) -> 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;
-
- /* Memory */
- pub fn LLVMBuildMalloc(B: BuilderRef, Ty: TypeRef, Name: *const c_char)
- -> ValueRef;
- pub fn LLVMBuildArrayMalloc(B: BuilderRef,
- Ty: TypeRef,
- Val: ValueRef,
- Name: *const c_char)
- -> ValueRef;
- pub fn LLVMBuildAlloca(B: BuilderRef, Ty: TypeRef, Name: *const c_char)
- -> ValueRef;
- pub fn LLVMBuildArrayAlloca(B: BuilderRef,
- Ty: TypeRef,
- Val: ValueRef,
- 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 LLVMBuildCall(B: BuilderRef,
- Fn: ValueRef,
- Args: *const ValueRef,
- NumArgs: c_uint,
- 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 LLVMBuildAtomicLoad(B: BuilderRef,
- PointerVal: ValueRef,
- Name: *const c_char,
- Order: AtomicOrdering,
- Alignment: c_uint)
- -> ValueRef;
-
- pub fn LLVMBuildAtomicStore(B: BuilderRef,
- Val: ValueRef,
- Ptr: ValueRef,
- Order: AtomicOrdering,
- Alignment: c_uint)
- -> ValueRef;
-
- pub fn LLVMBuildAtomicCmpXchg(B: BuilderRef,
- LHS: ValueRef,
- CMP: ValueRef,
- RHS: ValueRef,
- Order: AtomicOrdering,
- FailureOrder: AtomicOrdering)
- -> ValueRef;
- pub fn LLVMBuildAtomicRMW(B: BuilderRef,
- Op: AtomicBinOp,
- LHS: ValueRef,
- RHS: ValueRef,
- Order: AtomicOrdering,
- SingleThreaded: Bool)
- -> ValueRef;
-
- pub fn LLVMBuildAtomicFence(B: BuilderRef, Order: AtomicOrdering);
-
-
- /* 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;
- /// Adds the target data to the given pass manager. The pass manager
- /// references the target data only weakly.
- pub fn LLVMAddTargetData(TD: TargetDataRef, PM: PassManagerRef);
- /// 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 LLVMSetDebug(Enabled: c_int);
-
- /// Prepares inline assembly.
- pub fn LLVMInlineAsm(Ty: TypeRef,
- AsmString: *const c_char,
- Constraints: *const c_char,
- SideEffects: Bool,
- AlignStack: Bool,
- Dialect: c_uint)
- -> ValueRef;
-
- pub static LLVMRustDebugMetadataVersion: u32;
-
- pub fn LLVMRustAddModuleFlag(M: ModuleRef,
- name: *const c_char,
- value: u32);
-
- pub fn LLVMDIBuilderCreate(M: ModuleRef) -> DIBuilderRef;
-
- pub fn LLVMDIBuilderDispose(Builder: DIBuilderRef);
-
- pub fn LLVMDIBuilderFinalize(Builder: DIBuilderRef);
-
- pub fn LLVMDIBuilderCreateCompileUnit(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 LLVMDIBuilderCreateFile(Builder: DIBuilderRef,
- Filename: *const c_char,
- Directory: *const c_char)
- -> DIFile;
-
- pub fn LLVMDIBuilderCreateSubroutineType(Builder: DIBuilderRef,
- File: DIFile,
- ParameterTypes: DIArray)
- -> DICompositeType;
-
- pub fn LLVMDIBuilderCreateFunction(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: ValueRef,
- Decl: ValueRef)
- -> DISubprogram;
-
- pub fn LLVMDIBuilderCreateBasicType(Builder: DIBuilderRef,
- Name: *const c_char,
- SizeInBits: c_ulonglong,
- AlignInBits: c_ulonglong,
- Encoding: c_uint)
- -> DIBasicType;
-
- pub fn LLVMDIBuilderCreatePointerType(Builder: DIBuilderRef,
- PointeeTy: DIType,
- SizeInBits: c_ulonglong,
- AlignInBits: c_ulonglong,
- Name: *const c_char)
- -> DIDerivedType;
-
- pub fn LLVMDIBuilderCreateStructType(Builder: DIBuilderRef,
- Scope: DIDescriptor,
- Name: *const c_char,
- File: DIFile,
- LineNumber: c_uint,
- SizeInBits: c_ulonglong,
- AlignInBits: c_ulonglong,
- Flags: c_uint,
- DerivedFrom: DIType,
- Elements: DIArray,
- RunTimeLang: c_uint,
- VTableHolder: ValueRef,
- UniqueId: *const c_char)
- -> DICompositeType;
-
- pub fn LLVMDIBuilderCreateMemberType(Builder: DIBuilderRef,
- Scope: DIDescriptor,
- Name: *const c_char,
- File: DIFile,
- LineNo: c_uint,
- SizeInBits: c_ulonglong,
- AlignInBits: c_ulonglong,
- OffsetInBits: c_ulonglong,
- Flags: c_uint,
- Ty: DIType)
- -> DIDerivedType;
-
- pub fn LLVMDIBuilderCreateLexicalBlock(Builder: DIBuilderRef,
- Scope: DIDescriptor,
- File: DIFile,
- Line: c_uint,
- Col: c_uint)
- -> DILexicalBlock;
-
- pub fn LLVMDIBuilderCreateStaticVariable(Builder: DIBuilderRef,
- Context: DIDescriptor,
- Name: *const c_char,
- LinkageName: *const c_char,
- File: DIFile,
- LineNo: c_uint,
- Ty: DIType,
- isLocalToUnit: bool,
- Val: ValueRef,
- Decl: ValueRef)
- -> DIGlobalVariable;
-
- pub fn LLVMDIBuilderCreateLocalVariable(Builder: DIBuilderRef,
- Tag: c_uint,
- Scope: DIDescriptor,
- Name: *const c_char,
- File: DIFile,
- LineNo: c_uint,
- Ty: DIType,
- AlwaysPreserve: bool,
- Flags: c_uint,
- ArgNo: c_uint)
- -> DIVariable;
-
- pub fn LLVMDIBuilderCreateArrayType(Builder: DIBuilderRef,
- Size: c_ulonglong,
- AlignInBits: c_ulonglong,
- Ty: DIType,
- Subscripts: DIArray)
- -> DIType;
-
- pub fn LLVMDIBuilderCreateVectorType(Builder: DIBuilderRef,
- Size: c_ulonglong,
- AlignInBits: c_ulonglong,
- Ty: DIType,
- Subscripts: DIArray)
- -> DIType;
-
- pub fn LLVMDIBuilderGetOrCreateSubrange(Builder: DIBuilderRef,
- Lo: c_longlong,
- Count: c_longlong)
- -> DISubrange;
-
- pub fn LLVMDIBuilderGetOrCreateArray(Builder: DIBuilderRef,
- Ptr: *const DIDescriptor,
- Count: c_uint)
- -> DIArray;
-
- pub fn LLVMDIBuilderInsertDeclareAtEnd(Builder: DIBuilderRef,
- Val: ValueRef,
- VarInfo: DIVariable,
- InsertAtEnd: BasicBlockRef)
- -> ValueRef;
-
- pub fn LLVMDIBuilderInsertDeclareBefore(Builder: DIBuilderRef,
- Val: ValueRef,
- VarInfo: DIVariable,
- InsertBefore: ValueRef)
- -> ValueRef;
-
- pub fn LLVMDIBuilderCreateEnumerator(Builder: DIBuilderRef,
- Name: *const c_char,
- Val: c_ulonglong)
- -> ValueRef;
-
- pub fn LLVMDIBuilderCreateEnumerationType(Builder: DIBuilderRef,
- Scope: ValueRef,
- Name: *const c_char,
- File: ValueRef,
- LineNumber: c_uint,
- SizeInBits: c_ulonglong,
- AlignInBits: c_ulonglong,
- Elements: ValueRef,
- ClassType: ValueRef)
- -> ValueRef;
-
- pub fn LLVMDIBuilderCreateUnionType(Builder: DIBuilderRef,
- Scope: ValueRef,
- Name: *const c_char,
- File: ValueRef,
- LineNumber: c_uint,
- SizeInBits: c_ulonglong,
- AlignInBits: c_ulonglong,
- Flags: c_uint,
- Elements: ValueRef,
- RunTimeLang: c_uint,
- UniqueId: *const c_char)
- -> ValueRef;
-
- pub fn LLVMSetUnnamedAddr(GlobalVar: ValueRef, UnnamedAddr: Bool);
-
- pub fn LLVMDIBuilderCreateTemplateTypeParameter(Builder: DIBuilderRef,
- Scope: ValueRef,
- Name: *const c_char,
- Ty: ValueRef,
- File: ValueRef,
- LineNo: c_uint,
- ColumnNo: c_uint)
- -> ValueRef;
-
- pub fn LLVMDIBuilderCreateOpDeref(IntType: TypeRef) -> ValueRef;
-
- pub fn LLVMDIBuilderCreateOpPlus(IntType: TypeRef) -> ValueRef;
-
- pub fn LLVMDIBuilderCreateComplexVariable(Builder: DIBuilderRef,
- Tag: c_uint,
- Scope: ValueRef,
- Name: *const c_char,
- File: ValueRef,
- LineNo: c_uint,
- Ty: ValueRef,
- AddrOps: *const ValueRef,
- AddrOpsCount: c_uint,
- ArgNo: c_uint)
- -> ValueRef;
-
- pub fn LLVMDIBuilderCreateNameSpace(Builder: DIBuilderRef,
- Scope: ValueRef,
- Name: *const c_char,
- File: ValueRef,
- LineNo: c_uint)
- -> ValueRef;
-
- pub fn LLVMDICompositeTypeSetTypeArray(CompositeType: ValueRef, TypeArray: ValueRef);
- pub fn LLVMWriteTypeToString(Type: TypeRef, s: RustStringRef);
- pub fn LLVMWriteValueToString(value_ref: ValueRef, s: RustStringRef);
-
- pub fn LLVMIsAArgument(value_ref: ValueRef) -> ValueRef;
-
- pub fn LLVMIsAAllocaInst(value_ref: ValueRef) -> ValueRef;
-
- pub fn LLVMInitializeX86TargetInfo();
- pub fn LLVMInitializeX86Target();
- pub fn LLVMInitializeX86TargetMC();
- pub fn LLVMInitializeX86AsmPrinter();
- pub fn LLVMInitializeX86AsmParser();
- pub fn LLVMInitializeARMTargetInfo();
- pub fn LLVMInitializeARMTarget();
- pub fn LLVMInitializeARMTargetMC();
- pub fn LLVMInitializeARMAsmPrinter();
- pub fn LLVMInitializeARMAsmParser();
- pub fn LLVMInitializeAArch64TargetInfo();
- pub fn LLVMInitializeAArch64Target();
- pub fn LLVMInitializeAArch64TargetMC();
- pub fn LLVMInitializeAArch64AsmPrinter();
- pub fn LLVMInitializeAArch64AsmParser();
- pub fn LLVMInitializeMipsTargetInfo();
- pub fn LLVMInitializeMipsTarget();
- pub fn LLVMInitializeMipsTargetMC();
- pub fn LLVMInitializeMipsAsmPrinter();
- pub fn LLVMInitializeMipsAsmParser();
-
- pub fn LLVMRustAddPass(PM: PassManagerRef, Pass: *const c_char) -> bool;
- pub fn LLVMRustCreateTargetMachine(Triple: *const c_char,
- CPU: *const c_char,
- Features: *const c_char,
- Model: CodeGenModel,
- Reloc: RelocMode,
- Level: CodeGenOptLevel,
- EnableSegstk: bool,
- UseSoftFP: bool,
- NoFramePointerElim: 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 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) -> bool;
- 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 LLVMRustArchiveReadSection(AR: ArchiveRef, name: *const c_char,
- out_len: *mut size_t) -> *const c_char;
- pub fn LLVMRustDestroyArchive(AR: ArchiveRef);
-
- pub fn LLVMRustSetDLLExportStorageClass(V: ValueRef);
- pub fn LLVMVersionMajor() -> c_int;
- pub fn LLVMVersionMinor() -> c_int;
-
- pub fn LLVMRustGetSectionName(SI: SectionIteratorRef,
- data: *mut *const c_char) -> c_int;
-
- pub fn LLVMWriteTwineToString(T: TwineRef, s: RustStringRef);
-
- pub fn LLVMContextSetDiagnosticHandler(C: ContextRef,
- Handler: DiagnosticHandler,
- DiagnosticContext: *mut c_void);
-
- pub fn LLVMUnpackOptimizationDiagnostic(DI: DiagnosticInfoRef,
- pass_name_out: *mut *const c_char,
- function_out: *mut ValueRef,
- debugloc_out: *mut DebugLocRef,
- message_out: *mut TwineRef);
-
- pub fn LLVMWriteDiagnosticInfoToString(DI: DiagnosticInfoRef, s: RustStringRef);
- pub fn LLVMGetDiagInfoSeverity(DI: DiagnosticInfoRef) -> DiagnosticSeverity;
- pub fn LLVMGetDiagInfoKind(DI: DiagnosticInfoRef) -> DiagnosticKind;
-
- pub fn LLVMWriteDebugLocToString(C: ContextRef, DL: DebugLocRef, s: RustStringRef);
-
- pub fn LLVMSetInlineAsmDiagnosticHandler(C: ContextRef,
- H: InlineAsmDiagHandler,
- CX: *mut c_void);
+/// Appending to a Rust string -- used by RawRustStringOstream.
+#[no_mangle]
+pub unsafe extern "C" fn LLVMRustStringWriteImpl(sr: RustStringRef,
+ ptr: *const c_char,
+ size: size_t) {
+ let slice = slice::from_raw_parts(ptr as *const u8, size as usize);
- pub fn LLVMWriteSMDiagnosticToString(d: SMDiagnosticRef, s: RustStringRef);
+ let sr = sr as RustStringRepr;
+ (*sr).borrow_mut().extend_from_slice(slice);
}
pub fn SetInstructionCallConv(instr: ValueRef, cc: CallConv) {
LLVMSetFunctionCallConv(fn_, cc as c_uint);
}
}
-pub fn SetLinkage(global: ValueRef, link: Linkage) {
+
+// Externally visible symbols that might appear in multiple translation units need to appear in
+// their own comdat section so that the duplicates can be discarded at link time. This can for
+// example happen for generics when using multiple codegen units. This function simply uses the
+// value's name as the comdat value to make sure that it is in a 1-to-1 relationship to the
+// function.
+// For more details on COMDAT sections see e.g. http://www.airs.com/blog/archives/52
+pub fn SetUniqueComdat(llmod: ModuleRef, val: ValueRef) {
unsafe {
- LLVMSetLinkage(global, link as c_uint);
+ LLVMRustSetComdat(llmod, val, LLVMGetValueName(val));
+ }
+}
+
+pub fn UnsetComdat(val: ValueRef) {
+ unsafe {
+ LLVMRustUnsetComdat(val);
}
}
}
}
-pub fn ConstICmp(pred: IntPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
- unsafe {
- LLVMConstICmp(pred as c_ushort, v1, v2)
+impl Attribute {
+ pub fn apply_llfn(&self, idx: AttributePlace, llfn: ValueRef) {
+ unsafe { LLVMRustAddFunctionAttribute(llfn, idx.as_uint(), *self) }
}
-}
-pub fn ConstFCmp(pred: RealPredicate, v1: ValueRef, v2: ValueRef) -> ValueRef {
- unsafe {
- LLVMConstFCmp(pred as c_ushort, v1, v2)
+
+ pub fn apply_callsite(&self, idx: AttributePlace, callsite: ValueRef) {
+ unsafe { LLVMRustAddCallSiteAttribute(callsite, idx.as_uint(), *self) }
}
-}
-pub fn SetFunctionAttribute(fn_: ValueRef, attr: Attribute) {
- unsafe {
- LLVMAddFunctionAttribute(fn_, FunctionIndex as c_uint, attr.bits() as uint64_t)
+ pub fn unapply_llfn(&self, idx: AttributePlace, llfn: ValueRef) {
+ unsafe { LLVMRustRemoveFunctionAttributes(llfn, idx.as_uint(), *self) }
+ }
+
+ pub fn toggle_llfn(&self, idx: AttributePlace, llfn: ValueRef, set: bool) {
+ if set {
+ self.apply_llfn(idx, llfn);
+ } else {
+ self.unapply_llfn(idx, llfn);
+ }
}
}
-/* Memory-managed interface to target data. */
+// Memory-managed interface to target data.
pub struct TargetData {
- pub lltd: TargetDataRef
+ pub lltd: TargetDataRef,
}
impl Drop for TargetData {
}
pub fn mk_target_data(string_rep: &str) -> TargetData {
- let string_rep = CString::from_slice(string_rep.as_bytes());
- TargetData {
- lltd: unsafe { LLVMCreateTargetData(string_rep.as_ptr()) }
- }
+ let string_rep = CString::new(string_rep).unwrap();
+ TargetData { lltd: unsafe { LLVMCreateTargetData(string_rep.as_ptr()) } }
}
-/* Memory-managed interface to object files. */
+// Memory-managed interface to object files.
pub struct ObjectFile {
pub llof: ObjectFileRef,
pub fn new(llmb: MemoryBufferRef) -> Option<ObjectFile> {
unsafe {
let llof = LLVMCreateObjectFile(llmb);
- if llof as int == 0 {
+ if llof as isize == 0 {
// LLVMCreateObjectFile took ownership of llmb
- return None
+ return None;
}
- Some(ObjectFile {
- llof: llof,
- })
+ Some(ObjectFile { llof: llof })
}
}
}
}
}
-/* Memory-managed interface to section iterators. */
+// Memory-managed interface to section iterators.
pub struct SectionIter {
- pub llsi: SectionIteratorRef
+ pub llsi: SectionIteratorRef,
}
impl Drop for SectionIter {
}
pub fn mk_section_iter(llof: ObjectFileRef) -> SectionIter {
- unsafe {
- SectionIter {
- llsi: LLVMGetSections(llof)
- }
- }
+ unsafe { SectionIter { llsi: LLVMGetSections(llof) } }
}
/// Safe wrapper around `LLVMGetParam`, because segfaults are no fun.
pub fn get_param(llfn: ValueRef, index: c_uint) -> ValueRef {
unsafe {
- assert!(index < LLVMCountParams(llfn));
+ assert!(index < LLVMCountParams(llfn),
+ "out of bounds argument access: {} out of {} arguments", index, LLVMCountParams(llfn));
LLVMGetParam(llfn, index)
}
}
-#[allow(missing_copy_implementations)]
-pub enum RustString_opaque {}
-pub type RustStringRef = *mut RustString_opaque;
-type RustStringRepr = *mut RefCell<Vec<u8>>;
-
-/// Appending to a Rust string -- used by raw_rust_string_ostream.
-#[no_mangle]
-pub unsafe extern "C" fn rust_llvm_string_write_impl(sr: RustStringRef,
- ptr: *const c_char,
- size: size_t) {
- let slice: &[u8] = mem::transmute(raw::Slice {
- data: ptr as *const u8,
- len: size as uint,
- });
+pub fn get_params(llfn: ValueRef) -> Vec<ValueRef> {
+ unsafe {
+ let num_params = LLVMCountParams(llfn);
+ let mut params = Vec::with_capacity(num_params as usize);
+ for idx in 0..num_params {
+ params.push(LLVMGetParam(llfn, idx));
+ }
- let sr: RustStringRepr = mem::transmute(sr);
- (*sr).borrow_mut().push_all(slice);
+ params
+ }
}
-pub fn build_string<F>(f: F) -> Option<String> where F: FnOnce(RustStringRef){
+pub fn build_string<F>(f: F) -> Option<String>
+ where F: FnOnce(RustStringRef)
+{
let mut buf = RefCell::new(Vec::new());
f(&mut buf as RustStringRepr as RustStringRef);
String::from_utf8(buf.into_inner()).ok()
}
pub unsafe fn twine_to_string(tr: TwineRef) -> String {
- build_string(|s| LLVMWriteTwineToString(tr, s))
- .expect("got a non-UTF8 Twine from LLVM")
+ build_string(|s| LLVMRustWriteTwineToString(tr, s)).expect("got a non-UTF8 Twine from LLVM")
}
pub unsafe fn debug_loc_to_string(c: ContextRef, tr: DebugLocRef) -> String {
- build_string(|s| LLVMWriteDebugLocToString(c, tr, s))
+ build_string(|s| LLVMRustWriteDebugLocToString(c, tr, s))
.expect("got a non-UTF8 DebugLoc from LLVM")
}
-// FIXME #15460 - create a public function that actually calls our
-// static LLVM symbols. Otherwise the linker will just throw llvm
-// away. We're just calling lots of stuff until we transitively get
-// all of LLVM. This is worse than anything.
-pub unsafe fn static_link_hack_this_sucks() {
- LLVMInitializePasses();
-
- LLVMInitializeX86TargetInfo();
- LLVMInitializeX86Target();
- LLVMInitializeX86TargetMC();
- LLVMInitializeX86AsmPrinter();
- LLVMInitializeX86AsmParser();
-
- LLVMInitializeARMTargetInfo();
- LLVMInitializeARMTarget();
- LLVMInitializeARMTargetMC();
- LLVMInitializeARMAsmPrinter();
- LLVMInitializeARMAsmParser();
-
- LLVMInitializeAArch64TargetInfo();
- LLVMInitializeAArch64Target();
- LLVMInitializeAArch64TargetMC();
- LLVMInitializeAArch64AsmPrinter();
- LLVMInitializeAArch64AsmParser();
-
- LLVMInitializeMipsTargetInfo();
- LLVMInitializeMipsTarget();
- LLVMInitializeMipsTargetMC();
- LLVMInitializeMipsAsmPrinter();
- LLVMInitializeMipsAsmParser();
-
- LLVMRustSetLLVMOptions(0 as c_int,
- 0 as *const _);
-
- LLVMPassManagerBuilderPopulateModulePassManager(0 as *mut _, 0 as *mut _);
- LLVMPassManagerBuilderPopulateLTOPassManager(0 as *mut _, 0 as *mut _, False, False);
- LLVMPassManagerBuilderPopulateFunctionPassManager(0 as *mut _, 0 as *mut _);
- LLVMPassManagerBuilderSetOptLevel(0 as *mut _, 0 as c_uint);
- LLVMPassManagerBuilderUseInlinerWithThreshold(0 as *mut _, 0 as c_uint);
- LLVMWriteBitcodeToFile(0 as *mut _, 0 as *const _);
- LLVMPassManagerBuilderCreate();
- LLVMPassManagerBuilderDispose(0 as *mut _);
+pub fn initialize_available_targets() {
+ macro_rules! init_target(
+ ($cfg:meta, $($method:ident),*) => { {
+ #[cfg($cfg)]
+ fn init() {
+ extern {
+ $(fn $method();)*
+ }
+ unsafe {
+ $($method();)*
+ }
+ }
+ #[cfg(not($cfg))]
+ fn init() { }
+ init();
+ } }
+ );
+ init_target!(llvm_component = "x86",
+ LLVMInitializeX86TargetInfo,
+ LLVMInitializeX86Target,
+ LLVMInitializeX86TargetMC,
+ LLVMInitializeX86AsmPrinter,
+ LLVMInitializeX86AsmParser);
+ init_target!(llvm_component = "arm",
+ LLVMInitializeARMTargetInfo,
+ LLVMInitializeARMTarget,
+ LLVMInitializeARMTargetMC,
+ LLVMInitializeARMAsmPrinter,
+ LLVMInitializeARMAsmParser);
+ init_target!(llvm_component = "aarch64",
+ LLVMInitializeAArch64TargetInfo,
+ LLVMInitializeAArch64Target,
+ LLVMInitializeAArch64TargetMC,
+ LLVMInitializeAArch64AsmPrinter,
+ LLVMInitializeAArch64AsmParser);
+ init_target!(llvm_component = "mips",
+ LLVMInitializeMipsTargetInfo,
+ LLVMInitializeMipsTarget,
+ LLVMInitializeMipsTargetMC,
+ LLVMInitializeMipsAsmPrinter,
+ LLVMInitializeMipsAsmParser);
+ init_target!(llvm_component = "powerpc",
+ LLVMInitializePowerPCTargetInfo,
+ LLVMInitializePowerPCTarget,
+ LLVMInitializePowerPCTargetMC,
+ LLVMInitializePowerPCAsmPrinter,
+ LLVMInitializePowerPCAsmParser);
+ init_target!(llvm_component = "pnacl",
+ LLVMInitializePNaClTargetInfo,
+ LLVMInitializePNaClTarget,
+ LLVMInitializePNaClTargetMC);
+ init_target!(llvm_component = "systemz",
+ LLVMInitializeSystemZTargetInfo,
+ LLVMInitializeSystemZTarget,
+ LLVMInitializeSystemZTargetMC,
+ LLVMInitializeSystemZAsmPrinter,
+ LLVMInitializeSystemZAsmParser);
+ init_target!(llvm_component = "jsbackend",
+ LLVMInitializeJSBackendTargetInfo,
+ LLVMInitializeJSBackendTarget,
+ LLVMInitializeJSBackendTargetMC);
+ init_target!(llvm_component = "msp430",
+ LLVMInitializeMSP430TargetInfo,
+ LLVMInitializeMSP430Target,
+ LLVMInitializeMSP430TargetMC,
+ LLVMInitializeMSP430AsmPrinter);
+ init_target!(llvm_component = "sparc",
+ LLVMInitializeSparcTargetInfo,
+ LLVMInitializeSparcTarget,
+ LLVMInitializeSparcTargetMC,
+ LLVMInitializeSparcAsmPrinter,
+ LLVMInitializeSparcAsmParser);
+ init_target!(llvm_component = "nvptx",
+ LLVMInitializeNVPTXTargetInfo,
+ LLVMInitializeNVPTXTarget,
+ LLVMInitializeNVPTXTargetMC,
+ LLVMInitializeNVPTXAsmPrinter);
+}
+
+pub fn last_error() -> Option<String> {
+ unsafe {
+ let cstr = LLVMRustGetLastError();
+ if cstr.is_null() {
+ None
+ } else {
+ let err = CStr::from_ptr(cstr).to_bytes();
+ let err = String::from_utf8_lossy(err).to_string();
+ libc::free(cstr as *mut _);
+ Some(err)
+ }
+ }
+}
- LLVMRustLinkInExternalBitcode(0 as *mut _, 0 as *const _, 0 as size_t);
+pub struct OperandBundleDef {
+ inner: OperandBundleDefRef,
+}
- LLVMLinkInMCJIT();
- LLVMLinkInInterpreter();
+impl OperandBundleDef {
+ pub fn new(name: &str, vals: &[ValueRef]) -> OperandBundleDef {
+ let name = CString::new(name).unwrap();
+ let def = unsafe {
+ LLVMRustBuildOperandBundleDef(name.as_ptr(), vals.as_ptr(), vals.len() as c_uint)
+ };
+ OperandBundleDef { inner: def }
+ }
- extern {
- fn LLVMLinkInMCJIT();
- fn LLVMLinkInInterpreter();
+ pub fn raw(&self) -> OperandBundleDefRef {
+ self.inner
}
}
-// The module containing the native LLVM dependencies, generated by the build system
-// Note that this must come after the rustllvm extern declaration so that
-// parts of LLVM that rustllvm depends on aren't thrown away by the linker.
-// Works to the above fix for #15460 to ensure LLVM dependencies that
-// are only used by rustllvm don't get stripped by the linker.
-mod llvmdeps {
- include! { env!("CFG_LLVM_LINKAGE_FILE") }
+impl Drop for OperandBundleDef {
+ fn drop(&mut self) {
+ unsafe {
+ LLVMRustFreeOperandBundleDef(self.inner);
+ }
+ }
}