1 /* 2 * Copyright (C) 2011 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 "parsed_options.h" 18 19 #include <sstream> 20 21 #include <android-base/logging.h> 22 23 #include "base/file_utils.h" 24 #include "base/macros.h" 25 #include "base/stringpiece.h" 26 #include "base/utils.h" 27 #include "debugger.h" 28 #include "gc/heap.h" 29 #include "monitor.h" 30 #include "runtime.h" 31 #include "ti/agent.h" 32 #include "trace.h" 33 34 #include "cmdline_parser.h" 35 #include "runtime_options.h" 36 37 namespace art { 38 39 using MemoryKiB = Memory<1024>; 40 41 ParsedOptions::ParsedOptions() 42 : hook_is_sensitive_thread_(nullptr), 43 hook_vfprintf_(vfprintf), 44 hook_exit_(exit), 45 hook_abort_(nullptr) { // We don't call abort(3) by default; see 46 // Runtime::Abort 47 } 48 49 bool ParsedOptions::Parse(const RuntimeOptions& options, 50 bool ignore_unrecognized, 51 RuntimeArgumentMap* runtime_options) { 52 CHECK(runtime_options != nullptr); 53 54 ParsedOptions parser; 55 return parser.DoParse(options, ignore_unrecognized, runtime_options); 56 } 57 58 using RuntimeParser = CmdlineParser<RuntimeArgumentMap, RuntimeArgumentMap::Key>; 59 60 // Yes, the stack frame is huge. But we get called super early on (and just once) 61 // to pass the command line arguments, so we'll probably be ok. 62 // Ideas to avoid suppressing this diagnostic are welcome! 63 #pragma GCC diagnostic push 64 #pragma GCC diagnostic ignored "-Wframe-larger-than=" 65 66 std::unique_ptr<RuntimeParser> ParsedOptions::MakeParser(bool ignore_unrecognized) { 67 using M = RuntimeArgumentMap; 68 69 std::unique_ptr<RuntimeParser::Builder> parser_builder = 70 std::unique_ptr<RuntimeParser::Builder>(new RuntimeParser::Builder()); 71 72 parser_builder-> 73 Define("-Xzygote") 74 .IntoKey(M::Zygote) 75 .Define("-help") 76 .IntoKey(M::Help) 77 .Define("-showversion") 78 .IntoKey(M::ShowVersion) 79 .Define("-Xbootclasspath:_") 80 .WithType<std::string>() 81 .IntoKey(M::BootClassPath) 82 .Define("-Xbootclasspath-locations:_") 83 .WithType<ParseStringList<':'>>() // std::vector<std::string>, split by : 84 .IntoKey(M::BootClassPathLocations) 85 .Define({"-classpath _", "-cp _"}) 86 .WithType<std::string>() 87 .IntoKey(M::ClassPath) 88 .Define("-Ximage:_") 89 .WithType<std::string>() 90 .IntoKey(M::Image) 91 .Define("-Xcheck:jni") 92 .IntoKey(M::CheckJni) 93 .Define("-Xjniopts:forcecopy") 94 .IntoKey(M::JniOptsForceCopy) 95 .Define("-XjdwpProvider:_") 96 .WithType<JdwpProvider>() 97 .IntoKey(M::JdwpProvider) 98 .Define({"-Xrunjdwp:_", "-agentlib:jdwp=_", "-XjdwpOptions:_"}) 99 .WithType<std::string>() 100 .IntoKey(M::JdwpOptions) 101 // TODO Re-enable -agentlib: once I have a good way to transform the values. 102 // .Define("-agentlib:_") 103 // .WithType<std::vector<ti::Agent>>().AppendValues() 104 // .IntoKey(M::AgentLib) 105 .Define("-agentpath:_") 106 .WithType<std::list<ti::AgentSpec>>().AppendValues() 107 .IntoKey(M::AgentPath) 108 .Define("-Xms_") 109 .WithType<MemoryKiB>() 110 .IntoKey(M::MemoryInitialSize) 111 .Define("-Xmx_") 112 .WithType<MemoryKiB>() 113 .IntoKey(M::MemoryMaximumSize) 114 .Define("-XX:HeapGrowthLimit=_") 115 .WithType<MemoryKiB>() 116 .IntoKey(M::HeapGrowthLimit) 117 .Define("-XX:HeapMinFree=_") 118 .WithType<MemoryKiB>() 119 .IntoKey(M::HeapMinFree) 120 .Define("-XX:HeapMaxFree=_") 121 .WithType<MemoryKiB>() 122 .IntoKey(M::HeapMaxFree) 123 .Define("-XX:NonMovingSpaceCapacity=_") 124 .WithType<MemoryKiB>() 125 .IntoKey(M::NonMovingSpaceCapacity) 126 .Define("-XX:HeapTargetUtilization=_") 127 .WithType<double>().WithRange(0.1, 0.9) 128 .IntoKey(M::HeapTargetUtilization) 129 .Define("-XX:ForegroundHeapGrowthMultiplier=_") 130 .WithType<double>().WithRange(0.1, 5.0) 131 .IntoKey(M::ForegroundHeapGrowthMultiplier) 132 .Define("-XX:ParallelGCThreads=_") 133 .WithType<unsigned int>() 134 .IntoKey(M::ParallelGCThreads) 135 .Define("-XX:ConcGCThreads=_") 136 .WithType<unsigned int>() 137 .IntoKey(M::ConcGCThreads) 138 .Define("-Xss_") 139 .WithType<Memory<1>>() 140 .IntoKey(M::StackSize) 141 .Define("-XX:MaxSpinsBeforeThinLockInflation=_") 142 .WithType<unsigned int>() 143 .IntoKey(M::MaxSpinsBeforeThinLockInflation) 144 .Define("-XX:LongPauseLogThreshold=_") // in ms 145 .WithType<MillisecondsToNanoseconds>() // store as ns 146 .IntoKey(M::LongPauseLogThreshold) 147 .Define("-XX:LongGCLogThreshold=_") // in ms 148 .WithType<MillisecondsToNanoseconds>() // store as ns 149 .IntoKey(M::LongGCLogThreshold) 150 .Define("-XX:DumpGCPerformanceOnShutdown") 151 .IntoKey(M::DumpGCPerformanceOnShutdown) 152 .Define("-XX:DumpJITInfoOnShutdown") 153 .IntoKey(M::DumpJITInfoOnShutdown) 154 .Define("-XX:IgnoreMaxFootprint") 155 .IntoKey(M::IgnoreMaxFootprint) 156 .Define("-XX:LowMemoryMode") 157 .IntoKey(M::LowMemoryMode) 158 .Define("-XX:UseTLAB") 159 .WithValue(true) 160 .IntoKey(M::UseTLAB) 161 .Define({"-XX:EnableHSpaceCompactForOOM", "-XX:DisableHSpaceCompactForOOM"}) 162 .WithValues({true, false}) 163 .IntoKey(M::EnableHSpaceCompactForOOM) 164 .Define("-XX:DumpNativeStackOnSigQuit:_") 165 .WithType<bool>() 166 .WithValueMap({{"false", false}, {"true", true}}) 167 .IntoKey(M::DumpNativeStackOnSigQuit) 168 .Define("-XX:MadviseRandomAccess:_") 169 .WithType<bool>() 170 .WithValueMap({{"false", false}, {"true", true}}) 171 .IntoKey(M::MadviseRandomAccess) 172 .Define("-Xusejit:_") 173 .WithType<bool>() 174 .WithValueMap({{"false", false}, {"true", true}}) 175 .IntoKey(M::UseJitCompilation) 176 .Define("-Xjitinitialsize:_") 177 .WithType<MemoryKiB>() 178 .IntoKey(M::JITCodeCacheInitialCapacity) 179 .Define("-Xjitmaxsize:_") 180 .WithType<MemoryKiB>() 181 .IntoKey(M::JITCodeCacheMaxCapacity) 182 .Define("-Xjitthreshold:_") 183 .WithType<unsigned int>() 184 .IntoKey(M::JITCompileThreshold) 185 .Define("-Xjitwarmupthreshold:_") 186 .WithType<unsigned int>() 187 .IntoKey(M::JITWarmupThreshold) 188 .Define("-Xjitosrthreshold:_") 189 .WithType<unsigned int>() 190 .IntoKey(M::JITOsrThreshold) 191 .Define("-Xjitprithreadweight:_") 192 .WithType<unsigned int>() 193 .IntoKey(M::JITPriorityThreadWeight) 194 .Define("-Xjittransitionweight:_") 195 .WithType<unsigned int>() 196 .IntoKey(M::JITInvokeTransitionWeight) 197 .Define("-Xjitsaveprofilinginfo") 198 .WithType<ProfileSaverOptions>() 199 .AppendValues() 200 .IntoKey(M::ProfileSaverOpts) 201 .Define("-Xps-_") // profile saver options -Xps-<key>:<value> 202 .WithType<ProfileSaverOptions>() 203 .AppendValues() 204 .IntoKey(M::ProfileSaverOpts) // NOTE: Appends into same key as -Xjitsaveprofilinginfo 205 .Define("-XX:HspaceCompactForOOMMinIntervalMs=_") // in ms 206 .WithType<MillisecondsToNanoseconds>() // store as ns 207 .IntoKey(M::HSpaceCompactForOOMMinIntervalsMs) 208 .Define("-D_") 209 .WithType<std::vector<std::string>>().AppendValues() 210 .IntoKey(M::PropertiesList) 211 .Define("-Xjnitrace:_") 212 .WithType<std::string>() 213 .IntoKey(M::JniTrace) 214 .Define("-Xpatchoat:_") 215 .WithType<std::string>() 216 .IntoKey(M::PatchOat) 217 .Define({"-Xrelocate", "-Xnorelocate"}) 218 .WithValues({true, false}) 219 .IntoKey(M::Relocate) 220 .Define({"-Xdex2oat", "-Xnodex2oat"}) 221 .WithValues({true, false}) 222 .IntoKey(M::Dex2Oat) 223 .Define({"-Ximage-dex2oat", "-Xnoimage-dex2oat"}) 224 .WithValues({true, false}) 225 .IntoKey(M::ImageDex2Oat) 226 .Define("-Xint") 227 .WithValue(true) 228 .IntoKey(M::Interpret) 229 .Define("-Xgc:_") 230 .WithType<XGcOption>() 231 .IntoKey(M::GcOption) 232 .Define("-XX:LargeObjectSpace=_") 233 .WithType<gc::space::LargeObjectSpaceType>() 234 .WithValueMap({{"disabled", gc::space::LargeObjectSpaceType::kDisabled}, 235 {"freelist", gc::space::LargeObjectSpaceType::kFreeList}, 236 {"map", gc::space::LargeObjectSpaceType::kMap}}) 237 .IntoKey(M::LargeObjectSpace) 238 .Define("-XX:LargeObjectThreshold=_") 239 .WithType<Memory<1>>() 240 .IntoKey(M::LargeObjectThreshold) 241 .Define("-XX:BackgroundGC=_") 242 .WithType<BackgroundGcOption>() 243 .IntoKey(M::BackgroundGc) 244 .Define("-XX:+DisableExplicitGC") 245 .IntoKey(M::DisableExplicitGC) 246 .Define("-verbose:_") 247 .WithType<LogVerbosity>() 248 .IntoKey(M::Verbose) 249 .Define("-Xlockprofthreshold:_") 250 .WithType<unsigned int>() 251 .IntoKey(M::LockProfThreshold) 252 .Define("-Xstackdumplockprofthreshold:_") 253 .WithType<unsigned int>() 254 .IntoKey(M::StackDumpLockProfThreshold) 255 .Define("-Xusetombstonedtraces") 256 .WithValue(true) 257 .IntoKey(M::UseTombstonedTraces) 258 .Define("-Xstacktracefile:_") 259 .WithType<std::string>() 260 .IntoKey(M::StackTraceFile) 261 .Define("-Xmethod-trace") 262 .IntoKey(M::MethodTrace) 263 .Define("-Xmethod-trace-file:_") 264 .WithType<std::string>() 265 .IntoKey(M::MethodTraceFile) 266 .Define("-Xmethod-trace-file-size:_") 267 .WithType<unsigned int>() 268 .IntoKey(M::MethodTraceFileSize) 269 .Define("-Xmethod-trace-stream") 270 .IntoKey(M::MethodTraceStreaming) 271 .Define("-Xprofile:_") 272 .WithType<TraceClockSource>() 273 .WithValueMap({{"threadcpuclock", TraceClockSource::kThreadCpu}, 274 {"wallclock", TraceClockSource::kWall}, 275 {"dualclock", TraceClockSource::kDual}}) 276 .IntoKey(M::ProfileClock) 277 .Define("-Xcompiler:_") 278 .WithType<std::string>() 279 .IntoKey(M::Compiler) 280 .Define("-Xcompiler-option _") 281 .WithType<std::vector<std::string>>() 282 .AppendValues() 283 .IntoKey(M::CompilerOptions) 284 .Define("-Ximage-compiler-option _") 285 .WithType<std::vector<std::string>>() 286 .AppendValues() 287 .IntoKey(M::ImageCompilerOptions) 288 .Define("-Xverify:_") 289 .WithType<verifier::VerifyMode>() 290 .WithValueMap({{"none", verifier::VerifyMode::kNone}, 291 {"remote", verifier::VerifyMode::kEnable}, 292 {"all", verifier::VerifyMode::kEnable}, 293 {"softfail", verifier::VerifyMode::kSoftFail}}) 294 .IntoKey(M::Verify) 295 .Define("-XX:NativeBridge=_") 296 .WithType<std::string>() 297 .IntoKey(M::NativeBridge) 298 .Define("-Xzygote-max-boot-retry=_") 299 .WithType<unsigned int>() 300 .IntoKey(M::ZygoteMaxFailedBoots) 301 .Define("-Xno-dex-file-fallback") 302 .IntoKey(M::NoDexFileFallback) 303 .Define("-Xno-sig-chain") 304 .IntoKey(M::NoSigChain) 305 .Define("--cpu-abilist=_") 306 .WithType<std::string>() 307 .IntoKey(M::CpuAbiList) 308 .Define("-Xfingerprint:_") 309 .WithType<std::string>() 310 .IntoKey(M::Fingerprint) 311 .Define("-Xexperimental:_") 312 .WithType<ExperimentalFlags>() 313 .AppendValues() 314 .IntoKey(M::Experimental) 315 .Define("-Xforce-nb-testing") 316 .IntoKey(M::ForceNativeBridge) 317 .Define("-Xplugin:_") 318 .WithType<std::vector<Plugin>>().AppendValues() 319 .IntoKey(M::Plugins) 320 .Define("-XX:ThreadSuspendTimeout=_") // in ms 321 .WithType<MillisecondsToNanoseconds>() // store as ns 322 .IntoKey(M::ThreadSuspendTimeout) 323 .Define("-XX:GlobalRefAllocStackTraceLimit=_") // Number of free slots to enable tracing. 324 .WithType<unsigned int>() 325 .IntoKey(M::GlobalRefAllocStackTraceLimit) 326 .Define("-XX:SlowDebug=_") 327 .WithType<bool>() 328 .WithValueMap({{"false", false}, {"true", true}}) 329 .IntoKey(M::SlowDebug) 330 .Define("-Xtarget-sdk-version:_") 331 .WithType<int>() 332 .IntoKey(M::TargetSdkVersion) 333 .Define("-Xhidden-api-checks") 334 .IntoKey(M::HiddenApiChecks) 335 .Define("-Xuse-stderr-logger") 336 .IntoKey(M::UseStderrLogger) 337 .Define("-Xonly-use-system-oat-files") 338 .IntoKey(M::OnlyUseSystemOatFiles) 339 .Ignore({ 340 "-ea", "-da", "-enableassertions", "-disableassertions", "--runtime-arg", "-esa", 341 "-dsa", "-enablesystemassertions", "-disablesystemassertions", "-Xrs", "-Xint:_", 342 "-Xdexopt:_", "-Xnoquithandler", "-Xjnigreflimit:_", "-Xgenregmap", "-Xnogenregmap", 343 "-Xverifyopt:_", "-Xcheckdexsum", "-Xincludeselectedop", "-Xjitop:_", 344 "-Xincludeselectedmethod", "-Xjitthreshold:_", 345 "-Xjitblocking", "-Xjitmethod:_", "-Xjitclass:_", "-Xjitoffset:_", 346 "-Xjitconfig:_", "-Xjitcheckcg", "-Xjitverbose", "-Xjitprofile", 347 "-Xjitdisableopt", "-Xjitsuspendpoll", "-XX:mainThreadStackSize=_"}) 348 .IgnoreUnrecognized(ignore_unrecognized); 349 350 // TODO: Move Usage information into this DSL. 351 352 return std::unique_ptr<RuntimeParser>(new RuntimeParser(parser_builder->Build())); 353 } 354 355 #pragma GCC diagnostic pop 356 357 // Remove all the special options that have something in the void* part of the option. 358 // If runtime_options is not null, put the options in there. 359 // As a side-effect, populate the hooks from options. 360 bool ParsedOptions::ProcessSpecialOptions(const RuntimeOptions& options, 361 RuntimeArgumentMap* runtime_options, 362 std::vector<std::string>* out_options) { 363 using M = RuntimeArgumentMap; 364 365 // TODO: Move the below loop into JNI 366 // Handle special options that set up hooks 367 for (size_t i = 0; i < options.size(); ++i) { 368 const std::string option(options[i].first); 369 // TODO: support -Djava.class.path 370 if (option == "bootclasspath") { 371 auto boot_class_path = static_cast<std::vector<std::unique_ptr<const DexFile>>*>( 372 const_cast<void*>(options[i].second)); 373 374 if (runtime_options != nullptr) { 375 runtime_options->Set(M::BootClassPathDexList, boot_class_path); 376 } 377 } else if (option == "compilercallbacks") { 378 CompilerCallbacks* compiler_callbacks = 379 reinterpret_cast<CompilerCallbacks*>(const_cast<void*>(options[i].second)); 380 if (runtime_options != nullptr) { 381 runtime_options->Set(M::CompilerCallbacksPtr, compiler_callbacks); 382 } 383 } else if (option == "imageinstructionset") { 384 const char* isa_str = reinterpret_cast<const char*>(options[i].second); 385 auto&& image_isa = GetInstructionSetFromString(isa_str); 386 if (image_isa == InstructionSet::kNone) { 387 Usage("%s is not a valid instruction set.", isa_str); 388 return false; 389 } 390 if (runtime_options != nullptr) { 391 runtime_options->Set(M::ImageInstructionSet, image_isa); 392 } 393 } else if (option == "sensitiveThread") { 394 const void* hook = options[i].second; 395 bool (*hook_is_sensitive_thread)() = reinterpret_cast<bool (*)()>(const_cast<void*>(hook)); 396 397 if (runtime_options != nullptr) { 398 runtime_options->Set(M::HookIsSensitiveThread, hook_is_sensitive_thread); 399 } 400 } else if (option == "vfprintf") { 401 const void* hook = options[i].second; 402 if (hook == nullptr) { 403 Usage("vfprintf argument was nullptr"); 404 return false; 405 } 406 int (*hook_vfprintf)(FILE *, const char*, va_list) = 407 reinterpret_cast<int (*)(FILE *, const char*, va_list)>(const_cast<void*>(hook)); 408 409 if (runtime_options != nullptr) { 410 runtime_options->Set(M::HookVfprintf, hook_vfprintf); 411 } 412 hook_vfprintf_ = hook_vfprintf; 413 } else if (option == "exit") { 414 const void* hook = options[i].second; 415 if (hook == nullptr) { 416 Usage("exit argument was nullptr"); 417 return false; 418 } 419 void(*hook_exit)(jint) = reinterpret_cast<void(*)(jint)>(const_cast<void*>(hook)); 420 if (runtime_options != nullptr) { 421 runtime_options->Set(M::HookExit, hook_exit); 422 } 423 hook_exit_ = hook_exit; 424 } else if (option == "abort") { 425 const void* hook = options[i].second; 426 if (hook == nullptr) { 427 Usage("abort was nullptr\n"); 428 return false; 429 } 430 void(*hook_abort)() = reinterpret_cast<void(*)()>(const_cast<void*>(hook)); 431 if (runtime_options != nullptr) { 432 runtime_options->Set(M::HookAbort, hook_abort); 433 } 434 hook_abort_ = hook_abort; 435 } else { 436 // It is a regular option, that doesn't have a known 'second' value. 437 // Push it on to the regular options which will be parsed by our parser. 438 if (out_options != nullptr) { 439 out_options->push_back(option); 440 } 441 } 442 } 443 444 return true; 445 } 446 447 // Intended for local changes only. 448 static void MaybeOverrideVerbosity() { 449 // gLogVerbosity.class_linker = true; // TODO: don't check this in! 450 // gLogVerbosity.collector = true; // TODO: don't check this in! 451 // gLogVerbosity.compiler = true; // TODO: don't check this in! 452 // gLogVerbosity.deopt = true; // TODO: don't check this in! 453 // gLogVerbosity.gc = true; // TODO: don't check this in! 454 // gLogVerbosity.heap = true; // TODO: don't check this in! 455 // gLogVerbosity.jdwp = true; // TODO: don't check this in! 456 // gLogVerbosity.jit = true; // TODO: don't check this in! 457 // gLogVerbosity.jni = true; // TODO: don't check this in! 458 // gLogVerbosity.monitor = true; // TODO: don't check this in! 459 // gLogVerbosity.oat = true; // TODO: don't check this in! 460 // gLogVerbosity.profiler = true; // TODO: don't check this in! 461 // gLogVerbosity.signals = true; // TODO: don't check this in! 462 // gLogVerbosity.simulator = true; // TODO: don't check this in! 463 // gLogVerbosity.startup = true; // TODO: don't check this in! 464 // gLogVerbosity.third_party_jni = true; // TODO: don't check this in! 465 // gLogVerbosity.threads = true; // TODO: don't check this in! 466 // gLogVerbosity.verifier = true; // TODO: don't check this in! 467 } 468 469 bool ParsedOptions::DoParse(const RuntimeOptions& options, 470 bool ignore_unrecognized, 471 RuntimeArgumentMap* runtime_options) { 472 for (size_t i = 0; i < options.size(); ++i) { 473 if (true && options[0].first == "-Xzygote") { 474 LOG(INFO) << "option[" << i << "]=" << options[i].first; 475 } 476 } 477 478 auto parser = MakeParser(ignore_unrecognized); 479 480 // Convert to a simple string list (without the magic pointer options) 481 std::vector<std::string> argv_list; 482 if (!ProcessSpecialOptions(options, nullptr, &argv_list)) { 483 return false; 484 } 485 486 CmdlineResult parse_result = parser->Parse(argv_list); 487 488 // Handle parse errors by displaying the usage and potentially exiting. 489 if (parse_result.IsError()) { 490 if (parse_result.GetStatus() == CmdlineResult::kUsage) { 491 UsageMessage(stdout, "%s\n", parse_result.GetMessage().c_str()); 492 Exit(0); 493 } else if (parse_result.GetStatus() == CmdlineResult::kUnknown && !ignore_unrecognized) { 494 Usage("%s\n", parse_result.GetMessage().c_str()); 495 return false; 496 } else { 497 Usage("%s\n", parse_result.GetMessage().c_str()); 498 Exit(0); 499 } 500 501 UNREACHABLE(); 502 } 503 504 using M = RuntimeArgumentMap; 505 RuntimeArgumentMap args = parser->ReleaseArgumentsMap(); 506 507 // -help, -showversion, etc. 508 if (args.Exists(M::Help)) { 509 Usage(nullptr); 510 return false; 511 } else if (args.Exists(M::ShowVersion)) { 512 UsageMessage(stdout, 513 "ART version %s %s\n", 514 Runtime::GetVersion(), 515 GetInstructionSetString(kRuntimeISA)); 516 Exit(0); 517 } else if (args.Exists(M::BootClassPath)) { 518 LOG(INFO) << "setting boot class path to " << *args.Get(M::BootClassPath); 519 } 520 521 if (args.GetOrDefault(M::UseJitCompilation) && args.GetOrDefault(M::Interpret)) { 522 Usage("-Xusejit:true and -Xint cannot be specified together"); 523 Exit(0); 524 } 525 526 // Set a default boot class path if we didn't get an explicit one via command line. 527 if (getenv("BOOTCLASSPATH") != nullptr) { 528 args.SetIfMissing(M::BootClassPath, std::string(getenv("BOOTCLASSPATH"))); 529 } 530 531 // Set a default class path if we didn't get an explicit one via command line. 532 if (getenv("CLASSPATH") != nullptr) { 533 args.SetIfMissing(M::ClassPath, std::string(getenv("CLASSPATH"))); 534 } 535 536 // Default to number of processors minus one since the main GC thread also does work. 537 args.SetIfMissing(M::ParallelGCThreads, gc::Heap::kDefaultEnableParallelGC ? 538 static_cast<unsigned int>(sysconf(_SC_NPROCESSORS_CONF) - 1u) : 0u); 539 540 // -verbose: 541 { 542 LogVerbosity *log_verbosity = args.Get(M::Verbose); 543 if (log_verbosity != nullptr) { 544 gLogVerbosity = *log_verbosity; 545 } 546 } 547 548 MaybeOverrideVerbosity(); 549 550 SetRuntimeDebugFlagsEnabled(args.Get(M::SlowDebug)); 551 552 // -Xprofile: 553 Trace::SetDefaultClockSource(args.GetOrDefault(M::ProfileClock)); 554 555 if (!ProcessSpecialOptions(options, &args, nullptr)) { 556 return false; 557 } 558 559 { 560 // If not set, background collector type defaults to homogeneous compaction. 561 // If foreground is GSS, use GSS as background collector. 562 // If not low memory mode, semispace otherwise. 563 564 gc::CollectorType background_collector_type_; 565 gc::CollectorType collector_type_ = (XGcOption{}).collector_type_; 566 bool low_memory_mode_ = args.Exists(M::LowMemoryMode); 567 568 background_collector_type_ = args.GetOrDefault(M::BackgroundGc); 569 { 570 XGcOption* xgc = args.Get(M::GcOption); 571 if (xgc != nullptr && xgc->collector_type_ != gc::kCollectorTypeNone) { 572 collector_type_ = xgc->collector_type_; 573 } 574 } 575 576 if (background_collector_type_ == gc::kCollectorTypeNone) { 577 if (collector_type_ != gc::kCollectorTypeGSS) { 578 background_collector_type_ = low_memory_mode_ ? 579 gc::kCollectorTypeSS : gc::kCollectorTypeHomogeneousSpaceCompact; 580 } else { 581 background_collector_type_ = collector_type_; 582 } 583 } 584 585 args.Set(M::BackgroundGc, BackgroundGcOption { background_collector_type_ }); 586 } 587 588 // If a reference to the dalvik core.jar snuck in, replace it with 589 // the art specific version. This can happen with on device 590 // boot.art/boot.oat generation by GenerateImage which relies on the 591 // value of BOOTCLASSPATH. 592 #if defined(ART_TARGET) 593 std::string core_jar("/core.jar"); 594 std::string core_libart_jar("/core-libart.jar"); 595 #else 596 // The host uses hostdex files. 597 std::string core_jar("/core-hostdex.jar"); 598 std::string core_libart_jar("/core-libart-hostdex.jar"); 599 #endif 600 auto boot_class_path_string = args.GetOrDefault(M::BootClassPath); 601 602 size_t core_jar_pos = boot_class_path_string.find(core_jar); 603 if (core_jar_pos != std::string::npos) { 604 boot_class_path_string.replace(core_jar_pos, core_jar.size(), core_libart_jar); 605 args.Set(M::BootClassPath, boot_class_path_string); 606 } 607 608 { 609 auto&& boot_class_path = args.GetOrDefault(M::BootClassPath); 610 auto&& boot_class_path_locations = args.GetOrDefault(M::BootClassPathLocations); 611 if (args.Exists(M::BootClassPathLocations)) { 612 size_t boot_class_path_count = ParseStringList<':'>::Split(boot_class_path).Size(); 613 614 if (boot_class_path_count != boot_class_path_locations.Size()) { 615 Usage("The number of boot class path files does not match" 616 " the number of boot class path locations given\n" 617 " boot class path files (%zu): %s\n" 618 " boot class path locations (%zu): %s\n", 619 boot_class_path.size(), boot_class_path_string.c_str(), 620 boot_class_path_locations.Size(), boot_class_path_locations.Join().c_str()); 621 return false; 622 } 623 } 624 } 625 626 if (!args.Exists(M::CompilerCallbacksPtr) && !args.Exists(M::Image)) { 627 std::string image = GetAndroidRoot(); 628 image += "/framework/boot.art"; 629 args.Set(M::Image, image); 630 } 631 632 // 0 means no growth limit, and growth limit should be always <= heap size 633 if (args.GetOrDefault(M::HeapGrowthLimit) <= 0u || 634 args.GetOrDefault(M::HeapGrowthLimit) > args.GetOrDefault(M::MemoryMaximumSize)) { 635 args.Set(M::HeapGrowthLimit, args.GetOrDefault(M::MemoryMaximumSize)); 636 } 637 638 *runtime_options = std::move(args); 639 return true; 640 } 641 642 void ParsedOptions::Exit(int status) { 643 hook_exit_(status); 644 } 645 646 void ParsedOptions::Abort() { 647 hook_abort_(); 648 } 649 650 void ParsedOptions::UsageMessageV(FILE* stream, const char* fmt, va_list ap) { 651 hook_vfprintf_(stream, fmt, ap); 652 } 653 654 void ParsedOptions::UsageMessage(FILE* stream, const char* fmt, ...) { 655 va_list ap; 656 va_start(ap, fmt); 657 UsageMessageV(stream, fmt, ap); 658 va_end(ap); 659 } 660 661 void ParsedOptions::Usage(const char* fmt, ...) { 662 bool error = (fmt != nullptr); 663 FILE* stream = error ? stderr : stdout; 664 665 if (fmt != nullptr) { 666 va_list ap; 667 va_start(ap, fmt); 668 UsageMessageV(stream, fmt, ap); 669 va_end(ap); 670 } 671 672 const char* program = "dalvikvm"; 673 UsageMessage(stream, "%s: [options] class [argument ...]\n", program); 674 UsageMessage(stream, "\n"); 675 UsageMessage(stream, "The following standard options are supported:\n"); 676 UsageMessage(stream, " -classpath classpath (-cp classpath)\n"); 677 UsageMessage(stream, " -Dproperty=value\n"); 678 UsageMessage(stream, " -verbose:tag ('gc', 'jit', 'jni', or 'class')\n"); 679 UsageMessage(stream, " -showversion\n"); 680 UsageMessage(stream, " -help\n"); 681 UsageMessage(stream, " -agentlib:jdwp=options\n"); 682 // TODO add back in once -agentlib actually does something. 683 // UsageMessage(stream, " -agentlib:library=options (Experimental feature, " 684 // "requires -Xexperimental:agent, some features might not be supported)\n"); 685 UsageMessage(stream, " -agentpath:library_path=options (Experimental feature, " 686 "requires -Xexperimental:agent, some features might not be supported)\n"); 687 UsageMessage(stream, "\n"); 688 689 UsageMessage(stream, "The following extended options are supported:\n"); 690 UsageMessage(stream, " -Xrunjdwp:<options>\n"); 691 UsageMessage(stream, " -Xbootclasspath:bootclasspath\n"); 692 UsageMessage(stream, " -Xcheck:tag (e.g. 'jni')\n"); 693 UsageMessage(stream, " -XmsN (min heap, must be multiple of 1K, >= 1MB)\n"); 694 UsageMessage(stream, " -XmxN (max heap, must be multiple of 1K, >= 2MB)\n"); 695 UsageMessage(stream, " -XssN (stack size)\n"); 696 UsageMessage(stream, " -Xint\n"); 697 UsageMessage(stream, "\n"); 698 699 UsageMessage(stream, "The following Dalvik options are supported:\n"); 700 UsageMessage(stream, " -Xzygote\n"); 701 UsageMessage(stream, " -Xjnitrace:substring (eg NativeClass or nativeMethod)\n"); 702 UsageMessage(stream, " -Xstacktracefile:<filename>\n"); 703 UsageMessage(stream, " -Xgc:[no]preverify\n"); 704 UsageMessage(stream, " -Xgc:[no]postverify\n"); 705 UsageMessage(stream, " -XX:HeapGrowthLimit=N\n"); 706 UsageMessage(stream, " -XX:HeapMinFree=N\n"); 707 UsageMessage(stream, " -XX:HeapMaxFree=N\n"); 708 UsageMessage(stream, " -XX:NonMovingSpaceCapacity=N\n"); 709 UsageMessage(stream, " -XX:HeapTargetUtilization=doublevalue\n"); 710 UsageMessage(stream, " -XX:ForegroundHeapGrowthMultiplier=doublevalue\n"); 711 UsageMessage(stream, " -XX:LowMemoryMode\n"); 712 UsageMessage(stream, " -Xprofile:{threadcpuclock,wallclock,dualclock}\n"); 713 UsageMessage(stream, " -Xjitthreshold:integervalue\n"); 714 UsageMessage(stream, "\n"); 715 716 UsageMessage(stream, "The following unique to ART options are supported:\n"); 717 UsageMessage(stream, " -Xgc:[no]preverify_rosalloc\n"); 718 UsageMessage(stream, " -Xgc:[no]postsweepingverify_rosalloc\n"); 719 UsageMessage(stream, " -Xgc:[no]postverify_rosalloc\n"); 720 UsageMessage(stream, " -Xgc:[no]presweepingverify\n"); 721 UsageMessage(stream, " -Ximage:filename\n"); 722 UsageMessage(stream, " -Xbootclasspath-locations:bootclasspath\n" 723 " (override the dex locations of the -Xbootclasspath files)\n"); 724 UsageMessage(stream, " -XX:+DisableExplicitGC\n"); 725 UsageMessage(stream, " -XX:ParallelGCThreads=integervalue\n"); 726 UsageMessage(stream, " -XX:ConcGCThreads=integervalue\n"); 727 UsageMessage(stream, " -XX:MaxSpinsBeforeThinLockInflation=integervalue\n"); 728 UsageMessage(stream, " -XX:LongPauseLogThreshold=integervalue\n"); 729 UsageMessage(stream, " -XX:LongGCLogThreshold=integervalue\n"); 730 UsageMessage(stream, " -XX:ThreadSuspendTimeout=integervalue\n"); 731 UsageMessage(stream, " -XX:DumpGCPerformanceOnShutdown\n"); 732 UsageMessage(stream, " -XX:DumpJITInfoOnShutdown\n"); 733 UsageMessage(stream, " -XX:IgnoreMaxFootprint\n"); 734 UsageMessage(stream, " -XX:UseTLAB\n"); 735 UsageMessage(stream, " -XX:BackgroundGC=none\n"); 736 UsageMessage(stream, " -XX:LargeObjectSpace={disabled,map,freelist}\n"); 737 UsageMessage(stream, " -XX:LargeObjectThreshold=N\n"); 738 UsageMessage(stream, " -XX:DumpNativeStackOnSigQuit=booleanvalue\n"); 739 UsageMessage(stream, " -XX:MadviseRandomAccess:booleanvalue\n"); 740 UsageMessage(stream, " -XX:SlowDebug={false,true}\n"); 741 UsageMessage(stream, " -Xmethod-trace\n"); 742 UsageMessage(stream, " -Xmethod-trace-file:filename"); 743 UsageMessage(stream, " -Xmethod-trace-file-size:integervalue\n"); 744 UsageMessage(stream, " -Xps-min-save-period-ms:integervalue\n"); 745 UsageMessage(stream, " -Xps-save-resolved-classes-delay-ms:integervalue\n"); 746 UsageMessage(stream, " -Xps-hot-startup-method-samples:integervalue\n"); 747 UsageMessage(stream, " -Xps-min-methods-to-save:integervalue\n"); 748 UsageMessage(stream, " -Xps-min-classes-to-save:integervalue\n"); 749 UsageMessage(stream, " -Xps-min-notification-before-wake:integervalue\n"); 750 UsageMessage(stream, " -Xps-max-notification-before-wake:integervalue\n"); 751 UsageMessage(stream, " -Xps-profile-path:file-path\n"); 752 UsageMessage(stream, " -Xcompiler:filename\n"); 753 UsageMessage(stream, " -Xcompiler-option dex2oat-option\n"); 754 UsageMessage(stream, " -Ximage-compiler-option dex2oat-option\n"); 755 UsageMessage(stream, " -Xpatchoat:filename\n"); 756 UsageMessage(stream, " -Xusejit:booleanvalue\n"); 757 UsageMessage(stream, " -Xjitinitialsize:N\n"); 758 UsageMessage(stream, " -Xjitmaxsize:N\n"); 759 UsageMessage(stream, " -Xjitwarmupthreshold:integervalue\n"); 760 UsageMessage(stream, " -Xjitosrthreshold:integervalue\n"); 761 UsageMessage(stream, " -Xjitprithreadweight:integervalue\n"); 762 UsageMessage(stream, " -X[no]relocate\n"); 763 UsageMessage(stream, " -X[no]dex2oat (Whether to invoke dex2oat on the application)\n"); 764 UsageMessage(stream, " -X[no]image-dex2oat (Whether to create and use a boot image)\n"); 765 UsageMessage(stream, " -Xno-dex-file-fallback " 766 "(Don't fall back to dex files without oat files)\n"); 767 UsageMessage(stream, " -Xplugin:<library.so> " 768 "(Load a runtime plugin, requires -Xexperimental:runtime-plugins)\n"); 769 UsageMessage(stream, " -Xexperimental:runtime-plugins" 770 "(Enable new and experimental agent support)\n"); 771 UsageMessage(stream, " -Xexperimental:agents" 772 "(Enable new and experimental agent support)\n"); 773 UsageMessage(stream, "\n"); 774 775 UsageMessage(stream, "The following previously supported Dalvik options are ignored:\n"); 776 UsageMessage(stream, " -ea[:<package name>... |:<class name>]\n"); 777 UsageMessage(stream, " -da[:<package name>... |:<class name>]\n"); 778 UsageMessage(stream, " (-enableassertions, -disableassertions)\n"); 779 UsageMessage(stream, " -esa\n"); 780 UsageMessage(stream, " -dsa\n"); 781 UsageMessage(stream, " (-enablesystemassertions, -disablesystemassertions)\n"); 782 UsageMessage(stream, " -Xverify:{none,remote,all,softfail}\n"); 783 UsageMessage(stream, " -Xrs\n"); 784 UsageMessage(stream, " -Xint:portable, -Xint:fast, -Xint:jit\n"); 785 UsageMessage(stream, " -Xdexopt:{none,verified,all,full}\n"); 786 UsageMessage(stream, " -Xnoquithandler\n"); 787 UsageMessage(stream, " -Xjniopts:{warnonly,forcecopy}\n"); 788 UsageMessage(stream, " -Xjnigreflimit:integervalue\n"); 789 UsageMessage(stream, " -Xgc:[no]precise\n"); 790 UsageMessage(stream, " -Xgc:[no]verifycardtable\n"); 791 UsageMessage(stream, " -X[no]genregmap\n"); 792 UsageMessage(stream, " -Xverifyopt:[no]checkmon\n"); 793 UsageMessage(stream, " -Xcheckdexsum\n"); 794 UsageMessage(stream, " -Xincludeselectedop\n"); 795 UsageMessage(stream, " -Xjitop:hexopvalue[-endvalue][,hexopvalue[-endvalue]]*\n"); 796 UsageMessage(stream, " -Xincludeselectedmethod\n"); 797 UsageMessage(stream, " -Xjitblocking\n"); 798 UsageMessage(stream, " -Xjitmethod:signature[,signature]* (eg Ljava/lang/String\\;replace)\n"); 799 UsageMessage(stream, " -Xjitclass:classname[,classname]*\n"); 800 UsageMessage(stream, " -Xjitcodecachesize:N\n"); 801 UsageMessage(stream, " -Xjitoffset:offset[,offset]\n"); 802 UsageMessage(stream, " -Xjitconfig:filename\n"); 803 UsageMessage(stream, " -Xjitcheckcg\n"); 804 UsageMessage(stream, " -Xjitverbose\n"); 805 UsageMessage(stream, " -Xjitprofile\n"); 806 UsageMessage(stream, " -Xjitdisableopt\n"); 807 UsageMessage(stream, " -Xjitsuspendpoll\n"); 808 UsageMessage(stream, " -XX:mainThreadStackSize=N\n"); 809 UsageMessage(stream, "\n"); 810 811 Exit((error) ? 1 : 0); 812 } 813 814 } // namespace art 815
