/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "parsed_options.h" #include #include #include #include #include "base/file_utils.h" #include "base/macros.h" #include "base/utils.h" #include "debugger.h" #include "gc/heap.h" #include "jni_id_type.h" #include "monitor.h" #include "runtime.h" #include "ti/agent.h" #include "trace.h" #include "cmdline_parser.h" #include "runtime_options.h" namespace art { using MemoryKiB = Memory<1024>; ParsedOptions::ParsedOptions() : hook_is_sensitive_thread_(nullptr), hook_vfprintf_(vfprintf), hook_exit_(exit), hook_abort_(nullptr) { // We don't call abort(3) by default; see // Runtime::Abort } bool ParsedOptions::Parse(const RuntimeOptions& options, bool ignore_unrecognized, RuntimeArgumentMap* runtime_options) { CHECK(runtime_options != nullptr); ParsedOptions parser; return parser.DoParse(options, ignore_unrecognized, runtime_options); } using RuntimeParser = CmdlineParser; using HiddenapiPolicyValueMap = std::initializer_list>; // Yes, the stack frame is huge. But we get called super early on (and just once) // to pass the command line arguments, so we'll probably be ok. // Ideas to avoid suppressing this diagnostic are welcome! #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wframe-larger-than=" std::unique_ptr ParsedOptions::MakeParser(bool ignore_unrecognized) { using M = RuntimeArgumentMap; std::unique_ptr parser_builder = std::make_unique(); HiddenapiPolicyValueMap hiddenapi_policy_valuemap = {{"disabled", hiddenapi::EnforcementPolicy::kDisabled}, {"just-warn", hiddenapi::EnforcementPolicy::kJustWarn}, {"enabled", hiddenapi::EnforcementPolicy::kEnabled}}; DCHECK_EQ(hiddenapi_policy_valuemap.size(), static_cast(hiddenapi::EnforcementPolicy::kMax) + 1); parser_builder-> Define("-Xzygote") .IntoKey(M::Zygote) .Define("-Xprimaryzygote") .IntoKey(M::PrimaryZygote) .Define("-help") .IntoKey(M::Help) .Define("-showversion") .IntoKey(M::ShowVersion) .Define("-Xbootclasspath:_") .WithType>() // std::vector, split by : .IntoKey(M::BootClassPath) .Define("-Xbootclasspath-locations:_") .WithType>() // std::vector, split by : .IntoKey(M::BootClassPathLocations) .Define({"-classpath _", "-cp _"}) .WithType() .IntoKey(M::ClassPath) .Define("-Ximage:_") .WithType() .IntoKey(M::Image) .Define("-Ximage-load-order:_") .WithType() .WithValueMap({{"system", gc::space::ImageSpaceLoadingOrder::kSystemFirst}, {"data", gc::space::ImageSpaceLoadingOrder::kDataFirst}}) .IntoKey(M::ImageSpaceLoadingOrder) .Define("-Xcheck:jni") .IntoKey(M::CheckJni) .Define("-Xjniopts:forcecopy") .IntoKey(M::JniOptsForceCopy) .Define("-XjdwpProvider:_") .WithType() .IntoKey(M::JdwpProvider) .Define("-XjdwpOptions:_") .WithType() .IntoKey(M::JdwpOptions) // TODO Re-enable -agentlib: once I have a good way to transform the values. // .Define("-agentlib:_") // .WithType>().AppendValues() // .IntoKey(M::AgentLib) .Define("-agentpath:_") .WithType>().AppendValues() .IntoKey(M::AgentPath) .Define("-Xms_") .WithType() .IntoKey(M::MemoryInitialSize) .Define("-Xmx_") .WithType() .IntoKey(M::MemoryMaximumSize) .Define("-XX:HeapGrowthLimit=_") .WithType() .IntoKey(M::HeapGrowthLimit) .Define("-XX:HeapMinFree=_") .WithType() .IntoKey(M::HeapMinFree) .Define("-XX:HeapMaxFree=_") .WithType() .IntoKey(M::HeapMaxFree) .Define("-XX:NonMovingSpaceCapacity=_") .WithType() .IntoKey(M::NonMovingSpaceCapacity) .Define("-XX:StopForNativeAllocs=_") .WithType() .IntoKey(M::StopForNativeAllocs) .Define("-XX:HeapTargetUtilization=_") .WithType().WithRange(0.1, 0.9) .IntoKey(M::HeapTargetUtilization) .Define("-XX:ForegroundHeapGrowthMultiplier=_") .WithType().WithRange(0.1, 5.0) .IntoKey(M::ForegroundHeapGrowthMultiplier) .Define("-XX:ParallelGCThreads=_") .WithType() .IntoKey(M::ParallelGCThreads) .Define("-XX:ConcGCThreads=_") .WithType() .IntoKey(M::ConcGCThreads) .Define("-XX:FinalizerTimeoutMs=_") .WithType() .IntoKey(M::FinalizerTimeoutMs) .Define("-Xss_") .WithType>() .IntoKey(M::StackSize) .Define("-XX:MaxSpinsBeforeThinLockInflation=_") .WithType() .IntoKey(M::MaxSpinsBeforeThinLockInflation) .Define("-XX:LongPauseLogThreshold=_") // in ms .WithType() // store as ns .IntoKey(M::LongPauseLogThreshold) .Define("-XX:LongGCLogThreshold=_") // in ms .WithType() // store as ns .IntoKey(M::LongGCLogThreshold) .Define("-XX:DumpGCPerformanceOnShutdown") .IntoKey(M::DumpGCPerformanceOnShutdown) .Define("-XX:DumpRegionInfoBeforeGC") .IntoKey(M::DumpRegionInfoBeforeGC) .Define("-XX:DumpRegionInfoAfterGC") .IntoKey(M::DumpRegionInfoAfterGC) .Define("-XX:DumpJITInfoOnShutdown") .IntoKey(M::DumpJITInfoOnShutdown) .Define("-XX:IgnoreMaxFootprint") .IntoKey(M::IgnoreMaxFootprint) .Define("-XX:LowMemoryMode") .IntoKey(M::LowMemoryMode) .Define("-XX:UseTLAB") .WithValue(true) .IntoKey(M::UseTLAB) .Define({"-XX:EnableHSpaceCompactForOOM", "-XX:DisableHSpaceCompactForOOM"}) .WithValues({true, false}) .IntoKey(M::EnableHSpaceCompactForOOM) .Define("-XX:DumpNativeStackOnSigQuit:_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::DumpNativeStackOnSigQuit) .Define("-XX:MadviseRandomAccess:_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::MadviseRandomAccess) .Define("-Xusejit:_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::UseJitCompilation) .Define("-Xusetieredjit:_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::UseTieredJitCompilation) .Define("-Xjitinitialsize:_") .WithType() .IntoKey(M::JITCodeCacheInitialCapacity) .Define("-Xjitmaxsize:_") .WithType() .IntoKey(M::JITCodeCacheMaxCapacity) .Define("-Xjitthreshold:_") .WithType() .IntoKey(M::JITCompileThreshold) .Define("-Xjitwarmupthreshold:_") .WithType() .IntoKey(M::JITWarmupThreshold) .Define("-Xjitosrthreshold:_") .WithType() .IntoKey(M::JITOsrThreshold) .Define("-Xjitprithreadweight:_") .WithType() .IntoKey(M::JITPriorityThreadWeight) .Define("-Xjittransitionweight:_") .WithType() .IntoKey(M::JITInvokeTransitionWeight) .Define("-Xjitpthreadpriority:_") .WithType() .IntoKey(M::JITPoolThreadPthreadPriority) .Define("-Xjitsaveprofilinginfo") .WithType() .AppendValues() .IntoKey(M::ProfileSaverOpts) .Define("-Xps-_") // profile saver options -Xps-: .WithType() .AppendValues() .IntoKey(M::ProfileSaverOpts) // NOTE: Appends into same key as -Xjitsaveprofilinginfo .Define("-XX:HspaceCompactForOOMMinIntervalMs=_") // in ms .WithType() // store as ns .IntoKey(M::HSpaceCompactForOOMMinIntervalsMs) .Define("-D_") .WithType>().AppendValues() .IntoKey(M::PropertiesList) .Define("-Xjnitrace:_") .WithType() .IntoKey(M::JniTrace) .Define({"-Xrelocate", "-Xnorelocate"}) .WithValues({true, false}) .IntoKey(M::Relocate) .Define({"-Ximage-dex2oat", "-Xnoimage-dex2oat"}) .WithValues({true, false}) .IntoKey(M::ImageDex2Oat) .Define("-Xint") .WithValue(true) .IntoKey(M::Interpret) .Define("-Xgc:_") .WithType() .IntoKey(M::GcOption) .Define("-XX:LargeObjectSpace=_") .WithType() .WithValueMap({{"disabled", gc::space::LargeObjectSpaceType::kDisabled}, {"freelist", gc::space::LargeObjectSpaceType::kFreeList}, {"map", gc::space::LargeObjectSpaceType::kMap}}) .IntoKey(M::LargeObjectSpace) .Define("-XX:LargeObjectThreshold=_") .WithType>() .IntoKey(M::LargeObjectThreshold) .Define("-XX:BackgroundGC=_") .WithType() .IntoKey(M::BackgroundGc) .Define("-XX:+DisableExplicitGC") .IntoKey(M::DisableExplicitGC) .Define("-verbose:_") .WithType() .IntoKey(M::Verbose) .Define("-Xlockprofthreshold:_") .WithType() .IntoKey(M::LockProfThreshold) .Define("-Xstackdumplockprofthreshold:_") .WithType() .IntoKey(M::StackDumpLockProfThreshold) .Define("-Xmethod-trace") .IntoKey(M::MethodTrace) .Define("-Xmethod-trace-file:_") .WithType() .IntoKey(M::MethodTraceFile) .Define("-Xmethod-trace-file-size:_") .WithType() .IntoKey(M::MethodTraceFileSize) .Define("-Xmethod-trace-stream") .IntoKey(M::MethodTraceStreaming) .Define("-Xprofile:_") .WithType() .WithValueMap({{"threadcpuclock", TraceClockSource::kThreadCpu}, {"wallclock", TraceClockSource::kWall}, {"dualclock", TraceClockSource::kDual}}) .IntoKey(M::ProfileClock) .Define("-Xcompiler:_") .WithType() .IntoKey(M::Compiler) .Define("-Xcompiler-option _") .WithType>() .AppendValues() .IntoKey(M::CompilerOptions) .Define("-Ximage-compiler-option _") .WithType>() .AppendValues() .IntoKey(M::ImageCompilerOptions) .Define("-Xverify:_") .WithType() .WithValueMap({{"none", verifier::VerifyMode::kNone}, {"remote", verifier::VerifyMode::kEnable}, {"all", verifier::VerifyMode::kEnable}, {"softfail", verifier::VerifyMode::kSoftFail}}) .IntoKey(M::Verify) .Define("-XX:NativeBridge=_") .WithType() .IntoKey(M::NativeBridge) .Define("-Xzygote-max-boot-retry=_") .WithType() .IntoKey(M::ZygoteMaxFailedBoots) .Define("-Xno-dex-file-fallback") .IntoKey(M::NoDexFileFallback) .Define("-Xno-sig-chain") .IntoKey(M::NoSigChain) .Define("--cpu-abilist=_") .WithType() .IntoKey(M::CpuAbiList) .Define("-Xfingerprint:_") .WithType() .IntoKey(M::Fingerprint) .Define("-Xexperimental:_") .WithType() .AppendValues() .IntoKey(M::Experimental) .Define("-Xforce-nb-testing") .IntoKey(M::ForceNativeBridge) .Define("-Xplugin:_") .WithType>().AppendValues() .IntoKey(M::Plugins) .Define("-XX:ThreadSuspendTimeout=_") // in ms .WithType() // store as ns .IntoKey(M::ThreadSuspendTimeout) .Define("-XX:GlobalRefAllocStackTraceLimit=_") // Number of free slots to enable tracing. .WithType() .IntoKey(M::GlobalRefAllocStackTraceLimit) .Define("-XX:SlowDebug=_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::SlowDebug) .Define("-Xtarget-sdk-version:_") .WithType() .IntoKey(M::TargetSdkVersion) .Define("-Xhidden-api-policy:_") .WithType() .WithValueMap(hiddenapi_policy_valuemap) .IntoKey(M::HiddenApiPolicy) .Define("-Xcore-platform-api-policy:_") .WithType() .WithValueMap(hiddenapi_policy_valuemap) .IntoKey(M::CorePlatformApiPolicy) .Define("-Xuse-stderr-logger") .IntoKey(M::UseStderrLogger) .Define("-Xonly-use-system-oat-files") .IntoKey(M::OnlyUseSystemOatFiles) .Define("-Xverifier-logging-threshold=_") .WithType() .IntoKey(M::VerifierLoggingThreshold) .Define("-XX:FastClassNotFoundException=_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::FastClassNotFoundException) .Define("-Xopaque-jni-ids:_") .WithType() .WithValueMap({{"true", JniIdType::kIndices}, {"false", JniIdType::kPointer}, {"swapable", JniIdType::kSwapablePointer}, {"pointer", JniIdType::kPointer}, {"indices", JniIdType::kIndices}, {"default", JniIdType::kDefault}}) .IntoKey(M::OpaqueJniIds) .Define("-Xauto-promote-opaque-jni-ids:_") .WithType() .WithValueMap({{"true", true}, {"false", false}}) .IntoKey(M::AutoPromoteOpaqueJniIds) .Define("-XX:VerifierMissingKThrowFatal=_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::VerifierMissingKThrowFatal) .Define("-XX:PerfettoHprof=_") .WithType() .WithValueMap({{"false", false}, {"true", true}}) .IntoKey(M::PerfettoHprof) .Ignore({ "-ea", "-da", "-enableassertions", "-disableassertions", "--runtime-arg", "-esa", "-dsa", "-enablesystemassertions", "-disablesystemassertions", "-Xrs", "-Xint:_", "-Xdexopt:_", "-Xnoquithandler", "-Xjnigreflimit:_", "-Xgenregmap", "-Xnogenregmap", "-Xverifyopt:_", "-Xcheckdexsum", "-Xincludeselectedop", "-Xjitop:_", "-Xincludeselectedmethod", "-Xjitthreshold:_", "-Xjitblocking", "-Xjitmethod:_", "-Xjitclass:_", "-Xjitoffset:_", "-Xjitconfig:_", "-Xjitcheckcg", "-Xjitverbose", "-Xjitprofile", "-Xjitdisableopt", "-Xjitsuspendpoll", "-XX:mainThreadStackSize=_"}) .IgnoreUnrecognized(ignore_unrecognized); // TODO: Move Usage information into this DSL. return std::make_unique(parser_builder->Build()); } #pragma GCC diagnostic pop // Remove all the special options that have something in the void* part of the option. // If runtime_options is not null, put the options in there. // As a side-effect, populate the hooks from options. bool ParsedOptions::ProcessSpecialOptions(const RuntimeOptions& options, RuntimeArgumentMap* runtime_options, std::vector* out_options) { using M = RuntimeArgumentMap; // TODO: Move the below loop into JNI // Handle special options that set up hooks for (size_t i = 0; i < options.size(); ++i) { const std::string option(options[i].first); // TODO: support -Djava.class.path if (option == "bootclasspath") { auto boot_class_path = static_cast>*>( const_cast(options[i].second)); if (runtime_options != nullptr) { runtime_options->Set(M::BootClassPathDexList, boot_class_path); } } else if (option == "compilercallbacks") { CompilerCallbacks* compiler_callbacks = reinterpret_cast(const_cast(options[i].second)); if (runtime_options != nullptr) { runtime_options->Set(M::CompilerCallbacksPtr, compiler_callbacks); } } else if (option == "imageinstructionset") { const char* isa_str = reinterpret_cast(options[i].second); auto&& image_isa = GetInstructionSetFromString(isa_str); if (image_isa == InstructionSet::kNone) { Usage("%s is not a valid instruction set.", isa_str); return false; } if (runtime_options != nullptr) { runtime_options->Set(M::ImageInstructionSet, image_isa); } } else if (option == "sensitiveThread") { const void* hook = options[i].second; bool (*hook_is_sensitive_thread)() = reinterpret_cast(const_cast(hook)); if (runtime_options != nullptr) { runtime_options->Set(M::HookIsSensitiveThread, hook_is_sensitive_thread); } } else if (option == "vfprintf") { const void* hook = options[i].second; if (hook == nullptr) { Usage("vfprintf argument was nullptr"); return false; } int (*hook_vfprintf)(FILE *, const char*, va_list) = reinterpret_cast(const_cast(hook)); if (runtime_options != nullptr) { runtime_options->Set(M::HookVfprintf, hook_vfprintf); } hook_vfprintf_ = hook_vfprintf; } else if (option == "exit") { const void* hook = options[i].second; if (hook == nullptr) { Usage("exit argument was nullptr"); return false; } void(*hook_exit)(jint) = reinterpret_cast(const_cast(hook)); if (runtime_options != nullptr) { runtime_options->Set(M::HookExit, hook_exit); } hook_exit_ = hook_exit; } else if (option == "abort") { const void* hook = options[i].second; if (hook == nullptr) { Usage("abort was nullptr\n"); return false; } void(*hook_abort)() = reinterpret_cast(const_cast(hook)); if (runtime_options != nullptr) { runtime_options->Set(M::HookAbort, hook_abort); } hook_abort_ = hook_abort; } else { // It is a regular option, that doesn't have a known 'second' value. // Push it on to the regular options which will be parsed by our parser. if (out_options != nullptr) { out_options->push_back(option); } } } return true; } // Intended for local changes only. static void MaybeOverrideVerbosity() { // gLogVerbosity.class_linker = true; // TODO: don't check this in! // gLogVerbosity.collector = true; // TODO: don't check this in! // gLogVerbosity.compiler = true; // TODO: don't check this in! // gLogVerbosity.deopt = true; // TODO: don't check this in! // gLogVerbosity.gc = true; // TODO: don't check this in! // gLogVerbosity.heap = true; // TODO: don't check this in! // gLogVerbosity.interpreter = true; // TODO: don't check this in! // gLogVerbosity.jdwp = true; // TODO: don't check this in! // gLogVerbosity.jit = true; // TODO: don't check this in! // gLogVerbosity.jni = true; // TODO: don't check this in! // gLogVerbosity.monitor = true; // TODO: don't check this in! // gLogVerbosity.oat = true; // TODO: don't check this in! // gLogVerbosity.profiler = true; // TODO: don't check this in! // gLogVerbosity.signals = true; // TODO: don't check this in! // gLogVerbosity.simulator = true; // TODO: don't check this in! // gLogVerbosity.startup = true; // TODO: don't check this in! // gLogVerbosity.third_party_jni = true; // TODO: don't check this in! // gLogVerbosity.threads = true; // TODO: don't check this in! // gLogVerbosity.verifier = true; // TODO: don't check this in! } bool ParsedOptions::DoParse(const RuntimeOptions& options, bool ignore_unrecognized, RuntimeArgumentMap* runtime_options) { for (size_t i = 0; i < options.size(); ++i) { if (true && options[0].first == "-Xzygote") { LOG(INFO) << "option[" << i << "]=" << options[i].first; } } auto parser = MakeParser(ignore_unrecognized); // Convert to a simple string list (without the magic pointer options) std::vector argv_list; if (!ProcessSpecialOptions(options, nullptr, &argv_list)) { return false; } CmdlineResult parse_result = parser->Parse(argv_list); // Handle parse errors by displaying the usage and potentially exiting. if (parse_result.IsError()) { if (parse_result.GetStatus() == CmdlineResult::kUsage) { UsageMessage(stdout, "%s\n", parse_result.GetMessage().c_str()); Exit(0); } else if (parse_result.GetStatus() == CmdlineResult::kUnknown && !ignore_unrecognized) { Usage("%s\n", parse_result.GetMessage().c_str()); return false; } else { Usage("%s\n", parse_result.GetMessage().c_str()); Exit(0); } UNREACHABLE(); } using M = RuntimeArgumentMap; RuntimeArgumentMap args = parser->ReleaseArgumentsMap(); // -help, -showversion, etc. if (args.Exists(M::Help)) { Usage(nullptr); return false; } else if (args.Exists(M::ShowVersion)) { UsageMessage(stdout, "ART version %s %s\n", Runtime::GetVersion(), GetInstructionSetString(kRuntimeISA)); Exit(0); } else if (args.Exists(M::BootClassPath)) { LOG(INFO) << "setting boot class path to " << args.Get(M::BootClassPath)->Join(); } if (args.GetOrDefault(M::Interpret)) { if (args.Exists(M::UseJitCompilation) && *args.Get(M::UseJitCompilation)) { Usage("-Xusejit:true and -Xint cannot be specified together\n"); Exit(0); } args.Set(M::UseJitCompilation, false); } // Set a default boot class path if we didn't get an explicit one via command line. const char* env_bcp = getenv("BOOTCLASSPATH"); if (env_bcp != nullptr) { args.SetIfMissing(M::BootClassPath, ParseStringList<':'>::Split(env_bcp)); } // Set a default class path if we didn't get an explicit one via command line. if (getenv("CLASSPATH") != nullptr) { args.SetIfMissing(M::ClassPath, std::string(getenv("CLASSPATH"))); } // Default to number of processors minus one since the main GC thread also does work. args.SetIfMissing(M::ParallelGCThreads, gc::Heap::kDefaultEnableParallelGC ? static_cast(sysconf(_SC_NPROCESSORS_CONF) - 1u) : 0u); // -verbose: { LogVerbosity *log_verbosity = args.Get(M::Verbose); if (log_verbosity != nullptr) { gLogVerbosity = *log_verbosity; } } MaybeOverrideVerbosity(); SetRuntimeDebugFlagsEnabled(args.GetOrDefault(M::SlowDebug)); // -Xprofile: Trace::SetDefaultClockSource(args.GetOrDefault(M::ProfileClock)); if (!ProcessSpecialOptions(options, &args, nullptr)) { return false; } { // If not set, background collector type defaults to homogeneous compaction. // If not low memory mode, semispace otherwise. gc::CollectorType background_collector_type_; gc::CollectorType collector_type_ = (XGcOption{}).collector_type_; bool low_memory_mode_ = args.Exists(M::LowMemoryMode); background_collector_type_ = args.GetOrDefault(M::BackgroundGc); { XGcOption* xgc = args.Get(M::GcOption); if (xgc != nullptr && xgc->collector_type_ != gc::kCollectorTypeNone) { collector_type_ = xgc->collector_type_; } } if (background_collector_type_ == gc::kCollectorTypeNone) { background_collector_type_ = low_memory_mode_ ? gc::kCollectorTypeSS : gc::kCollectorTypeHomogeneousSpaceCompact; } args.Set(M::BackgroundGc, BackgroundGcOption { background_collector_type_ }); } const ParseStringList<':'>* boot_class_path_locations = args.Get(M::BootClassPathLocations); if (boot_class_path_locations != nullptr && boot_class_path_locations->Size() != 0u) { const ParseStringList<':'>* boot_class_path = args.Get(M::BootClassPath); if (boot_class_path == nullptr || boot_class_path_locations->Size() != boot_class_path->Size()) { Usage("The number of boot class path files does not match" " the number of boot class path locations given\n" " boot class path files (%zu): %s\n" " boot class path locations (%zu): %s\n", (boot_class_path != nullptr) ? boot_class_path->Size() : 0u, (boot_class_path != nullptr) ? boot_class_path->Join().c_str() : "", boot_class_path_locations->Size(), boot_class_path_locations->Join().c_str()); return false; } } if (!args.Exists(M::CompilerCallbacksPtr) && !args.Exists(M::Image)) { std::string image = GetDefaultBootImageLocation(GetAndroidRoot()); args.Set(M::Image, image); } // 0 means no growth limit, and growth limit should be always <= heap size if (args.GetOrDefault(M::HeapGrowthLimit) <= 0u || args.GetOrDefault(M::HeapGrowthLimit) > args.GetOrDefault(M::MemoryMaximumSize)) { args.Set(M::HeapGrowthLimit, args.GetOrDefault(M::MemoryMaximumSize)); } *runtime_options = std::move(args); return true; } void ParsedOptions::Exit(int status) { hook_exit_(status); } void ParsedOptions::Abort() { hook_abort_(); } void ParsedOptions::UsageMessageV(FILE* stream, const char* fmt, va_list ap) { hook_vfprintf_(stream, fmt, ap); } void ParsedOptions::UsageMessage(FILE* stream, const char* fmt, ...) { va_list ap; va_start(ap, fmt); UsageMessageV(stream, fmt, ap); va_end(ap); } void ParsedOptions::Usage(const char* fmt, ...) { bool error = (fmt != nullptr); FILE* stream = error ? stderr : stdout; if (fmt != nullptr) { va_list ap; va_start(ap, fmt); UsageMessageV(stream, fmt, ap); va_end(ap); } const char* program = "dalvikvm"; UsageMessage(stream, "%s: [options] class [argument ...]\n", program); UsageMessage(stream, "\n"); UsageMessage(stream, "The following standard options are supported:\n"); UsageMessage(stream, " -classpath classpath (-cp classpath)\n"); UsageMessage(stream, " -Dproperty=value\n"); UsageMessage(stream, " -verbose:tag[,tag...] (currently valid tags: 'agents', 'class',\n" " 'collector', 'compiler', 'deopt', 'dex', 'gc', 'heap', 'image',\n" " 'interpreter', 'jdwp', 'jit', 'jni', 'monitor', 'oat', 'profiler',\n" " 'signals', 'simulator', 'startup', 'systrace-locks',\n" " 'third-party-jni', 'threads', 'verifier', 'verifier-debug')\n"); UsageMessage(stream, " -showversion\n"); UsageMessage(stream, " -help\n"); // TODO add back in once -agentlib actually does something. // UsageMessage(stream, " -agentlib:library=options (Experimental feature, " // "requires -Xexperimental:agent, some features might not be supported)\n"); UsageMessage(stream, " -agentpath:library_path=options (Experimental feature, requires\n" " -Xexperimental:agent, some features might not be supported)\n"); UsageMessage(stream, "\n"); UsageMessage(stream, "The following extended options are supported:\n"); UsageMessage(stream, " -Xbootclasspath:bootclasspath\n"); UsageMessage(stream, " -Xcheck:tag (e.g. 'jni')\n"); UsageMessage(stream, " -XmsN (min heap, must be multiple of 1K, >= 1MB)\n"); UsageMessage(stream, " -XmxN (max heap, must be multiple of 1K, >= 2MB)\n"); UsageMessage(stream, " -XssN (stack size)\n"); UsageMessage(stream, " -Xint\n"); UsageMessage(stream, "\n"); UsageMessage(stream, "The following Dalvik options are supported:\n"); UsageMessage(stream, " -Xzygote\n"); UsageMessage(stream, " -Xjnitrace:substring (eg NativeClass or nativeMethod)\n"); UsageMessage(stream, " -Xgc:[no]preverify\n"); UsageMessage(stream, " -Xgc:[no]postverify\n"); UsageMessage(stream, " -XX:HeapGrowthLimit=N\n"); UsageMessage(stream, " -XX:HeapMinFree=N\n"); UsageMessage(stream, " -XX:HeapMaxFree=N\n"); UsageMessage(stream, " -XX:NonMovingSpaceCapacity=N\n"); UsageMessage(stream, " -XX:HeapTargetUtilization=doublevalue\n"); UsageMessage(stream, " -XX:ForegroundHeapGrowthMultiplier=doublevalue\n"); UsageMessage(stream, " -XX:LowMemoryMode\n"); UsageMessage(stream, " -Xprofile:{threadcpuclock,wallclock,dualclock}\n"); UsageMessage(stream, " -Xjitthreshold:integervalue\n"); UsageMessage(stream, "\n"); UsageMessage(stream, "The following unique to ART options are supported:\n"); UsageMessage(stream, " -Xgc:[no]preverify_rosalloc\n"); UsageMessage(stream, " -Xgc:[no]postsweepingverify_rosalloc\n"); UsageMessage(stream, " -Xgc:[no]postverify_rosalloc\n"); UsageMessage(stream, " -Xgc:[no]presweepingverify\n"); UsageMessage(stream, " -Xgc:[no]generational_cc\n"); UsageMessage(stream, " -Ximage:filename\n"); UsageMessage(stream, " -Xbootclasspath-locations:bootclasspath\n" " (override the dex locations of the -Xbootclasspath files)\n"); UsageMessage(stream, " -XX:+DisableExplicitGC\n"); UsageMessage(stream, " -XX:ParallelGCThreads=integervalue\n"); UsageMessage(stream, " -XX:ConcGCThreads=integervalue\n"); UsageMessage(stream, " -XX:FinalizerTimeoutMs=integervalue\n"); UsageMessage(stream, " -XX:MaxSpinsBeforeThinLockInflation=integervalue\n"); UsageMessage(stream, " -XX:LongPauseLogThreshold=integervalue\n"); UsageMessage(stream, " -XX:LongGCLogThreshold=integervalue\n"); UsageMessage(stream, " -XX:ThreadSuspendTimeout=integervalue\n"); UsageMessage(stream, " -XX:DumpGCPerformanceOnShutdown\n"); UsageMessage(stream, " -XX:DumpJITInfoOnShutdown\n"); UsageMessage(stream, " -XX:IgnoreMaxFootprint\n"); UsageMessage(stream, " -XX:UseTLAB\n"); UsageMessage(stream, " -XX:BackgroundGC=none\n"); UsageMessage(stream, " -XX:LargeObjectSpace={disabled,map,freelist}\n"); UsageMessage(stream, " -XX:LargeObjectThreshold=N\n"); UsageMessage(stream, " -XX:StopForNativeAllocs=N\n"); UsageMessage(stream, " -XX:DumpNativeStackOnSigQuit=booleanvalue\n"); UsageMessage(stream, " -XX:MadviseRandomAccess:booleanvalue\n"); UsageMessage(stream, " -XX:SlowDebug={false,true}\n"); UsageMessage(stream, " -Xmethod-trace\n"); UsageMessage(stream, " -Xmethod-trace-file:filename\n"); UsageMessage(stream, " -Xmethod-trace-file-size:integervalue\n"); UsageMessage(stream, " -Xps-min-save-period-ms:integervalue\n"); UsageMessage(stream, " -Xps-save-resolved-classes-delay-ms:integervalue\n"); UsageMessage(stream, " -Xps-hot-startup-method-samples:integervalue\n"); UsageMessage(stream, " -Xps-min-methods-to-save:integervalue\n"); UsageMessage(stream, " -Xps-min-classes-to-save:integervalue\n"); UsageMessage(stream, " -Xps-min-notification-before-wake:integervalue\n"); UsageMessage(stream, " -Xps-max-notification-before-wake:integervalue\n"); UsageMessage(stream, " -Xps-profile-path:file-path\n"); UsageMessage(stream, " -Xcompiler:filename\n"); UsageMessage(stream, " -Xcompiler-option dex2oat-option\n"); UsageMessage(stream, " -Ximage-compiler-option dex2oat-option\n"); UsageMessage(stream, " -Xusejit:booleanvalue\n"); UsageMessage(stream, " -Xjitinitialsize:N\n"); UsageMessage(stream, " -Xjitmaxsize:N\n"); UsageMessage(stream, " -Xjitwarmupthreshold:integervalue\n"); UsageMessage(stream, " -Xjitosrthreshold:integervalue\n"); UsageMessage(stream, " -Xjitprithreadweight:integervalue\n"); UsageMessage(stream, " -X[no]relocate\n"); UsageMessage(stream, " -X[no]dex2oat (Whether to invoke dex2oat on the application)\n"); UsageMessage(stream, " -X[no]image-dex2oat (Whether to create and use a boot image)\n"); UsageMessage(stream, " -Xno-dex-file-fallback " "(Don't fall back to dex files without oat files)\n"); UsageMessage(stream, " -Xplugin: " "(Load a runtime plugin, requires -Xexperimental:runtime-plugins)\n"); UsageMessage(stream, " -Xexperimental:runtime-plugins" "(Enable new and experimental agent support)\n"); UsageMessage(stream, " -Xexperimental:agents" "(Enable new and experimental agent support)\n"); UsageMessage(stream, " -Xopaque-jni-ids:{true,false,swapable}"); UsageMessage(stream, "(Use opauque integers for jni ids, yes, no or punt for later)\n"); UsageMessage(stream, "\n"); UsageMessage(stream, "The following previously supported Dalvik options are ignored:\n"); UsageMessage(stream, " -ea[:... |:]\n"); UsageMessage(stream, " -da[:... |:]\n"); UsageMessage(stream, " (-enableassertions, -disableassertions)\n"); UsageMessage(stream, " -esa\n"); UsageMessage(stream, " -dsa\n"); UsageMessage(stream, " (-enablesystemassertions, -disablesystemassertions)\n"); UsageMessage(stream, " -Xverify:{none,remote,all,softfail}\n"); UsageMessage(stream, " -Xrs\n"); UsageMessage(stream, " -Xint:portable, -Xint:fast, -Xint:jit\n"); UsageMessage(stream, " -Xdexopt:{none,verified,all,full}\n"); UsageMessage(stream, " -Xnoquithandler\n"); UsageMessage(stream, " -Xjniopts:{warnonly,forcecopy}\n"); UsageMessage(stream, " -Xjnigreflimit:integervalue\n"); UsageMessage(stream, " -Xgc:[no]precise\n"); UsageMessage(stream, " -Xgc:[no]verifycardtable\n"); UsageMessage(stream, " -X[no]genregmap\n"); UsageMessage(stream, " -Xverifyopt:[no]checkmon\n"); UsageMessage(stream, " -Xcheckdexsum\n"); UsageMessage(stream, " -Xincludeselectedop\n"); UsageMessage(stream, " -Xjitop:hexopvalue[-endvalue][,hexopvalue[-endvalue]]*\n"); UsageMessage(stream, " -Xincludeselectedmethod\n"); UsageMessage(stream, " -Xjitblocking\n"); UsageMessage(stream, " -Xjitmethod:signature[,signature]* (eg Ljava/lang/String\\;replace)\n"); UsageMessage(stream, " -Xjitclass:classname[,classname]*\n"); UsageMessage(stream, " -Xjitcodecachesize:N\n"); UsageMessage(stream, " -Xjitoffset:offset[,offset]\n"); UsageMessage(stream, " -Xjitconfig:filename\n"); UsageMessage(stream, " -Xjitcheckcg\n"); UsageMessage(stream, " -Xjitverbose\n"); UsageMessage(stream, " -Xjitprofile\n"); UsageMessage(stream, " -Xjitdisableopt\n"); UsageMessage(stream, " -Xjitsuspendpoll\n"); UsageMessage(stream, " -XX:mainThreadStackSize=N\n"); UsageMessage(stream, "\n"); Exit((error) ? 1 : 0); } } // namespace art