| /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"
68 // JIT lazy compilation code.
78 llvm_unreachable("The JIT doesn't know how to handle a"
111 /// Instance of the JIT this ResolverState serves.
112 JIT *TheJIT;
116 JITResolverState(JIT *jit) : FunctionToLazyStubMap(this),
119 TheJIT = jit;
[all...] |
| /external/chromium_org/v8/test/webkit/fast/js/kde/ |
| operators.js | 27 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
38 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
49 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
60 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
71 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
82 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
93 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
104 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
115 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
|
| /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. */
196 LLVMExecutionEngineRef JIT;
198 if (LLVMCreateJITCompilerForModule(&JIT, M, Int_val(OptLevel), &Error))
200 return JIT;
|
| /dalvik/vm/ |
| Android.mk | 64 # Enable assertions and JIT tuning
76 # Enable assertions and JIT self-verification
88 # Compile out the JIT
|
| /external/chromium_org/v8/test/webkit/ |
| apply-varargs.js | 24 description('Test that we properly fill in missing args with "undefined" in JIT code.');
76 // Run multiple times so that the JIT kicks in
|
| dfg-float32-array-nan.js | 25 "Tests what happens in the DFG JIT if we load from a Float32 array that contains a weirdly formatted NaN."
|
| dfg-inline-constant.js | 25 "This tests that function inlining in the DFG JIT doesn't get confused by constants being reused between inliner and inlinee."
|
| sort-no-jit-code-crash.js | 25 "This test checks that non-numeric sort functions always have JIT code. This test passes if it does not crash."
|
| dfg-min-max.js | 25 "This tests that Math.min and Math.max for doubles works correctly in the DFG JIT."
|
| mod-crash.js | 51 // The + operator on objects is a reliable way to avoid the speculative JIT path for now at least.
|
| /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'
29 #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/utils/ |
| GenLibDeps.pl | 104 $libpath =~ s/^JIT/ExecutionEngine\/JIT/;
145 $libpath =~ s/^JIT/ExecutionEngine\/JIT/;
|
| /external/llvm/ |
| Android.mk | 14 lib/ExecutionEngine/JIT \
|
| /external/llvm/tools/llvm-jitlistener/ |
| llvm-jitlistener.cpp | 11 // interface. It registers a mock JIT event listener, generates a module from
50 "Error: The JIT event listener did not provide a event data.";
79 "Error: The JIT event listener did not provide a event data.";
111 // usable by the JIT.
150 .setEngineKind(EngineKind::JIT)
181 // Destroy the JIT engine instead of unregistering to get unload events.
200 cl::ParseCommandLineOptions(argc, argv, "llvm jit event listener test utility\n");
|
| /external/llvm/include/llvm/ExecutionEngine/ |
| ExecutionEngine.h | 99 /// designed to support both interpreter and just-in-time (JIT) compiler
112 /// Whether lazy JIT compilation is enabled.
115 /// Whether JIT compilation of external global variables is allowed.
118 /// Whether the JIT should perform lookups of external symbols (e.g.,
125 /// The list of Modules that we are JIT'ing from. We use a SmallVector to
134 // To avoid having libexecutionengine depend on the JIT and interpreter
152 /// pointer is invoked to create it. If this returns null, the JIT will
156 /// ExceptionTableRegister - If Exception Handling is set, the JIT will
166 /// lock - This lock protects the ExecutionEngine, JIT, JITResolver and
194 /// createJIT - This is the factory method for creating a JIT for the curren
[all...] |
| /external/llvm/tools/bugpoint/ |
| ToolRunner.cpp | 574 // JIT Implementation of AbstractIntepreter interface
577 class JIT : public AbstractInterpreter {
581 JIT(const std::string &Path, const std::vector<std::string> *Args)
601 int JIT::ExecuteProgram(const std::string &Bitcode,
629 outs() << "<jit>"; outs().flush();
649 return new JIT(LLIPath, Args);
[all...] |
| /external/llvm/unittests/ExecutionEngine/JIT/ |
| JITEventListenerTest.cpp | 13 #include "llvm/ExecutionEngine/JIT.h"
69 .setEngineKind(EngineKind::JIT)
77 // Tests on SystemZ disabled as we're running the old JIT
89 // Tests that a single JITEventListener follows JIT events accurately.
129 // Tests that a single JITEventListener follows JIT events accurately.
233 // Required to create a JIT.
|
| JITEventListenerTestCommon.h | 17 #include "llvm/ExecutionEngine/JIT.h"
35 // Required to create a JIT.
70 .setEngineKind(llvm::EngineKind::JIT)
77 "JIT",
78 "JIT",
79 "JIT",
|
| /external/llvm/unittests/ExecutionEngine/MCJIT/ |
| MCJITTestBase.h | 186 TheJIT.reset(EB.setEngineKind(EngineKind::JIT)
|
| /external/llvm/lib/ExecutionEngine/ |
| ExecutionEngine.cpp | 15 #define DEBUG_TYPE "jit"
163 DEBUG(dbgs() << "JIT: Map \'" << GV->getName()
274 DEBUG(dbgs() << "JIT: ARGV = " << (void*)Array << "\n");
281 DEBUG(dbgs() << "JIT: ARGV[" << i << "] = " << (void*)Dest << "\n");
409 : EngineKind::JIT)
417 /// createJIT - This is the factory method for creating a JIT for the current
429 *ErrorStr = "JIT has not been linked in.";
436 EB.setEngineKind(EngineKind::JIT);
462 // create, we assume they only want the JIT, and we fail if they only want
465 if (WhichEngine & EngineKind::JIT)
[all...] |
| /dalvik/vm/mterp/armv5te/ |
| footer.S | 312 cmp r0, #0 @ JIT switched off?
360 mov r3, #0 @ 0 means not in the JIT code cache
369 * r2 is jit state.
374 bne 3f @ already doing JIT work, continue
455 * The JIT's invoke method needs to remember the callsite class and
773 str r10, [rSELF, #offThread_inJitCodeCache] @ may return to JIT'ed land
[all...] |
| /external/llvm/tools/lli/ |
| lli.cpp | 12 // compiler, or through an interpreter if no JIT is available for this platform.
25 #include "llvm/ExecutionEngine/JIT.h"
68 cl::desc("Force interpretation: disable JIT"),
72 "use-mcjit", cl::desc("Enable use of the MC-based JIT (if available)"),
80 // the JIT compilation process. Use a forked process and a copying
132 cl::desc("Disable JIT lazy compilation"),
155 "Target default JIT code model"),
190 EmitJitDebugInfo("jit-emit-debug",
196 EmitJitDebugInfoToDisk("jit-emit-debug-to-disk",
299 // usable by the JIT
[all...] |
| /external/chromium_org/v8/tools/ |
| codemap.js | 36 * Dynamic code entries. Used for JIT compiled code.
|
| /external/v8/tools/ |
| codemap.js | 36 * Dynamic code entries. Used for JIT compiled code.
|
