1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! The ORC JIT.

use super::error::LLVMErrorRef;
use super::prelude::*;
use super::target_machine::LLVMTargetMachineRef;

#[derive(Debug)]
pub enum LLVMOrcOpaqueJITStack {}

pub type LLVMOrcJITStackRef = *mut LLVMOrcOpaqueJITStack;
pub type LLVMOrcModuleHandle = u64;
pub type LLVMOrcTargetAddress = u64;

pub type LLVMOrcSymbolResolverFn =
    Option<extern "C" fn(*const ::libc::c_char, *mut ::libc::c_void) -> u64>;
pub type LLVMOrcLazyCompileCallbackFn =
    Option<extern "C" fn(LLVMOrcJITStackRef, *mut ::libc::c_void)>;
extern "C" {
    /// Create an ORC JIT stack.
    ///
    /// The client owns the returned stack and must call OrcDisposeInstance
    /// when done with it. The JIT stack takes ownership of the provided
    /// TargetMachine.
    pub fn LLVMOrcCreateInstance(TM: LLVMTargetMachineRef) -> LLVMOrcJITStackRef;

    /// Get the error message for the most recent error (if any).
    ///
    /// The returned message is owned by the ORC JIT stack.
    pub fn LLVMOrcGetErrorMsg(JITStack: LLVMOrcJITStackRef) -> *const ::libc::c_char;

    /// Mangle the given symbol.
    ///
    /// Memory is allocated for the mangled symbol, which will be owned by
    /// the client.
    pub fn LLVMOrcGetMangledSymbol(
        JITStack: LLVMOrcJITStackRef,
        MangledSymbol: *mut *mut ::libc::c_char,
        Symbol: *const ::libc::c_char,
    );

    /// Dispose of a mangled symbol.
    pub fn LLVMOrcDisposeMangledSymbol(MangledSymbol: *mut ::libc::c_char);

    /// Create a lazy compile callback.
    pub fn LLVMOrcCreateLazyCompileCallback(
        JITStack: LLVMOrcJITStackRef,
        RetAddr: *mut LLVMOrcTargetAddress,
        Callback: LLVMOrcLazyCompileCallbackFn,
        CallbackCtx: *mut ::libc::c_void,
    ) -> LLVMErrorRef;

    /// Create a named indirect call stub.
    pub fn LLVMOrcCreateIndirectStub(
        JITStack: LLVMOrcJITStackRef,
        StubName: *const ::libc::c_char,
        InitAddr: LLVMOrcTargetAddress,
    ) -> LLVMErrorRef;

    /// Set the pointer for the given indirect stub.
    pub fn LLVMOrcSetIndirectStubPointer(
        JITStack: LLVMOrcJITStackRef,
        StubName: *const ::libc::c_char,
        NewAddr: LLVMOrcTargetAddress,
    ) -> LLVMErrorRef;

    /// Add a module to be eagerly compiled.
    pub fn LLVMOrcAddEagerlyCompiledIR(
        JITStack: LLVMOrcJITStackRef,
        RetHandle: *mut LLVMOrcModuleHandle,
        Mod: LLVMModuleRef,
        SymbolResolver: LLVMOrcSymbolResolverFn,
        SymbolResolverCtx: *mut ::libc::c_void,
    ) -> LLVMErrorRef;

    /// Add a module to be lazily compiled one function at a time.
    pub fn LLVMOrcAddLazilyCompiledIR(
        JITStack: LLVMOrcJITStackRef,
        RetHandle: *mut LLVMOrcModuleHandle,
        Mod: LLVMModuleRef,
        SymbolResolver: LLVMOrcSymbolResolverFn,
        SymbolResolverCtx: *mut ::libc::c_void,
    ) -> LLVMErrorRef;

    /// Add an object file.
    pub fn LLVMOrcAddObjectFile(
        JITStack: LLVMOrcJITStackRef,
        RetHandle: *mut LLVMOrcModuleHandle,
        Obj: LLVMMemoryBufferRef,
        SymbolResolver: LLVMOrcSymbolResolverFn,
        SymbolResolverCtx: *mut ::libc::c_void,
    ) -> LLVMErrorRef;

    /// Remove a module set from the JIT.
    pub fn LLVMOrcRemoveModule(
        JITStack: LLVMOrcJITStackRef,
        H: LLVMOrcModuleHandle,
    ) -> LLVMErrorRef;

    /// Get symbol address from JIT instance.
    pub fn LLVMOrcGetSymbolAddress(
        JITStack: LLVMOrcJITStackRef,
        RetAddr: *mut LLVMOrcTargetAddress,
        SymbolName: *const ::libc::c_char,
    ) -> LLVMErrorRef;

    /// Get symbol address from JIT instance, searching only the specified handle.
    pub fn LLVMOrcGetSymbolAddressIn(
        JITStack: LLVMOrcJITStackRef,
        RetAddr: *mut LLVMOrcTargetAddress,
        H: LLVMOrcModuleHandle,
        SymbolName: *const ::libc::c_char,
    ) -> LLVMErrorRef;

    /// Dispose of an ORC JIT stack.
    pub fn LLVMOrcDisposeInstance(JITStack: LLVMOrcJITStackRef) -> LLVMErrorRef;

    /// Register a JIT Event Listener.
    ///
    /// A NULL listener is ignored.
    pub fn LLVMOrcRegisterJITEventListener(
        JITStack: LLVMOrcJITStackRef,
        L: LLVMJITEventListenerRef,
    );

    /// Unegister a JIT Event Listener.
    ///
    /// A NULL listener is ignored.
    pub fn LLVMOrcUnregisterJITEventListener(
        JITStack: LLVMOrcJITStackRef,
        L: LLVMJITEventListenerRef,
    );
}