mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-11-04 06:09:05 +00:00
0e1327e4aa
CodeModel: It's now possible to create an MCJIT instance with any CodeModel you like. Previously it was only possible to create an MCJIT that used CodeModel::JITDefault. EnableFastISel: It's now possible to turn on the fast instruction selector. The CodeModel option required some trickery. The problem is that previously, we were ensuring future binary compatibility in the MCJITCompilerOptions by mandating that the user bzero's the options struct and passes the sizeof() that he saw; the bindings then bzero the remaining bits. This works great but assumes that the bitwise zero equivalent of any field is a sensible default value. But this is not the case for LLVMCodeModel, or its internal equivalent, llvm::CodeModel::Model. In both of those, the default for a JIT is CodeModel::JITDefault (or LLVMCodeModelJITDefault), which is not bitwise zero. Hence this change introduces LLVMInitializeMCJITCompilerOptions(), which will initialize the user's options struct with defaults. The user will use this in the same way that they would have previously used memset() or bzero(). MCJITCAPITest.cpp illustrates the change, as does the comment in ExecutionEngine.h. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@180893 91177308-0d34-0410-b5e6-96231b3b80d8
179 lines
7.0 KiB
C++
179 lines
7.0 KiB
C++
/*===-- 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;
|
|
|
|
struct LLVMMCJITCompilerOptions {
|
|
unsigned OptLevel;
|
|
LLVMCodeModel CodeModel;
|
|
LLVMBool NoFramePointerElim;
|
|
LLVMBool EnableFastISel;
|
|
};
|
|
|
|
/*===-- 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);
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /* defined(__cplusplus) */
|
|
|
|
#endif
|