uint32_t image_oat_checksum = 0;
uintptr_t image_oat_data_begin = 0;
int32_t image_patch_delta = 0;
- if (instruction_set == Runtime::Current()->GetInstructionSet()) {
+ if (instruction_set == runtime->GetInstructionSet()) {
const ImageHeader& image_header = image_space->GetImageHeader();
image_oat_checksum = image_header.GetOatChecksum();
image_oat_data_begin = reinterpret_cast<uintptr_t>(image_header.GetOatDataBegin());
arg_vector.push_back(oat_file_option_string);
Runtime::Current()->AddCurrentRuntimeFeaturesAsDex2OatArguments(&arg_vector);
- CHECK_EQ(image_isa, kRuntimeISA) << "We should always be generating an image for the current isa.";
+ CHECK_EQ(image_isa, kRuntimeISA)
+ << "We should always be generating an image for the current isa.";
int32_t base_offset = ChooseRelocationOffsetDelta(ART_BASE_ADDRESS_MIN_DELTA,
ART_BASE_ADDRESS_MAX_DELTA);
return Exec(argv, error_msg);
}
-static ImageHeader* ReadSpecificImageHeaderOrDie(const char* filename) {
+static ImageHeader* ReadSpecificImageHeader(const char* filename, std::string* error_msg) {
std::unique_ptr<ImageHeader> hdr(new ImageHeader);
if (!ReadSpecificImageHeader(filename, hdr.get())) {
- LOG(FATAL) << "Unable to read image header for " << filename;
+ *error_msg = StringPrintf("Unable to read image header for %s", filename);
return nullptr;
}
return hdr.release();
ImageHeader* ImageSpace::ReadImageHeaderOrDie(const char* image_location,
const InstructionSet image_isa) {
+ std::string error_msg;
+ ImageHeader* image_header = ReadImageHeader(image_location, image_isa, &error_msg);
+ if (image_header == nullptr) {
+ LOG(FATAL) << error_msg;
+ }
+ return image_header;
+}
+
+ImageHeader* ImageSpace::ReadImageHeader(const char* image_location,
+ const InstructionSet image_isa,
+ std::string* error_msg) {
std::string system_filename;
bool has_system = false;
std::string cache_filename;
std::unique_ptr<ImageHeader> sys_hdr(new ImageHeader);
std::unique_ptr<ImageHeader> cache_hdr(new ImageHeader);
if (!ReadSpecificImageHeader(system_filename.c_str(), sys_hdr.get())) {
- LOG(FATAL) << "Unable to read image header for " << image_location << " at "
- << system_filename;
+ *error_msg = StringPrintf("Unable to read image header for %s at %s",
+ image_location, system_filename.c_str());
return nullptr;
}
if (!ReadSpecificImageHeader(cache_filename.c_str(), cache_hdr.get())) {
- LOG(FATAL) << "Unable to read image header for " << image_location << " at "
- << cache_filename;
+ *error_msg = StringPrintf("Unable to read image header for %s at %s",
+ image_location, cache_filename.c_str());
return nullptr;
}
if (sys_hdr->GetOatChecksum() != cache_hdr->GetOatChecksum()) {
- LOG(FATAL) << "Unable to find a relocated version of image file " << image_location;
+ *error_msg = StringPrintf("Unable to find a relocated version of image file %s",
+ image_location);
return nullptr;
}
return cache_hdr.release();
} else if (!has_cache) {
- LOG(FATAL) << "Unable to find a relocated version of image file " << image_location;
+ *error_msg = StringPrintf("Unable to find a relocated version of image file %s",
+ image_location);
return nullptr;
} else if (!has_system && has_cache) {
// This can probably just use the cache one.
- return ReadSpecificImageHeaderOrDie(cache_filename.c_str());
+ return ReadSpecificImageHeader(cache_filename.c_str(), error_msg);
}
} else {
// We don't want to relocate, Just pick the appropriate one if we have it and return.
if (has_system && has_cache) {
// We want the cache if the checksum matches, otherwise the system.
- std::unique_ptr<ImageHeader> system(ReadSpecificImageHeaderOrDie(system_filename.c_str()));
- std::unique_ptr<ImageHeader> cache(ReadSpecificImageHeaderOrDie(cache_filename.c_str()));
+ std::unique_ptr<ImageHeader> system(ReadSpecificImageHeader(system_filename.c_str(),
+ error_msg));
+ std::unique_ptr<ImageHeader> cache(ReadSpecificImageHeader(cache_filename.c_str(),
+ error_msg));
if (system.get() == nullptr ||
(cache.get() != nullptr && cache->GetOatChecksum() == system->GetOatChecksum())) {
return cache.release();
return system.release();
}
} else if (has_system) {
- return ReadSpecificImageHeaderOrDie(system_filename.c_str());
+ return ReadSpecificImageHeader(system_filename.c_str(), error_msg);
} else if (has_cache) {
- return ReadSpecificImageHeaderOrDie(cache_filename.c_str());
+ return ReadSpecificImageHeader(cache_filename.c_str(), error_msg);
}
}
}
- LOG(FATAL) << "Unable to find image file for: " << image_location;
+ *error_msg = StringPrintf("Unable to find image file for %s", image_location);
return nullptr;
}
CHECK_EQ(image_header.GetImageBegin(), map->Begin());
DCHECK_EQ(0, memcmp(&image_header, map->Begin(), sizeof(ImageHeader)));
- std::unique_ptr<MemMap> image_map(MemMap::MapFileAtAddress(nullptr, image_header.GetImageBitmapSize(),
- PROT_READ, MAP_PRIVATE,
- file->Fd(), image_header.GetBitmapOffset(),
- false,
- image_filename,
- error_msg));
+ std::unique_ptr<MemMap> image_map(
+ MemMap::MapFileAtAddress(nullptr, image_header.GetImageBitmapSize(),
+ PROT_READ, MAP_PRIVATE,
+ file->Fd(), image_header.GetBitmapOffset(),
+ false,
+ image_filename,
+ error_msg));
if (image_map.get() == nullptr) {
*error_msg = StringPrintf("Failed to map image bitmap: %s", error_msg->c_str());
return nullptr;
runtime->SetDefaultImt(down_cast<mirror::ObjectArray<mirror::ArtMethod>*>(default_imt));
mirror::Object* callee_save_method = image_header.GetImageRoot(ImageHeader::kCalleeSaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kSaveAll);
+ runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method),
+ Runtime::kSaveAll);
callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsOnlySaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kRefsOnly);
+ runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method),
+ Runtime::kRefsOnly);
callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsAndArgsSaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method), Runtime::kRefsAndArgs);
+ runtime->SetCalleeSaveMethod(down_cast<mirror::ArtMethod*>(callee_save_method),
+ Runtime::kRefsAndArgs);
if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
LOG(INFO) << "ImageSpace::Init exiting (" << PrettyDuration(NanoTime() - start_time)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Reads the image header from the specified image location for the
- // instruction set image_isa.
+ // instruction set image_isa or dies trying.
static ImageHeader* ReadImageHeaderOrDie(const char* image_location,
InstructionSet image_isa);
+ // Reads the image header from the specified image location for the
+ // instruction set image_isa. Returns nullptr on failure, with
+ // reason in error_msg.
+ static ImageHeader* ReadImageHeader(const char* image_location,
+ InstructionSet image_isa,
+ std::string* error_msg);
+
// Give access to the OatFile.
const OatFile* GetOatFile() const;
#include <limits.h>
+#include "ScopedUtfChars.h"
#include "class_linker-inl.h"
#include "common_throws.h"
#include "debugger.h"
#include "gc/allocator/dlmalloc.h"
#include "gc/heap.h"
#include "gc/space/dlmalloc_space.h"
+#include "gc/space/image_space.h"
+#include "instruction_set.h"
#include "intern_table.h"
#include "jni_internal.h"
#include "mirror/art_method-inl.h"
return nullptr;
}
Runtime* runtime = Runtime::Current();
- mirror::Class* array_class = runtime->GetClassLinker()->FindArrayClass(soa.Self(), &element_class);
+ mirror::Class* array_class = runtime->GetClassLinker()->FindArrayClass(soa.Self(),
+ &element_class);
if (UNLIKELY(array_class == nullptr)) {
return nullptr;
}
env->ReleaseStringUTFChars(pkgName, pkgNameChars);
}
+static jboolean VMRuntime_isBootClassPathOnDisk(JNIEnv* env, jclass, jstring java_instruction_set) {
+ ScopedUtfChars instruction_set(env, java_instruction_set);
+ if (instruction_set.c_str() == nullptr) {
+ return JNI_FALSE;
+ }
+ InstructionSet isa = GetInstructionSetFromString(instruction_set.c_str());
+ if (isa == kNone) {
+ ScopedLocalRef<jclass> iae(env, env->FindClass("java/lang/IllegalArgumentException"));
+ std::string message(StringPrintf("Instruction set %s is invalid.", instruction_set.c_str()));
+ env->ThrowNew(iae.get(), message.c_str());
+ return JNI_FALSE;
+ }
+ std::string error_msg;
+ std::unique_ptr<ImageHeader> image_header(gc::space::ImageSpace::ReadImageHeader(
+ Runtime::Current()->GetImageLocation().c_str(), isa, &error_msg));
+ return image_header.get() != nullptr;
+}
+
+static jstring VMRuntime_getCurrentInstructionSet(JNIEnv* env, jclass) {
+ return env->NewStringUTF(GetInstructionSetString(kRuntimeISA));
+}
+
static JNINativeMethod gMethods[] = {
NATIVE_METHOD(VMRuntime, addressOf, "!(Ljava/lang/Object;)J"),
NATIVE_METHOD(VMRuntime, bootClassPath, "()Ljava/lang/String;"),
NATIVE_METHOD(VMRuntime, is64Bit, "!()Z"),
NATIVE_METHOD(VMRuntime, isCheckJniEnabled, "!()Z"),
NATIVE_METHOD(VMRuntime, preloadDexCaches, "()V"),
- NATIVE_METHOD(VMRuntime, registerAppInfo, "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"),
+ NATIVE_METHOD(VMRuntime, registerAppInfo,
+ "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"),
+ NATIVE_METHOD(VMRuntime, isBootClassPathOnDisk, "(Ljava/lang/String;)Z"),
+ NATIVE_METHOD(VMRuntime, getCurrentInstructionSet, "()Ljava/lang/String;"),
};
void register_dalvik_system_VMRuntime(JNIEnv* env) {
compiler_executable_ = options->compiler_executable_;
compiler_options_ = options->compiler_options_;
image_compiler_options_ = options->image_compiler_options_;
+ image_location_ = options->image_;
max_spins_before_thin_lock_inflation_ = options->max_spins_before_thin_lock_inflation_;
return image_compiler_options_;
}
+ const std::string& GetImageLocation() const {
+ return image_location_;
+ }
+
const ProfilerOptions& GetProfilerOptions() const {
return profiler_options_;
}
std::string patchoat_executable_;
std::vector<std::string> compiler_options_;
std::vector<std::string> image_compiler_options_;
+ std::string image_location_;
std::string boot_class_path_string_;
std::string class_path_string_;
Run -Xnoimage-dex2oat
-Has image is false, is image dex2oat enabled is false.
+Has image is false, is image dex2oat enabled is false, is BOOTCLASSPATH on disk is false.
Run -Ximage-dex2oat
-Has image is true, is image dex2oat enabled is true.
+Has image is true, is image dex2oat enabled is true, is BOOTCLASSPATH on disk is true.
Run default
-Has image is true, is image dex2oat enabled is true.
+Has image is true, is image dex2oat enabled is true, is BOOTCLASSPATH on disk is true.
* limitations under the License.
*/
+import java.lang.reflect.Method;
+
public class Main {
- public static void main(String[] args) {
+ public static void main(String[] args) throws Exception {
boolean hasImage = hasImage();
+ String instructionSet = VMRuntime.getCurrentInstructionSet();
+ boolean isBootClassPathOnDisk = VMRuntime.isBootClassPathOnDisk(instructionSet);
System.out.println(
"Has image is " + hasImage + ", is image dex2oat enabled is "
- + isImageDex2OatEnabled() + ".");
+ + isImageDex2OatEnabled() + ", is BOOTCLASSPATH on disk is "
+ + isBootClassPathOnDisk + ".");
if (hasImage && !isImageDex2OatEnabled()) {
throw new Error("Image with dex2oat disabled runs with an oat file");
} else if (!hasImage && isImageDex2OatEnabled()) {
throw new Error("Image with dex2oat enabled runs without an oat file");
}
+ if (hasImage && !isBootClassPathOnDisk) {
+ throw new Error("Image with dex2oat disabled runs with an image file");
+ } else if (!hasImage && isBootClassPathOnDisk) {
+ throw new Error("Image with dex2oat enabled runs without an image file");
+ }
}
static {
private native static boolean hasImage();
private native static boolean isImageDex2OatEnabled();
+
+ private static class VMRuntime {
+ private static final Method getCurrentInstructionSetMethod;
+ private static final Method isBootClassPathOnDiskMethod;
+ static {
+ try {
+ Class c = Class.forName("dalvik.system.VMRuntime");
+ getCurrentInstructionSetMethod = c.getDeclaredMethod("getCurrentInstructionSet");
+ isBootClassPathOnDiskMethod = c.getDeclaredMethod("isBootClassPathOnDisk",
+ String.class);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public static String getCurrentInstructionSet() throws Exception {
+ return (String) getCurrentInstructionSetMethod.invoke(null);
+ }
+ public static boolean isBootClassPathOnDisk(String instructionSet) throws Exception {
+ return (boolean) isBootClassPathOnDiskMethod.invoke(null, instructionSet);
+ }
+ }
}
OSDN Git Service
