27 #define DEBUG_TYPE "jit"
70 return unwrap(GenValRef)->IntVal.getBitWidth();
83 return unwrap(GenVal)->PointerVal;
89 return unwrap(GenVal)->FloatVal;
91 return unwrap(GenVal)->DoubleVal;
114 *OutError = strdup(Error.c_str());
126 *OutInterp =
wrap(Interp);
129 *OutError = strdup(Error.c_str());
146 *OutError = strdup(Error.c_str());
151 size_t SizeOfPassedOptions) {
153 memset(&options, 0,
sizeof(options));
156 memcpy(PassedOptions, &options,
157 std::min(
sizeof(options), SizeOfPassedOptions));
167 if (SizeOfPassedOptions >
sizeof(options)) {
169 "Refusing to use options struct that is larger than my own; assuming "
170 "LLVM library mismatch.");
179 memcpy(&options, PassedOptions, SizeOfPassedOptions);
183 std::unique_ptr<Module> Mod(
unwrap(M));
188 for (
auto &
F : *Mod) {
189 auto Attrs =
F.getAttributes();
192 "no-frame-pointer-elim", Value);
193 F.setAttributes(Attrs);
205 std::unique_ptr<RTDyldMemoryManager>(
unwrap(options.
MCJMM)));
210 *OutError = strdup(Error.c_str());
219 unwrap(EE)->finalizeObject();
220 unwrap(EE)->runStaticConstructorsDestructors(
false);
224 unwrap(EE)->finalizeObject();
225 unwrap(EE)->runStaticConstructorsDestructors(
true);
229 unsigned ArgC,
const char *
const *ArgV,
230 const char *
const *EnvP) {
231 unwrap(EE)->finalizeObject();
233 std::vector<std::string> ArgVec(ArgV, ArgV + ArgC);
234 return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
240 unwrap(EE)->finalizeObject();
242 std::vector<GenericValue> ArgVec;
243 ArgVec.reserve(NumArgs);
244 for (
unsigned I = 0;
I != NumArgs; ++
I)
245 ArgVec.push_back(*
unwrap(Args[
I]));
248 *Result =
unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
256 unwrap(EE)->addModule(std::unique_ptr<Module>(
unwrap(M)));
262 unwrap(EE)->removeModule(Mod);
292 unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
296 unwrap(EE)->finalizeObject();
298 return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
302 return unwrap(EE)->getGlobalValueAddress(Name);
306 return unwrap(EE)->getFunctionAddress(Name);
313 struct SimpleBindingMMFunctions {
322 SimpleBindingMemoryManager(
const SimpleBindingMMFunctions& Functions,
324 ~SimpleBindingMemoryManager()
override;
326 uint8_t *allocateCodeSection(uintptr_t Size,
unsigned Alignment,
330 uint8_t *allocateDataSection(uintptr_t Size,
unsigned Alignment,
334 bool finalizeMemory(std::string *ErrMsg)
override;
337 SimpleBindingMMFunctions Functions;
341 SimpleBindingMemoryManager::SimpleBindingMemoryManager(
342 const SimpleBindingMMFunctions& Functions,
344 : Functions(Functions), Opaque(Opaque) {
345 assert(Functions.AllocateCodeSection &&
346 "No AllocateCodeSection function provided!");
347 assert(Functions.AllocateDataSection &&
348 "No AllocateDataSection function provided!");
349 assert(Functions.FinalizeMemory &&
350 "No FinalizeMemory function provided!");
351 assert(Functions.Destroy &&
352 "No Destroy function provided!");
355 SimpleBindingMemoryManager::~SimpleBindingMemoryManager() {
356 Functions.Destroy(Opaque);
359 uint8_t *SimpleBindingMemoryManager::allocateCodeSection(
360 uintptr_t Size,
unsigned Alignment,
unsigned SectionID,
362 return Functions.AllocateCodeSection(Opaque, Size, Alignment, SectionID,
363 SectionName.
str().c_str());
366 uint8_t *SimpleBindingMemoryManager::allocateDataSection(
367 uintptr_t Size,
unsigned Alignment,
unsigned SectionID,
369 return Functions.AllocateDataSection(Opaque, Size, Alignment, SectionID,
370 SectionName.
str().c_str(),
374 bool SimpleBindingMemoryManager::finalizeMemory(std::string *ErrMsg) {
375 char *errMsgCString =
nullptr;
376 bool result = Functions.FinalizeMemory(Opaque, &errMsgCString);
377 assert((result || !errMsgCString) &&
378 "Did not expect an error message if FinalizeMemory succeeded");
381 *ErrMsg = errMsgCString;
396 if (!AllocateCodeSection || !AllocateDataSection || !FinalizeMemory ||
401 functions.AllocateCodeSection = AllocateCodeSection;
402 functions.AllocateDataSection = AllocateDataSection;
403 functions.FinalizeMemory = FinalizeMemory;
404 functions.Destroy = Destroy;
405 return wrap(
new SimpleBindingMemoryManager(functions, Opaque));
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
LLVMBool(* LLVMMemoryManagerFinalizeMemoryCallback)(void *Opaque, char **ErrMsg)
LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N)
uint64_t getZExtValue() const
Get zero extended value.
void LLVMInitializeMCJITCompilerOptions(LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions)
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
LLVMMCJITMemoryManagerRef MCJMM
struct LLVMOpaqueExecutionEngine * LLVMExecutionEngineRef
unsigned EnableFastISel
EnableFastISel - This flag enables fast-path instruction selection which trades away generated code q...
A Module instance is used to store all the information related to an LLVM module. ...
2: 32-bit floating point type
void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE)
void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal)
void * LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn)
LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M, unsigned OptLevel, char **OutError)
double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal)
void * LLVMGenericValueToPointer(LLVMGenericValueRef GenVal)
struct LLVMOpaqueMCJITMemoryManager * LLVMMCJITMemoryManagerRef
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
struct LLVMOpaqueTargetMachine * LLVMTargetMachineRef
Attribute unwrap(LLVMAttributeRef Attr)
LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P)
void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global, void *Addr)
always Inliner for always_inline functions
struct LLVMOpaqueType * LLVMTypeRef
Each value in the LLVM IR has a type, an LLVMTypeRef.
void(* LLVMMemoryManagerDestroyCallback)(void *Opaque)
uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name)
EngineBuilder & setCodeModel(CodeModel::Model M)
setCodeModel - Set the CodeModel that the ExecutionEngine target data is using.
LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(void *Opaque, LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection, LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection, LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory, LLVMMemoryManagerDestroyCallback Destroy)
Create a simple custom MCJIT memory manager.
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with etc Experimental Use value profile to guide fuzzing Number of simultaneous worker processes to run the jobs If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F, unsigned ArgC, const char *const *ArgV, const char *const *EnvP)
EngineBuilder & setEngineKind(EngineKind::Kind w)
setEngineKind - Controls whether the user wants the interpreter, the JIT, or whichever engine works...
LLVMBool NoFramePointerElim
LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE, LLVMModuleRef M, char **OutError)
int64_t getSExtValue() const
Get sign extended value.
EngineBuilder & setErrorStr(std::string *e)
setErrorStr - Set the error string to write to on error.
LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty, unsigned long long N, LLVMBool IsSigned)
LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE)
void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM)
void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE)
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Abstract interface for implementation execution of LLVM modules, designed to support both interpreter...
void * LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global)
EngineBuilder & setTargetOptions(const TargetOptions &Opts)
setTargetOptions - Set the target options that the ExecutionEngine target is using.
static bool isReadOnly(const GlobalValue *GV)
Module.h This file contains the declarations for the Module class.
uint8_t *(* LLVMMemoryManagerAllocateDataSectionCallback)(void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID, const char *SectionName, LLVMBool IsReadOnly)
LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp, LLVMModuleRef M, char **OutError)
Class for arbitrary precision integers.
static char getTypeID(Type *Ty)
static LLVMTargetMachineRef wrap(const TargetMachine *P)
ExecutionEngine * create()
void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE)
LLVMAttributeRef wrap(Attribute Attr)
void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M)
uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name)
unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef, LLVMBool IsSigned)
LLVMTargetMachineRef LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE)
LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F, unsigned NumArgs, LLVMGenericValueRef *Args)
uint8_t *(* LLVMMemoryManagerAllocateCodeSectionCallback)(void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID, const char *SectionName)
Builder class for ExecutionEngines.
EngineBuilder & setMCJITMemoryManager(std::unique_ptr< RTDyldMemoryManager > mcjmm)
setMCJITMemoryManager - Sets the MCJIT memory manager to use.
unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef)
3: 64-bit floating point type
LLVMBool LLVMCreateMCJITCompilerForModule(LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M, LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions, char **OutError)
Create an MCJIT execution engine for a module, with the given options.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F)
Primary interface to the complete machine description for the target machine.
StringRef - Represent a constant reference to a string, i.e.
struct LLVMOpaqueGenericValue * LLVMGenericValueRef
EngineBuilder & setOptLevel(CodeGenOpt::Level l)
setOptLevel - Set the optimization level for the JIT.
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
struct LLVMOpaqueTargetData * LLVMTargetDataRef
LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name, LLVMValueRef *OutFn)
LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M, LLVMModuleRef *OutMod, char **OutError)