runtime/parsed_options.cc

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