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