blob: ccc5f7a8ee8624a79a6ed3c39c8069763339dcc2 [file] [log] [blame]
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001/*
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"
Ian Rogers576ca0c2014-06-06 15:58:22 -070018
Ian Rogersc7dd2952014-10-21 23:31:19 -070019#include <sstream>
20
Ian Rogers576ca0c2014-06-06 15:58:22 -070021#include "base/stringpiece.h"
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080022#include "debugger.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070023#include "gc/heap.h"
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080024#include "monitor.h"
Ian Rogerse63db272014-07-15 15:36:11 -070025#include "runtime.h"
Alex Light7233c7e2016-07-28 10:07:45 -070026#include "ti/agent.h"
Ian Rogerse63db272014-07-15 15:36:11 -070027#include "trace.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070028#include "utils.h"
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080029
Igor Murashkinaaebaa02015-01-26 10:55:53 -080030#include "cmdline_parser.h"
31#include "runtime_options.h"
32
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080033namespace art {
34
Igor Murashkinaaebaa02015-01-26 10:55:53 -080035using MemoryKiB = Memory<1024>;
36
Andreas Gampe313f4032014-08-29 16:01:25 -070037ParsedOptions::ParsedOptions()
Igor Murashkinaaebaa02015-01-26 10:55:53 -080038 : hook_is_sensitive_thread_(nullptr),
Andreas Gampe313f4032014-08-29 16:01:25 -070039 hook_vfprintf_(vfprintf),
40 hook_exit_(exit),
Igor Murashkinaaebaa02015-01-26 10:55:53 -080041 hook_abort_(nullptr) { // We don't call abort(3) by default; see
42 // Runtime::Abort
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080043}
Andreas Gampe313f4032014-08-29 16:01:25 -070044
Vladimir Marko88b2b802015-12-04 14:19:04 +000045bool ParsedOptions::Parse(const RuntimeOptions& options,
46 bool ignore_unrecognized,
47 RuntimeArgumentMap* runtime_options) {
Igor Murashkinb1d8c312015-08-04 11:18:43 -070048 CHECK(runtime_options != nullptr);
49
Vladimir Marko88b2b802015-12-04 14:19:04 +000050 ParsedOptions parser;
51 return parser.DoParse(options, ignore_unrecognized, runtime_options);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080052}
53
Igor Murashkinaaebaa02015-01-26 10:55:53 -080054using RuntimeParser = CmdlineParser<RuntimeArgumentMap, RuntimeArgumentMap::Key>;
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080055
Igor Murashkinaaebaa02015-01-26 10:55:53 -080056// Yes, the stack frame is huge. But we get called super early on (and just once)
57// to pass the command line arguments, so we'll probably be ok.
58// Ideas to avoid suppressing this diagnostic are welcome!
59#pragma GCC diagnostic push
60#pragma GCC diagnostic ignored "-Wframe-larger-than="
61
62std::unique_ptr<RuntimeParser> ParsedOptions::MakeParser(bool ignore_unrecognized) {
63 using M = RuntimeArgumentMap;
64
65 std::unique_ptr<RuntimeParser::Builder> parser_builder =
66 std::unique_ptr<RuntimeParser::Builder>(new RuntimeParser::Builder());
67
68 parser_builder->
69 Define("-Xzygote")
70 .IntoKey(M::Zygote)
71 .Define("-help")
72 .IntoKey(M::Help)
73 .Define("-showversion")
74 .IntoKey(M::ShowVersion)
75 .Define("-Xbootclasspath:_")
76 .WithType<std::string>()
77 .IntoKey(M::BootClassPath)
78 .Define("-Xbootclasspath-locations:_")
79 .WithType<ParseStringList<':'>>() // std::vector<std::string>, split by :
80 .IntoKey(M::BootClassPathLocations)
81 .Define({"-classpath _", "-cp _"})
82 .WithType<std::string>()
83 .IntoKey(M::ClassPath)
84 .Define("-Ximage:_")
85 .WithType<std::string>()
86 .IntoKey(M::Image)
87 .Define("-Xcheck:jni")
88 .IntoKey(M::CheckJni)
89 .Define("-Xjniopts:forcecopy")
90 .IntoKey(M::JniOptsForceCopy)
91 .Define({"-Xrunjdwp:_", "-agentlib:jdwp=_"})
92 .WithType<JDWP::JdwpOptions>()
93 .IntoKey(M::JdwpOptions)
Alex Light7233c7e2016-07-28 10:07:45 -070094 // TODO Re-enable -agentlib: once I have a good way to transform the values.
95 // .Define("-agentlib:_")
96 // .WithType<std::vector<ti::Agent>>().AppendValues()
97 // .IntoKey(M::AgentLib)
98 .Define("-agentpath:_")
99 .WithType<std::vector<ti::Agent>>().AppendValues()
100 .IntoKey(M::AgentPath)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800101 .Define("-Xms_")
102 .WithType<MemoryKiB>()
103 .IntoKey(M::MemoryInitialSize)
104 .Define("-Xmx_")
105 .WithType<MemoryKiB>()
106 .IntoKey(M::MemoryMaximumSize)
107 .Define("-XX:HeapGrowthLimit=_")
108 .WithType<MemoryKiB>()
109 .IntoKey(M::HeapGrowthLimit)
110 .Define("-XX:HeapMinFree=_")
111 .WithType<MemoryKiB>()
112 .IntoKey(M::HeapMinFree)
113 .Define("-XX:HeapMaxFree=_")
114 .WithType<MemoryKiB>()
115 .IntoKey(M::HeapMaxFree)
116 .Define("-XX:NonMovingSpaceCapacity=_")
117 .WithType<MemoryKiB>()
118 .IntoKey(M::NonMovingSpaceCapacity)
119 .Define("-XX:HeapTargetUtilization=_")
120 .WithType<double>().WithRange(0.1, 0.9)
121 .IntoKey(M::HeapTargetUtilization)
122 .Define("-XX:ForegroundHeapGrowthMultiplier=_")
123 .WithType<double>().WithRange(0.1, 1.0)
124 .IntoKey(M::ForegroundHeapGrowthMultiplier)
125 .Define("-XX:ParallelGCThreads=_")
126 .WithType<unsigned int>()
127 .IntoKey(M::ParallelGCThreads)
128 .Define("-XX:ConcGCThreads=_")
129 .WithType<unsigned int>()
130 .IntoKey(M::ConcGCThreads)
131 .Define("-Xss_")
132 .WithType<Memory<1>>()
133 .IntoKey(M::StackSize)
134 .Define("-XX:MaxSpinsBeforeThinLockInflation=_")
135 .WithType<unsigned int>()
136 .IntoKey(M::MaxSpinsBeforeThinLockInflation)
137 .Define("-XX:LongPauseLogThreshold=_") // in ms
138 .WithType<MillisecondsToNanoseconds>() // store as ns
139 .IntoKey(M::LongPauseLogThreshold)
140 .Define("-XX:LongGCLogThreshold=_") // in ms
141 .WithType<MillisecondsToNanoseconds>() // store as ns
142 .IntoKey(M::LongGCLogThreshold)
143 .Define("-XX:DumpGCPerformanceOnShutdown")
144 .IntoKey(M::DumpGCPerformanceOnShutdown)
Mathieu Chartiera4885cb2015-03-09 15:38:54 -0700145 .Define("-XX:DumpJITInfoOnShutdown")
146 .IntoKey(M::DumpJITInfoOnShutdown)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800147 .Define("-XX:IgnoreMaxFootprint")
148 .IntoKey(M::IgnoreMaxFootprint)
149 .Define("-XX:LowMemoryMode")
150 .IntoKey(M::LowMemoryMode)
151 .Define("-XX:UseTLAB")
Hiroshi Yamauchif360ad02015-02-20 11:28:03 -0800152 .WithValue(true)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800153 .IntoKey(M::UseTLAB)
154 .Define({"-XX:EnableHSpaceCompactForOOM", "-XX:DisableHSpaceCompactForOOM"})
155 .WithValues({true, false})
156 .IntoKey(M::EnableHSpaceCompactForOOM)
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000157 .Define("-XX:DumpNativeStackOnSigQuit:_")
158 .WithType<bool>()
159 .WithValueMap({{"false", false}, {"true", true}})
160 .IntoKey(M::DumpNativeStackOnSigQuit)
Mathieu Chartier1972a8e2015-03-05 17:12:54 -0800161 .Define("-Xusejit:_")
162 .WithType<bool>()
163 .WithValueMap({{"false", false}, {"true", true}})
Calin Juravleffc87072016-04-20 14:22:09 +0100164 .IntoKey(M::UseJitCompilation)
Nicolas Geoffray56782292015-11-19 14:25:43 +0000165 .Define("-Xjitinitialsize:_")
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800166 .WithType<MemoryKiB>()
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000167 .IntoKey(M::JITCodeCacheInitialCapacity)
Nicolas Geoffray56782292015-11-19 14:25:43 +0000168 .Define("-Xjitmaxsize:_")
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000169 .WithType<MemoryKiB>()
170 .IntoKey(M::JITCodeCacheMaxCapacity)
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800171 .Define("-Xjitthreshold:_")
172 .WithType<unsigned int>()
173 .IntoKey(M::JITCompileThreshold)
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100174 .Define("-Xjitwarmupthreshold:_")
175 .WithType<unsigned int>()
176 .IntoKey(M::JITWarmupThreshold)
Nicolas Geoffray83f080a2016-03-08 16:50:21 +0000177 .Define("-Xjitosrthreshold:_")
178 .WithType<unsigned int>()
179 .IntoKey(M::JITOsrThreshold)
Calin Juravleb2771b42016-04-07 17:09:25 +0100180 .Define("-Xjitprithreadweight:_")
181 .WithType<unsigned int>()
182 .IntoKey(M::JITPriorityThreadWeight)
Calin Juravle155ff3d2016-04-27 14:14:58 +0100183 .Define("-Xjittransitionweight:_")
184 .WithType<unsigned int>()
185 .IntoKey(M::JITInvokeTransitionWeight)
Calin Juravle31f2c152015-10-23 17:56:15 +0100186 .Define("-Xjitsaveprofilinginfo")
Calin Juravle138dbff2016-06-28 19:36:58 +0100187 .WithType<ProfileSaverOptions>()
188 .AppendValues()
189 .IntoKey(M::ProfileSaverOpts)
190 .Define("-Xps-_") // profile saver options -Xps-<key>:<value>
191 .WithType<ProfileSaverOptions>()
192 .AppendValues()
193 .IntoKey(M::ProfileSaverOpts) // NOTE: Appends into same key as -Xjitsaveprofilinginfo
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800194 .Define("-XX:HspaceCompactForOOMMinIntervalMs=_") // in ms
195 .WithType<MillisecondsToNanoseconds>() // store as ns
196 .IntoKey(M::HSpaceCompactForOOMMinIntervalsMs)
197 .Define("-D_")
198 .WithType<std::vector<std::string>>().AppendValues()
199 .IntoKey(M::PropertiesList)
200 .Define("-Xjnitrace:_")
201 .WithType<std::string>()
202 .IntoKey(M::JniTrace)
203 .Define("-Xpatchoat:_")
204 .WithType<std::string>()
205 .IntoKey(M::PatchOat)
206 .Define({"-Xrelocate", "-Xnorelocate"})
207 .WithValues({true, false})
208 .IntoKey(M::Relocate)
209 .Define({"-Xdex2oat", "-Xnodex2oat"})
210 .WithValues({true, false})
211 .IntoKey(M::Dex2Oat)
212 .Define({"-Ximage-dex2oat", "-Xnoimage-dex2oat"})
213 .WithValues({true, false})
214 .IntoKey(M::ImageDex2Oat)
215 .Define("-Xint")
216 .WithValue(true)
217 .IntoKey(M::Interpret)
218 .Define("-Xgc:_")
219 .WithType<XGcOption>()
220 .IntoKey(M::GcOption)
221 .Define("-XX:LargeObjectSpace=_")
222 .WithType<gc::space::LargeObjectSpaceType>()
223 .WithValueMap({{"disabled", gc::space::LargeObjectSpaceType::kDisabled},
224 {"freelist", gc::space::LargeObjectSpaceType::kFreeList},
225 {"map", gc::space::LargeObjectSpaceType::kMap}})
226 .IntoKey(M::LargeObjectSpace)
227 .Define("-XX:LargeObjectThreshold=_")
228 .WithType<Memory<1>>()
229 .IntoKey(M::LargeObjectThreshold)
230 .Define("-XX:BackgroundGC=_")
231 .WithType<BackgroundGcOption>()
232 .IntoKey(M::BackgroundGc)
233 .Define("-XX:+DisableExplicitGC")
234 .IntoKey(M::DisableExplicitGC)
235 .Define("-verbose:_")
236 .WithType<LogVerbosity>()
237 .IntoKey(M::Verbose)
238 .Define("-Xlockprofthreshold:_")
239 .WithType<unsigned int>()
240 .IntoKey(M::LockProfThreshold)
241 .Define("-Xstacktracefile:_")
242 .WithType<std::string>()
243 .IntoKey(M::StackTraceFile)
244 .Define("-Xmethod-trace")
245 .IntoKey(M::MethodTrace)
246 .Define("-Xmethod-trace-file:_")
247 .WithType<std::string>()
248 .IntoKey(M::MethodTraceFile)
249 .Define("-Xmethod-trace-file-size:_")
250 .WithType<unsigned int>()
251 .IntoKey(M::MethodTraceFileSize)
Andreas Gampe40da2862015-02-27 12:49:04 -0800252 .Define("-Xmethod-trace-stream")
253 .IntoKey(M::MethodTraceStreaming)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800254 .Define("-Xprofile:_")
255 .WithType<TraceClockSource>()
256 .WithValueMap({{"threadcpuclock", TraceClockSource::kThreadCpu},
257 {"wallclock", TraceClockSource::kWall},
258 {"dualclock", TraceClockSource::kDual}})
259 .IntoKey(M::ProfileClock)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800260 .Define("-Xcompiler:_")
261 .WithType<std::string>()
262 .IntoKey(M::Compiler)
263 .Define("-Xcompiler-option _")
264 .WithType<std::vector<std::string>>()
265 .AppendValues()
266 .IntoKey(M::CompilerOptions)
267 .Define("-Ximage-compiler-option _")
268 .WithType<std::vector<std::string>>()
269 .AppendValues()
270 .IntoKey(M::ImageCompilerOptions)
271 .Define("-Xverify:_")
Igor Murashkin7617abd2015-07-10 18:27:47 -0700272 .WithType<verifier::VerifyMode>()
273 .WithValueMap({{"none", verifier::VerifyMode::kNone},
274 {"remote", verifier::VerifyMode::kEnable},
275 {"all", verifier::VerifyMode::kEnable},
276 {"softfail", verifier::VerifyMode::kSoftFail}})
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800277 .IntoKey(M::Verify)
278 .Define("-XX:NativeBridge=_")
279 .WithType<std::string>()
280 .IntoKey(M::NativeBridge)
Andreas Gampe9106e522015-03-31 14:54:03 -0700281 .Define("-Xzygote-max-boot-retry=_")
Narayan Kamath5a2be3f2015-02-16 13:51:51 +0000282 .WithType<unsigned int>()
283 .IntoKey(M::ZygoteMaxFailedBoots)
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700284 .Define("-Xno-dex-file-fallback")
285 .IntoKey(M::NoDexFileFallback)
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100286 .Define("-Xno-sig-chain")
287 .IntoKey(M::NoSigChain)
Dmitriy Ivanov785049f2014-07-18 10:08:57 -0700288 .Define("--cpu-abilist=_")
289 .WithType<std::string>()
290 .IntoKey(M::CpuAbiList)
Andreas Gampedd671252015-07-23 14:37:18 -0700291 .Define("-Xfingerprint:_")
292 .WithType<std::string>()
293 .IntoKey(M::Fingerprint)
Alex Lighteb7c1442015-08-31 13:17:42 -0700294 .Define("-Xexperimental:_")
295 .WithType<ExperimentalFlags>()
296 .AppendValues()
297 .IntoKey(M::Experimental)
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000298 .Define("-Xforce-nb-testing")
299 .IntoKey(M::ForceNativeBridge)
Alex Light185d1342016-08-11 10:48:03 -0700300 .Define("-Xplugin:_")
301 .WithType<std::vector<Plugin>>().AppendValues()
302 .IntoKey(M::Plugins)
Alex Light6b16d892016-11-11 11:21:04 -0800303 .Define("-Xfully-deoptable")
304 .IntoKey(M::FullyDeoptable)
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800305 .Define("-XX:ThreadSuspendTimeout=_") // in ms
306 .WithType<MillisecondsToNanoseconds>() // store as ns
307 .IntoKey(M::ThreadSuspendTimeout)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800308 .Ignore({
309 "-ea", "-da", "-enableassertions", "-disableassertions", "--runtime-arg", "-esa",
310 "-dsa", "-enablesystemassertions", "-disablesystemassertions", "-Xrs", "-Xint:_",
311 "-Xdexopt:_", "-Xnoquithandler", "-Xjnigreflimit:_", "-Xgenregmap", "-Xnogenregmap",
312 "-Xverifyopt:_", "-Xcheckdexsum", "-Xincludeselectedop", "-Xjitop:_",
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800313 "-Xincludeselectedmethod", "-Xjitthreshold:_",
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800314 "-Xjitblocking", "-Xjitmethod:_", "-Xjitclass:_", "-Xjitoffset:_",
315 "-Xjitconfig:_", "-Xjitcheckcg", "-Xjitverbose", "-Xjitprofile",
316 "-Xjitdisableopt", "-Xjitsuspendpoll", "-XX:mainThreadStackSize=_"})
317 .IgnoreUnrecognized(ignore_unrecognized);
318
319 // TODO: Move Usage information into this DSL.
320
321 return std::unique_ptr<RuntimeParser>(new RuntimeParser(parser_builder->Build()));
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800322}
323
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800324#pragma GCC diagnostic pop
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800325
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800326// Remove all the special options that have something in the void* part of the option.
327// If runtime_options is not null, put the options in there.
328// As a side-effect, populate the hooks from options.
329bool ParsedOptions::ProcessSpecialOptions(const RuntimeOptions& options,
330 RuntimeArgumentMap* runtime_options,
331 std::vector<std::string>* out_options) {
332 using M = RuntimeArgumentMap;
333
334 // TODO: Move the below loop into JNI
335 // Handle special options that set up hooks
336 for (size_t i = 0; i < options.size(); ++i) {
337 const std::string option(options[i].first);
338 // TODO: support -Djava.class.path
339 if (option == "bootclasspath") {
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000340 auto boot_class_path = static_cast<std::vector<std::unique_ptr<const DexFile>>*>(
341 const_cast<void*>(options[i].second));
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800342
343 if (runtime_options != nullptr) {
344 runtime_options->Set(M::BootClassPathDexList, boot_class_path);
345 }
346 } else if (option == "compilercallbacks") {
347 CompilerCallbacks* compiler_callbacks =
348 reinterpret_cast<CompilerCallbacks*>(const_cast<void*>(options[i].second));
349 if (runtime_options != nullptr) {
350 runtime_options->Set(M::CompilerCallbacksPtr, compiler_callbacks);
351 }
352 } else if (option == "imageinstructionset") {
353 const char* isa_str = reinterpret_cast<const char*>(options[i].second);
354 auto&& image_isa = GetInstructionSetFromString(isa_str);
355 if (image_isa == kNone) {
356 Usage("%s is not a valid instruction set.", isa_str);
357 return false;
358 }
359 if (runtime_options != nullptr) {
360 runtime_options->Set(M::ImageInstructionSet, image_isa);
361 }
362 } else if (option == "sensitiveThread") {
363 const void* hook = options[i].second;
364 bool (*hook_is_sensitive_thread)() = reinterpret_cast<bool (*)()>(const_cast<void*>(hook));
365
366 if (runtime_options != nullptr) {
367 runtime_options->Set(M::HookIsSensitiveThread, hook_is_sensitive_thread);
368 }
369 } else if (option == "vfprintf") {
370 const void* hook = options[i].second;
371 if (hook == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700372 Usage("vfprintf argument was nullptr");
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800373 return false;
374 }
375 int (*hook_vfprintf)(FILE *, const char*, va_list) =
376 reinterpret_cast<int (*)(FILE *, const char*, va_list)>(const_cast<void*>(hook));
377
378 if (runtime_options != nullptr) {
379 runtime_options->Set(M::HookVfprintf, hook_vfprintf);
380 }
381 hook_vfprintf_ = hook_vfprintf;
382 } else if (option == "exit") {
383 const void* hook = options[i].second;
384 if (hook == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700385 Usage("exit argument was nullptr");
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800386 return false;
387 }
388 void(*hook_exit)(jint) = reinterpret_cast<void(*)(jint)>(const_cast<void*>(hook));
389 if (runtime_options != nullptr) {
390 runtime_options->Set(M::HookExit, hook_exit);
391 }
392 hook_exit_ = hook_exit;
393 } else if (option == "abort") {
394 const void* hook = options[i].second;
395 if (hook == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700396 Usage("abort was nullptr\n");
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800397 return false;
398 }
399 void(*hook_abort)() = reinterpret_cast<void(*)()>(const_cast<void*>(hook));
400 if (runtime_options != nullptr) {
401 runtime_options->Set(M::HookAbort, hook_abort);
402 }
403 hook_abort_ = hook_abort;
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700404 } else {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800405 // It is a regular option, that doesn't have a known 'second' value.
406 // Push it on to the regular options which will be parsed by our parser.
407 if (out_options != nullptr) {
408 out_options->push_back(option);
409 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700410 }
411 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800412
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700413 return true;
414}
415
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200416// Intended for local changes only.
417static void MaybeOverrideVerbosity() {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800418 // gLogVerbosity.class_linker = true; // TODO: don't check this in!
Mathieu Chartier66a55392016-02-19 10:25:39 -0800419 // gLogVerbosity.collector = true; // TODO: don't check this in!
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800420 // gLogVerbosity.compiler = true; // TODO: don't check this in!
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200421 // gLogVerbosity.deopt = true; // TODO: don't check this in!
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800422 // gLogVerbosity.gc = true; // TODO: don't check this in!
423 // gLogVerbosity.heap = true; // TODO: don't check this in!
424 // gLogVerbosity.jdwp = true; // TODO: don't check this in!
425 // gLogVerbosity.jit = true; // TODO: don't check this in!
426 // gLogVerbosity.jni = true; // TODO: don't check this in!
427 // gLogVerbosity.monitor = true; // TODO: don't check this in!
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200428 // gLogVerbosity.oat = true; // TODO: don't check this in!
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800429 // gLogVerbosity.profiler = true; // TODO: don't check this in!
430 // gLogVerbosity.signals = true; // TODO: don't check this in!
Phil Wang751beff2015-08-28 15:17:15 +0800431 // gLogVerbosity.simulator = true; // TODO: don't check this in!
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800432 // gLogVerbosity.startup = true; // TODO: don't check this in!
433 // gLogVerbosity.third_party_jni = true; // TODO: don't check this in!
434 // gLogVerbosity.threads = true; // TODO: don't check this in!
435 // gLogVerbosity.verifier = true; // TODO: don't check this in!
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200436}
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800437
Vladimir Marko88b2b802015-12-04 14:19:04 +0000438bool ParsedOptions::DoParse(const RuntimeOptions& options,
439 bool ignore_unrecognized,
440 RuntimeArgumentMap* runtime_options) {
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800441 for (size_t i = 0; i < options.size(); ++i) {
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800442 if (true && options[0].first == "-Xzygote") {
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800443 LOG(INFO) << "option[" << i << "]=" << options[i].first;
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800444 }
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800445 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800446
447 auto parser = MakeParser(ignore_unrecognized);
448
449 // Convert to a simple string list (without the magic pointer options)
450 std::vector<std::string> argv_list;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700451 if (!ProcessSpecialOptions(options, nullptr, &argv_list)) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800452 return false;
453 }
454
455 CmdlineResult parse_result = parser->Parse(argv_list);
456
457 // Handle parse errors by displaying the usage and potentially exiting.
458 if (parse_result.IsError()) {
459 if (parse_result.GetStatus() == CmdlineResult::kUsage) {
460 UsageMessage(stdout, "%s\n", parse_result.GetMessage().c_str());
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800461 Exit(0);
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800462 } else if (parse_result.GetStatus() == CmdlineResult::kUnknown && !ignore_unrecognized) {
463 Usage("%s\n", parse_result.GetMessage().c_str());
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800464 return false;
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800465 } else {
466 Usage("%s\n", parse_result.GetMessage().c_str());
467 Exit(0);
468 }
469
470 UNREACHABLE();
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800471 }
472
473 using M = RuntimeArgumentMap;
474 RuntimeArgumentMap args = parser->ReleaseArgumentsMap();
475
476 // -help, -showversion, etc.
477 if (args.Exists(M::Help)) {
478 Usage(nullptr);
479 return false;
480 } else if (args.Exists(M::ShowVersion)) {
481 UsageMessage(stdout, "ART version %s\n", Runtime::GetVersion());
482 Exit(0);
483 } else if (args.Exists(M::BootClassPath)) {
484 LOG(INFO) << "setting boot class path to " << *args.Get(M::BootClassPath);
485 }
486
Calin Juravleaf36e492016-04-27 18:50:45 +0100487 if (args.GetOrDefault(M::UseJitCompilation) && args.GetOrDefault(M::Interpret)) {
488 Usage("-Xusejit:true and -Xint cannot be specified together");
489 Exit(0);
490 }
491
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800492 // Set a default boot class path if we didn't get an explicit one via command line.
493 if (getenv("BOOTCLASSPATH") != nullptr) {
494 args.SetIfMissing(M::BootClassPath, std::string(getenv("BOOTCLASSPATH")));
495 }
496
497 // Set a default class path if we didn't get an explicit one via command line.
498 if (getenv("CLASSPATH") != nullptr) {
499 args.SetIfMissing(M::ClassPath, std::string(getenv("CLASSPATH")));
500 }
501
502 // Default to number of processors minus one since the main GC thread also does work.
Mathieu Chartier10d68862015-04-15 14:21:33 -0700503 args.SetIfMissing(M::ParallelGCThreads, gc::Heap::kDefaultEnableParallelGC ?
504 static_cast<unsigned int>(sysconf(_SC_NPROCESSORS_CONF) - 1u) : 0u);
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800505
Igor Murashkin9d4b6da2016-07-29 09:51:58 -0700506 // -verbose:
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800507 {
508 LogVerbosity *log_verbosity = args.Get(M::Verbose);
509 if (log_verbosity != nullptr) {
510 gLogVerbosity = *log_verbosity;
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800511 }
512 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800513
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200514 MaybeOverrideVerbosity();
515
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800516 // -Xprofile:
517 Trace::SetDefaultClockSource(args.GetOrDefault(M::ProfileClock));
518
519 if (!ProcessSpecialOptions(options, &args, nullptr)) {
520 return false;
521 }
522
523 {
524 // If not set, background collector type defaults to homogeneous compaction.
525 // If foreground is GSS, use GSS as background collector.
526 // If not low memory mode, semispace otherwise.
527
528 gc::CollectorType background_collector_type_;
529 gc::CollectorType collector_type_ = (XGcOption{}).collector_type_; // NOLINT [whitespace/braces] [5]
530 bool low_memory_mode_ = args.Exists(M::LowMemoryMode);
531
532 background_collector_type_ = args.GetOrDefault(M::BackgroundGc);
533 {
534 XGcOption* xgc = args.Get(M::GcOption);
535 if (xgc != nullptr && xgc->collector_type_ != gc::kCollectorTypeNone) {
536 collector_type_ = xgc->collector_type_;
537 }
538 }
539
540 if (background_collector_type_ == gc::kCollectorTypeNone) {
541 if (collector_type_ != gc::kCollectorTypeGSS) {
542 background_collector_type_ = low_memory_mode_ ?
543 gc::kCollectorTypeSS : gc::kCollectorTypeHomogeneousSpaceCompact;
544 } else {
545 background_collector_type_ = collector_type_;
546 }
547 }
548
549 args.Set(M::BackgroundGc, BackgroundGcOption { background_collector_type_ });
Mathieu Chartier6b2352b2014-08-20 14:13:18 -0700550 }
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800551
552 // If a reference to the dalvik core.jar snuck in, replace it with
553 // the art specific version. This can happen with on device
554 // boot.art/boot.oat generation by GenerateImage which relies on the
555 // value of BOOTCLASSPATH.
Kenny Rootd5185342014-05-13 14:47:05 -0700556#if defined(ART_TARGET)
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800557 std::string core_jar("/core.jar");
Kenny Rootd5185342014-05-13 14:47:05 -0700558 std::string core_libart_jar("/core-libart.jar");
559#else
560 // The host uses hostdex files.
561 std::string core_jar("/core-hostdex.jar");
562 std::string core_libart_jar("/core-libart-hostdex.jar");
563#endif
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800564 auto boot_class_path_string = args.GetOrDefault(M::BootClassPath);
565
566 size_t core_jar_pos = boot_class_path_string.find(core_jar);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800567 if (core_jar_pos != std::string::npos) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800568 boot_class_path_string.replace(core_jar_pos, core_jar.size(), core_libart_jar);
569 args.Set(M::BootClassPath, boot_class_path_string);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800570 }
571
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800572 {
573 auto&& boot_class_path = args.GetOrDefault(M::BootClassPath);
574 auto&& boot_class_path_locations = args.GetOrDefault(M::BootClassPathLocations);
575 if (args.Exists(M::BootClassPathLocations)) {
576 size_t boot_class_path_count = ParseStringList<':'>::Split(boot_class_path).Size();
Richard Uhlerc2752592015-01-02 13:28:22 -0800577
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800578 if (boot_class_path_count != boot_class_path_locations.Size()) {
579 Usage("The number of boot class path files does not match"
580 " the number of boot class path locations given\n"
581 " boot class path files (%zu): %s\n"
582 " boot class path locations (%zu): %s\n",
583 boot_class_path.size(), boot_class_path_string.c_str(),
584 boot_class_path_locations.Size(), boot_class_path_locations.Join().c_str());
585 return false;
586 }
Richard Uhlerc2752592015-01-02 13:28:22 -0800587 }
588 }
589
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800590 if (!args.Exists(M::CompilerCallbacksPtr) && !args.Exists(M::Image)) {
591 std::string image = GetAndroidRoot();
592 image += "/framework/boot.art";
593 args.Set(M::Image, image);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800594 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800595
Lin Zang8cd63ab2015-11-06 14:08:51 +0800596 // 0 means no growth limit, and growth limit should be always <= heap size
597 if (args.GetOrDefault(M::HeapGrowthLimit) <= 0u ||
598 args.GetOrDefault(M::HeapGrowthLimit) > args.GetOrDefault(M::MemoryMaximumSize)) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800599 args.Set(M::HeapGrowthLimit, args.GetOrDefault(M::MemoryMaximumSize));
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800600 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800601
602 *runtime_options = std::move(args);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800603 return true;
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800604}
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800605
606void ParsedOptions::Exit(int status) {
607 hook_exit_(status);
608}
609
610void ParsedOptions::Abort() {
611 hook_abort_();
612}
613
614void ParsedOptions::UsageMessageV(FILE* stream, const char* fmt, va_list ap) {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700615 hook_vfprintf_(stream, fmt, ap);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800616}
617
618void ParsedOptions::UsageMessage(FILE* stream, const char* fmt, ...) {
619 va_list ap;
620 va_start(ap, fmt);
621 UsageMessageV(stream, fmt, ap);
622 va_end(ap);
623}
624
625void ParsedOptions::Usage(const char* fmt, ...) {
626 bool error = (fmt != nullptr);
627 FILE* stream = error ? stderr : stdout;
628
629 if (fmt != nullptr) {
630 va_list ap;
631 va_start(ap, fmt);
632 UsageMessageV(stream, fmt, ap);
633 va_end(ap);
634 }
635
636 const char* program = "dalvikvm";
637 UsageMessage(stream, "%s: [options] class [argument ...]\n", program);
638 UsageMessage(stream, "\n");
639 UsageMessage(stream, "The following standard options are supported:\n");
640 UsageMessage(stream, " -classpath classpath (-cp classpath)\n");
641 UsageMessage(stream, " -Dproperty=value\n");
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800642 UsageMessage(stream, " -verbose:tag ('gc', 'jit', 'jni', or 'class')\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800643 UsageMessage(stream, " -showversion\n");
644 UsageMessage(stream, " -help\n");
645 UsageMessage(stream, " -agentlib:jdwp=options\n");
Alex Light7233c7e2016-07-28 10:07:45 -0700646 // TODO add back in once -agentlib actually does something.
647 // UsageMessage(stream, " -agentlib:library=options (Experimental feature, "
648 // "requires -Xexperimental:agent, some features might not be supported)\n");
649 UsageMessage(stream, " -agentpath:library_path=options (Experimental feature, "
650 "requires -Xexperimental:agent, some features might not be supported)\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800651 UsageMessage(stream, "\n");
652
653 UsageMessage(stream, "The following extended options are supported:\n");
654 UsageMessage(stream, " -Xrunjdwp:<options>\n");
655 UsageMessage(stream, " -Xbootclasspath:bootclasspath\n");
656 UsageMessage(stream, " -Xcheck:tag (e.g. 'jni')\n");
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100657 UsageMessage(stream, " -XmsN (min heap, must be multiple of 1K, >= 1MB)\n");
658 UsageMessage(stream, " -XmxN (max heap, must be multiple of 1K, >= 2MB)\n");
659 UsageMessage(stream, " -XssN (stack size)\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800660 UsageMessage(stream, " -Xint\n");
661 UsageMessage(stream, "\n");
662
663 UsageMessage(stream, "The following Dalvik options are supported:\n");
664 UsageMessage(stream, " -Xzygote\n");
665 UsageMessage(stream, " -Xjnitrace:substring (eg NativeClass or nativeMethod)\n");
666 UsageMessage(stream, " -Xstacktracefile:<filename>\n");
667 UsageMessage(stream, " -Xgc:[no]preverify\n");
668 UsageMessage(stream, " -Xgc:[no]postverify\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800669 UsageMessage(stream, " -XX:HeapGrowthLimit=N\n");
670 UsageMessage(stream, " -XX:HeapMinFree=N\n");
671 UsageMessage(stream, " -XX:HeapMaxFree=N\n");
Mathieu Chartier6a7824d2014-08-22 14:53:04 -0700672 UsageMessage(stream, " -XX:NonMovingSpaceCapacity=N\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800673 UsageMessage(stream, " -XX:HeapTargetUtilization=doublevalue\n");
Mathieu Chartier455820e2014-04-18 12:02:39 -0700674 UsageMessage(stream, " -XX:ForegroundHeapGrowthMultiplier=doublevalue\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800675 UsageMessage(stream, " -XX:LowMemoryMode\n");
676 UsageMessage(stream, " -Xprofile:{threadcpuclock,wallclock,dualclock}\n");
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800677 UsageMessage(stream, " -Xjitthreshold:integervalue\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800678 UsageMessage(stream, "\n");
679
680 UsageMessage(stream, "The following unique to ART options are supported:\n");
681 UsageMessage(stream, " -Xgc:[no]preverify_rosalloc\n");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700682 UsageMessage(stream, " -Xgc:[no]postsweepingverify_rosalloc\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800683 UsageMessage(stream, " -Xgc:[no]postverify_rosalloc\n");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700684 UsageMessage(stream, " -Xgc:[no]presweepingverify\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800685 UsageMessage(stream, " -Ximage:filename\n");
Richard Uhlerc2752592015-01-02 13:28:22 -0800686 UsageMessage(stream, " -Xbootclasspath-locations:bootclasspath\n"
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800687 " (override the dex locations of the -Xbootclasspath files)\n");
Mathieu Chartier2dbe6272014-09-16 10:43:23 -0700688 UsageMessage(stream, " -XX:+DisableExplicitGC\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800689 UsageMessage(stream, " -XX:ParallelGCThreads=integervalue\n");
690 UsageMessage(stream, " -XX:ConcGCThreads=integervalue\n");
691 UsageMessage(stream, " -XX:MaxSpinsBeforeThinLockInflation=integervalue\n");
692 UsageMessage(stream, " -XX:LongPauseLogThreshold=integervalue\n");
693 UsageMessage(stream, " -XX:LongGCLogThreshold=integervalue\n");
Mathieu Chartier3fceaf52017-01-22 13:33:40 -0800694 UsageMessage(stream, " -XX:ThreadSuspendTimeout=integervalue\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800695 UsageMessage(stream, " -XX:DumpGCPerformanceOnShutdown\n");
Mathieu Chartiera4885cb2015-03-09 15:38:54 -0700696 UsageMessage(stream, " -XX:DumpJITInfoOnShutdown\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800697 UsageMessage(stream, " -XX:IgnoreMaxFootprint\n");
698 UsageMessage(stream, " -XX:UseTLAB\n");
699 UsageMessage(stream, " -XX:BackgroundGC=none\n");
Mathieu Chartier2dbe6272014-09-16 10:43:23 -0700700 UsageMessage(stream, " -XX:LargeObjectSpace={disabled,map,freelist}\n");
701 UsageMessage(stream, " -XX:LargeObjectThreshold=N\n");
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000702 UsageMessage(stream, " -XX:DumpNativeStackOnSigQuit=booleanvalue\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800703 UsageMessage(stream, " -Xmethod-trace\n");
704 UsageMessage(stream, " -Xmethod-trace-file:filename");
705 UsageMessage(stream, " -Xmethod-trace-file-size:integervalue\n");
Calin Juravle138dbff2016-06-28 19:36:58 +0100706 UsageMessage(stream, " -Xps-min-save-period-ms:integervalue\n");
707 UsageMessage(stream, " -Xps-save-resolved-classes-delay-ms:integervalue\n");
708 UsageMessage(stream, " -Xps-startup-method-samples:integervalue\n");
709 UsageMessage(stream, " -Xps-min-methods-to-save:integervalue\n");
710 UsageMessage(stream, " -Xps-min-classes-to-save:integervalue\n");
711 UsageMessage(stream, " -Xps-min-notification-before-wake:integervalue\n");
712 UsageMessage(stream, " -Xps-max-notification-before-wake:integervalue\n");
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700713 UsageMessage(stream, " -Xcompiler:filename\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800714 UsageMessage(stream, " -Xcompiler-option dex2oat-option\n");
715 UsageMessage(stream, " -Ximage-compiler-option dex2oat-option\n");
Alex Lighta59dd802014-07-02 16:28:08 -0700716 UsageMessage(stream, " -Xpatchoat:filename\n");
Mathieu Chartier1972a8e2015-03-05 17:12:54 -0800717 UsageMessage(stream, " -Xusejit:booleanvalue\n");
Nicolas Geoffray56782292015-11-19 14:25:43 +0000718 UsageMessage(stream, " -Xjitinitialsize:N\n");
719 UsageMessage(stream, " -Xjitmaxsize:N\n");
Nicolas Geoffray83f080a2016-03-08 16:50:21 +0000720 UsageMessage(stream, " -Xjitwarmupthreshold:integervalue\n");
721 UsageMessage(stream, " -Xjitosrthreshold:integervalue\n");
Calin Juravleb2771b42016-04-07 17:09:25 +0100722 UsageMessage(stream, " -Xjitprithreadweight:integervalue\n");
Alex Lighta59dd802014-07-02 16:28:08 -0700723 UsageMessage(stream, " -X[no]relocate\n");
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100724 UsageMessage(stream, " -X[no]dex2oat (Whether to invoke dex2oat on the application)\n");
Alex Light64ad14d2014-08-19 14:23:13 -0700725 UsageMessage(stream, " -X[no]image-dex2oat (Whether to create and use a boot image)\n");
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700726 UsageMessage(stream, " -Xno-dex-file-fallback "
727 "(Don't fall back to dex files without oat files)\n");
Alex Light185d1342016-08-11 10:48:03 -0700728 UsageMessage(stream, " -Xplugin:<library.so> "
729 "(Load a runtime plugin, requires -Xexperimental:runtime-plugins)\n");
730 UsageMessage(stream, " -Xexperimental:runtime-plugins"
731 "(Enable new and experimental agent support)\n");
Alex Light7233c7e2016-07-28 10:07:45 -0700732 UsageMessage(stream, " -Xexperimental:agents"
733 "(Enable new and experimental agent support)\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800734 UsageMessage(stream, "\n");
735
736 UsageMessage(stream, "The following previously supported Dalvik options are ignored:\n");
737 UsageMessage(stream, " -ea[:<package name>... |:<class name>]\n");
738 UsageMessage(stream, " -da[:<package name>... |:<class name>]\n");
739 UsageMessage(stream, " (-enableassertions, -disableassertions)\n");
740 UsageMessage(stream, " -esa\n");
741 UsageMessage(stream, " -dsa\n");
742 UsageMessage(stream, " (-enablesystemassertions, -disablesystemassertions)\n");
Igor Murashkin7617abd2015-07-10 18:27:47 -0700743 UsageMessage(stream, " -Xverify:{none,remote,all,softfail}\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800744 UsageMessage(stream, " -Xrs\n");
745 UsageMessage(stream, " -Xint:portable, -Xint:fast, -Xint:jit\n");
746 UsageMessage(stream, " -Xdexopt:{none,verified,all,full}\n");
747 UsageMessage(stream, " -Xnoquithandler\n");
748 UsageMessage(stream, " -Xjniopts:{warnonly,forcecopy}\n");
749 UsageMessage(stream, " -Xjnigreflimit:integervalue\n");
750 UsageMessage(stream, " -Xgc:[no]precise\n");
751 UsageMessage(stream, " -Xgc:[no]verifycardtable\n");
752 UsageMessage(stream, " -X[no]genregmap\n");
753 UsageMessage(stream, " -Xverifyopt:[no]checkmon\n");
754 UsageMessage(stream, " -Xcheckdexsum\n");
755 UsageMessage(stream, " -Xincludeselectedop\n");
756 UsageMessage(stream, " -Xjitop:hexopvalue[-endvalue][,hexopvalue[-endvalue]]*\n");
757 UsageMessage(stream, " -Xincludeselectedmethod\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800758 UsageMessage(stream, " -Xjitblocking\n");
759 UsageMessage(stream, " -Xjitmethod:signature[,signature]* (eg Ljava/lang/String\\;replace)\n");
760 UsageMessage(stream, " -Xjitclass:classname[,classname]*\n");
Nicolas Geoffray56782292015-11-19 14:25:43 +0000761 UsageMessage(stream, " -Xjitcodecachesize:N\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800762 UsageMessage(stream, " -Xjitoffset:offset[,offset]\n");
763 UsageMessage(stream, " -Xjitconfig:filename\n");
764 UsageMessage(stream, " -Xjitcheckcg\n");
765 UsageMessage(stream, " -Xjitverbose\n");
766 UsageMessage(stream, " -Xjitprofile\n");
767 UsageMessage(stream, " -Xjitdisableopt\n");
768 UsageMessage(stream, " -Xjitsuspendpoll\n");
769 UsageMessage(stream, " -XX:mainThreadStackSize=N\n");
770 UsageMessage(stream, "\n");
771
772 Exit((error) ? 1 : 0);
773}
774
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800775} // namespace art