blob: 2b92303fe211fe1ff8da8fb377c2d314c5d85ea3 [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"
26#include "trace.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070027#include "utils.h"
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080028
Igor Murashkinaaebaa02015-01-26 10:55:53 -080029#include "cmdline_parser.h"
30#include "runtime_options.h"
31
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080032namespace art {
33
Igor Murashkinaaebaa02015-01-26 10:55:53 -080034using MemoryKiB = Memory<1024>;
35
Andreas Gampe313f4032014-08-29 16:01:25 -070036ParsedOptions::ParsedOptions()
Igor Murashkinaaebaa02015-01-26 10:55:53 -080037 : hook_is_sensitive_thread_(nullptr),
Andreas Gampe313f4032014-08-29 16:01:25 -070038 hook_vfprintf_(vfprintf),
39 hook_exit_(exit),
Igor Murashkinaaebaa02015-01-26 10:55:53 -080040 hook_abort_(nullptr) { // We don't call abort(3) by default; see
41 // Runtime::Abort
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080042}
Andreas Gampe313f4032014-08-29 16:01:25 -070043
Vladimir Marko88b2b802015-12-04 14:19:04 +000044bool ParsedOptions::Parse(const RuntimeOptions& options,
45 bool ignore_unrecognized,
46 RuntimeArgumentMap* runtime_options) {
Igor Murashkinb1d8c312015-08-04 11:18:43 -070047 CHECK(runtime_options != nullptr);
48
Vladimir Marko88b2b802015-12-04 14:19:04 +000049 ParsedOptions parser;
50 return parser.DoParse(options, ignore_unrecognized, runtime_options);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080051}
52
Igor Murashkinaaebaa02015-01-26 10:55:53 -080053using RuntimeParser = CmdlineParser<RuntimeArgumentMap, RuntimeArgumentMap::Key>;
Brian Carlstrom491ca9e2014-03-02 18:24:38 -080054
Igor Murashkinaaebaa02015-01-26 10:55:53 -080055// 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
61std::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)
Mathieu Chartiera4885cb2015-03-09 15:38:54 -0700137 .Define("-XX:DumpJITInfoOnShutdown")
138 .IntoKey(M::DumpJITInfoOnShutdown)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800139 .Define("-XX:IgnoreMaxFootprint")
140 .IntoKey(M::IgnoreMaxFootprint)
141 .Define("-XX:LowMemoryMode")
142 .IntoKey(M::LowMemoryMode)
143 .Define("-XX:UseTLAB")
Hiroshi Yamauchif360ad02015-02-20 11:28:03 -0800144 .WithValue(true)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800145 .IntoKey(M::UseTLAB)
146 .Define({"-XX:EnableHSpaceCompactForOOM", "-XX:DisableHSpaceCompactForOOM"})
147 .WithValues({true, false})
148 .IntoKey(M::EnableHSpaceCompactForOOM)
Mathieu Chartier1972a8e2015-03-05 17:12:54 -0800149 .Define("-Xusejit:_")
150 .WithType<bool>()
151 .WithValueMap({{"false", false}, {"true", true}})
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800152 .IntoKey(M::UseJIT)
Nicolas Geoffray56782292015-11-19 14:25:43 +0000153 .Define("-Xjitinitialsize:_")
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800154 .WithType<MemoryKiB>()
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000155 .IntoKey(M::JITCodeCacheInitialCapacity)
Nicolas Geoffray56782292015-11-19 14:25:43 +0000156 .Define("-Xjitmaxsize:_")
Nicolas Geoffray0a3be162015-11-18 11:15:22 +0000157 .WithType<MemoryKiB>()
158 .IntoKey(M::JITCodeCacheMaxCapacity)
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800159 .Define("-Xjitthreshold:_")
160 .WithType<unsigned int>()
161 .IntoKey(M::JITCompileThreshold)
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100162 .Define("-Xjitwarmupthreshold:_")
163 .WithType<unsigned int>()
164 .IntoKey(M::JITWarmupThreshold)
Calin Juravle31f2c152015-10-23 17:56:15 +0100165 .Define("-Xjitsaveprofilinginfo")
166 .WithValue(true)
167 .IntoKey(M::JITSaveProfilingInfo)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800168 .Define("-XX:HspaceCompactForOOMMinIntervalMs=_") // in ms
169 .WithType<MillisecondsToNanoseconds>() // store as ns
170 .IntoKey(M::HSpaceCompactForOOMMinIntervalsMs)
171 .Define("-D_")
172 .WithType<std::vector<std::string>>().AppendValues()
173 .IntoKey(M::PropertiesList)
174 .Define("-Xjnitrace:_")
175 .WithType<std::string>()
176 .IntoKey(M::JniTrace)
177 .Define("-Xpatchoat:_")
178 .WithType<std::string>()
179 .IntoKey(M::PatchOat)
180 .Define({"-Xrelocate", "-Xnorelocate"})
181 .WithValues({true, false})
182 .IntoKey(M::Relocate)
183 .Define({"-Xdex2oat", "-Xnodex2oat"})
184 .WithValues({true, false})
185 .IntoKey(M::Dex2Oat)
186 .Define({"-Ximage-dex2oat", "-Xnoimage-dex2oat"})
187 .WithValues({true, false})
188 .IntoKey(M::ImageDex2Oat)
189 .Define("-Xint")
190 .WithValue(true)
191 .IntoKey(M::Interpret)
192 .Define("-Xgc:_")
193 .WithType<XGcOption>()
194 .IntoKey(M::GcOption)
195 .Define("-XX:LargeObjectSpace=_")
196 .WithType<gc::space::LargeObjectSpaceType>()
197 .WithValueMap({{"disabled", gc::space::LargeObjectSpaceType::kDisabled},
198 {"freelist", gc::space::LargeObjectSpaceType::kFreeList},
199 {"map", gc::space::LargeObjectSpaceType::kMap}})
200 .IntoKey(M::LargeObjectSpace)
201 .Define("-XX:LargeObjectThreshold=_")
202 .WithType<Memory<1>>()
203 .IntoKey(M::LargeObjectThreshold)
204 .Define("-XX:BackgroundGC=_")
205 .WithType<BackgroundGcOption>()
206 .IntoKey(M::BackgroundGc)
207 .Define("-XX:+DisableExplicitGC")
208 .IntoKey(M::DisableExplicitGC)
209 .Define("-verbose:_")
210 .WithType<LogVerbosity>()
211 .IntoKey(M::Verbose)
212 .Define("-Xlockprofthreshold:_")
213 .WithType<unsigned int>()
214 .IntoKey(M::LockProfThreshold)
215 .Define("-Xstacktracefile:_")
216 .WithType<std::string>()
217 .IntoKey(M::StackTraceFile)
218 .Define("-Xmethod-trace")
219 .IntoKey(M::MethodTrace)
220 .Define("-Xmethod-trace-file:_")
221 .WithType<std::string>()
222 .IntoKey(M::MethodTraceFile)
223 .Define("-Xmethod-trace-file-size:_")
224 .WithType<unsigned int>()
225 .IntoKey(M::MethodTraceFileSize)
Andreas Gampe40da2862015-02-27 12:49:04 -0800226 .Define("-Xmethod-trace-stream")
227 .IntoKey(M::MethodTraceStreaming)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800228 .Define("-Xprofile:_")
229 .WithType<TraceClockSource>()
230 .WithValueMap({{"threadcpuclock", TraceClockSource::kThreadCpu},
231 {"wallclock", TraceClockSource::kWall},
232 {"dualclock", TraceClockSource::kDual}})
233 .IntoKey(M::ProfileClock)
234 .Define("-Xenable-profiler")
235 .WithType<TestProfilerOptions>()
236 .AppendValues()
237 .IntoKey(M::ProfilerOpts) // NOTE: Appends into same key as -Xprofile-*
238 .Define("-Xprofile-_") // -Xprofile-<key>:<value>
239 .WithType<TestProfilerOptions>()
240 .AppendValues()
241 .IntoKey(M::ProfilerOpts) // NOTE: Appends into same key as -Xenable-profiler
242 .Define("-Xcompiler:_")
243 .WithType<std::string>()
244 .IntoKey(M::Compiler)
245 .Define("-Xcompiler-option _")
246 .WithType<std::vector<std::string>>()
247 .AppendValues()
248 .IntoKey(M::CompilerOptions)
249 .Define("-Ximage-compiler-option _")
250 .WithType<std::vector<std::string>>()
251 .AppendValues()
252 .IntoKey(M::ImageCompilerOptions)
253 .Define("-Xverify:_")
Igor Murashkin7617abd2015-07-10 18:27:47 -0700254 .WithType<verifier::VerifyMode>()
255 .WithValueMap({{"none", verifier::VerifyMode::kNone},
256 {"remote", verifier::VerifyMode::kEnable},
257 {"all", verifier::VerifyMode::kEnable},
258 {"softfail", verifier::VerifyMode::kSoftFail}})
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800259 .IntoKey(M::Verify)
260 .Define("-XX:NativeBridge=_")
261 .WithType<std::string>()
262 .IntoKey(M::NativeBridge)
Andreas Gampe9106e522015-03-31 14:54:03 -0700263 .Define("-Xzygote-max-boot-retry=_")
Narayan Kamath5a2be3f2015-02-16 13:51:51 +0000264 .WithType<unsigned int>()
265 .IntoKey(M::ZygoteMaxFailedBoots)
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700266 .Define("-Xno-dex-file-fallback")
267 .IntoKey(M::NoDexFileFallback)
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100268 .Define("-Xno-sig-chain")
269 .IntoKey(M::NoSigChain)
Dmitriy Ivanov785049f2014-07-18 10:08:57 -0700270 .Define("--cpu-abilist=_")
271 .WithType<std::string>()
272 .IntoKey(M::CpuAbiList)
Andreas Gampedd671252015-07-23 14:37:18 -0700273 .Define("-Xfingerprint:_")
274 .WithType<std::string>()
275 .IntoKey(M::Fingerprint)
Alex Lighteb7c1442015-08-31 13:17:42 -0700276 .Define("-Xexperimental:_")
277 .WithType<ExperimentalFlags>()
278 .AppendValues()
279 .IntoKey(M::Experimental)
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800280 .Ignore({
281 "-ea", "-da", "-enableassertions", "-disableassertions", "--runtime-arg", "-esa",
282 "-dsa", "-enablesystemassertions", "-disablesystemassertions", "-Xrs", "-Xint:_",
283 "-Xdexopt:_", "-Xnoquithandler", "-Xjnigreflimit:_", "-Xgenregmap", "-Xnogenregmap",
284 "-Xverifyopt:_", "-Xcheckdexsum", "-Xincludeselectedop", "-Xjitop:_",
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800285 "-Xincludeselectedmethod", "-Xjitthreshold:_",
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800286 "-Xjitblocking", "-Xjitmethod:_", "-Xjitclass:_", "-Xjitoffset:_",
287 "-Xjitconfig:_", "-Xjitcheckcg", "-Xjitverbose", "-Xjitprofile",
288 "-Xjitdisableopt", "-Xjitsuspendpoll", "-XX:mainThreadStackSize=_"})
289 .IgnoreUnrecognized(ignore_unrecognized);
290
291 // TODO: Move Usage information into this DSL.
292
293 return std::unique_ptr<RuntimeParser>(new RuntimeParser(parser_builder->Build()));
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800294}
295
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800296#pragma GCC diagnostic pop
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800297
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800298// Remove all the special options that have something in the void* part of the option.
299// If runtime_options is not null, put the options in there.
300// As a side-effect, populate the hooks from options.
301bool ParsedOptions::ProcessSpecialOptions(const RuntimeOptions& options,
302 RuntimeArgumentMap* runtime_options,
303 std::vector<std::string>* out_options) {
304 using M = RuntimeArgumentMap;
305
306 // TODO: Move the below loop into JNI
307 // Handle special options that set up hooks
308 for (size_t i = 0; i < options.size(); ++i) {
309 const std::string option(options[i].first);
310 // TODO: support -Djava.class.path
311 if (option == "bootclasspath") {
312 auto boot_class_path
313 = reinterpret_cast<const std::vector<const DexFile*>*>(options[i].second);
314
315 if (runtime_options != nullptr) {
316 runtime_options->Set(M::BootClassPathDexList, boot_class_path);
317 }
318 } else if (option == "compilercallbacks") {
319 CompilerCallbacks* compiler_callbacks =
320 reinterpret_cast<CompilerCallbacks*>(const_cast<void*>(options[i].second));
321 if (runtime_options != nullptr) {
322 runtime_options->Set(M::CompilerCallbacksPtr, compiler_callbacks);
323 }
324 } else if (option == "imageinstructionset") {
325 const char* isa_str = reinterpret_cast<const char*>(options[i].second);
326 auto&& image_isa = GetInstructionSetFromString(isa_str);
327 if (image_isa == kNone) {
328 Usage("%s is not a valid instruction set.", isa_str);
329 return false;
330 }
331 if (runtime_options != nullptr) {
332 runtime_options->Set(M::ImageInstructionSet, image_isa);
333 }
334 } else if (option == "sensitiveThread") {
335 const void* hook = options[i].second;
336 bool (*hook_is_sensitive_thread)() = reinterpret_cast<bool (*)()>(const_cast<void*>(hook));
337
338 if (runtime_options != nullptr) {
339 runtime_options->Set(M::HookIsSensitiveThread, hook_is_sensitive_thread);
340 }
341 } else if (option == "vfprintf") {
342 const void* hook = options[i].second;
343 if (hook == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700344 Usage("vfprintf argument was nullptr");
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800345 return false;
346 }
347 int (*hook_vfprintf)(FILE *, const char*, va_list) =
348 reinterpret_cast<int (*)(FILE *, const char*, va_list)>(const_cast<void*>(hook));
349
350 if (runtime_options != nullptr) {
351 runtime_options->Set(M::HookVfprintf, hook_vfprintf);
352 }
353 hook_vfprintf_ = hook_vfprintf;
354 } else if (option == "exit") {
355 const void* hook = options[i].second;
356 if (hook == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700357 Usage("exit argument was nullptr");
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800358 return false;
359 }
360 void(*hook_exit)(jint) = reinterpret_cast<void(*)(jint)>(const_cast<void*>(hook));
361 if (runtime_options != nullptr) {
362 runtime_options->Set(M::HookExit, hook_exit);
363 }
364 hook_exit_ = hook_exit;
365 } else if (option == "abort") {
366 const void* hook = options[i].second;
367 if (hook == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700368 Usage("abort was nullptr\n");
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800369 return false;
370 }
371 void(*hook_abort)() = reinterpret_cast<void(*)()>(const_cast<void*>(hook));
372 if (runtime_options != nullptr) {
373 runtime_options->Set(M::HookAbort, hook_abort);
374 }
375 hook_abort_ = hook_abort;
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700376 } else {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800377 // It is a regular option, that doesn't have a known 'second' value.
378 // Push it on to the regular options which will be parsed by our parser.
379 if (out_options != nullptr) {
380 out_options->push_back(option);
381 }
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700382 }
383 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800384
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700385 return true;
386}
387
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200388// Intended for local changes only.
389static void MaybeOverrideVerbosity() {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800390 // gLogVerbosity.class_linker = true; // TODO: don't check this in!
391 // gLogVerbosity.compiler = true; // TODO: don't check this in!
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200392 // gLogVerbosity.deopt = true; // TODO: don't check this in!
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800393 // gLogVerbosity.gc = true; // TODO: don't check this in!
394 // gLogVerbosity.heap = true; // TODO: don't check this in!
395 // gLogVerbosity.jdwp = true; // TODO: don't check this in!
396 // gLogVerbosity.jit = true; // TODO: don't check this in!
397 // gLogVerbosity.jni = true; // TODO: don't check this in!
398 // gLogVerbosity.monitor = true; // TODO: don't check this in!
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200399 // gLogVerbosity.oat = true; // TODO: don't check this in!
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800400 // gLogVerbosity.profiler = true; // TODO: don't check this in!
401 // gLogVerbosity.signals = true; // TODO: don't check this in!
Phil Wang751beff2015-08-28 15:17:15 +0800402 // gLogVerbosity.simulator = true; // TODO: don't check this in!
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800403 // gLogVerbosity.startup = true; // TODO: don't check this in!
404 // gLogVerbosity.third_party_jni = true; // TODO: don't check this in!
405 // gLogVerbosity.threads = true; // TODO: don't check this in!
406 // gLogVerbosity.verifier = true; // TODO: don't check this in!
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200407}
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800408
Vladimir Marko88b2b802015-12-04 14:19:04 +0000409bool ParsedOptions::DoParse(const RuntimeOptions& options,
410 bool ignore_unrecognized,
411 RuntimeArgumentMap* runtime_options) {
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800412 for (size_t i = 0; i < options.size(); ++i) {
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800413 if (true && options[0].first == "-Xzygote") {
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800414 LOG(INFO) << "option[" << i << "]=" << options[i].first;
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800415 }
Brian Carlstrom2ec65202014-03-03 15:16:37 -0800416 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800417
418 auto parser = MakeParser(ignore_unrecognized);
419
420 // Convert to a simple string list (without the magic pointer options)
421 std::vector<std::string> argv_list;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700422 if (!ProcessSpecialOptions(options, nullptr, &argv_list)) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800423 return false;
424 }
425
426 CmdlineResult parse_result = parser->Parse(argv_list);
427
428 // Handle parse errors by displaying the usage and potentially exiting.
429 if (parse_result.IsError()) {
430 if (parse_result.GetStatus() == CmdlineResult::kUsage) {
431 UsageMessage(stdout, "%s\n", parse_result.GetMessage().c_str());
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800432 Exit(0);
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800433 } else if (parse_result.GetStatus() == CmdlineResult::kUnknown && !ignore_unrecognized) {
434 Usage("%s\n", parse_result.GetMessage().c_str());
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800435 return false;
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800436 } else {
437 Usage("%s\n", parse_result.GetMessage().c_str());
438 Exit(0);
439 }
440
441 UNREACHABLE();
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800442 }
443
444 using M = RuntimeArgumentMap;
445 RuntimeArgumentMap args = parser->ReleaseArgumentsMap();
446
447 // -help, -showversion, etc.
448 if (args.Exists(M::Help)) {
449 Usage(nullptr);
450 return false;
451 } else if (args.Exists(M::ShowVersion)) {
452 UsageMessage(stdout, "ART version %s\n", Runtime::GetVersion());
453 Exit(0);
454 } else if (args.Exists(M::BootClassPath)) {
455 LOG(INFO) << "setting boot class path to " << *args.Get(M::BootClassPath);
456 }
457
458 // Set a default boot class path if we didn't get an explicit one via command line.
459 if (getenv("BOOTCLASSPATH") != nullptr) {
460 args.SetIfMissing(M::BootClassPath, std::string(getenv("BOOTCLASSPATH")));
461 }
462
463 // Set a default class path if we didn't get an explicit one via command line.
464 if (getenv("CLASSPATH") != nullptr) {
465 args.SetIfMissing(M::ClassPath, std::string(getenv("CLASSPATH")));
466 }
467
468 // Default to number of processors minus one since the main GC thread also does work.
Mathieu Chartier10d68862015-04-15 14:21:33 -0700469 args.SetIfMissing(M::ParallelGCThreads, gc::Heap::kDefaultEnableParallelGC ?
470 static_cast<unsigned int>(sysconf(_SC_NPROCESSORS_CONF) - 1u) : 0u);
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800471
472 // -Xverbose:
473 {
474 LogVerbosity *log_verbosity = args.Get(M::Verbose);
475 if (log_verbosity != nullptr) {
476 gLogVerbosity = *log_verbosity;
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800477 }
478 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800479
Sebastien Hertzbba348e2015-06-01 08:28:18 +0200480 MaybeOverrideVerbosity();
481
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800482 // -Xprofile:
483 Trace::SetDefaultClockSource(args.GetOrDefault(M::ProfileClock));
484
485 if (!ProcessSpecialOptions(options, &args, nullptr)) {
486 return false;
487 }
488
489 {
490 // If not set, background collector type defaults to homogeneous compaction.
491 // If foreground is GSS, use GSS as background collector.
492 // If not low memory mode, semispace otherwise.
493
494 gc::CollectorType background_collector_type_;
495 gc::CollectorType collector_type_ = (XGcOption{}).collector_type_; // NOLINT [whitespace/braces] [5]
496 bool low_memory_mode_ = args.Exists(M::LowMemoryMode);
497
498 background_collector_type_ = args.GetOrDefault(M::BackgroundGc);
499 {
500 XGcOption* xgc = args.Get(M::GcOption);
501 if (xgc != nullptr && xgc->collector_type_ != gc::kCollectorTypeNone) {
502 collector_type_ = xgc->collector_type_;
503 }
504 }
505
506 if (background_collector_type_ == gc::kCollectorTypeNone) {
507 if (collector_type_ != gc::kCollectorTypeGSS) {
508 background_collector_type_ = low_memory_mode_ ?
509 gc::kCollectorTypeSS : gc::kCollectorTypeHomogeneousSpaceCompact;
510 } else {
511 background_collector_type_ = collector_type_;
512 }
513 }
514
515 args.Set(M::BackgroundGc, BackgroundGcOption { background_collector_type_ });
Mathieu Chartier6b2352b2014-08-20 14:13:18 -0700516 }
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800517
518 // If a reference to the dalvik core.jar snuck in, replace it with
519 // the art specific version. This can happen with on device
520 // boot.art/boot.oat generation by GenerateImage which relies on the
521 // value of BOOTCLASSPATH.
Kenny Rootd5185342014-05-13 14:47:05 -0700522#if defined(ART_TARGET)
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800523 std::string core_jar("/core.jar");
Kenny Rootd5185342014-05-13 14:47:05 -0700524 std::string core_libart_jar("/core-libart.jar");
525#else
526 // The host uses hostdex files.
527 std::string core_jar("/core-hostdex.jar");
528 std::string core_libart_jar("/core-libart-hostdex.jar");
529#endif
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800530 auto boot_class_path_string = args.GetOrDefault(M::BootClassPath);
531
532 size_t core_jar_pos = boot_class_path_string.find(core_jar);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800533 if (core_jar_pos != std::string::npos) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800534 boot_class_path_string.replace(core_jar_pos, core_jar.size(), core_libart_jar);
535 args.Set(M::BootClassPath, boot_class_path_string);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800536 }
537
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800538 {
539 auto&& boot_class_path = args.GetOrDefault(M::BootClassPath);
540 auto&& boot_class_path_locations = args.GetOrDefault(M::BootClassPathLocations);
541 if (args.Exists(M::BootClassPathLocations)) {
542 size_t boot_class_path_count = ParseStringList<':'>::Split(boot_class_path).Size();
Richard Uhlerc2752592015-01-02 13:28:22 -0800543
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800544 if (boot_class_path_count != boot_class_path_locations.Size()) {
545 Usage("The number of boot class path files does not match"
546 " the number of boot class path locations given\n"
547 " boot class path files (%zu): %s\n"
548 " boot class path locations (%zu): %s\n",
549 boot_class_path.size(), boot_class_path_string.c_str(),
550 boot_class_path_locations.Size(), boot_class_path_locations.Join().c_str());
551 return false;
552 }
Richard Uhlerc2752592015-01-02 13:28:22 -0800553 }
554 }
555
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800556 if (!args.Exists(M::CompilerCallbacksPtr) && !args.Exists(M::Image)) {
557 std::string image = GetAndroidRoot();
558 image += "/framework/boot.art";
559 args.Set(M::Image, image);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800560 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800561
Lin Zang8cd63ab2015-11-06 14:08:51 +0800562 // 0 means no growth limit, and growth limit should be always <= heap size
563 if (args.GetOrDefault(M::HeapGrowthLimit) <= 0u ||
564 args.GetOrDefault(M::HeapGrowthLimit) > args.GetOrDefault(M::MemoryMaximumSize)) {
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800565 args.Set(M::HeapGrowthLimit, args.GetOrDefault(M::MemoryMaximumSize));
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800566 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800567
Alex Lighteb7c1442015-08-31 13:17:42 -0700568 if (args.GetOrDefault(M::Experimental) & ExperimentalFlags::kDefaultMethods) {
569 LOG(WARNING) << "Default method support has been enabled. The verifier will be less strict "
570 << "in some cases. All existing invoke opcodes have an unstable updated "
571 << "specification and are nearly guaranteed to change over time. Do not attempt "
572 << "to write shipping code against the invoke opcodes with this flag.";
573 }
574
575 if (args.GetOrDefault(M::Experimental) & ExperimentalFlags::kLambdas) {
Igor Murashkin158f35c2015-06-10 15:55:30 -0700576 LOG(WARNING) << "Experimental lambdas have been enabled. All lambda opcodes have "
577 << "an unstable specification and are nearly guaranteed to change over time. "
578 << "Do not attempt to write shipping code against these opcodes.";
579 }
580
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800581 *runtime_options = std::move(args);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800582 return true;
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800583}
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800584
585void ParsedOptions::Exit(int status) {
586 hook_exit_(status);
587}
588
589void ParsedOptions::Abort() {
590 hook_abort_();
591}
592
593void ParsedOptions::UsageMessageV(FILE* stream, const char* fmt, va_list ap) {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700594 hook_vfprintf_(stream, fmt, ap);
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800595}
596
597void ParsedOptions::UsageMessage(FILE* stream, const char* fmt, ...) {
598 va_list ap;
599 va_start(ap, fmt);
600 UsageMessageV(stream, fmt, ap);
601 va_end(ap);
602}
603
604void ParsedOptions::Usage(const char* fmt, ...) {
605 bool error = (fmt != nullptr);
606 FILE* stream = error ? stderr : stdout;
607
608 if (fmt != nullptr) {
609 va_list ap;
610 va_start(ap, fmt);
611 UsageMessageV(stream, fmt, ap);
612 va_end(ap);
613 }
614
615 const char* program = "dalvikvm";
616 UsageMessage(stream, "%s: [options] class [argument ...]\n", program);
617 UsageMessage(stream, "\n");
618 UsageMessage(stream, "The following standard options are supported:\n");
619 UsageMessage(stream, " -classpath classpath (-cp classpath)\n");
620 UsageMessage(stream, " -Dproperty=value\n");
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800621 UsageMessage(stream, " -verbose:tag ('gc', 'jit', 'jni', or 'class')\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800622 UsageMessage(stream, " -showversion\n");
623 UsageMessage(stream, " -help\n");
624 UsageMessage(stream, " -agentlib:jdwp=options\n");
625 UsageMessage(stream, "\n");
626
627 UsageMessage(stream, "The following extended options are supported:\n");
628 UsageMessage(stream, " -Xrunjdwp:<options>\n");
629 UsageMessage(stream, " -Xbootclasspath:bootclasspath\n");
630 UsageMessage(stream, " -Xcheck:tag (e.g. 'jni')\n");
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100631 UsageMessage(stream, " -XmsN (min heap, must be multiple of 1K, >= 1MB)\n");
632 UsageMessage(stream, " -XmxN (max heap, must be multiple of 1K, >= 2MB)\n");
633 UsageMessage(stream, " -XssN (stack size)\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800634 UsageMessage(stream, " -Xint\n");
635 UsageMessage(stream, "\n");
636
637 UsageMessage(stream, "The following Dalvik options are supported:\n");
638 UsageMessage(stream, " -Xzygote\n");
639 UsageMessage(stream, " -Xjnitrace:substring (eg NativeClass or nativeMethod)\n");
640 UsageMessage(stream, " -Xstacktracefile:<filename>\n");
641 UsageMessage(stream, " -Xgc:[no]preverify\n");
642 UsageMessage(stream, " -Xgc:[no]postverify\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800643 UsageMessage(stream, " -XX:HeapGrowthLimit=N\n");
644 UsageMessage(stream, " -XX:HeapMinFree=N\n");
645 UsageMessage(stream, " -XX:HeapMaxFree=N\n");
Mathieu Chartier6a7824d2014-08-22 14:53:04 -0700646 UsageMessage(stream, " -XX:NonMovingSpaceCapacity=N\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800647 UsageMessage(stream, " -XX:HeapTargetUtilization=doublevalue\n");
Mathieu Chartier455820e2014-04-18 12:02:39 -0700648 UsageMessage(stream, " -XX:ForegroundHeapGrowthMultiplier=doublevalue\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800649 UsageMessage(stream, " -XX:LowMemoryMode\n");
650 UsageMessage(stream, " -Xprofile:{threadcpuclock,wallclock,dualclock}\n");
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800651 UsageMessage(stream, " -Xjitthreshold:integervalue\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800652 UsageMessage(stream, "\n");
653
654 UsageMessage(stream, "The following unique to ART options are supported:\n");
655 UsageMessage(stream, " -Xgc:[no]preverify_rosalloc\n");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700656 UsageMessage(stream, " -Xgc:[no]postsweepingverify_rosalloc\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800657 UsageMessage(stream, " -Xgc:[no]postverify_rosalloc\n");
Mathieu Chartier6f365cc2014-04-23 12:42:27 -0700658 UsageMessage(stream, " -Xgc:[no]presweepingverify\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800659 UsageMessage(stream, " -Ximage:filename\n");
Richard Uhlerc2752592015-01-02 13:28:22 -0800660 UsageMessage(stream, " -Xbootclasspath-locations:bootclasspath\n"
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800661 " (override the dex locations of the -Xbootclasspath files)\n");
Mathieu Chartier2dbe6272014-09-16 10:43:23 -0700662 UsageMessage(stream, " -XX:+DisableExplicitGC\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800663 UsageMessage(stream, " -XX:ParallelGCThreads=integervalue\n");
664 UsageMessage(stream, " -XX:ConcGCThreads=integervalue\n");
665 UsageMessage(stream, " -XX:MaxSpinsBeforeThinLockInflation=integervalue\n");
666 UsageMessage(stream, " -XX:LongPauseLogThreshold=integervalue\n");
667 UsageMessage(stream, " -XX:LongGCLogThreshold=integervalue\n");
668 UsageMessage(stream, " -XX:DumpGCPerformanceOnShutdown\n");
Mathieu Chartiera4885cb2015-03-09 15:38:54 -0700669 UsageMessage(stream, " -XX:DumpJITInfoOnShutdown\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800670 UsageMessage(stream, " -XX:IgnoreMaxFootprint\n");
671 UsageMessage(stream, " -XX:UseTLAB\n");
672 UsageMessage(stream, " -XX:BackgroundGC=none\n");
Mathieu Chartier2dbe6272014-09-16 10:43:23 -0700673 UsageMessage(stream, " -XX:LargeObjectSpace={disabled,map,freelist}\n");
674 UsageMessage(stream, " -XX:LargeObjectThreshold=N\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800675 UsageMessage(stream, " -Xmethod-trace\n");
676 UsageMessage(stream, " -Xmethod-trace-file:filename");
677 UsageMessage(stream, " -Xmethod-trace-file-size:integervalue\n");
Calin Juravlec1b643c2014-05-30 23:44:11 +0100678 UsageMessage(stream, " -Xenable-profiler\n");
Wei Jin2221e3b2014-05-21 18:35:19 -0700679 UsageMessage(stream, " -Xprofile-filename:filename\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800680 UsageMessage(stream, " -Xprofile-period:integervalue\n");
681 UsageMessage(stream, " -Xprofile-duration:integervalue\n");
682 UsageMessage(stream, " -Xprofile-interval:integervalue\n");
Calin Juravle54c73ca2014-05-22 12:13:54 +0100683 UsageMessage(stream, " -Xprofile-backoff:doublevalue\n");
Calin Juravlec1b643c2014-05-30 23:44:11 +0100684 UsageMessage(stream, " -Xprofile-start-immediately\n");
685 UsageMessage(stream, " -Xprofile-top-k-threshold:doublevalue\n");
686 UsageMessage(stream, " -Xprofile-top-k-change-threshold:doublevalue\n");
Wei Jin445220d2014-06-20 15:56:53 -0700687 UsageMessage(stream, " -Xprofile-type:{method,stack}\n");
688 UsageMessage(stream, " -Xprofile-max-stack-depth:integervalue\n");
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700689 UsageMessage(stream, " -Xcompiler:filename\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800690 UsageMessage(stream, " -Xcompiler-option dex2oat-option\n");
691 UsageMessage(stream, " -Ximage-compiler-option dex2oat-option\n");
Alex Lighta59dd802014-07-02 16:28:08 -0700692 UsageMessage(stream, " -Xpatchoat:filename\n");
Mathieu Chartier1972a8e2015-03-05 17:12:54 -0800693 UsageMessage(stream, " -Xusejit:booleanvalue\n");
Nicolas Geoffray56782292015-11-19 14:25:43 +0000694 UsageMessage(stream, " -Xjitinitialsize:N\n");
695 UsageMessage(stream, " -Xjitmaxsize:N\n");
Alex Lighta59dd802014-07-02 16:28:08 -0700696 UsageMessage(stream, " -X[no]relocate\n");
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100697 UsageMessage(stream, " -X[no]dex2oat (Whether to invoke dex2oat on the application)\n");
Alex Light64ad14d2014-08-19 14:23:13 -0700698 UsageMessage(stream, " -X[no]image-dex2oat (Whether to create and use a boot image)\n");
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700699 UsageMessage(stream, " -Xno-dex-file-fallback "
700 "(Don't fall back to dex files without oat files)\n");
Alex Lighteb7c1442015-08-31 13:17:42 -0700701 UsageMessage(stream, " -Xexperimental:{lambdas,default-methods} "
702 "(Enable new experimental dalvik opcodes and semantics, off by default)\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800703 UsageMessage(stream, "\n");
704
705 UsageMessage(stream, "The following previously supported Dalvik options are ignored:\n");
706 UsageMessage(stream, " -ea[:<package name>... |:<class name>]\n");
707 UsageMessage(stream, " -da[:<package name>... |:<class name>]\n");
708 UsageMessage(stream, " (-enableassertions, -disableassertions)\n");
709 UsageMessage(stream, " -esa\n");
710 UsageMessage(stream, " -dsa\n");
711 UsageMessage(stream, " (-enablesystemassertions, -disablesystemassertions)\n");
Igor Murashkin7617abd2015-07-10 18:27:47 -0700712 UsageMessage(stream, " -Xverify:{none,remote,all,softfail}\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800713 UsageMessage(stream, " -Xrs\n");
714 UsageMessage(stream, " -Xint:portable, -Xint:fast, -Xint:jit\n");
715 UsageMessage(stream, " -Xdexopt:{none,verified,all,full}\n");
716 UsageMessage(stream, " -Xnoquithandler\n");
717 UsageMessage(stream, " -Xjniopts:{warnonly,forcecopy}\n");
718 UsageMessage(stream, " -Xjnigreflimit:integervalue\n");
719 UsageMessage(stream, " -Xgc:[no]precise\n");
720 UsageMessage(stream, " -Xgc:[no]verifycardtable\n");
721 UsageMessage(stream, " -X[no]genregmap\n");
722 UsageMessage(stream, " -Xverifyopt:[no]checkmon\n");
723 UsageMessage(stream, " -Xcheckdexsum\n");
724 UsageMessage(stream, " -Xincludeselectedop\n");
725 UsageMessage(stream, " -Xjitop:hexopvalue[-endvalue][,hexopvalue[-endvalue]]*\n");
726 UsageMessage(stream, " -Xincludeselectedmethod\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800727 UsageMessage(stream, " -Xjitblocking\n");
728 UsageMessage(stream, " -Xjitmethod:signature[,signature]* (eg Ljava/lang/String\\;replace)\n");
729 UsageMessage(stream, " -Xjitclass:classname[,classname]*\n");
Nicolas Geoffray56782292015-11-19 14:25:43 +0000730 UsageMessage(stream, " -Xjitcodecachesize:N\n");
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800731 UsageMessage(stream, " -Xjitoffset:offset[,offset]\n");
732 UsageMessage(stream, " -Xjitconfig:filename\n");
733 UsageMessage(stream, " -Xjitcheckcg\n");
734 UsageMessage(stream, " -Xjitverbose\n");
735 UsageMessage(stream, " -Xjitprofile\n");
736 UsageMessage(stream, " -Xjitdisableopt\n");
737 UsageMessage(stream, " -Xjitsuspendpoll\n");
738 UsageMessage(stream, " -XX:mainThreadStackSize=N\n");
739 UsageMessage(stream, "\n");
740
741 Exit((error) ? 1 : 0);
742}
743
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800744} // namespace art