text: /*===-- llvm-c/ExecutionEngine.h - ExecutionEngine Lib C Iface --*- C++ -*-===*\
  |*                                                                            *|
  |*                     The LLVM Compiler Infrastructure                       *|
  |*                                                                            *|
  |* This file is distributed under the University of Illinois Open Source      *|
  |* License. See LICENSE.TXT for details.                                      *|
  |*                                                                            *|
  |*===----------------------------------------------------------------------===*|
  |*                                                                            *|
  |* This header declares the C interface to libLLVMExecutionEngine.o, which    *|
  |* implements various analyses of the LLVM IR.                                *|
  |*                                                                            *|
  |* Many exotic languages can interoperate with C code but have a harder time  *|
  |* with C++ due to name mangling. So in addition to C, this interface enables *|
  |* tools written in such languages.                                           *|
  |*                                                                            *|
  \*===----------------------------------------------------------------------===*/
  
  #ifndef LLVM_C_EXECUTIONENGINE_H
  #define LLVM_C_EXECUTIONENGINE_H
  
  #include "llvm-c/Core.h"
  #include "llvm-c/Target.h"
  #include "llvm-c/TargetMachine.h"
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /**
   * @defgroup LLVMCExecutionEngine Execution Engine
   * @ingroup LLVMC
   *
   * @{
   */
  
  void LLVMLinkInJIT(void);
  void LLVMLinkInMCJIT(void);
  void LLVMLinkInInterpreter(void);
  
  typedef struct LLVMOpaqueGenericValue *LLVMGenericValueRef;
  typedef struct LLVMOpaqueExecutionEngine *LLVMExecutionEngineRef;
  typedef struct LLVMOpaqueMCJITMemoryManager *LLVMMCJITMemoryManagerRef;
  
  struct LLVMMCJITCompilerOptions {
    unsigned OptLevel;
    LLVMCodeModel CodeModel;
    LLVMBool NoFramePointerElim;
    LLVMBool EnableFastISel;
    LLVMMCJITMemoryManagerRef MCJMM;
  };
  
  /*===-- Operations on generic values --------------------------------------===*/
  
  LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty,
                                                  unsigned long long N,
                                                  LLVMBool IsSigned);
  
  LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P);
  
  LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef Ty, double N);
  
  unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef);
  
  unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenVal,
                                           LLVMBool IsSigned);
  
  void *LLVMGenericValueToPointer(LLVMGenericValueRef GenVal);
  
  double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal);
  
  void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal);
  
  /*===-- Operations on execution engines -----------------------------------===*/
  
  LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE,
                                              LLVMModuleRef M,
                                              char **OutError);
  
  LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp,
                                          LLVMModuleRef M,
                                          char **OutError);
  
  LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT,
                                          LLVMModuleRef M,
                                          unsigned OptLevel,
                                          char **OutError);
  
  void LLVMInitializeMCJITCompilerOptions(
    struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions);
  
  /**
   * Create an MCJIT execution engine for a module, with the given options. It is
   * the responsibility of the caller to ensure that all fields in Options up to
   * the given SizeOfOptions are initialized. It is correct to pass a smaller
   * value of SizeOfOptions that omits some fields. The canonical way of using
   * this is:
   *
   * LLVMMCJITCompilerOptions options;
   * LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
   * ... fill in those options you care about
   * LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
   *                                  &error);
   *
   * Note that this is also correct, though possibly suboptimal:
   *
   * LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
   */
  LLVMBool LLVMCreateMCJITCompilerForModule(
    LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M,
    struct LLVMMCJITCompilerOptions *Options, size_t SizeOfOptions,
    char **OutError);
  
  /** Deprecated: Use LLVMCreateExecutionEngineForModule instead. */
  LLVMBool LLVMCreateExecutionEngine(LLVMExecutionEngineRef *OutEE,
                                     LLVMModuleProviderRef MP,
                                     char **OutError);
  
  /** Deprecated: Use LLVMCreateInterpreterForModule instead. */
  LLVMBool LLVMCreateInterpreter(LLVMExecutionEngineRef *OutInterp,
                                 LLVMModuleProviderRef MP,
                                 char **OutError);
  
  /** Deprecated: Use LLVMCreateJITCompilerForModule instead. */
  LLVMBool LLVMCreateJITCompiler(LLVMExecutionEngineRef *OutJIT,
                                 LLVMModuleProviderRef MP,
                                 unsigned OptLevel,
                                 char **OutError);
  
  void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE);
  
  void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE);
  
  void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE);
  
  int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F,
                            unsigned ArgC, const char * const *ArgV,
                            const char * const *EnvP);
  
  LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F,
                                      unsigned NumArgs,
                                      LLVMGenericValueRef *Args);
  
  void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F);
  
  void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M);
  
  /** Deprecated: Use LLVMAddModule instead. */
  void LLVMAddModuleProvider(LLVMExecutionEngineRef EE, LLVMModuleProviderRef MP);
  
  LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M,
                            LLVMModuleRef *OutMod, char **OutError);
  
  /** Deprecated: Use LLVMRemoveModule instead. */
  LLVMBool LLVMRemoveModuleProvider(LLVMExecutionEngineRef EE,
                                    LLVMModuleProviderRef MP,
                                    LLVMModuleRef *OutMod, char **OutError);
  
  LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name,
                            LLVMValueRef *OutFn);
  
  void *LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE,
                                       LLVMValueRef Fn);
  
  LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE);
  
  void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global,
                            void* Addr);
  
  void *LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global);
  
  /*===-- Operations on memory managers -------------------------------------===*/
  
  typedef uint8_t *(*LLVMMemoryManagerAllocateCodeSectionCallback)(
    void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
    const char *SectionName);
  typedef uint8_t *(*LLVMMemoryManagerAllocateDataSectionCallback)(
    void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID,
    const char *SectionName, LLVMBool IsReadOnly);
  typedef LLVMBool (*LLVMMemoryManagerFinalizeMemoryCallback)(
    void *Opaque, char **ErrMsg);
  typedef void (*LLVMMemoryManagerDestroyCallback)(void *Opaque);
  
  /**
   * Create a simple custom MCJIT memory manager. This memory manager can
   * intercept allocations in a module-oblivious way. This will return NULL
   * if any of the passed functions are NULL.
   *
   * @param Opaque An opaque client object to pass back to the callbacks.
   * @param AllocateCodeSection Allocate a block of memory for executable code.
   * @param AllocateDataSection Allocate a block of memory for data.
   * @param FinalizeMemory Set page permissions and flush cache. Return 0 on
   *   success, 1 on error.
   */
  LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(
    void *Opaque,
    LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection,
    LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection,
    LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory,
    LLVMMemoryManagerDestroyCallback Destroy);
  
  void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM);
  
  /**
   * @}
   */
  
  #ifdef __cplusplus
  }
  #endif /* defined(__cplusplus) */
  
  #endif
  