/external/llvm/lib/ExecutionEngine/JIT/ |
H A D | JITEmitter.cpp | 10 // This file defines a MachineCodeEmitter object that is used by the JIT to 16 #include "JIT.h" 69 // JIT lazy compilation code. 79 llvm_unreachable("The JIT doesn't know how to handle a" 111 /// Instance of the JIT this ResolverState serves. 112 JIT *TheJIT; 115 JITResolverState(JIT *jit) : FunctionToLazyStubMap(this), 189 /// Instance of JIT corresponding to this Resolver. 190 JIT *TheJIT; 193 explicit JITResolver(JIT [all...] |
/external/llvm/bindings/ocaml/executionengine/ |
H A D | llvm_executionengine.mli | 10 (** JIT Interpreter. 12 This interface provides an ocaml API for LLVM execution engine (JIT/ 84 (** An execution engine is either a JIT compiler or an interpreter, capable of 90 module [m] if successful. Creates a JIT if possible, else falls back to an 103 (** [create_jit m optlevel] creates a new JIT (just-in-time compiler), taking
|
H A D | executionengine_ocaml.c | 27 /* Force the LLVM interpreter and JIT to be linked in. */ 193 LLVMExecutionEngineRef JIT; local 195 if (LLVMCreateJITCompilerForModule(&JIT, M, Int_val(OptLevel), &Error)) 197 return JIT;
|
/external/webkit/Source/JavaScriptCore/wtf/ |
H A D | Platform.h | 1104 /* Disable the JIT on versions of GCC prior to 4.1 */ 1109 /* JIT is not implemented for 64 bit on MSVC */ 1114 /* The JIT is enabled by default on all x86, x64-64, ARM & MIPS platforms. */ 1123 #if ENABLE(JIT) && USE(JSVALUE64) && PLATFORM(MAC) 1129 /* Ensure that either the JIT or the interpreter has been enabled. */ 1130 #if !defined(ENABLE_INTERPRETER) && !ENABLE(JIT) 1133 #if !(ENABLE(JIT) || ENABLE(INTERPRETER)) 1145 /* Configure the JIT */ 1146 #if ENABLE(JIT) 1186 /* Yet Another Regex Runtime - turned on by default for JIT enable [all...] |
/external/llvm/examples/Fibonacci/ |
H A D | fibonacci.cpp | 1 //===--- examples/Fibonacci/fibonacci.cpp - An example use of the JIT -----===// 11 // with function Fibonacci and execute it with the JIT. 21 // Once we have this, we compile the module via JIT, then execute the `fib' 32 #include "llvm/ExecutionEngine/JIT.h" 104 // Now we going to create JIT 109 .setEngineKind(EngineKind::JIT) 126 errs() << "---------\nstarting fibonacci(" << n << ") with JIT...\n";
|
/external/webkit/Source/JavaScriptCore/bytecode/ |
H A D | StructureStubInfo.h | 29 #if ENABLE(JIT)
|
H A D | Instruction.h | 43 // *Sigh*, If the JIT is enabled we need to track the stubRountine (of type CodeLocationLabel), 44 // If the JIT is not in use we don't actually need the variable (that said, if the JIT is not in use we don't 47 #if ENABLE(JIT)
|
H A D | SamplingTool.h | 44 friend class JIT;
|
/external/webkit/Source/JavaScriptCore/runtime/ |
H A D | JSFunction.h | 42 friend class JIT;
|
H A D | StringConstructor.cpp | 58 #if ENABLE(JIT) && ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
|
H A D | JSGlobalData.cpp | 213 #if ENABLE(JIT) && ENABLE(INTERPRETER) 232 #if ENABLE(JIT) 355 #if ENABLE(JIT) 423 printf("Regular Expression JIT Address calls found\n");
|
H A D | ArgList.h | 180 friend class JIT;
|
/external/llvm/unittests/ExecutionEngine/JIT/ |
H A D | JITTest.cpp | 1 //===- JITTest.cpp - Unit tests for the JIT -------------------------------===// 19 #include "llvm/ExecutionEngine/JIT.h" 211 TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT) 227 // Regression test for a bug. The JIT used to allocate globals inside the same 232 TEST(JIT, GlobalInFunction) { 241 OwningPtr<ExecutionEngine> JIT(EngineBuilder(M) 242 .setEngineKind(EngineKind::JIT) 263 // Get the pointer to the native code to force it to JIT the function and 266 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F1)); 269 int32_t *GPtr = (int32_t*)JIT [all...] |
H A D | JITEventListenerTest.cpp | 17 #include "llvm/ExecutionEngine/JIT.h" 70 .setEngineKind(EngineKind::JIT) 88 // Tests that a single JITEventListener follows JIT events accurately. 128 // Tests that a single JITEventListener follows JIT events accurately. 231 // Required to create a JIT.
|
H A D | JITEventListenerTestCommon.h | 17 #include "llvm/ExecutionEngine/JIT.h" 37 // Required to create a JIT. 72 .setEngineKind(llvm::EngineKind::JIT) 79 "JIT", 80 "JIT", 81 "JIT",
|
/external/llvm/ |
H A D | Android.mk | 15 lib/ExecutionEngine/JIT \
|
/external/webkit/Source/JavaScriptCore/interpreter/ |
H A D | Interpreter.h | 69 friend class JIT;
|
H A D | CallFrame.h | 94 #if ENABLE(JIT) 113 setReturnPC(vPC); // This is either an Instruction* or a pointer into JIT generated code stored as an Instruction*.
|
/external/webkit/Source/JavaScriptCore/jit/ |
H A D | SpecializedThunkJIT.h | 29 #if ENABLE(JIT) 163 #endif // ENABLE(JIT)
|
H A D | JITStubs.cpp | 33 #if ENABLE(JIT) 44 #include "JIT.h" 391 #error "JIT not supported on this platform." 416 // Form the JIT stubs area 463 #error "JIT not supported on this platform." 760 JIT::compileCTIMachineTrampolines(globalData, &m_executablePool, &m_trampolineStructure); 847 JIT::compilePutByIdTransition(callFrame->scopeChain()->globalData, codeBlock, stubInfo, structure->previousID(), structure, slot.cachedOffset(), prototypeChain, returnAddress, direct); 853 JIT::patchPutByIdReplace(codeBlock, stubInfo, structure, slot.cachedOffset(), returnAddress, direct); 870 JIT::compilePatchGetArrayLength(callFrame->scopeChain()->globalData, codeBlock, returnAddress); 903 JIT [all...] |
H A D | ThunkGenerators.cpp | 33 #if ENABLE(JIT) 162 #endif // ENABLE(JIT)
|
/external/llvm/include/llvm/ExecutionEngine/ |
H A D | ExecutionEngine.h | 96 /// designed to support both interpreter and just-in-time (JIT) compiler 109 /// Whether lazy JIT compilation is enabled. 112 /// Whether JIT compilation of external global variables is allowed. 115 /// Whether the JIT should perform lookups of external symbols (e.g., 122 /// The list of Modules that we are JIT'ing from. We use a SmallVector to 131 // To avoid having libexecutionengine depend on the JIT and interpreter 149 /// pointer is invoked to create it. If this returns null, the JIT will 153 /// ExceptionTableRegister - If Exception Handling is set, the JIT will 163 /// lock - This lock protects the ExecutionEngine, JIT, JITResolver and 191 /// createJIT - This is the factory method for creating a JIT fo 469 JIT = 0x1, enumerator in enum:llvm::EngineKind::Kind [all...] |
/external/llvm/lib/ExecutionEngine/ |
H A D | ExecutionEngine.cpp | 162 DEBUG(dbgs() << "JIT: Map \'" << GV->getName() 273 DEBUG(dbgs() << "JIT: ARGV = " << (void*)Array << "\n"); 280 DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n"); 408 : EngineKind::JIT) 416 /// createJIT - This is the factory method for creating a JIT for the current 428 *ErrorStr = "JIT has not been linked in."; 435 EB.setEngineKind(EngineKind::JIT); 459 // create, we assume they only want the JIT, and we fail if they only want 462 if (WhichEngine & EngineKind::JIT) 463 WhichEngine = EngineKind::JIT; [all...] |
/external/llvm/tools/bugpoint/ |
H A D | ToolRunner.cpp | 544 // JIT Implementation of AbstractIntepreter interface 547 class JIT : public AbstractInterpreter { class in namespace:__anon7879 551 JIT(const std::string &Path, const std::vector<std::string> *Args) function in class:__anon7879::JIT 571 int JIT::ExecuteProgram(const std::string &Bitcode, 619 return new JIT(LLIPath, Args);
|
/external/llvm/tools/lli/ |
H A D | lli.cpp | 12 // compiler, or through an interpreter if no JIT is available for this platform. 24 #include "llvm/ExecutionEngine/JIT.h" 57 cl::desc("Force interpretation: disable JIT"), 61 "use-mcjit", cl::desc("Enable use of the MC-based JIT (if available)"), 110 cl::desc("Disable JIT lazy compilation"), 133 "Target default JIT code model"), 189 // usable by the JIT. 229 : EngineKind::JIT);
|