1 /* 2 * Copyright (C) 2015 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 "jni.h" 18 19 #include <android-base/logging.h> 20 #include <android-base/macros.h> 21 22 #include "art_method-inl.h" 23 #include "base/enums.h" 24 #include "dex/dex_file-inl.h" 25 #include "instrumentation.h" 26 #include "jit/jit.h" 27 #include "jit/jit_code_cache.h" 28 #include "jit/profile_compilation_info.h" 29 #include "jit/profiling_info.h" 30 #include "mirror/class-inl.h" 31 #include "nativehelper/ScopedUtfChars.h" 32 #include "oat_file.h" 33 #include "oat_quick_method_header.h" 34 #include "runtime.h" 35 #include "scoped_thread_state_change-inl.h" 36 #include "thread-current-inl.h" 37 38 namespace art { 39 40 // public static native boolean hasJit(); 41 42 static jit::Jit* GetJitIfEnabled() { 43 Runtime* runtime = Runtime::Current(); 44 bool can_jit = 45 runtime != nullptr 46 && runtime->GetJit() != nullptr 47 && runtime->GetInstrumentation()->GetCurrentInstrumentationLevel() != 48 instrumentation::Instrumentation::InstrumentationLevel::kInstrumentWithInterpreter; 49 return can_jit ? runtime->GetJit() : nullptr; 50 } 51 52 extern "C" JNIEXPORT jboolean JNICALL Java_Main_hasJit(JNIEnv*, jclass) { 53 return GetJitIfEnabled() != nullptr; 54 } 55 56 // public static native boolean hasOatFile(); 57 58 extern "C" JNIEXPORT jboolean JNICALL Java_Main_hasOatFile(JNIEnv* env, jclass cls) { 59 ScopedObjectAccess soa(env); 60 61 ObjPtr<mirror::Class> klass = soa.Decode<mirror::Class>(cls); 62 const DexFile& dex_file = klass->GetDexFile(); 63 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 64 return (oat_dex_file != nullptr) ? JNI_TRUE : JNI_FALSE; 65 } 66 67 // public static native boolean runtimeIsSoftFail(); 68 69 extern "C" JNIEXPORT jboolean JNICALL Java_Main_runtimeIsSoftFail(JNIEnv* env ATTRIBUTE_UNUSED, 70 jclass cls ATTRIBUTE_UNUSED) { 71 return Runtime::Current()->IsVerificationSoftFail() ? JNI_TRUE : JNI_FALSE; 72 } 73 74 // public static native boolean isDex2OatEnabled(); 75 76 extern "C" JNIEXPORT jboolean JNICALL Java_Main_isDex2OatEnabled(JNIEnv* env ATTRIBUTE_UNUSED, 77 jclass cls ATTRIBUTE_UNUSED) { 78 return Runtime::Current()->IsDex2OatEnabled(); 79 } 80 81 // public static native boolean hasImage(); 82 83 extern "C" JNIEXPORT jboolean JNICALL Java_Main_hasImage(JNIEnv* env ATTRIBUTE_UNUSED, 84 jclass cls ATTRIBUTE_UNUSED) { 85 return Runtime::Current()->GetHeap()->HasBootImageSpace(); 86 } 87 88 // public static native boolean isImageDex2OatEnabled(); 89 90 extern "C" JNIEXPORT jboolean JNICALL Java_Main_isImageDex2OatEnabled(JNIEnv* env ATTRIBUTE_UNUSED, 91 jclass cls ATTRIBUTE_UNUSED) { 92 return Runtime::Current()->IsImageDex2OatEnabled(); 93 } 94 95 // public static native boolean compiledWithOptimizing(); 96 // Did we use the optimizing compiler to compile this? 97 98 extern "C" JNIEXPORT jboolean JNICALL Java_Main_compiledWithOptimizing(JNIEnv* env, jclass cls) { 99 ScopedObjectAccess soa(env); 100 101 ObjPtr<mirror::Class> klass = soa.Decode<mirror::Class>(cls); 102 const DexFile& dex_file = klass->GetDexFile(); 103 const OatFile::OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 104 if (oat_dex_file == nullptr) { 105 // Could be JIT, which also uses optimizing, but conservatively say no. 106 return JNI_FALSE; 107 } 108 const OatFile* oat_file = oat_dex_file->GetOatFile(); 109 CHECK(oat_file != nullptr); 110 111 const char* cmd_line = oat_file->GetOatHeader().GetStoreValueByKey(OatHeader::kDex2OatCmdLineKey); 112 CHECK(cmd_line != nullptr); // Huh? This should not happen. 113 114 // Check the backend. 115 constexpr const char* kCompilerBackend = "--compiler-backend="; 116 const char* backend = strstr(cmd_line, kCompilerBackend); 117 if (backend != nullptr) { 118 // If it's set, make sure it's optimizing. 119 backend += strlen(kCompilerBackend); 120 if (strncmp(backend, "Optimizing", strlen("Optimizing")) != 0) { 121 return JNI_FALSE; 122 } 123 } 124 125 // Check the filter. 126 constexpr const char* kCompilerFilter = "--compiler-filter="; 127 const char* filter = strstr(cmd_line, kCompilerFilter); 128 if (filter != nullptr) { 129 // If it's set, make sure it's not interpret-only|verify-none|verify-at-runtime. 130 // Note: The space filter might have an impact on the test, but ignore that for now. 131 filter += strlen(kCompilerFilter); 132 constexpr const char* kInterpretOnly = "interpret-only"; 133 constexpr const char* kVerifyNone = "verify-none"; 134 constexpr const char* kVerifyAtRuntime = "verify-at-runtime"; 135 if (strncmp(filter, kInterpretOnly, strlen(kInterpretOnly)) == 0 || 136 strncmp(filter, kVerifyNone, strlen(kVerifyNone)) == 0 || 137 strncmp(filter, kVerifyAtRuntime, strlen(kVerifyAtRuntime)) == 0) { 138 return JNI_FALSE; 139 } 140 } 141 142 return JNI_TRUE; 143 } 144 145 extern "C" JNIEXPORT jboolean JNICALL Java_Main_isAotCompiled(JNIEnv* env, 146 jclass, 147 jclass cls, 148 jstring method_name) { 149 Thread* self = Thread::Current(); 150 ScopedObjectAccess soa(self); 151 ScopedUtfChars chars(env, method_name); 152 CHECK(chars.c_str() != nullptr); 153 ArtMethod* method = soa.Decode<mirror::Class>(cls)->FindDeclaredDirectMethodByName( 154 chars.c_str(), kRuntimePointerSize); 155 const void* oat_code = method->GetOatMethodQuickCode(kRuntimePointerSize); 156 if (oat_code == nullptr) { 157 return false; 158 } 159 const void* actual_code = method->GetEntryPointFromQuickCompiledCodePtrSize(kRuntimePointerSize); 160 bool interpreter = 161 Runtime::Current()->GetClassLinker()->ShouldUseInterpreterEntrypoint(method, actual_code); 162 return !interpreter; 163 } 164 165 extern "C" JNIEXPORT jboolean JNICALL Java_Main_hasJitCompiledEntrypoint(JNIEnv* env, 166 jclass, 167 jclass cls, 168 jstring method_name) { 169 jit::Jit* jit = GetJitIfEnabled(); 170 if (jit == nullptr) { 171 return false; 172 } 173 Thread* self = Thread::Current(); 174 ScopedObjectAccess soa(self); 175 ScopedUtfChars chars(env, method_name); 176 CHECK(chars.c_str() != nullptr); 177 ArtMethod* method = soa.Decode<mirror::Class>(cls)->FindDeclaredDirectMethodByName( 178 chars.c_str(), kRuntimePointerSize); 179 return jit->GetCodeCache()->ContainsPc(method->GetEntryPointFromQuickCompiledCode()); 180 } 181 182 extern "C" JNIEXPORT jboolean JNICALL Java_Main_hasJitCompiledCode(JNIEnv* env, 183 jclass, 184 jclass cls, 185 jstring method_name) { 186 jit::Jit* jit = GetJitIfEnabled(); 187 if (jit == nullptr) { 188 return false; 189 } 190 Thread* self = Thread::Current(); 191 ScopedObjectAccess soa(self); 192 ScopedUtfChars chars(env, method_name); 193 CHECK(chars.c_str() != nullptr); 194 ArtMethod* method = soa.Decode<mirror::Class>(cls)->FindDeclaredDirectMethodByName( 195 chars.c_str(), kRuntimePointerSize); 196 return jit->GetCodeCache()->ContainsMethod(method); 197 } 198 199 extern "C" JNIEXPORT void JNICALL Java_Main_ensureJitCompiled(JNIEnv* env, 200 jclass, 201 jclass cls, 202 jstring method_name) { 203 jit::Jit* jit = GetJitIfEnabled(); 204 if (jit == nullptr) { 205 return; 206 } 207 208 Thread* self = Thread::Current(); 209 ArtMethod* method = nullptr; 210 { 211 ScopedObjectAccess soa(self); 212 213 ScopedUtfChars chars(env, method_name); 214 CHECK(chars.c_str() != nullptr); 215 method = soa.Decode<mirror::Class>(cls)->FindDeclaredDirectMethodByName( 216 chars.c_str(), kRuntimePointerSize); 217 if (method == nullptr) { 218 method = soa.Decode<mirror::Class>(cls)->FindDeclaredVirtualMethodByName( 219 chars.c_str(), kRuntimePointerSize); 220 } 221 DCHECK(method != nullptr) << "Unable to find method called " << chars.c_str(); 222 } 223 224 jit::JitCodeCache* code_cache = jit->GetCodeCache(); 225 // Update the code cache to make sure the JIT code does not get deleted. 226 // Note: this will apply to all JIT compilations. 227 code_cache->SetGarbageCollectCode(false); 228 while (true) { 229 const void* pc = method->GetEntryPointFromQuickCompiledCode(); 230 if (code_cache->ContainsPc(pc)) { 231 break; 232 } else { 233 // Sleep to yield to the compiler thread. 234 usleep(1000); 235 ScopedObjectAccess soa(self); 236 // Make sure there is a profiling info, required by the compiler. 237 ProfilingInfo::Create(self, method, /* retry_allocation */ true); 238 // Will either ensure it's compiled or do the compilation itself. 239 jit->CompileMethod(method, self, /* osr */ false); 240 } 241 } 242 } 243 244 extern "C" JNIEXPORT jboolean JNICALL Java_Main_hasSingleImplementation(JNIEnv* env, 245 jclass, 246 jclass cls, 247 jstring method_name) { 248 ArtMethod* method = nullptr; 249 ScopedObjectAccess soa(Thread::Current()); 250 ScopedUtfChars chars(env, method_name); 251 CHECK(chars.c_str() != nullptr); 252 method = soa.Decode<mirror::Class>(cls)->FindDeclaredVirtualMethodByName( 253 chars.c_str(), kRuntimePointerSize); 254 return method->HasSingleImplementation(); 255 } 256 257 extern "C" JNIEXPORT int JNICALL Java_Main_getHotnessCounter(JNIEnv* env, 258 jclass, 259 jclass cls, 260 jstring method_name) { 261 ArtMethod* method = nullptr; 262 { 263 ScopedObjectAccess soa(Thread::Current()); 264 265 ScopedUtfChars chars(env, method_name); 266 CHECK(chars.c_str() != nullptr); 267 method = soa.Decode<mirror::Class>(cls)->FindDeclaredDirectMethodByName( 268 chars.c_str(), kRuntimePointerSize); 269 } 270 271 return method->GetCounter(); 272 } 273 274 extern "C" JNIEXPORT int JNICALL Java_Main_numberOfDeoptimizations(JNIEnv*, jclass) { 275 return Runtime::Current()->GetNumberOfDeoptimizations(); 276 } 277 278 extern "C" JNIEXPORT void JNICALL Java_Main_fetchProfiles(JNIEnv*, jclass) { 279 jit::Jit* jit = GetJitIfEnabled(); 280 if (jit == nullptr) { 281 return; 282 } 283 jit::JitCodeCache* code_cache = jit->GetCodeCache(); 284 std::vector<ProfileMethodInfo> unused_vector; 285 std::set<std::string> unused_locations; 286 unused_locations.insert("fake_location"); 287 ScopedObjectAccess soa(Thread::Current()); 288 code_cache->GetProfiledMethods(unused_locations, unused_vector); 289 } 290 291 extern "C" JNIEXPORT jboolean JNICALL Java_Main_isClassMoveable(JNIEnv*, 292 jclass, 293 jclass cls) { 294 Runtime* runtime = Runtime::Current(); 295 ScopedObjectAccess soa(Thread::Current()); 296 ObjPtr<mirror::Class> klass = soa.Decode<mirror::Class>(cls); 297 return runtime->GetHeap()->IsMovableObject(klass); 298 } 299 300 extern "C" JNIEXPORT void JNICALL Java_Main_waitForCompilation(JNIEnv*, jclass) { 301 jit::Jit* jit = Runtime::Current()->GetJit(); 302 if (jit != nullptr) { 303 jit->WaitForCompilationToFinish(Thread::Current()); 304 } 305 } 306 307 extern "C" JNIEXPORT void JNICALL Java_Main_stopJit(JNIEnv*, jclass) { 308 jit::Jit* jit = Runtime::Current()->GetJit(); 309 if (jit != nullptr) { 310 jit->Stop(); 311 } 312 } 313 314 extern "C" JNIEXPORT void JNICALL Java_Main_startJit(JNIEnv*, jclass) { 315 jit::Jit* jit = Runtime::Current()->GetJit(); 316 if (jit != nullptr) { 317 jit->Start(); 318 } 319 } 320 321 } // namespace art 322
