1 /* 2 * Copyright (C) 2008 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 <algorithm> 18 #include <set> 19 #include <fcntl.h> 20 #ifdef __linux__ 21 #include <sys/sendfile.h> 22 #else 23 #include <sys/socket.h> 24 #endif 25 #include <sys/stat.h> 26 #include <unistd.h> 27 28 #include "base/logging.h" 29 #include "base/stl_util.h" 30 #include "base/stringprintf.h" 31 #include "class_linker.h" 32 #include "common_throws.h" 33 #include "dex_file-inl.h" 34 #include "gc/space/image_space.h" 35 #include "gc/space/space-inl.h" 36 #include "image.h" 37 #include "jni_internal.h" 38 #include "mirror/class_loader.h" 39 #include "mirror/object-inl.h" 40 #include "mirror/string.h" 41 #include "oat.h" 42 #include "os.h" 43 #include "profiler.h" 44 #include "runtime.h" 45 #include "scoped_thread_state_change.h" 46 #include "ScopedFd.h" 47 #include "ScopedLocalRef.h" 48 #include "ScopedUtfChars.h" 49 #include "utils.h" 50 #include "well_known_classes.h" 51 #include "zip_archive.h" 52 53 namespace art { 54 55 // A smart pointer that provides read-only access to a Java string's UTF chars. 56 // Unlike libcore's NullableScopedUtfChars, this will *not* throw NullPointerException if 57 // passed a null jstring. The correct idiom is: 58 // 59 // NullableScopedUtfChars name(env, javaName); 60 // if (env->ExceptionCheck()) { 61 // return NULL; 62 // } 63 // // ... use name.c_str() 64 // 65 // TODO: rewrite to get rid of this, or change ScopedUtfChars to offer this option. 66 class NullableScopedUtfChars { 67 public: 68 NullableScopedUtfChars(JNIEnv* env, jstring s) : mEnv(env), mString(s) { 69 mUtfChars = (s != NULL) ? env->GetStringUTFChars(s, NULL) : NULL; 70 } 71 72 ~NullableScopedUtfChars() { 73 if (mUtfChars) { 74 mEnv->ReleaseStringUTFChars(mString, mUtfChars); 75 } 76 } 77 78 const char* c_str() const { 79 return mUtfChars; 80 } 81 82 size_t size() const { 83 return strlen(mUtfChars); 84 } 85 86 // Element access. 87 const char& operator[](size_t n) const { 88 return mUtfChars[n]; 89 } 90 91 private: 92 JNIEnv* mEnv; 93 jstring mString; 94 const char* mUtfChars; 95 96 // Disallow copy and assignment. 97 NullableScopedUtfChars(const NullableScopedUtfChars&); 98 void operator=(const NullableScopedUtfChars&); 99 }; 100 101 static jlong DexFile_openDexFileNative(JNIEnv* env, jclass, jstring javaSourceName, jstring javaOutputName, jint) { 102 ScopedUtfChars sourceName(env, javaSourceName); 103 if (sourceName.c_str() == NULL) { 104 return 0; 105 } 106 NullableScopedUtfChars outputName(env, javaOutputName); 107 if (env->ExceptionCheck()) { 108 return 0; 109 } 110 111 ClassLinker* linker = Runtime::Current()->GetClassLinker(); 112 std::unique_ptr<std::vector<const DexFile*>> dex_files(new std::vector<const DexFile*>()); 113 std::vector<std::string> error_msgs; 114 115 bool success = linker->OpenDexFilesFromOat(sourceName.c_str(), outputName.c_str(), &error_msgs, 116 dex_files.get()); 117 118 if (success || !dex_files->empty()) { 119 // In the case of non-success, we have not found or could not generate the oat file. 120 // But we may still have found a dex file that we can use. 121 return static_cast<jlong>(reinterpret_cast<uintptr_t>(dex_files.release())); 122 } else { 123 // The vector should be empty after a failed loading attempt. 124 DCHECK_EQ(0U, dex_files->size()); 125 126 ScopedObjectAccess soa(env); 127 CHECK(!error_msgs.empty()); 128 // The most important message is at the end. So set up nesting by going forward, which will 129 // wrap the existing exception as a cause for the following one. 130 auto it = error_msgs.begin(); 131 auto itEnd = error_msgs.end(); 132 for ( ; it != itEnd; ++it) { 133 ThrowWrappedIOException("%s", it->c_str()); 134 } 135 136 return 0; 137 } 138 } 139 140 static std::vector<const DexFile*>* toDexFiles(jlong dex_file_address, JNIEnv* env) { 141 std::vector<const DexFile*>* dex_files = reinterpret_cast<std::vector<const DexFile*>*>( 142 static_cast<uintptr_t>(dex_file_address)); 143 if (UNLIKELY(dex_files == nullptr)) { 144 ScopedObjectAccess soa(env); 145 ThrowNullPointerException(NULL, "dex_file == null"); 146 } 147 return dex_files; 148 } 149 150 static void DexFile_closeDexFile(JNIEnv* env, jclass, jlong cookie) { 151 std::unique_ptr<std::vector<const DexFile*>> dex_files(toDexFiles(cookie, env)); 152 if (dex_files.get() == nullptr) { 153 return; 154 } 155 ScopedObjectAccess soa(env); 156 157 size_t index = 0; 158 for (const DexFile* dex_file : *dex_files) { 159 if (Runtime::Current()->GetClassLinker()->IsDexFileRegistered(*dex_file)) { 160 (*dex_files)[index] = nullptr; 161 } 162 index++; 163 } 164 165 STLDeleteElements(dex_files.get()); 166 // Unique_ptr will delete the vector itself. 167 } 168 169 static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader, 170 jlong cookie) { 171 std::vector<const DexFile*>* dex_files = toDexFiles(cookie, env); 172 if (dex_files == NULL) { 173 VLOG(class_linker) << "Failed to find dex_file"; 174 return NULL; 175 } 176 ScopedUtfChars class_name(env, javaName); 177 if (class_name.c_str() == NULL) { 178 VLOG(class_linker) << "Failed to find class_name"; 179 return NULL; 180 } 181 const std::string descriptor(DotToDescriptor(class_name.c_str())); 182 183 for (const DexFile* dex_file : *dex_files) { 184 const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor.c_str()); 185 if (dex_class_def != nullptr) { 186 ScopedObjectAccess soa(env); 187 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 188 class_linker->RegisterDexFile(*dex_file); 189 StackHandleScope<1> hs(soa.Self()); 190 Handle<mirror::ClassLoader> class_loader( 191 hs.NewHandle(soa.Decode<mirror::ClassLoader*>(javaLoader))); 192 mirror::Class* result = class_linker->DefineClass(descriptor.c_str(), class_loader, *dex_file, 193 *dex_class_def); 194 if (result != nullptr) { 195 VLOG(class_linker) << "DexFile_defineClassNative returning " << result; 196 return soa.AddLocalReference<jclass>(result); 197 } 198 } 199 } 200 VLOG(class_linker) << "Failed to find dex_class_def"; 201 return nullptr; 202 } 203 204 // Needed as a compare functor for sets of const char 205 struct CharPointerComparator { 206 bool operator()(const char *str1, const char *str2) const { 207 return strcmp(str1, str2) < 0; 208 } 209 }; 210 211 // Note: this can be an expensive call, as we sort out duplicates in MultiDex files. 212 static jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jlong cookie) { 213 jobjectArray result = nullptr; 214 std::vector<const DexFile*>* dex_files = toDexFiles(cookie, env); 215 216 if (dex_files != nullptr) { 217 // Push all class descriptors into a set. Use set instead of unordered_set as we want to 218 // retrieve all in the end. 219 std::set<const char*, CharPointerComparator> descriptors; 220 for (const DexFile* dex_file : *dex_files) { 221 for (size_t i = 0; i < dex_file->NumClassDefs(); ++i) { 222 const DexFile::ClassDef& class_def = dex_file->GetClassDef(i); 223 const char* descriptor = dex_file->GetClassDescriptor(class_def); 224 descriptors.insert(descriptor); 225 } 226 } 227 228 // Now create output array and copy the set into it. 229 result = env->NewObjectArray(descriptors.size(), WellKnownClasses::java_lang_String, nullptr); 230 if (result != nullptr) { 231 auto it = descriptors.begin(); 232 auto it_end = descriptors.end(); 233 jsize i = 0; 234 for (; it != it_end; it++, ++i) { 235 std::string descriptor(DescriptorToDot(*it)); 236 ScopedLocalRef<jstring> jdescriptor(env, env->NewStringUTF(descriptor.c_str())); 237 if (jdescriptor.get() == nullptr) { 238 return nullptr; 239 } 240 env->SetObjectArrayElement(result, i, jdescriptor.get()); 241 } 242 } 243 } 244 return result; 245 } 246 247 static void CopyProfileFile(const char* oldfile, const char* newfile) { 248 ScopedFd src(open(oldfile, O_RDONLY)); 249 if (src.get() == -1) { 250 PLOG(ERROR) << "Failed to open profile file " << oldfile 251 << ". My uid:gid is " << getuid() << ":" << getgid(); 252 return; 253 } 254 255 struct stat stat_src; 256 if (fstat(src.get(), &stat_src) == -1) { 257 PLOG(ERROR) << "Failed to get stats for profile file " << oldfile 258 << ". My uid:gid is " << getuid() << ":" << getgid(); 259 return; 260 } 261 262 // Create the copy with rw------- (only accessible by system) 263 ScopedFd dst(open(newfile, O_WRONLY|O_CREAT|O_TRUNC, 0600)); 264 if (dst.get() == -1) { 265 PLOG(ERROR) << "Failed to create/write prev profile file " << newfile 266 << ". My uid:gid is " << getuid() << ":" << getgid(); 267 return; 268 } 269 270 #ifdef __linux__ 271 if (sendfile(dst.get(), src.get(), nullptr, stat_src.st_size) == -1) { 272 #else 273 off_t len; 274 if (sendfile(dst.get(), src.get(), 0, &len, nullptr, 0) == -1) { 275 #endif 276 PLOG(ERROR) << "Failed to copy profile file " << oldfile << " to " << newfile 277 << ". My uid:gid is " << getuid() << ":" << getgid(); 278 } 279 } 280 281 // Java: dalvik.system.DexFile.UP_TO_DATE 282 static const jbyte kUpToDate = 0; 283 // Java: dalvik.system.DexFile.DEXOPT_NEEDED 284 static const jbyte kPatchoatNeeded = 1; 285 // Java: dalvik.system.DexFile.PATCHOAT_NEEDED 286 static const jbyte kDexoptNeeded = 2; 287 288 template <const bool kVerboseLogging, const bool kReasonLogging> 289 static jbyte IsDexOptNeededForFile(const std::string& oat_filename, const char* filename, 290 InstructionSet target_instruction_set) { 291 std::string error_msg; 292 std::unique_ptr<const OatFile> oat_file(OatFile::Open(oat_filename, oat_filename, nullptr, 293 false, &error_msg)); 294 if (oat_file.get() == nullptr) { 295 if (kReasonLogging) { 296 LOG(INFO) << "DexFile_isDexOptNeeded failed to open oat file '" << oat_filename 297 << "' for file location '" << filename << "': " << error_msg; 298 } 299 error_msg.clear(); 300 return kDexoptNeeded; 301 } 302 bool should_relocate_if_possible = Runtime::Current()->ShouldRelocate(); 303 uint32_t location_checksum = 0; 304 const art::OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(filename, nullptr, 305 kReasonLogging); 306 if (oat_dex_file != nullptr) { 307 // If its not possible to read the classes.dex assume up-to-date as we won't be able to 308 // compile it anyway. 309 if (!DexFile::GetChecksum(filename, &location_checksum, &error_msg)) { 310 if (kVerboseLogging) { 311 LOG(INFO) << "DexFile_isDexOptNeeded found precompiled stripped file: " 312 << filename << " for " << oat_filename << ": " << error_msg; 313 } 314 if (ClassLinker::VerifyOatChecksums(oat_file.get(), target_instruction_set, &error_msg)) { 315 if (kVerboseLogging) { 316 LOG(INFO) << "DexFile_isDexOptNeeded file " << oat_filename 317 << " is up-to-date for " << filename; 318 } 319 return kUpToDate; 320 } else if (should_relocate_if_possible && 321 ClassLinker::VerifyOatImageChecksum(oat_file.get(), target_instruction_set)) { 322 if (kReasonLogging) { 323 LOG(INFO) << "DexFile_isDexOptNeeded file " << oat_filename 324 << " needs to be relocated for " << filename; 325 } 326 return kPatchoatNeeded; 327 } else { 328 if (kReasonLogging) { 329 LOG(INFO) << "DexFile_isDexOptNeeded file " << oat_filename 330 << " is out of date for " << filename; 331 } 332 return kDexoptNeeded; 333 } 334 // If we get here the file is out of date and we should use the system one to relocate. 335 } else { 336 if (ClassLinker::VerifyOatAndDexFileChecksums(oat_file.get(), filename, location_checksum, 337 target_instruction_set, &error_msg)) { 338 if (kVerboseLogging) { 339 LOG(INFO) << "DexFile_isDexOptNeeded file " << oat_filename 340 << " is up-to-date for " << filename; 341 } 342 return kUpToDate; 343 } else if (location_checksum == oat_dex_file->GetDexFileLocationChecksum() 344 && should_relocate_if_possible 345 && ClassLinker::VerifyOatImageChecksum(oat_file.get(), target_instruction_set)) { 346 if (kReasonLogging) { 347 LOG(INFO) << "DexFile_isDexOptNeeded file " << oat_filename 348 << " needs to be relocated for " << filename; 349 } 350 return kPatchoatNeeded; 351 } else { 352 if (kReasonLogging) { 353 LOG(INFO) << "DexFile_isDexOptNeeded file " << oat_filename 354 << " is out of date for " << filename; 355 } 356 return kDexoptNeeded; 357 } 358 } 359 } else { 360 if (kReasonLogging) { 361 LOG(INFO) << "DexFile_isDexOptNeeded file " << oat_filename 362 << " does not contain " << filename; 363 } 364 return kDexoptNeeded; 365 } 366 } 367 368 static jbyte IsDexOptNeededInternal(JNIEnv* env, const char* filename, 369 const char* pkgname, const char* instruction_set, const jboolean defer) { 370 // Spammy logging for kUpToDate 371 const bool kVerboseLogging = false; 372 // Logging of reason for returning kDexoptNeeded or kPatchoatNeeded. 373 const bool kReasonLogging = true; 374 375 if ((filename == nullptr) || !OS::FileExists(filename)) { 376 LOG(ERROR) << "DexFile_isDexOptNeeded file '" << filename << "' does not exist"; 377 ScopedLocalRef<jclass> fnfe(env, env->FindClass("java/io/FileNotFoundException")); 378 const char* message = (filename == nullptr) ? "<empty file name>" : filename; 379 env->ThrowNew(fnfe.get(), message); 380 return kUpToDate; 381 } 382 383 // Always treat elements of the bootclasspath as up-to-date. The 384 // fact that code is running at all means that this should be true. 385 Runtime* runtime = Runtime::Current(); 386 ClassLinker* class_linker = runtime->GetClassLinker(); 387 // TODO: We're assuming that the 64 and 32 bit runtimes have identical 388 // class paths. isDexOptNeeded will not necessarily be called on a runtime 389 // that has the same instruction set as the file being dexopted. 390 const std::vector<const DexFile*>& boot_class_path = class_linker->GetBootClassPath(); 391 for (size_t i = 0; i < boot_class_path.size(); i++) { 392 if (boot_class_path[i]->GetLocation() == filename) { 393 if (kVerboseLogging) { 394 LOG(INFO) << "DexFile_isDexOptNeeded ignoring boot class path file: " << filename; 395 } 396 return kUpToDate; 397 } 398 } 399 400 bool force_system_only = false; 401 bool require_system_version = false; 402 403 // Check the profile file. We need to rerun dex2oat if the profile has changed significantly 404 // since the last time, or it's new. 405 // If the 'defer' argument is true then this will be retried later. In this case we 406 // need to make sure that the profile file copy is not made so that we will get the 407 // same result second time. 408 std::string profile_file; 409 std::string prev_profile_file; 410 bool should_copy_profile = false; 411 if (Runtime::Current()->GetProfilerOptions().IsEnabled() && (pkgname != nullptr)) { 412 profile_file = GetDalvikCacheOrDie("profiles", false /* create_if_absent */) 413 + std::string("/") + pkgname; 414 prev_profile_file = profile_file + std::string("@old"); 415 416 struct stat profstat, prevstat; 417 int e1 = stat(profile_file.c_str(), &profstat); 418 int e1_errno = errno; 419 int e2 = stat(prev_profile_file.c_str(), &prevstat); 420 int e2_errno = errno; 421 if (e1 < 0) { 422 if (e1_errno != EACCES) { 423 // No profile file, need to run dex2oat, unless we find a file in system 424 if (kReasonLogging) { 425 LOG(INFO) << "DexFile_isDexOptNeededInternal profile file " << profile_file << " doesn't exist. " 426 << "Will check odex to see if we can find a working version."; 427 } 428 // Force it to only accept system files/files with versions in system. 429 require_system_version = true; 430 } else { 431 LOG(INFO) << "DexFile_isDexOptNeededInternal recieved EACCES trying to stat profile file " 432 << profile_file; 433 } 434 } else if (e2 == 0) { 435 // There is a previous profile file. Check if the profile has changed significantly. 436 // A change in profile is considered significant if X% (change_thr property) of the top K% 437 // (compile_thr property) samples has changed. 438 double top_k_threshold = Runtime::Current()->GetProfilerOptions().GetTopKThreshold(); 439 double change_threshold = Runtime::Current()->GetProfilerOptions().GetTopKChangeThreshold(); 440 double change_percent = 0.0; 441 ProfileFile new_profile, old_profile; 442 bool new_ok = new_profile.LoadFile(profile_file); 443 bool old_ok = old_profile.LoadFile(prev_profile_file); 444 if (!new_ok || !old_ok) { 445 if (kVerboseLogging) { 446 LOG(INFO) << "DexFile_isDexOptNeededInternal Ignoring invalid profiles: " 447 << (new_ok ? "" : profile_file) << " " << (old_ok ? "" : prev_profile_file); 448 } 449 } else { 450 std::set<std::string> new_top_k, old_top_k; 451 new_profile.GetTopKSamples(new_top_k, top_k_threshold); 452 old_profile.GetTopKSamples(old_top_k, top_k_threshold); 453 if (new_top_k.empty()) { 454 if (kVerboseLogging) { 455 LOG(INFO) << "DexFile_isDexOptNeededInternal empty profile: " << profile_file; 456 } 457 // If the new topK is empty we shouldn't optimize so we leave the change_percent at 0.0. 458 } else { 459 std::set<std::string> diff; 460 std::set_difference(new_top_k.begin(), new_top_k.end(), old_top_k.begin(), old_top_k.end(), 461 std::inserter(diff, diff.end())); 462 // TODO: consider using the usedPercentage instead of the plain diff count. 463 change_percent = 100.0 * static_cast<double>(diff.size()) / static_cast<double>(new_top_k.size()); 464 if (kVerboseLogging) { 465 std::set<std::string>::iterator end = diff.end(); 466 for (std::set<std::string>::iterator it = diff.begin(); it != end; it++) { 467 LOG(INFO) << "DexFile_isDexOptNeededInternal new in topK: " << *it; 468 } 469 } 470 } 471 } 472 473 if (change_percent > change_threshold) { 474 if (kReasonLogging) { 475 LOG(INFO) << "DexFile_isDexOptNeededInternal size of new profile file " << profile_file << 476 " is significantly different from old profile file " << prev_profile_file << " (top " 477 << top_k_threshold << "% samples changed in proportion of " << change_percent << "%)"; 478 } 479 should_copy_profile = !defer; 480 // Force us to only accept system files. 481 force_system_only = true; 482 } 483 } else if (e2_errno == ENOENT) { 484 // Previous profile does not exist. Make a copy of the current one. 485 if (kVerboseLogging) { 486 LOG(INFO) << "DexFile_isDexOptNeededInternal previous profile doesn't exist: " << prev_profile_file; 487 } 488 should_copy_profile = !defer; 489 } else { 490 PLOG(INFO) << "Unable to stat previous profile file " << prev_profile_file; 491 } 492 } 493 494 const InstructionSet target_instruction_set = GetInstructionSetFromString(instruction_set); 495 if (target_instruction_set == kNone) { 496 ScopedLocalRef<jclass> iae(env, env->FindClass("java/lang/IllegalArgumentException")); 497 std::string message(StringPrintf("Instruction set %s is invalid.", instruction_set)); 498 env->ThrowNew(iae.get(), message.c_str()); 499 return 0; 500 } 501 502 // Get the filename for odex file next to the dex file. 503 std::string odex_filename(DexFilenameToOdexFilename(filename, target_instruction_set)); 504 // Get the filename for the dalvik-cache file 505 std::string cache_dir; 506 bool have_android_data = false; 507 bool dalvik_cache_exists = false; 508 bool is_global_cache = false; 509 GetDalvikCache(instruction_set, false, &cache_dir, &have_android_data, &dalvik_cache_exists, 510 &is_global_cache); 511 std::string cache_filename; // was cache_location 512 bool have_cache_filename = false; 513 if (dalvik_cache_exists) { 514 std::string error_msg; 515 have_cache_filename = GetDalvikCacheFilename(filename, cache_dir.c_str(), &cache_filename, 516 &error_msg); 517 if (!have_cache_filename && kVerboseLogging) { 518 LOG(INFO) << "DexFile_isDexOptNeededInternal failed to find cache file for dex file " << filename 519 << ": " << error_msg; 520 } 521 } 522 523 bool should_relocate_if_possible = Runtime::Current()->ShouldRelocate(); 524 525 jbyte dalvik_cache_decision = -1; 526 // Lets try the cache first (since we want to load from there since thats where the relocated 527 // versions will be). 528 if (have_cache_filename && !force_system_only) { 529 // We can use the dalvik-cache if we find a good file. 530 dalvik_cache_decision = 531 IsDexOptNeededForFile<kVerboseLogging, kReasonLogging>(cache_filename, filename, 532 target_instruction_set); 533 // We will only return DexOptNeeded if both the cache and system return it. 534 if (dalvik_cache_decision != kDexoptNeeded && !require_system_version) { 535 CHECK(!(dalvik_cache_decision == kPatchoatNeeded && !should_relocate_if_possible)) 536 << "May not return PatchoatNeeded when patching is disabled."; 537 return dalvik_cache_decision; 538 } 539 // We couldn't find one thats easy. We should now try the system. 540 } 541 542 jbyte system_decision = 543 IsDexOptNeededForFile<kVerboseLogging, kReasonLogging>(odex_filename, filename, 544 target_instruction_set); 545 CHECK(!(system_decision == kPatchoatNeeded && !should_relocate_if_possible)) 546 << "May not return PatchoatNeeded when patching is disabled."; 547 548 if (require_system_version && system_decision == kPatchoatNeeded 549 && dalvik_cache_decision == kUpToDate) { 550 // We have a version from system relocated to the cache. Return it. 551 return dalvik_cache_decision; 552 } 553 554 if (should_copy_profile && system_decision == kDexoptNeeded) { 555 CopyProfileFile(profile_file.c_str(), prev_profile_file.c_str()); 556 } 557 558 return system_decision; 559 } 560 561 static jbyte DexFile_isDexOptNeededInternal(JNIEnv* env, jclass, jstring javaFilename, 562 jstring javaPkgname, jstring javaInstructionSet, jboolean defer) { 563 ScopedUtfChars filename(env, javaFilename); 564 if (env->ExceptionCheck()) { 565 return 0; 566 } 567 568 NullableScopedUtfChars pkgname(env, javaPkgname); 569 570 ScopedUtfChars instruction_set(env, javaInstructionSet); 571 if (env->ExceptionCheck()) { 572 return 0; 573 } 574 575 return IsDexOptNeededInternal(env, filename.c_str(), pkgname.c_str(), 576 instruction_set.c_str(), defer); 577 } 578 579 // public API, NULL pkgname 580 static jboolean DexFile_isDexOptNeeded(JNIEnv* env, jclass, jstring javaFilename) { 581 const char* instruction_set = GetInstructionSetString(kRuntimeISA); 582 ScopedUtfChars filename(env, javaFilename); 583 return kUpToDate != IsDexOptNeededInternal(env, filename.c_str(), nullptr /* pkgname */, 584 instruction_set, false /* defer */); 585 } 586 587 588 static JNINativeMethod gMethods[] = { 589 NATIVE_METHOD(DexFile, closeDexFile, "(J)V"), 590 NATIVE_METHOD(DexFile, defineClassNative, "(Ljava/lang/String;Ljava/lang/ClassLoader;J)Ljava/lang/Class;"), 591 NATIVE_METHOD(DexFile, getClassNameList, "(J)[Ljava/lang/String;"), 592 NATIVE_METHOD(DexFile, isDexOptNeeded, "(Ljava/lang/String;)Z"), 593 NATIVE_METHOD(DexFile, isDexOptNeededInternal, "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)B"), 594 NATIVE_METHOD(DexFile, openDexFileNative, "(Ljava/lang/String;Ljava/lang/String;I)J"), 595 }; 596 597 void register_dalvik_system_DexFile(JNIEnv* env) { 598 REGISTER_NATIVE_METHODS("dalvik/system/DexFile"); 599 } 600 601 } // namespace art 602
