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