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