Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "jit_compiler.h" |
| 18 | |
| 19 | #include "arch/instruction_set.h" |
| 20 | #include "arch/instruction_set_features.h" |
David Srbecky | 4fda4eb | 2016-02-05 13:34:46 +0000 | [diff] [blame] | 21 | #include "art_method-inl.h" |
Mathieu Chartier | 085fc87 | 2015-10-15 18:19:01 -0700 | [diff] [blame] | 22 | #include "base/stringpiece.h" |
Vladimir Marko | 80afd02 | 2015-05-19 18:08:00 +0100 | [diff] [blame] | 23 | #include "base/time_utils.h" |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 24 | #include "base/timing_logger.h" |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 25 | #include "base/unix_file/fd_file.h" |
David Srbecky | c5bfa97 | 2016-02-05 15:49:10 +0000 | [diff] [blame] | 26 | #include "debug/elf_debug_writer.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 27 | #include "driver/compiler_driver.h" |
| 28 | #include "driver/compiler_options.h" |
Tamas Berghammer | 160e6df | 2016-01-05 14:29:02 +0000 | [diff] [blame] | 29 | #include "jit/debugger_interface.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 30 | #include "jit/jit.h" |
| 31 | #include "jit/jit_code_cache.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 32 | #include "oat_file-inl.h" |
Nicolas Geoffray | 524e7ea | 2015-10-16 17:13:34 +0100 | [diff] [blame] | 33 | #include "oat_quick_method_header.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 34 | #include "object_lock.h" |
Matthew Gharrity | 2cd05b7 | 2016-08-03 16:57:37 -0700 | [diff] [blame] | 35 | #include "optimizing/register_allocator.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 36 | #include "thread_list.h" |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 37 | |
| 38 | namespace art { |
| 39 | namespace jit { |
| 40 | |
| 41 | JitCompiler* JitCompiler::Create() { |
| 42 | return new JitCompiler(); |
| 43 | } |
| 44 | |
Nicolas Geoffray | 5b82d33 | 2016-02-18 14:22:32 +0000 | [diff] [blame] | 45 | extern "C" void* jit_load(bool* generate_debug_info) { |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 46 | VLOG(jit) << "loading jit compiler"; |
| 47 | auto* const jit_compiler = JitCompiler::Create(); |
| 48 | CHECK(jit_compiler != nullptr); |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 49 | *generate_debug_info = jit_compiler->GetCompilerOptions()->GetGenerateDebugInfo(); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 50 | VLOG(jit) << "Done loading jit compiler"; |
| 51 | return jit_compiler; |
| 52 | } |
| 53 | |
| 54 | extern "C" void jit_unload(void* handle) { |
| 55 | DCHECK(handle != nullptr); |
| 56 | delete reinterpret_cast<JitCompiler*>(handle); |
| 57 | } |
| 58 | |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 59 | extern "C" bool jit_compile_method( |
| 60 | void* handle, ArtMethod* method, Thread* self, bool osr) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 61 | SHARED_REQUIRES(Locks::mutator_lock_) { |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 62 | auto* jit_compiler = reinterpret_cast<JitCompiler*>(handle); |
| 63 | DCHECK(jit_compiler != nullptr); |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 64 | return jit_compiler->CompileMethod(self, method, osr); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 65 | } |
| 66 | |
Tamas Berghammer | fffbee4 | 2016-01-15 13:09:34 +0000 | [diff] [blame] | 67 | extern "C" void jit_types_loaded(void* handle, mirror::Class** types, size_t count) |
Tamas Berghammer | 160e6df | 2016-01-05 14:29:02 +0000 | [diff] [blame] | 68 | SHARED_REQUIRES(Locks::mutator_lock_) { |
| 69 | auto* jit_compiler = reinterpret_cast<JitCompiler*>(handle); |
| 70 | DCHECK(jit_compiler != nullptr); |
| 71 | if (jit_compiler->GetCompilerOptions()->GetGenerateDebugInfo()) { |
Tamas Berghammer | fffbee4 | 2016-01-15 13:09:34 +0000 | [diff] [blame] | 72 | const ArrayRef<mirror::Class*> types_array(types, count); |
Vladimir Marko | 93205e3 | 2016-04-13 11:59:46 +0100 | [diff] [blame] | 73 | std::vector<uint8_t> elf_file = debug::WriteDebugElfFileForClasses( |
David Srbecky | 5d81120 | 2016-03-08 13:21:22 +0000 | [diff] [blame] | 74 | kRuntimeISA, jit_compiler->GetCompilerDriver()->GetInstructionSetFeatures(), types_array); |
Vladimir Marko | 93205e3 | 2016-04-13 11:59:46 +0100 | [diff] [blame] | 75 | CreateJITCodeEntry(std::move(elf_file)); |
Tamas Berghammer | 160e6df | 2016-01-05 14:29:02 +0000 | [diff] [blame] | 76 | } |
| 77 | } |
| 78 | |
Nicolas Geoffray | abbb0f7 | 2015-10-29 18:55:58 +0000 | [diff] [blame] | 79 | // Callers of this method assume it has NO_RETURN. |
| 80 | NO_RETURN static void Usage(const char* fmt, ...) { |
| 81 | va_list ap; |
| 82 | va_start(ap, fmt); |
| 83 | std::string error; |
| 84 | StringAppendV(&error, fmt, ap); |
| 85 | LOG(FATAL) << error; |
| 86 | va_end(ap); |
| 87 | exit(EXIT_FAILURE); |
| 88 | } |
| 89 | |
Nicolas Geoffray | bcd94c8 | 2016-03-03 13:23:33 +0000 | [diff] [blame] | 90 | JitCompiler::JitCompiler() { |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 91 | compiler_options_.reset(new CompilerOptions( |
Richard Uhler | f4b3487 | 2016-04-13 11:03:46 -0700 | [diff] [blame] | 92 | CompilerFilter::kDefaultCompilerFilter, |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 93 | CompilerOptions::kDefaultHugeMethodThreshold, |
| 94 | CompilerOptions::kDefaultLargeMethodThreshold, |
| 95 | CompilerOptions::kDefaultSmallMethodThreshold, |
| 96 | CompilerOptions::kDefaultTinyMethodThreshold, |
| 97 | CompilerOptions::kDefaultNumDexMethodsThreshold, |
Calin Juravle | ec74835 | 2015-07-29 13:52:12 +0100 | [diff] [blame] | 98 | CompilerOptions::kDefaultInlineDepthLimit, |
| 99 | CompilerOptions::kDefaultInlineMaxCodeUnits, |
Jeff Hao | dcdc85b | 2015-12-04 14:06:18 -0800 | [diff] [blame] | 100 | /* no_inline_from */ nullptr, |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 101 | /* include_patch_information */ false, |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 102 | CompilerOptions::kDefaultTopKProfileThreshold, |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 103 | Runtime::Current()->IsDebuggable(), |
David Srbecky | 8363c77 | 2015-05-28 16:12:43 +0100 | [diff] [blame] | 104 | CompilerOptions::kDefaultGenerateDebugInfo, |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 105 | /* implicit_null_checks */ true, |
| 106 | /* implicit_so_checks */ true, |
| 107 | /* implicit_suspend_checks */ false, |
| 108 | /* pic */ true, // TODO: Support non-PIC in optimizing. |
| 109 | /* verbose_methods */ nullptr, |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 110 | /* init_failure_output */ nullptr, |
Nicolas Geoffray | c903b6a | 2016-01-18 12:56:06 +0000 | [diff] [blame] | 111 | /* abort_on_hard_verifier_failure */ false, |
| 112 | /* dump_cfg_file_name */ "", |
Andreas Gampe | ace0dc1 | 2016-01-20 13:33:13 -0800 | [diff] [blame] | 113 | /* dump_cfg_append */ false, |
Matthew Gharrity | 2cd05b7 | 2016-08-03 16:57:37 -0700 | [diff] [blame] | 114 | /* force_determinism */ false, |
Wojciech Staszkiewicz | 5319d3c | 2016-08-01 17:48:59 -0700 | [diff] [blame] | 115 | RegisterAllocator::kRegisterAllocatorDefault, |
| 116 | /* passes_to_run */ nullptr)); |
Nicolas Geoffray | abbb0f7 | 2015-10-29 18:55:58 +0000 | [diff] [blame] | 117 | for (const std::string& argument : Runtime::Current()->GetCompilerOptions()) { |
| 118 | compiler_options_->ParseCompilerOption(argument, Usage); |
| 119 | } |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 120 | const InstructionSet instruction_set = kRuntimeISA; |
Mathieu Chartier | 085fc87 | 2015-10-15 18:19:01 -0700 | [diff] [blame] | 121 | for (const StringPiece option : Runtime::Current()->GetCompilerOptions()) { |
| 122 | VLOG(compiler) << "JIT compiler option " << option; |
| 123 | std::string error_msg; |
| 124 | if (option.starts_with("--instruction-set-variant=")) { |
| 125 | StringPiece str = option.substr(strlen("--instruction-set-variant=")).data(); |
| 126 | VLOG(compiler) << "JIT instruction set variant " << str; |
| 127 | instruction_set_features_.reset(InstructionSetFeatures::FromVariant( |
| 128 | instruction_set, str.as_string(), &error_msg)); |
| 129 | if (instruction_set_features_ == nullptr) { |
| 130 | LOG(WARNING) << "Error parsing " << option << " message=" << error_msg; |
| 131 | } |
| 132 | } else if (option.starts_with("--instruction-set-features=")) { |
| 133 | StringPiece str = option.substr(strlen("--instruction-set-features=")).data(); |
| 134 | VLOG(compiler) << "JIT instruction set features " << str; |
| 135 | if (instruction_set_features_.get() == nullptr) { |
| 136 | instruction_set_features_.reset(InstructionSetFeatures::FromVariant( |
| 137 | instruction_set, "default", &error_msg)); |
| 138 | if (instruction_set_features_ == nullptr) { |
| 139 | LOG(WARNING) << "Error parsing " << option << " message=" << error_msg; |
| 140 | } |
| 141 | } |
| 142 | instruction_set_features_.reset( |
| 143 | instruction_set_features_->AddFeaturesFromString(str.as_string(), &error_msg)); |
| 144 | if (instruction_set_features_ == nullptr) { |
| 145 | LOG(WARNING) << "Error parsing " << option << " message=" << error_msg; |
| 146 | } |
| 147 | } |
| 148 | } |
| 149 | if (instruction_set_features_ == nullptr) { |
| 150 | instruction_set_features_.reset(InstructionSetFeatures::FromCppDefines()); |
| 151 | } |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 152 | cumulative_logger_.reset(new CumulativeLogger("jit times")); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 153 | method_inliner_map_.reset(new DexFileToMethodInlinerMap); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 154 | compiler_driver_.reset(new CompilerDriver( |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 155 | compiler_options_.get(), |
Nicolas Geoffray | 5b82d33 | 2016-02-18 14:22:32 +0000 | [diff] [blame] | 156 | /* verification_results */ nullptr, |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 157 | method_inliner_map_.get(), |
| 158 | Compiler::kOptimizing, |
| 159 | instruction_set, |
| 160 | instruction_set_features_.get(), |
Mathieu Chartier | 91288d8 | 2016-04-28 09:44:54 -0700 | [diff] [blame] | 161 | /* boot_image */ false, |
| 162 | /* app_image */ false, |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 163 | /* image_classes */ nullptr, |
| 164 | /* compiled_classes */ nullptr, |
| 165 | /* compiled_methods */ nullptr, |
| 166 | /* thread_count */ 1, |
| 167 | /* dump_stats */ false, |
| 168 | /* dump_passes */ false, |
Nicolas Geoffray | 7a4d015 | 2015-07-10 17:29:39 +0100 | [diff] [blame] | 169 | cumulative_logger_.get(), |
| 170 | /* swap_fd */ -1, |
Calin Juravle | 998c216 | 2015-12-21 15:39:33 +0200 | [diff] [blame] | 171 | /* profile_compilation_info */ nullptr)); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 172 | // Disable dedupe so we can remove compiled methods. |
| 173 | compiler_driver_->SetDedupeEnabled(false); |
| 174 | compiler_driver_->SetSupportBootImageFixup(false); |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 175 | |
Nicolas Geoffray | b6e20ae | 2016-03-07 14:29:04 +0000 | [diff] [blame] | 176 | size_t thread_count = compiler_driver_->GetThreadCount(); |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 177 | if (compiler_options_->GetGenerateDebugInfo()) { |
Bilyan Borisov | bb661c0 | 2016-04-04 16:27:32 +0100 | [diff] [blame] | 178 | #ifdef ART_TARGET_ANDROID |
Tamas Berghammer | f0615a3 | 2016-01-27 16:15:56 +0000 | [diff] [blame] | 179 | const char* prefix = "/data/misc/trace"; |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 180 | #else |
| 181 | const char* prefix = "/tmp"; |
| 182 | #endif |
Nicolas Geoffray | b6e20ae | 2016-03-07 14:29:04 +0000 | [diff] [blame] | 183 | DCHECK_EQ(thread_count, 1u) |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 184 | << "Generating debug info only works with one compiler thread"; |
| 185 | std::string perf_filename = std::string(prefix) + "/perf-" + std::to_string(getpid()) + ".map"; |
| 186 | perf_file_.reset(OS::CreateEmptyFileWriteOnly(perf_filename.c_str())); |
| 187 | if (perf_file_ == nullptr) { |
Tamas Berghammer | f0615a3 | 2016-01-27 16:15:56 +0000 | [diff] [blame] | 188 | LOG(ERROR) << "Could not create perf file at " << perf_filename << |
| 189 | " Are you on a user build? Perf only works on userdebug/eng builds"; |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 190 | } |
| 191 | } |
Nicolas Geoffray | b6e20ae | 2016-03-07 14:29:04 +0000 | [diff] [blame] | 192 | |
| 193 | size_t inline_depth_limit = compiler_driver_->GetCompilerOptions().GetInlineDepthLimit(); |
| 194 | DCHECK_LT(thread_count * inline_depth_limit, std::numeric_limits<uint16_t>::max()) |
| 195 | << "ProfilingInfo's inline counter can potentially overflow"; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | JitCompiler::~JitCompiler() { |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 199 | if (perf_file_ != nullptr) { |
| 200 | UNUSED(perf_file_->Flush()); |
| 201 | UNUSED(perf_file_->Close()); |
| 202 | } |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 203 | } |
| 204 | |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 205 | bool JitCompiler::CompileMethod(Thread* self, ArtMethod* method, bool osr) { |
Nicolas Geoffray | d9994f0 | 2016-02-11 17:35:55 +0000 | [diff] [blame] | 206 | DCHECK(!method->IsProxyMethod()); |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 207 | TimingLogger logger("JIT compiler timing logger", true, VLOG_IS_ON(jit)); |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 208 | StackHandleScope<2> hs(self); |
| 209 | self->AssertNoPendingException(); |
| 210 | Runtime* runtime = Runtime::Current(); |
Nicolas Geoffray | 0c3c266 | 2015-10-15 13:53:04 +0100 | [diff] [blame] | 211 | |
Nicolas Geoffray | 0c3c266 | 2015-10-15 13:53:04 +0100 | [diff] [blame] | 212 | // Ensure the class is initialized. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 213 | Handle<mirror::Class> h_class(hs.NewHandle(method->GetDeclaringClass())); |
Nicolas Geoffray | 0c3c266 | 2015-10-15 13:53:04 +0100 | [diff] [blame] | 214 | if (!runtime->GetClassLinker()->EnsureInitialized(self, h_class, true, true)) { |
| 215 | VLOG(jit) << "JIT failed to initialize " << PrettyMethod(method); |
| 216 | return false; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 217 | } |
Nicolas Geoffray | 0c3c266 | 2015-10-15 13:53:04 +0100 | [diff] [blame] | 218 | |
| 219 | // Do the compilation. |
Nicolas Geoffray | d28b969 | 2015-11-04 14:36:55 +0000 | [diff] [blame] | 220 | bool success = false; |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 221 | { |
| 222 | TimingLogger::ScopedTiming t2("Compiling", &logger); |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 223 | JitCodeCache* const code_cache = runtime->GetJit()->GetCodeCache(); |
Nicolas Geoffray | d9994f0 | 2016-02-11 17:35:55 +0000 | [diff] [blame] | 224 | success = compiler_driver_->GetCompiler()->JitCompile(self, code_cache, method, osr); |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 225 | if (success && (perf_file_ != nullptr)) { |
Nicolas Geoffray | d9994f0 | 2016-02-11 17:35:55 +0000 | [diff] [blame] | 226 | const void* ptr = method->GetEntryPointFromQuickCompiledCode(); |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 227 | std::ostringstream stream; |
| 228 | stream << std::hex |
| 229 | << reinterpret_cast<uintptr_t>(ptr) |
| 230 | << " " |
| 231 | << code_cache->GetMemorySizeOfCodePointer(ptr) |
| 232 | << " " |
Nicolas Geoffray | d9994f0 | 2016-02-11 17:35:55 +0000 | [diff] [blame] | 233 | << PrettyMethod(method) |
Nicolas Geoffray | a25dce9 | 2016-01-12 16:41:10 +0000 | [diff] [blame] | 234 | << std::endl; |
| 235 | std::string str = stream.str(); |
| 236 | bool res = perf_file_->WriteFully(str.c_str(), str.size()); |
| 237 | CHECK(res); |
| 238 | } |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 239 | } |
Nicolas Geoffray | 0c3c266 | 2015-10-15 13:53:04 +0100 | [diff] [blame] | 240 | |
| 241 | // Trim maps to reduce memory usage. |
Nicolas Geoffray | 25e0456 | 2016-03-01 13:17:58 +0000 | [diff] [blame] | 242 | // TODO: move this to an idle phase. |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 243 | { |
| 244 | TimingLogger::ScopedTiming t2("TrimMaps", &logger); |
Nicolas Geoffray | 25e0456 | 2016-03-01 13:17:58 +0000 | [diff] [blame] | 245 | runtime->GetJitArenaPool()->TrimMaps(); |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 246 | } |
Nicolas Geoffray | 0c3c266 | 2015-10-15 13:53:04 +0100 | [diff] [blame] | 247 | |
Mathieu Chartier | a4885cb | 2015-03-09 15:38:54 -0700 | [diff] [blame] | 248 | runtime->GetJit()->AddTimingLogger(logger); |
Nicolas Geoffray | d28b969 | 2015-11-04 14:36:55 +0000 | [diff] [blame] | 249 | return success; |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 250 | } |
| 251 | |
Mathieu Chartier | e5f13e5 | 2015-02-24 09:37:21 -0800 | [diff] [blame] | 252 | } // namespace jit |
| 253 | } // namespace art |