LLVM  14.0.0git
ExecutionEngineBindings.cpp
Go to the documentation of this file.
1 //===-- ExecutionEngineBindings.cpp - C bindings for EEs ------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the C bindings for the ExecutionEngine library.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "llvm-c/ExecutionEngine.h"
18 #include "llvm/IR/DerivedTypes.h"
19 #include "llvm/IR/Module.h"
23 #include <cstring>
24 
25 using namespace llvm;
26 
27 #define DEBUG_TYPE "jit"
28 
29 // Wrapping the C bindings types.
31 
32 
34  return
35  reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine*>(P));
36 }
37 
38 /*===-- Operations on generic values --------------------------------------===*/
39 
41  unsigned long long N,
42  LLVMBool IsSigned) {
43  GenericValue *GenVal = new GenericValue();
44  GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
45  return wrap(GenVal);
46 }
47 
49  GenericValue *GenVal = new GenericValue();
50  GenVal->PointerVal = P;
51  return wrap(GenVal);
52 }
53 
55  GenericValue *GenVal = new GenericValue();
56  switch (unwrap(TyRef)->getTypeID()) {
57  case Type::FloatTyID:
58  GenVal->FloatVal = N;
59  break;
60  case Type::DoubleTyID:
61  GenVal->DoubleVal = N;
62  break;
63  default:
64  llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
65  }
66  return wrap(GenVal);
67 }
68 
70  return unwrap(GenValRef)->IntVal.getBitWidth();
71 }
72 
73 unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef,
74  LLVMBool IsSigned) {
75  GenericValue *GenVal = unwrap(GenValRef);
76  if (IsSigned)
77  return GenVal->IntVal.getSExtValue();
78  else
79  return GenVal->IntVal.getZExtValue();
80 }
81 
83  return unwrap(GenVal)->PointerVal;
84 }
85 
87  switch (unwrap(TyRef)->getTypeID()) {
88  case Type::FloatTyID:
89  return unwrap(GenVal)->FloatVal;
90  case Type::DoubleTyID:
91  return unwrap(GenVal)->DoubleVal;
92  default:
93  llvm_unreachable("LLVMGenericValueToFloat supports only float and double.");
94  }
95 }
96 
98  delete unwrap(GenVal);
99 }
100 
101 /*===-- Operations on execution engines -----------------------------------===*/
102 
104  LLVMModuleRef M,
105  char **OutError) {
106  std::string Error;
107  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
108  builder.setEngineKind(EngineKind::Either)
109  .setErrorStr(&Error);
110  if (ExecutionEngine *EE = builder.create()){
111  *OutEE = wrap(EE);
112  return 0;
113  }
114  *OutError = strdup(Error.c_str());
115  return 1;
116 }
117 
119  LLVMModuleRef M,
120  char **OutError) {
121  std::string Error;
122  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
123  builder.setEngineKind(EngineKind::Interpreter)
124  .setErrorStr(&Error);
125  if (ExecutionEngine *Interp = builder.create()) {
126  *OutInterp = wrap(Interp);
127  return 0;
128  }
129  *OutError = strdup(Error.c_str());
130  return 1;
131 }
132 
134  LLVMModuleRef M,
135  unsigned OptLevel,
136  char **OutError) {
137  std::string Error;
138  EngineBuilder builder(std::unique_ptr<Module>(unwrap(M)));
139  builder.setEngineKind(EngineKind::JIT)
140  .setErrorStr(&Error)
141  .setOptLevel((CodeGenOpt::Level)OptLevel);
142  if (ExecutionEngine *JIT = builder.create()) {
143  *OutJIT = wrap(JIT);
144  return 0;
145  }
146  *OutError = strdup(Error.c_str());
147  return 1;
148 }
149 
151  size_t SizeOfPassedOptions) {
153  memset(&options, 0, sizeof(options)); // Most fields are zero by default.
154  options.CodeModel = LLVMCodeModelJITDefault;
155 
156  memcpy(PassedOptions, &options,
157  std::min(sizeof(options), SizeOfPassedOptions));
158 }
159 
162  LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions,
163  char **OutError) {
165  // If the user passed a larger sized options struct, then they were compiled
166  // against a newer LLVM. Tell them that something is wrong.
167  if (SizeOfPassedOptions > sizeof(options)) {
168  *OutError = strdup(
169  "Refusing to use options struct that is larger than my own; assuming "
170  "LLVM library mismatch.");
171  return 1;
172  }
173 
174  // Defend against the user having an old version of the API by ensuring that
175  // any fields they didn't see are cleared. We must defend against fields being
176  // set to the bitwise equivalent of zero, and assume that this means "do the
177  // default" as if that option hadn't been available.
179  memcpy(&options, PassedOptions, SizeOfPassedOptions);
180 
181  TargetOptions targetOptions;
182  targetOptions.EnableFastISel = options.EnableFastISel;
183  std::unique_ptr<Module> Mod(unwrap(M));
184 
185  if (Mod)
186  // Set function attribute "frame-pointer" based on
187  // NoFramePointerElim.
188  for (auto &F : *Mod) {
189  auto Attrs = F.getAttributes();
190  StringRef Value = options.NoFramePointerElim ? "all" : "none";
191  Attrs = Attrs.addFnAttribute(F.getContext(), "frame-pointer", Value);
192  F.setAttributes(Attrs);
193  }
194 
195  std::string Error;
197  builder.setEngineKind(EngineKind::JIT)
198  .setErrorStr(&Error)
199  .setOptLevel((CodeGenOpt::Level)options.OptLevel)
200  .setTargetOptions(targetOptions);
201  bool JIT;
202  if (Optional<CodeModel::Model> CM = unwrap(options.CodeModel, JIT))
203  builder.setCodeModel(*CM);
204  if (options.MCJMM)
205  builder.setMCJITMemoryManager(
206  std::unique_ptr<RTDyldMemoryManager>(unwrap(options.MCJMM)));
207  if (ExecutionEngine *JIT = builder.create()) {
208  *OutJIT = wrap(JIT);
209  return 0;
210  }
211  *OutError = strdup(Error.c_str());
212  return 1;
213 }
214 
216  delete unwrap(EE);
217 }
218 
220  unwrap(EE)->finalizeObject();
221  unwrap(EE)->runStaticConstructorsDestructors(false);
222 }
223 
225  unwrap(EE)->finalizeObject();
226  unwrap(EE)->runStaticConstructorsDestructors(true);
227 }
228 
230  unsigned ArgC, const char * const *ArgV,
231  const char * const *EnvP) {
232  unwrap(EE)->finalizeObject();
233 
234  std::vector<std::string> ArgVec(ArgV, ArgV + ArgC);
235  return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
236 }
237 
239  unsigned NumArgs,
241  unwrap(EE)->finalizeObject();
242 
243  std::vector<GenericValue> ArgVec;
244  ArgVec.reserve(NumArgs);
245  for (unsigned I = 0; I != NumArgs; ++I)
246  ArgVec.push_back(*unwrap(Args[I]));
247 
248  GenericValue *Result = new GenericValue();
249  *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
250  return wrap(Result);
251 }
252 
254 }
255 
257  unwrap(EE)->addModule(std::unique_ptr<Module>(unwrap(M)));
258 }
259 
261  LLVMModuleRef *OutMod, char **OutError) {
262  Module *Mod = unwrap(M);
263  unwrap(EE)->removeModule(Mod);
264  *OutMod = wrap(Mod);
265  return 0;
266 }
267 
269  LLVMValueRef *OutFn) {
270  if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
271  *OutFn = wrap(F);
272  return 0;
273  }
274  return 1;
275 }
276 
278  LLVMValueRef Fn) {
279  return nullptr;
280 }
281 
283  return wrap(&unwrap(EE)->getDataLayout());
284 }
285 
288  return wrap(unwrap(EE)->getTargetMachine());
289 }
290 
292  void* Addr) {
293  unwrap(EE)->addGlobalMapping(unwrap<GlobalValue>(Global), Addr);
294 }
295 
297  unwrap(EE)->finalizeObject();
298 
299  return unwrap(EE)->getPointerToGlobal(unwrap<GlobalValue>(Global));
300 }
301 
303  return unwrap(EE)->getGlobalValueAddress(Name);
304 }
305 
307  return unwrap(EE)->getFunctionAddress(Name);
308 }
309 
311  char **OutError) {
312  assert(OutError && "OutError must be non-null");
313  auto *ExecEngine = unwrap(EE);
314  if (ExecEngine->hasError()) {
315  *OutError = strdup(ExecEngine->getErrorMessage().c_str());
316  ExecEngine->clearErrorMessage();
317  return true;
318  }
319  return false;
320 }
321 
322 /*===-- Operations on memory managers -------------------------------------===*/
323 
324 namespace {
325 
326 struct SimpleBindingMMFunctions {
331 };
332 
333 class SimpleBindingMemoryManager : public RTDyldMemoryManager {
334 public:
335  SimpleBindingMemoryManager(const SimpleBindingMMFunctions& Functions,
336  void *Opaque);
337  ~SimpleBindingMemoryManager() override;
338 
339  uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
340  unsigned SectionID,
341  StringRef SectionName) override;
342 
343  uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
344  unsigned SectionID, StringRef SectionName,
345  bool isReadOnly) override;
346 
347  bool finalizeMemory(std::string *ErrMsg) override;
348 
349 private:
350  SimpleBindingMMFunctions Functions;
351  void *Opaque;
352 };
353 
354 SimpleBindingMemoryManager::SimpleBindingMemoryManager(
355  const SimpleBindingMMFunctions& Functions,
356  void *Opaque)
357  : Functions(Functions), Opaque(Opaque) {
358  assert(Functions.AllocateCodeSection &&
359  "No AllocateCodeSection function provided!");
360  assert(Functions.AllocateDataSection &&
361  "No AllocateDataSection function provided!");
362  assert(Functions.FinalizeMemory &&
363  "No FinalizeMemory function provided!");
364  assert(Functions.Destroy &&
365  "No Destroy function provided!");
366 }
367 
368 SimpleBindingMemoryManager::~SimpleBindingMemoryManager() {
369  Functions.Destroy(Opaque);
370 }
371 
372 uint8_t *SimpleBindingMemoryManager::allocateCodeSection(
373  uintptr_t Size, unsigned Alignment, unsigned SectionID,
375  return Functions.AllocateCodeSection(Opaque, Size, Alignment, SectionID,
376  SectionName.str().c_str());
377 }
378 
379 uint8_t *SimpleBindingMemoryManager::allocateDataSection(
380  uintptr_t Size, unsigned Alignment, unsigned SectionID,
381  StringRef SectionName, bool isReadOnly) {
382  return Functions.AllocateDataSection(Opaque, Size, Alignment, SectionID,
383  SectionName.str().c_str(),
384  isReadOnly);
385 }
386 
387 bool SimpleBindingMemoryManager::finalizeMemory(std::string *ErrMsg) {
388  char *errMsgCString = nullptr;
389  bool result = Functions.FinalizeMemory(Opaque, &errMsgCString);
390  assert((result || !errMsgCString) &&
391  "Did not expect an error message if FinalizeMemory succeeded");
392  if (errMsgCString) {
393  if (ErrMsg)
394  *ErrMsg = errMsgCString;
395  free(errMsgCString);
396  }
397  return result;
398 }
399 
400 } // anonymous namespace
401 
403  void *Opaque,
408 
409  if (!AllocateCodeSection || !AllocateDataSection || !FinalizeMemory ||
410  !Destroy)
411  return nullptr;
412 
413  SimpleBindingMMFunctions functions;
414  functions.AllocateCodeSection = AllocateCodeSection;
415  functions.AllocateDataSection = AllocateDataSection;
416  functions.FinalizeMemory = FinalizeMemory;
417  functions.Destroy = Destroy;
418  return wrap(new SimpleBindingMemoryManager(functions, Opaque));
419 }
420 
422  delete unwrap(MM);
423 }
424 
425 /*===-- JIT Event Listener functions -------------------------------------===*/
426 
427 
428 #if !LLVM_USE_INTEL_JITEVENTS
430 {
431  return nullptr;
432 }
433 #endif
434 
435 #if !LLVM_USE_OPROFILE
437 {
438  return nullptr;
439 }
440 #endif
441 
442 #if !LLVM_USE_PERF
444 {
445  return nullptr;
446 }
447 #endif
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
LLVMInitializeMCJITCompilerOptions
void LLVMInitializeMCJITCompilerOptions(LLVMMCJITCompilerOptions *PassedOptions, size_t SizeOfPassedOptions)
Definition: ExecutionEngineBindings.cpp:150
functions
amdgpu propagate attributes Late propagate attributes from kernels to functions
Definition: AMDGPUPropagateAttributes.cpp:199
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::Type::FloatTyID
@ FloatTyID
32-bit floating point type
Definition: Type.h:58
wrap
static LLVMTargetMachineRef wrap(const TargetMachine *P)
Definition: ExecutionEngineBindings.cpp:33
LLVMFindFunction
LLVMBool LLVMFindFunction(LLVMExecutionEngineRef EE, const char *Name, LLVMValueRef *OutFn)
Definition: ExecutionEngineBindings.cpp:268
llvm::Type::DoubleTyID
@ DoubleTyID
64-bit floating point type
Definition: Type.h:59
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
LLVMDisposeGenericValue
void LLVMDisposeGenericValue(LLVMGenericValueRef GenVal)
Definition: ExecutionEngineBindings.cpp:97
LLVMMemoryManagerAllocateCodeSectionCallback
uint8_t *(* LLVMMemoryManagerAllocateCodeSectionCallback)(void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID, const char *SectionName)
Definition: ExecutionEngine.h:159
llvm::TargetOptions
Definition: TargetOptions.h:124
llvm::Function
Definition: Function.h:61
LLVMCreateGenericValueOfFloat
LLVMGenericValueRef LLVMCreateGenericValueOfFloat(LLVMTypeRef TyRef, double N)
Definition: ExecutionEngineBindings.cpp:54
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
ExecutionEngine.h
LLVMExecutionEngineRef
struct LLVMOpaqueExecutionEngine * LLVMExecutionEngineRef
Definition: ExecutionEngine.h:40
llvm::GenericValue::PointerVal
PointerTy PointerVal
Definition: GenericValue.h:31
llvm::APInt::getSExtValue
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1467
ErrorHandling.h
builder
assume builder
Definition: AssumeBundleBuilder.cpp:650
LLVMCreateJITCompilerForModule
LLVMBool LLVMCreateJITCompilerForModule(LLVMExecutionEngineRef *OutJIT, LLVMModuleRef M, unsigned OptLevel, char **OutError)
Definition: ExecutionEngineBindings.cpp:133
LLVMRunStaticConstructors
void LLVMRunStaticConstructors(LLVMExecutionEngineRef EE)
Definition: ExecutionEngineBindings.cpp:219
Module.h
llvm::EngineBuilder
Builder class for ExecutionEngines.
Definition: ExecutionEngine.h:534
LLVMGenericValueToFloat
double LLVMGenericValueToFloat(LLVMTypeRef TyRef, LLVMGenericValueRef GenVal)
Definition: ExecutionEngineBindings.cpp:86
LLVMMCJITMemoryManagerRef
struct LLVMOpaqueMCJITMemoryManager * LLVMMCJITMemoryManagerRef
Definition: ExecutionEngine.h:41
llvm::Optional< CodeModel::Model >
LLVMRecompileAndRelinkFunction
void * LLVMRecompileAndRelinkFunction(LLVMExecutionEngineRef EE, LLVMValueRef Fn)
Definition: ExecutionEngineBindings.cpp:277
getBitWidth
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type.
Definition: ValueTracking.cpp:89
LLVMAddGlobalMapping
void LLVMAddGlobalMapping(LLVMExecutionEngineRef EE, LLVMValueRef Global, void *Addr)
Definition: ExecutionEngineBindings.cpp:291
F
#define F(x, y, z)
Definition: MD5.cpp:56
DEFINE_SIMPLE_CONVERSION_FUNCTIONS
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
Definition: CBindingWrapping.h:19
LLVMTargetDataRef
struct LLVMOpaqueTargetData * LLVMTargetDataRef
Definition: DataLayout.h:40
result
It looks like we only need to define PPCfmarto for these because according to these instructions perform RTO on fma s result
Definition: README_P9.txt:256
llvm::RTDyldMemoryManager
Definition: RTDyldMemoryManager.h:60
LLVMGenericValueToPointer
void * LLVMGenericValueToPointer(LLVMGenericValueRef GenVal)
Definition: ExecutionEngineBindings.cpp:82
llvm::GenericValue
Definition: GenericValue.h:23
llvm::GenericValue::IntVal
APInt IntVal
Definition: GenericValue.h:35
LLVMCreateOProfileJITEventListener
LLVMJITEventListenerRef LLVMCreateOProfileJITEventListener(void)
Definition: ExecutionEngineBindings.cpp:436
LLVMGetFunctionAddress
uint64_t LLVMGetFunctionAddress(LLVMExecutionEngineRef EE, const char *Name)
Definition: ExecutionEngineBindings.cpp:306
LLVMCreateGenericValueOfPointer
LLVMGenericValueRef LLVMCreateGenericValueOfPointer(void *P)
Definition: ExecutionEngineBindings.cpp:48
LLVMCreateSimpleMCJITMemoryManager
LLVMMCJITMemoryManagerRef LLVMCreateSimpleMCJITMemoryManager(void *Opaque, LLVMMemoryManagerAllocateCodeSectionCallback AllocateCodeSection, LLVMMemoryManagerAllocateDataSectionCallback AllocateDataSection, LLVMMemoryManagerFinalizeMemoryCallback FinalizeMemory, LLVMMemoryManagerDestroyCallback Destroy)
Create a simple custom MCJIT memory manager.
Definition: ExecutionEngineBindings.cpp:402
LLVMCodeModelJITDefault
@ LLVMCodeModelJITDefault
Definition: TargetMachine.h:50
LLVMRunFunctionAsMain
int LLVMRunFunctionAsMain(LLVMExecutionEngineRef EE, LLVMValueRef F, unsigned ArgC, const char *const *ArgV, const char *const *EnvP)
Definition: ExecutionEngineBindings.cpp:229
llvm::unwrap
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:256
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1453
LLVMTypeRef
struct LLVMOpaqueType * LLVMTypeRef
Each value in the LLVM IR has a type, an LLVMTypeRef.
Definition: Types.h:68
GenericValue.h
LLVMCreateIntelJITEventListener
LLVMJITEventListenerRef LLVMCreateIntelJITEventListener(void)
Definition: ExecutionEngineBindings.cpp:429
LLVMCreatePerfJITEventListener
LLVMJITEventListenerRef LLVMCreatePerfJITEventListener(void)
Definition: ExecutionEngineBindings.cpp:443
CodeGenCWrappers.h
LLVMCreateGenericValueOfInt
LLVMGenericValueRef LLVMCreateGenericValueOfInt(LLVMTypeRef Ty, unsigned long long N, LLVMBool IsSigned)
Definition: ExecutionEngineBindings.cpp:40
LLVMMemoryManagerFinalizeMemoryCallback
LLVMBool(* LLVMMemoryManagerFinalizeMemoryCallback)(void *Opaque, char **ErrMsg)
Definition: ExecutionEngine.h:165
LLVMMCJITCompilerOptions
Definition: ExecutionEngine.h:43
LLVMDisposeMCJITMemoryManager
void LLVMDisposeMCJITMemoryManager(LLVMMCJITMemoryManagerRef MM)
Definition: ExecutionEngineBindings.cpp:421
LLVMDisposeExecutionEngine
void LLVMDisposeExecutionEngine(LLVMExecutionEngineRef EE)
Definition: ExecutionEngineBindings.cpp:215
LLVMCreateExecutionEngineForModule
LLVMBool LLVMCreateExecutionEngineForModule(LLVMExecutionEngineRef *OutEE, LLVMModuleRef M, char **OutError)
Definition: ExecutionEngineBindings.cpp:103
uint64_t
llvm::EngineKind::JIT
@ JIT
Definition: ExecutionEngine.h:524
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
LLVMTargetMachineRef
typedefLLVM_C_EXTERN_C_BEGIN struct LLVMOpaqueTargetMachine * LLVMTargetMachineRef
Definition: TargetMachine.h:28
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:80
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
I
#define I(x, y, z)
Definition: MD5.cpp:59
LLVMGetExecutionEngineTargetData
LLVMTargetDataRef LLVMGetExecutionEngineTargetData(LLVMExecutionEngineRef EE)
Definition: ExecutionEngineBindings.cpp:282
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:79
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
LLVMGetPointerToGlobal
void * LLVMGetPointerToGlobal(LLVMExecutionEngineRef EE, LLVMValueRef Global)
Definition: ExecutionEngineBindings.cpp:296
LLVMMemoryManagerAllocateDataSectionCallback
uint8_t *(* LLVMMemoryManagerAllocateDataSectionCallback)(void *Opaque, uintptr_t Size, unsigned Alignment, unsigned SectionID, const char *SectionName, LLVMBool IsReadOnly)
Definition: ExecutionEngine.h:162
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::EngineKind::Either
const static Kind Either
Definition: ExecutionEngine.h:527
llvm::TargetOptions::EnableFastISel
unsigned EnableFastISel
EnableFastISel - This flag enables fast-path instruction selection which trades away generated code q...
Definition: TargetOptions.h:224
llvm::APInt
Class for arbitrary precision integers.
Definition: APInt.h:75
llvm::wrap
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:251
TargetOptions.h
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
llvm::CodeGenOpt::Level
Level
Definition: CodeGen.h:52
llvm::GenericValue::DoubleVal
double DoubleVal
Definition: GenericValue.h:29
LLVMAddModule
void LLVMAddModule(LLVMExecutionEngineRef EE, LLVMModuleRef M)
Definition: ExecutionEngineBindings.cpp:256
RTDyldMemoryManager.h
LLVMRunStaticDestructors
void LLVMRunStaticDestructors(LLVMExecutionEngineRef EE)
Definition: ExecutionEngineBindings.cpp:224
llvm::GenericValue::FloatVal
float FloatVal
Definition: GenericValue.h:30
llvm::ExecutionEngine
Abstract interface for implementation execution of LLVM modules, designed to support both interpreter...
Definition: ExecutionEngine.h:99
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
LLVMBool
int LLVMBool
Definition: Types.h:28
LLVMGenericValueToInt
unsigned long long LLVMGenericValueToInt(LLVMGenericValueRef GenValRef, LLVMBool IsSigned)
Definition: ExecutionEngineBindings.cpp:73
llvm::SectionName
Definition: DWARFSection.h:21
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
options
The object format emitted by the WebAssembly backed is documented see the home and packaging for producing WebAssembly applications that can run in browsers and other environments wasi sdk provides a more minimal C C SDK based on llvm and a libc based on for producing WebAssemmbly applictions that use the WASI ABI Rust provides WebAssembly support integrated into Cargo There are two main options
Definition: README.txt:24
LLVMCreateInterpreterForModule
LLVMBool LLVMCreateInterpreterForModule(LLVMExecutionEngineRef *OutInterp, LLVMModuleRef M, char **OutError)
Definition: ExecutionEngineBindings.cpp:118
getTypeID
static char getTypeID(Type *Ty)
Definition: ExternalFunctions.cpp:73
ExecutionEngine.h
LLVMExecutionEngineGetErrMsg
LLVMBool LLVMExecutionEngineGetErrMsg(LLVMExecutionEngineRef EE, char **OutError)
Returns true on error, false on success.
Definition: ExecutionEngineBindings.cpp:310
LLVMRunFunction
LLVMGenericValueRef LLVMRunFunction(LLVMExecutionEngineRef EE, LLVMValueRef F, unsigned NumArgs, LLVMGenericValueRef *Args)
Definition: ExecutionEngineBindings.cpp:238
LLVMCreateMCJITCompilerForModule
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.
Definition: ExecutionEngineBindings.cpp:160
LLVMGenericValueIntWidth
unsigned LLVMGenericValueIntWidth(LLVMGenericValueRef GenValRef)
Definition: ExecutionEngineBindings.cpp:69
LLVMGetExecutionEngineTargetMachine
LLVMTargetMachineRef LLVMGetExecutionEngineTargetMachine(LLVMExecutionEngineRef EE)
Definition: ExecutionEngineBindings.cpp:287
LLVMFreeMachineCodeForFunction
void LLVMFreeMachineCodeForFunction(LLVMExecutionEngineRef EE, LLVMValueRef F)
Definition: ExecutionEngineBindings.cpp:253
LLVMGetGlobalValueAddress
uint64_t LLVMGetGlobalValueAddress(LLVMExecutionEngineRef EE, const char *Name)
Definition: ExecutionEngineBindings.cpp:302
N
#define N
LLVMValueRef
struct LLVMOpaqueValue * LLVMValueRef
Represents an individual value in LLVM IR.
Definition: Types.h:75
DerivedTypes.h
LLVMMemoryManagerDestroyCallback
void(* LLVMMemoryManagerDestroyCallback)(void *Opaque)
Definition: ExecutionEngine.h:167
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::EngineKind::Interpreter
@ Interpreter
Definition: ExecutionEngine.h:525
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
LLVMRemoveModule
LLVMBool LLVMRemoveModule(LLVMExecutionEngineRef EE, LLVMModuleRef M, LLVMModuleRef *OutMod, char **OutError)
Definition: ExecutionEngineBindings.cpp:260
LLVMJITEventListenerRef
struct LLVMOpaqueJITEventListener * LLVMJITEventListenerRef
Definition: Types.h:163
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
JITEventListener.h
LLVMModuleRef
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Types.h:61
LLVMGenericValueRef
struct LLVMOpaqueGenericValue * LLVMGenericValueRef
Definition: ExecutionEngine.h:39