| /external/webkit/Source/WebCore/bindings/scripts/test/JS/ |
| JSTestInterface.cpp | 37 #if ENABLE(JIT)
52 #if ENABLE(JIT)
116 #if ENABLE(JIT)
|
| JSTestMediaQueryListListener.cpp | 38 #if ENABLE(JIT)
53 #if ENABLE(JIT)
101 #if ENABLE(JIT)
|
| JSTestSerializedScriptValueInterface.cpp | 38 #if ENABLE(JIT)
54 #if ENABLE(JIT)
102 #if ENABLE(JIT)
|
| /external/llvm/lib/ExecutionEngine/JIT/ |
| JITEmitter.cpp | 10 // This file defines a MachineCodeEmitter object that is used by the JIT to
15 #define DEBUG_TYPE "jit"
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),
117 TheJIT(jit) {}
[all...] |
| /external/llvm/bindings/ocaml/executionengine/ |
| 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
|
| executionengine_ocaml.c | 27 /* Force the LLVM interpreter and JIT to be linked in. */
193 LLVMExecutionEngineRef JIT;
195 if (LLVMCreateJITCompilerForModule(&JIT, M, Int_val(OptLevel), &Error))
197 return JIT;
|
| /external/webkit/Source/JavaScriptCore/wtf/ |
| 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)
[all...] |
| /external/llvm/examples/Fibonacci/ |
| 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/llvm/unittests/ExecutionEngine/JIT/ |
| 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->getPointerToGlobalIfAvailable(G)
[all...] |
| /external/llvm/utils/ |
| GenLibDeps.pl | 104 $libpath =~ s/^JIT/ExecutionEngine\/JIT/;
145 $libpath =~ s/^JIT/ExecutionEngine\/JIT/;
|
| /external/webkit/Source/JavaScriptCore/bytecode/ |
| StructureStubInfo.h | 29 #if ENABLE(JIT)
|
| 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)
|
| /external/webkit/Source/JavaScriptCore/runtime/ |
| JSFunction.h | 42 friend class JIT;
|
| StringConstructor.cpp | 58 #if ENABLE(JIT) && ENABLE(JIT_OPTIMIZE_NATIVE_CALL)
|
| 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");
|
| ArgList.h | 180 friend class JIT;
|
| JSVariableObject.h | 44 friend class JIT;
|
| /external/llvm/ |
| Android.mk | 15 lib/ExecutionEngine/JIT \
|
| /external/webkit/Source/JavaScriptCore/interpreter/ |
| 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*.
|
| Interpreter.h | 69 friend class JIT;
|
| /external/webkit/Source/JavaScriptCore/jit/ |
| SpecializedThunkJIT.h | 29 #if ENABLE(JIT)
163 #endif // ENABLE(JIT)
|
| /external/llvm/include/llvm/ExecutionEngine/ |
| 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 for the curren
[all...] |
| /external/llvm/lib/ExecutionEngine/ |
| ExecutionEngine.cpp | 15 #define DEBUG_TYPE "jit"
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)
[all...] |
| /external/llvm/tools/bugpoint/ |
| ToolRunner.cpp | 544 // JIT Implementation of AbstractIntepreter interface
547 class JIT : public AbstractInterpreter {
551 JIT(const std::string &Path, const std::vector<std::string> *Args)
571 int JIT::ExecuteProgram(const std::string &Bitcode,
599 outs() << "<jit>"; outs().flush();
619 return new JIT(LLIPath, Args);
[all...] |
| /external/llvm/tools/lli/ |
| 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"),
145 EnableJITExceptionHandling("jit-enable-eh",
156 EmitJitDebugInfo("jit-emit-debug",
162 EmitJitDebugInfoToDisk("jit-emit-debug-to-disk",
189 // usable by the JIT
[all...] |
