1 /*
2 * Copyright (c) 1998, 2024, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/symbolTable.hpp"
27 #include "compiler/compilerDirectives.hpp"
28 #include "compiler/compilerOracle.hpp"
29 #include "compiler/methodMatcher.hpp"
30 #include "jvm.h"
31 #include "memory/allocation.inline.hpp"
32 #include "memory/oopFactory.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "oops/klass.hpp"
35 #include "oops/method.inline.hpp"
36 #include "oops/symbol.hpp"
37 #include "opto/phasetype.hpp"
38 #include "opto/traceAutoVectorizationTag.hpp"
39 #include "runtime/globals_extension.hpp"
40 #include "runtime/handles.inline.hpp"
41 #include "runtime/jniHandles.hpp"
42 #include "runtime/os.hpp"
43 #include "utilities/istream.hpp"
44 #include "utilities/parseInteger.hpp"
45
46 // Default compile commands, if defined, are parsed before any of the
47 // explicitly defined compile commands. Thus, explicitly defined compile
48 // commands take precedence over default compile commands. The effect is
49 // as if the default compile commands had been specified at the start of
50 // the command line.
51 static const char* const default_compile_commands[] = {
52 #ifdef ASSERT
53 // In debug builds, impose a (generous) per-compilation memory limit
54 // to catch pathological compilations during testing. The suboption
55 // "crash" will cause the JVM to assert.
56 //
57 // Note: to disable the default limit at the command line,
58 // set a limit of 0 (e.g. -XX:CompileCommand=MemLimit,*.*,0).
59 "MemLimit,*.*,1G~crash",
60 #endif
61 nullptr };
62
63 static const char* optiontype_names[] = {
64 #define enum_of_types(type, name) name,
65 OPTION_TYPES(enum_of_types)
66 #undef enum_of_types
67 };
68
69 static const char* optiontype2name(enum OptionType type) {
70 return optiontype_names[static_cast<int>(type)];
71 }
72
73 static enum OptionType option_types[] = {
74 #define enum_of_options(option, name, ctype) OptionType::ctype,
75 COMPILECOMMAND_OPTIONS(enum_of_options)
76 #undef enum_of_options
77 };
78
79 static enum OptionType option2type(CompileCommandEnum option) {
80 return option_types[static_cast<int>(option)];
81 }
82
83 static const char* option_names[] = {
84 #define enum_of_options(option, name, ctype) name,
85 COMPILECOMMAND_OPTIONS(enum_of_options)
86 #undef enum_of_options
87 };
88
89 static const char* option2name(CompileCommandEnum option) {
90 return option_names[static_cast<int>(option)];
91 }
92
93 /* Methods to map real type names to OptionType */
94 template<typename T>
95 static OptionType get_type_for() {
96 return OptionType::Unknown;
97 };
98
99 template<> OptionType get_type_for<intx>() {
100 return OptionType::Intx;
101 }
102
103 template<> OptionType get_type_for<uintx>() {
104 return OptionType::Uintx;
105 }
106
107 template<> OptionType get_type_for<bool>() {
108 return OptionType::Bool;
109 }
110
111 template<> OptionType get_type_for<ccstr>() {
112 return OptionType::Ccstr;
113 }
114
115 template<> OptionType get_type_for<double>() {
116 return OptionType::Double;
117 }
118
119 class MethodMatcher;
120 class TypedMethodOptionMatcher;
121
122 static TypedMethodOptionMatcher* option_list = nullptr;
123 static bool any_set = false;
124 static bool print_final_memstat_report = false;
125
126 // A filter for quick lookup if an option is set
127 static bool option_filter[static_cast<int>(CompileCommandEnum::Unknown) + 1] = { 0 };
128
129 static void command_set_in_filter(CompileCommandEnum option) {
130 assert(option != CompileCommandEnum::Unknown, "sanity");
131 assert(option2type(option) != OptionType::Unknown, "sanity");
132
133 if ((option != CompileCommandEnum::DontInline) &&
134 (option != CompileCommandEnum::Inline) &&
135 (option != CompileCommandEnum::Log)) {
136 any_set = true;
137 }
138 option_filter[static_cast<int>(option)] = true;
139 }
140
141 static bool has_command(CompileCommandEnum option) {
142 return option_filter[static_cast<int>(option)];
143 }
144
145 class TypedMethodOptionMatcher : public MethodMatcher {
146 private:
147 TypedMethodOptionMatcher* _next;
148 CompileCommandEnum _option;
149 public:
150
151 union {
152 bool bool_value;
153 intx intx_value;
154 uintx uintx_value;
155 double double_value;
156 ccstr ccstr_value;
157 } _u;
158
159 TypedMethodOptionMatcher() : MethodMatcher(),
160 _next(nullptr),
161 _option(CompileCommandEnum::Unknown) {
162 memset(&_u, 0, sizeof(_u));
163 }
164
165 ~TypedMethodOptionMatcher();
166 static TypedMethodOptionMatcher* parse_method_pattern(char*& line, char* errorbuf, const int buf_size);
167 TypedMethodOptionMatcher* match(const methodHandle &method, CompileCommandEnum option);
168
169 void init(CompileCommandEnum option, TypedMethodOptionMatcher* next) {
170 _next = next;
171 _option = option;
172 }
173
174 void init_matcher(Symbol* class_name, Mode class_mode,
175 Symbol* method_name, Mode method_mode,
176 Symbol* signature) {
177 MethodMatcher::init(class_name, class_mode, method_name, method_mode, signature);
178 }
179
180 void set_next(TypedMethodOptionMatcher* next) {_next = next; }
181 TypedMethodOptionMatcher* next() { return _next; }
182 CompileCommandEnum option() { return _option; }
183 template<typename T> T value();
184 template<typename T> void set_value(T value);
185 void print();
186 void print_all();
187 TypedMethodOptionMatcher* clone();
188 };
189
190 // A few templated accessors instead of a full template class.
191 template<> intx TypedMethodOptionMatcher::value<intx>() {
192 return _u.intx_value;
193 }
194
195 template<> uintx TypedMethodOptionMatcher::value<uintx>() {
196 return _u.uintx_value;
197 }
198
199 template<> bool TypedMethodOptionMatcher::value<bool>() {
200 return _u.bool_value;
201 }
202
203 template<> double TypedMethodOptionMatcher::value<double>() {
204 return _u.double_value;
205 }
206
207 template<> ccstr TypedMethodOptionMatcher::value<ccstr>() {
208 return _u.ccstr_value;
209 }
210
211 template<> void TypedMethodOptionMatcher::set_value(intx value) {
212 _u.intx_value = value;
213 }
214
215 template<> void TypedMethodOptionMatcher::set_value(uintx value) {
216 _u.uintx_value = value;
217 }
218
219 template<> void TypedMethodOptionMatcher::set_value(double value) {
220 _u.double_value = value;
221 }
222
223 template<> void TypedMethodOptionMatcher::set_value(bool value) {
224 _u.bool_value = value;
225 }
226
227 template<> void TypedMethodOptionMatcher::set_value(ccstr value) {
228 _u.ccstr_value = (ccstr)os::strdup_check_oom(value);
229 }
230
231 void TypedMethodOptionMatcher::print() {
232 ttyLocker ttyl;
233 print_base(tty);
234 const char* name = option2name(_option);
235 enum OptionType type = option2type(_option);
236 switch (type) {
237 case OptionType::Intx:
238 tty->print_cr(" intx %s = " INTX_FORMAT, name, value<intx>());
239 break;
240 case OptionType::Uintx:
241 tty->print_cr(" uintx %s = " UINTX_FORMAT, name, value<uintx>());
242 break;
243 case OptionType::Bool:
244 tty->print_cr(" bool %s = %s", name, value<bool>() ? "true" : "false");
245 break;
246 case OptionType::Double:
247 tty->print_cr(" double %s = %f", name, value<double>());
248 break;
249 case OptionType::Ccstr:
250 case OptionType::Ccstrlist:
251 tty->print_cr(" const char* %s = '%s'", name, value<ccstr>());
252 break;
253 default:
254 ShouldNotReachHere();
255 }
256 }
257
258 void TypedMethodOptionMatcher::print_all() {
259 print();
260 if (_next != nullptr) {
261 tty->print(" ");
262 _next->print_all();
263 }
264 }
265
266 TypedMethodOptionMatcher* TypedMethodOptionMatcher::clone() {
267 TypedMethodOptionMatcher* m = new TypedMethodOptionMatcher();
268 m->_class_mode = _class_mode;
269 m->_class_name = _class_name;
270 m->_method_mode = _method_mode;
271 m->_method_name = _method_name;
272 m->_signature = _signature;
273 // Need to ref count the symbols
274 if (_class_name != nullptr) {
275 _class_name->increment_refcount();
276 }
277 if (_method_name != nullptr) {
278 _method_name->increment_refcount();
279 }
280 if (_signature != nullptr) {
281 _signature->increment_refcount();
282 }
283 return m;
284 }
285
286 TypedMethodOptionMatcher::~TypedMethodOptionMatcher() {
287 enum OptionType type = option2type(_option);
288 if (type == OptionType::Ccstr || type == OptionType::Ccstrlist) {
289 ccstr v = value<ccstr>();
290 os::free((void*)v);
291 }
292 }
293
294 TypedMethodOptionMatcher* TypedMethodOptionMatcher::parse_method_pattern(char*& line, char* errorbuf, const int buf_size) {
295 assert(*errorbuf == '\0', "Dont call here with error_msg already set");
296 const char* error_msg = nullptr;
297 TypedMethodOptionMatcher* tom = new TypedMethodOptionMatcher();
298 MethodMatcher::parse_method_pattern(line, error_msg, tom);
299 if (error_msg != nullptr) {
300 jio_snprintf(errorbuf, buf_size, error_msg);
301 delete tom;
302 return nullptr;
303 }
304 return tom;
305 }
306
307 TypedMethodOptionMatcher* TypedMethodOptionMatcher::match(const methodHandle& method, CompileCommandEnum option) {
308 TypedMethodOptionMatcher* current = this;
309 while (current != nullptr) {
310 if (current->_option == option) {
311 if (current->matches(method)) {
312 return current;
313 }
314 }
315 current = current->next();
316 }
317 return nullptr;
318 }
319
320 template<typename T>
321 static void register_command(TypedMethodOptionMatcher* matcher,
322 CompileCommandEnum option,
323 T value) {
324 assert(matcher != option_list, "No circular lists please");
325 if (option == CompileCommandEnum::Log && !LogCompilation) {
326 tty->print_cr("Warning: +LogCompilation must be enabled in order for individual methods to be logged with ");
327 tty->print_cr(" CompileCommand=log,<method pattern>");
328 }
329 assert(CompilerOracle::option_matches_type(option, value), "Value must match option type");
330
331 if (option == CompileCommandEnum::Blackhole && !UnlockExperimentalVMOptions) {
332 warning("Blackhole compile option is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions");
333 // Delete matcher as we don't keep it
334 delete matcher;
335 return;
336 }
337
338 matcher->init(option, option_list);
339 matcher->set_value<T>(value);
340 option_list = matcher;
341 command_set_in_filter(option);
342
343 if (!CompilerOracle::be_quiet()) {
344 // Print out the successful registration of a compile command
345 ttyLocker ttyl;
346 tty->print("CompileCommand: %s ", option2name(option));
347 matcher->print();
348 }
349
350 return;
351 }
352
353 template<typename T>
354 bool CompilerOracle::has_option_value(const methodHandle& method, CompileCommandEnum option, T& value) {
355 assert(option_matches_type(option, value), "Value must match option type");
356 if (!has_command(option)) {
357 return false;
358 }
359 if (option_list != nullptr) {
360 TypedMethodOptionMatcher* m = option_list->match(method, option);
361 if (m != nullptr) {
362 value = m->value<T>();
363 return true;
364 }
365 }
366 return false;
367 }
368
369 static bool resolve_inlining_predicate(CompileCommandEnum option, const methodHandle& method) {
370 assert(option == CompileCommandEnum::Inline || option == CompileCommandEnum::DontInline, "Sanity");
371 bool v1 = false;
372 bool v2 = false;
373 bool has_inline = CompilerOracle::has_option_value(method, CompileCommandEnum::Inline, v1);
374 bool has_dnotinline = CompilerOracle::has_option_value(method, CompileCommandEnum::DontInline, v2);
375 if (has_inline && has_dnotinline) {
376 if (v1 && v2) {
377 // Conflict options detected
378 // Find the last one for that method and return the predicate accordingly
379 // option_list lists options in reverse order. So the first option we find is the last which was specified.
380 CompileCommandEnum last_one = CompileCommandEnum::Unknown;
381 TypedMethodOptionMatcher* current = option_list;
382 while (current != nullptr) {
383 last_one = current->option();
384 if (last_one == CompileCommandEnum::Inline || last_one == CompileCommandEnum::DontInline) {
385 if (current->matches(method)) {
386 return last_one == option;
387 }
388 }
389 current = current->next();
390 }
391 ShouldNotReachHere();
392 return false;
393 } else {
394 // No conflicts
395 return option == CompileCommandEnum::Inline ? v1 : v2;
396 }
397 } else {
398 if (option == CompileCommandEnum::Inline) {
399 return has_inline ? v1 : false;
400 } else {
401 return has_dnotinline ? v2 : false;
402 }
403 }
404 }
405
406 static bool check_predicate(CompileCommandEnum option, const methodHandle& method) {
407 // Special handling for Inline and DontInline since conflict options may be specified
408 if (option == CompileCommandEnum::Inline || option == CompileCommandEnum::DontInline) {
409 return resolve_inlining_predicate(option, method);
410 }
411
412 bool value = false;
413 if (CompilerOracle::has_option_value(method, option, value)) {
414 return value;
415 }
416 return false;
417 }
418
419 bool CompilerOracle::has_any_command_set() {
420 return any_set;
421 }
422
423 // Explicit instantiation for all OptionTypes supported.
424 template bool CompilerOracle::has_option_value<intx>(const methodHandle& method, CompileCommandEnum option, intx& value);
425 template bool CompilerOracle::has_option_value<uintx>(const methodHandle& method, CompileCommandEnum option, uintx& value);
426 template bool CompilerOracle::has_option_value<bool>(const methodHandle& method, CompileCommandEnum option, bool& value);
427 template bool CompilerOracle::has_option_value<ccstr>(const methodHandle& method, CompileCommandEnum option, ccstr& value);
428 template bool CompilerOracle::has_option_value<double>(const methodHandle& method, CompileCommandEnum option, double& value);
429
430 template<typename T>
431 bool CompilerOracle::option_matches_type(CompileCommandEnum option, T& value) {
432 enum OptionType option_type = option2type(option);
433 if (option_type == OptionType::Unknown) {
434 return false; // Can't query options with type Unknown.
435 }
436 if (option_type == OptionType::Ccstrlist) {
437 option_type = OptionType::Ccstr; // CCstrList type options are stored as Ccstr
438 }
439 return (get_type_for<T>() == option_type);
440 }
441
442 template bool CompilerOracle::option_matches_type<intx>(CompileCommandEnum option, intx& value);
443 template bool CompilerOracle::option_matches_type<uintx>(CompileCommandEnum option, uintx& value);
444 template bool CompilerOracle::option_matches_type<bool>(CompileCommandEnum option, bool& value);
445 template bool CompilerOracle::option_matches_type<ccstr>(CompileCommandEnum option, ccstr& value);
446 template bool CompilerOracle::option_matches_type<double>(CompileCommandEnum option, double& value);
447
448 bool CompilerOracle::has_option(const methodHandle& method, CompileCommandEnum option) {
449 bool value = false;
450 has_option_value(method, option, value);
451 return value;
452 }
453
454 bool CompilerOracle::should_exclude(const methodHandle& method) {
455 if (check_predicate(CompileCommandEnum::Exclude, method)) {
456 return true;
457 }
458 if (has_command(CompileCommandEnum::CompileOnly)) {
459 return !check_predicate(CompileCommandEnum::CompileOnly, method);
460 }
461 return false;
462 }
463
464 bool CompilerOracle::should_inline(const methodHandle& method) {
465 return (check_predicate(CompileCommandEnum::Inline, method));
466 }
467
468 bool CompilerOracle::should_not_inline(const methodHandle& method) {
469 return check_predicate(CompileCommandEnum::DontInline, method) || check_predicate(CompileCommandEnum::Exclude, method);
470 }
471
472 bool CompilerOracle::should_print(const methodHandle& method) {
473 return check_predicate(CompileCommandEnum::Print, method);
474 }
475
476 bool CompilerOracle::should_print_methods() {
477 return has_command(CompileCommandEnum::Print);
478 }
479
480 // Tells whether there are any methods to collect memory statistics for
481 bool CompilerOracle::should_collect_memstat() {
482 return has_command(CompileCommandEnum::MemStat) || has_command(CompileCommandEnum::MemLimit);
483 }
484
485 bool CompilerOracle::should_print_final_memstat_report() {
486 return print_final_memstat_report;
487 }
488
489 bool CompilerOracle::should_log(const methodHandle& method) {
490 if (!LogCompilation) return false;
491 if (!has_command(CompileCommandEnum::Log)) {
492 return true; // by default, log all
493 }
494 return (check_predicate(CompileCommandEnum::Log, method));
495 }
496
497 bool CompilerOracle::should_break_at(const methodHandle& method) {
498 return check_predicate(CompileCommandEnum::Break, method);
499 }
500
501 void CompilerOracle::tag_blackhole_if_possible(const methodHandle& method) {
502 if (!check_predicate(CompileCommandEnum::Blackhole, method)) {
503 return;
504 }
505 guarantee(UnlockExperimentalVMOptions, "Checked during initial parsing");
506 if (method->result_type() != T_VOID) {
507 warning("Blackhole compile option only works for methods with void type: %s",
508 method->name_and_sig_as_C_string());
509 return;
510 }
511 if (!method->is_empty_method()) {
512 warning("Blackhole compile option only works for empty methods: %s",
513 method->name_and_sig_as_C_string());
514 return;
515 }
516 if (!method->is_static()) {
517 warning("Blackhole compile option only works for static methods: %s",
518 method->name_and_sig_as_C_string());
519 return;
520 }
521 if (method->intrinsic_id() == vmIntrinsics::_blackhole) {
522 return;
523 }
524 if (method->intrinsic_id() != vmIntrinsics::_none) {
525 warning("Blackhole compile option only works for methods that do not have intrinsic set: %s, %s",
526 method->name_and_sig_as_C_string(), vmIntrinsics::name_at(method->intrinsic_id()));
527 return;
528 }
529 method->set_intrinsic_id(vmIntrinsics::_blackhole);
530 }
531
532 static CompileCommandEnum match_option_name(const char* line, int* bytes_read, char* errorbuf, int bufsize) {
533 assert(ARRAY_SIZE(option_names) == static_cast<int>(CompileCommandEnum::Count), "option_names size mismatch");
534
535 *bytes_read = 0;
536 char option_buf[256];
537 int matches = sscanf(line, "%255[a-zA-Z0-9]%n", option_buf, bytes_read);
538 if (matches > 0 && strcasecmp(option_buf, "unknown") != 0) {
539 for (uint i = 0; i < ARRAY_SIZE(option_names); i++) {
540 if (strcasecmp(option_buf, option_names[i]) == 0) {
541 return static_cast<CompileCommandEnum>(i);
542 }
543 }
544 }
545 jio_snprintf(errorbuf, bufsize, "Unrecognized option '%s'", option_buf);
546 return CompileCommandEnum::Unknown;
547 }
548
549 // match exactly and don't mess with errorbuf
550 CompileCommandEnum CompilerOracle::parse_option_name(const char* line) {
551 for (uint i = 0; i < ARRAY_SIZE(option_names); i++) {
552 if (strcasecmp(line, option_names[i]) == 0) {
553 return static_cast<CompileCommandEnum>(i);
554 }
555 }
556 return CompileCommandEnum::Unknown;
557 }
558
559 enum OptionType CompilerOracle::parse_option_type(const char* type_str) {
560 for (uint i = 0; i < ARRAY_SIZE(optiontype_names); i++) {
561 if (strcasecmp(type_str, optiontype_names[i]) == 0) {
562 return static_cast<enum OptionType>(i);
563 }
564 }
565 return OptionType::Unknown;
566 }
567
568 static void print_tip() { // CMH Update info
569 tty->cr();
570 tty->print_cr("Usage: '-XX:CompileCommand=<option>,<method pattern>' - to set boolean option to true");
571 tty->print_cr("Usage: '-XX:CompileCommand=<option>,<method pattern>,<value>'");
572 tty->print_cr("Use: '-XX:CompileCommand=help' for more information and to list all option.");
573 tty->cr();
574 }
575
576 static void print_option(CompileCommandEnum option, const char* name, enum OptionType type) {
577 if (type != OptionType::Unknown) {
578 tty->print_cr(" %s (%s)", name, optiontype2name(type));
579 }
580 }
581
582 static void print_commands() {
583 tty->cr();
584 tty->print_cr("All available options:");
585 #define enum_of_options(option, name, ctype) print_option(CompileCommandEnum::option, name, OptionType::ctype);
586 COMPILECOMMAND_OPTIONS(enum_of_options)
587 #undef enum_of_options
588 tty->cr();
589 }
590
591 static void usage() {
592 tty->cr();
593 tty->print_cr("The CompileCommand option enables the user of the JVM to control specific");
594 tty->print_cr("behavior of the dynamic compilers.");
595 tty->cr();
596 tty->print_cr("Compile commands has this general form:");
597 tty->print_cr("-XX:CompileCommand=<option><method pattern><value>");
598 tty->print_cr(" Sets <option> to the specified value for methods matching <method pattern>");
599 tty->print_cr(" All options are typed");
600 tty->cr();
601 tty->print_cr("-XX:CompileCommand=<option><method pattern>");
602 tty->print_cr(" Sets <option> to true for methods matching <method pattern>");
603 tty->print_cr(" Only applies to boolean options.");
604 tty->cr();
605 tty->print_cr("-XX:CompileCommand=quiet");
606 tty->print_cr(" Silence the compile command output");
607 tty->cr();
608 tty->print_cr("-XX:CompileCommand=help");
609 tty->print_cr(" Prints this help text");
610 tty->cr();
611 print_commands();
612 tty->cr();
613 tty->print_cr("Method patterns has the format:");
614 tty->print_cr(" package/Class.method()");
615 tty->cr();
616 tty->print_cr("For backward compatibility this form is also allowed:");
617 tty->print_cr(" package.Class::method()");
618 tty->cr();
619 tty->print_cr("The signature can be separated by an optional whitespace or comma:");
620 tty->print_cr(" package/Class.method ()");
621 tty->cr();
622 tty->print_cr("The class and method identifier can be used together with leading or");
623 tty->print_cr("trailing *'s for wildcard matching:");
624 tty->print_cr(" *ackage/Clas*.*etho*()");
625 tty->cr();
626 tty->print_cr("It is possible to use more than one CompileCommand on the command line:");
627 tty->print_cr(" -XX:CompileCommand=exclude,java/*.* -XX:CompileCommand=log,java*.*");
628 tty->cr();
629 tty->print_cr("The CompileCommands can be loaded from a file with the flag");
630 tty->print_cr("-XX:CompileCommandFile=<file> or be added to the file '.hotspot_compiler'");
631 tty->print_cr("Use the same format in the file as the argument to the CompileCommand flag.");
632 tty->print_cr("Add one command on each line.");
633 tty->print_cr(" exclude java/*.*");
634 tty->print_cr(" option java/*.* ReplayInline");
635 tty->cr();
636 tty->print_cr("The following commands have conflicting behavior: 'exclude', 'inline', 'dontinline',");
637 tty->print_cr("and 'compileonly'. There is no priority of commands. Applying (a subset of) these");
638 tty->print_cr("commands to the same method results in undefined behavior.");
639 tty->cr();
640 tty->print_cr("The 'exclude' command excludes methods from top-level compilations as well as");
641 tty->print_cr("from inlining, whereas the 'compileonly' command only excludes methods from");
642 tty->print_cr("top-level compilations (i.e. they can still be inlined into other compilation units).");
643 tty->cr();
644 };
645
646 static int skip_whitespace(char* &line) {
647 // Skip any leading spaces
648 int whitespace_read = 0;
649 sscanf(line, "%*[ \t]%n", &whitespace_read);
650 line += whitespace_read;
651 return whitespace_read;
652 }
653
654 static void skip_comma(char* &line) {
655 // Skip any leading spaces
656 if (*line == ',') {
657 line++;
658 }
659 }
660
661 static bool parseMemLimit(const char* line, intx& value, int& bytes_read, char* errorbuf, const int buf_size) {
662 // Format:
663 // "<memory size>['~' <suboption>]"
664 // <memory size> can have units, e.g. M
665 // <suboption> one of "crash" "stop", if omitted, "stop" is implied.
666 //
667 // Examples:
668 // -XX:CompileCommand='memlimit,*.*,20m'
669 // -XX:CompileCommand='memlimit,*.*,20m~stop'
670 // -XX:CompileCommand='memlimit,Option::toString,1m~crash'
671 //
672 // The resulting intx carries the size and whether we are to stop or crash:
673 // - neg. value means crash
674 // - pos. value (default) means stop
675 size_t s = 0;
676 char* end;
677 if (!parse_integer<size_t>(line, &end, &s)) {
678 jio_snprintf(errorbuf, buf_size, "MemLimit: invalid value");
679 return false;
680 }
681 bytes_read = (int)(end - line);
682
683 intx v = (intx)s;
684 if ((*end) != '\0') {
685 if (strncasecmp(end, "~crash", 6) == 0) {
686 v = -v;
687 bytes_read += 6;
688 } else if (strncasecmp(end, "~stop", 5) == 0) {
689 // ok, this is the default
690 bytes_read += 5;
691 } else {
692 jio_snprintf(errorbuf, buf_size, "MemLimit: invalid option");
693 return false;
694 }
695 }
696 value = v;
697 return true;
698 }
699
700 static bool parseMemStat(const char* line, uintx& value, int& bytes_read, char* errorbuf, const int buf_size) {
701
702 #define IF_ENUM_STRING(S, CMD) \
703 if (strncasecmp(line, S, strlen(S)) == 0) { \
704 bytes_read += (int)strlen(S); \
705 CMD \
706 return true; \
707 }
708
709 IF_ENUM_STRING("collect", {
710 value = (uintx)MemStatAction::collect;
711 });
712 IF_ENUM_STRING("print", {
713 value = (uintx)MemStatAction::print;
714 print_final_memstat_report = true;
715 });
716 #undef IF_ENUM_STRING
717
718 jio_snprintf(errorbuf, buf_size, "MemStat: invalid option");
719
720 return false;
721 }
722
723 static void scan_value(enum OptionType type, char* line, int& total_bytes_read,
724 TypedMethodOptionMatcher* matcher, CompileCommandEnum option, char* errorbuf, const int buf_size) {
725 int bytes_read = 0;
726 const char* ccname = option2name(option);
727 const char* type_str = optiontype2name(type);
728 int skipped = skip_whitespace(line);
729 total_bytes_read += skipped;
730 if (type == OptionType::Intx) {
731 intx value;
732 bool success = false;
733 if (option == CompileCommandEnum::MemLimit) {
734 // Special parsing for MemLimit
735 success = parseMemLimit(line, value, bytes_read, errorbuf, buf_size);
736 } else {
737 // Is it a raw number?
738 success = sscanf(line, "" INTX_FORMAT "%n", &value, &bytes_read) == 1;
739 }
740 if (success) {
741 total_bytes_read += bytes_read;
742 line += bytes_read;
743 register_command(matcher, option, value);
744 return;
745 } else {
746 jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
747 }
748 } else if (type == OptionType::Uintx) {
749 uintx value;
750 bool success = false;
751 if (option == CompileCommandEnum::MemStat) {
752 // Special parsing for MemStat
753 success = parseMemStat(line, value, bytes_read, errorbuf, buf_size);
754 } else {
755 // parse as raw number
756 success = sscanf(line, "" UINTX_FORMAT "%n", &value, &bytes_read) == 1;
757 }
758 if (success) {
759 total_bytes_read += bytes_read;
760 line += bytes_read;
761 register_command(matcher, option, value);
762 } else {
763 jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
764 }
765 } else if (type == OptionType::Ccstr) {
766 ResourceMark rm;
767 char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
768 if (sscanf(line, "%255[_a-zA-Z0-9]%n", value, &bytes_read) == 1) {
769 total_bytes_read += bytes_read;
770 line += bytes_read;
771 register_command(matcher, option, (ccstr) value);
772 return;
773 } else {
774 jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
775 }
776 } else if (type == OptionType::Ccstrlist) {
777 // Accumulates several strings into one. The internal type is ccstr.
778 ResourceMark rm;
779 char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
780 char* next_value = value;
781 if (sscanf(line, "%255[_a-zA-Z0-9+\\-]%n", next_value, &bytes_read) == 1) {
782 total_bytes_read += bytes_read;
783 line += bytes_read;
784 next_value += bytes_read + 1;
785 char* end_value = next_value - 1;
786 while (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9+\\-]%n", next_value, &bytes_read) == 1) {
787 total_bytes_read += bytes_read;
788 line += bytes_read;
789 *end_value = ' '; // override '\0'
790 next_value += bytes_read;
791 end_value = next_value-1;
792 }
793
794 if (option == CompileCommandEnum::ControlIntrinsic || option == CompileCommandEnum::DisableIntrinsic) {
795 ControlIntrinsicValidator validator(value, (option == CompileCommandEnum::DisableIntrinsic));
796
797 if (!validator.is_valid()) {
798 jio_snprintf(errorbuf, buf_size, "Unrecognized intrinsic detected in %s: %s", option2name(option), validator.what());
799 }
800 }
801 #if !defined(PRODUCT) && defined(COMPILER2)
802 else if (option == CompileCommandEnum::TraceAutoVectorization) {
803 TraceAutoVectorizationTagValidator validator(value, true);
804
805 if (!validator.is_valid()) {
806 jio_snprintf(errorbuf, buf_size, "Unrecognized tag name in %s: %s", option2name(option), validator.what());
807 }
808 } else if (option == CompileCommandEnum::PrintIdealPhase) {
809 PhaseNameValidator validator(value);
810
811 if (!validator.is_valid()) {
812 jio_snprintf(errorbuf, buf_size, "Unrecognized phase name in %s: %s", option2name(option), validator.what());
813 }
814 } else if (option == CompileCommandEnum::TestOptionList) {
815 // all values are ok
816 } else if (option == CompileCommandEnum::TooManyTrapsAtBCI) {
817 // FIXME
818 }
819 #endif
820 else {
821 assert(false, "Ccstrlist type option missing validator");
822 }
823
824 register_command(matcher, option, (ccstr) value);
825 return;
826 } else {
827 jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
828 }
829 } else if (type == OptionType::Bool) {
830 char value[256];
831 if (*line == '\0') {
832 // Short version of a CompileCommand sets a boolean Option to true
833 // -XXCompileCommand=<Option>,<method pattern>
834 register_command(matcher, option, true);
835 return;
836 }
837 if (sscanf(line, "%255[a-zA-Z]%n", value, &bytes_read) == 1) {
838 if (strcasecmp(value, "true") == 0) {
839 total_bytes_read += bytes_read;
840 line += bytes_read;
841 register_command(matcher, option, true);
842 return;
843 } else if (strcasecmp(value, "false") == 0) {
844 total_bytes_read += bytes_read;
845 line += bytes_read;
846 register_command(matcher, option, false);
847 return;
848 } else {
849 jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
850 }
851 } else {
852 jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
853 }
854 } else if (type == OptionType::Double) {
855 char buffer[2][256];
856 // Decimal separator '.' has been replaced with ' ' or '/' earlier,
857 // so read integer and fraction part of double value separately.
858 if (sscanf(line, "%255[0-9]%*[ /\t]%255[0-9]%n", buffer[0], buffer[1], &bytes_read) == 2) {
859 char value[512] = "";
860 jio_snprintf(value, sizeof(value), "%s.%s", buffer[0], buffer[1]);
861 total_bytes_read += bytes_read;
862 line += bytes_read;
863 register_command(matcher, option, atof(value));
864 return;
865 } else {
866 jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
867 }
868 } else {
869 jio_snprintf(errorbuf, buf_size, "Type '%s' not supported ", type_str);
870 }
871 }
872
873 // Scan next option and value in line, return MethodMatcher object on success, nullptr on failure.
874 // On failure, error_msg contains description for the first error.
875 // For future extensions: set error_msg on first error.
876 static void scan_option_and_value(enum OptionType type, char* line, int& total_bytes_read,
877 TypedMethodOptionMatcher* matcher,
878 char* errorbuf, const int buf_size) {
879 total_bytes_read = 0;
880 int bytes_read = 0;
881 char option_buf[256];
882
883 // Read option name.
884 if (sscanf(line, "%*[ \t]%255[a-zA-Z0-9]%n", option_buf, &bytes_read) == 1) {
885 line += bytes_read;
886 total_bytes_read += bytes_read;
887 int bytes_read2 = 0;
888 total_bytes_read += skip_whitespace(line);
889 CompileCommandEnum option = match_option_name(option_buf, &bytes_read2, errorbuf, buf_size);
890 if (option == CompileCommandEnum::Unknown) {
891 assert(*errorbuf != '\0', "error must have been set");
892 return;
893 }
894 enum OptionType optiontype = option2type(option);
895 if (option2type(option) != type) {
896 const char* optiontype_name = optiontype2name(optiontype);
897 const char* type_name = optiontype2name(type);
898 jio_snprintf(errorbuf, buf_size, "Option '%s' with type '%s' doesn't match supplied type '%s'", option_buf, optiontype_name, type_name);
899 return;
900 }
901 scan_value(type, line, total_bytes_read, matcher, option, errorbuf, buf_size);
902 } else {
903 const char* type_str = optiontype2name(type);
904 jio_snprintf(errorbuf, buf_size, "Option name for type '%s' should be alphanumeric ", type_str);
905 }
906 return;
907 }
908
909 void CompilerOracle::print_parse_error(char* error_msg, char* original_line) {
910 assert(*error_msg != '\0', "Must have error_message");
911 ttyLocker ttyl;
912 tty->print_cr("CompileCommand: An error occurred during parsing");
913 tty->print_cr("Error: %s", error_msg);
914 tty->print_cr("Line: '%s'", original_line);
915 print_tip();
916 }
917
918 class LineCopy : StackObj {
919 const char* _copy;
920 public:
921 LineCopy(char* line) {
922 _copy = os::strdup(line, mtInternal);
923 }
924 ~LineCopy() {
925 os::free((void*)_copy);
926 }
927 char* get() {
928 return (char*)_copy;
929 }
930 };
931
932 bool CompilerOracle::parse_from_line_quietly(char* line) {
933 const bool quiet0 = _quiet;
934 _quiet = true;
935 const bool result = parse_from_line(line);
936 _quiet = quiet0;
937 return result;
938 }
939
940 bool CompilerOracle::parse_from_line(char* line) {
941 if ((line[0] == '\0') || (line[0] == '#')) {
942 return true;
943 }
944
945 LineCopy original(line);
946 int bytes_read;
947 char error_buf[1024] = {0};
948
949 CompileCommandEnum option = match_option_name(line, &bytes_read, error_buf, sizeof(error_buf));
950 line += bytes_read;
951 ResourceMark rm;
952
953 if (option == CompileCommandEnum::Unknown) {
954 print_parse_error(error_buf, original.get());
955 return false;
956 }
957
958 if (option == CompileCommandEnum::Quiet) {
959 _quiet = true;
960 return true;
961 }
962
963 if (option == CompileCommandEnum::Help) {
964 usage();
965 return true;
966 }
967
968 if (option == CompileCommandEnum::Option) {
969 // Look for trailing options.
970 //
971 // Two types of trailing options are
972 // supported:
973 //
974 // (1) CompileCommand=option,Klass::method,option
975 // (2) CompileCommand=option,Klass::method,type,option,value
976 //
977 // Type (1) is used to enable a boolean option for a method.
978 //
979 // Type (2) is used to support options with a value. Values can have the
980 // the following types: intx, uintx, bool, ccstr, ccstrlist, and double.
981
982 char option_type[256]; // stores option for Type (1) and type of Type (2)
983 skip_comma(line);
984 TypedMethodOptionMatcher* archetype = TypedMethodOptionMatcher::parse_method_pattern(line, error_buf, sizeof(error_buf));
985 if (archetype == nullptr) {
986 print_parse_error(error_buf, original.get());
987 return false;
988 }
989
990 skip_whitespace(line);
991
992 // This is unnecessarily complex. Should retire multi-option lines and skip while loop
993 while (sscanf(line, "%255[a-zA-Z0-9]%n", option_type, &bytes_read) == 1) {
994 line += bytes_read;
995
996 // typed_matcher is used as a blueprint for each option, deleted at the end
997 TypedMethodOptionMatcher* typed_matcher = archetype->clone();
998 enum OptionType type = parse_option_type(option_type);
999 if (type != OptionType::Unknown) {
1000 // Type (2) option: parse option name and value.
1001 scan_option_and_value(type, line, bytes_read, typed_matcher, error_buf, sizeof(error_buf));
1002 if (*error_buf != '\0') {
1003 print_parse_error(error_buf, original.get());
1004 return false;
1005 }
1006 line += bytes_read;
1007 } else {
1008 // Type (1) option - option_type contains the option name -> bool value = true is implied
1009 int bytes_read;
1010 CompileCommandEnum option = match_option_name(option_type, &bytes_read, error_buf, sizeof(error_buf));
1011 if (option == CompileCommandEnum::Unknown) {
1012 print_parse_error(error_buf, original.get());
1013 return false;
1014 }
1015 if (option2type(option) == OptionType::Bool) {
1016 register_command(typed_matcher, option, true);
1017 } else {
1018 jio_snprintf(error_buf, sizeof(error_buf), " Missing type '%s' before option '%s'",
1019 optiontype2name(option2type(option)), option2name(option));
1020 print_parse_error(error_buf, original.get());
1021 return false;
1022 }
1023 }
1024 assert(typed_matcher != nullptr, "sanity");
1025 assert(*error_buf == '\0', "No error here");
1026 skip_whitespace(line);
1027 } // while(
1028 delete archetype;
1029 } else { // not an OptionCommand
1030 // Command has the following form:
1031 // CompileCommand=<option>,<method pattern><value>
1032 // CompileCommand=<option>,<method pattern> (implies option is bool and value is true)
1033 assert(*error_buf == '\0', "Don't call here with error_buf already set");
1034 enum OptionType type = option2type(option);
1035 int bytes_read = 0;
1036 skip_comma(line);
1037 TypedMethodOptionMatcher* matcher = TypedMethodOptionMatcher::parse_method_pattern(line, error_buf, sizeof(error_buf));
1038 if (matcher == nullptr) {
1039 print_parse_error(error_buf, original.get());
1040 return false;
1041 }
1042 skip_whitespace(line);
1043 if (*line == '\0') {
1044 if (option2type(option) == OptionType::Bool) {
1045 // if this is a bool option this implies true
1046 register_command(matcher, option, true);
1047 return true;
1048 } else if (option == CompileCommandEnum::MemStat) {
1049 // MemStat default action is to collect data but to not print
1050 register_command(matcher, option, (uintx)MemStatAction::collect);
1051 return true;
1052 } else {
1053 jio_snprintf(error_buf, sizeof(error_buf), " Option '%s' is not followed by a value", option2name(option));
1054 print_parse_error(error_buf, original.get());
1055 return false;
1056 }
1057 }
1058 scan_value(type, line, bytes_read, matcher, option, error_buf, sizeof(error_buf));
1059 if (*error_buf != '\0') {
1060 print_parse_error(error_buf, original.get());
1061 return false;
1062 }
1063 assert(matcher != nullptr, "consistency");
1064 }
1065 return true;
1066 }
1067
1068 static const char* default_cc_file = ".hotspot_compiler";
1069
1070 static const char* cc_file() {
1071 #ifdef ASSERT
1072 if (CompileCommandFile == nullptr)
1073 return default_cc_file;
1074 #endif
1075 return CompileCommandFile;
1076 }
1077
1078 bool CompilerOracle::has_command_file() {
1079 return cc_file() != nullptr;
1080 }
1081
1082 bool CompilerOracle::_quiet = false;
1083
1084 bool CompilerOracle::parse_from_file() {
1085 assert(has_command_file(), "command file must be specified");
1086 FILE* stream = os::fopen(cc_file(), "rt");
1087 if (stream == nullptr) {
1088 return true;
1089 }
1090
1091 FileInput input(stream, /*need_close=*/ true);
1092 return parse_from_input(&input, parse_from_line);
1093 }
1094
1095 bool CompilerOracle::parse_from_input(inputStream::Input* input,
1096 CompilerOracle::
1097 parse_from_line_fn_t* parse_from_line) {
1098 bool success = true;
1099 for (inputStream in(input); !in.done(); in.next()) {
1100 if (!parse_from_line(in.current_line())) {
1101 success = false;
1102 }
1103 }
1104 return success;
1105 }
1106
1107 bool CompilerOracle::parse_from_string(const char* str,
1108 CompilerOracle::
1109 parse_from_line_fn_t* parse_from_line) {
1110 MemoryInput input(str, strlen(str));
1111 return parse_from_input(&input, parse_from_line);
1112 }
1113
1114 bool compilerOracle_init() {
1115 bool success = true;
1116 // Register default compile commands first - any commands specified via CompileCommand will
1117 // supersede these default commands.
1118 for (int i = 0; default_compile_commands[i] != nullptr; i ++) {
1119 char* s = os::strdup(default_compile_commands[i]);
1120 success = CompilerOracle::parse_from_line_quietly(s);
1121 os::free(s);
1122 assert(success, "default compile command \"%s\" failed to parse", default_compile_commands[i]);
1123 }
1124 if (!CompilerOracle::parse_from_string(CompileCommand, CompilerOracle::parse_from_line)) {
1125 success = false;
1126 }
1127 if (!CompilerOracle::parse_from_string(CompileOnly, CompilerOracle::parse_compile_only)) {
1128 success = false;
1129 }
1130 if (CompilerOracle::has_command_file()) {
1131 if (!CompilerOracle::parse_from_file()) {
1132 success = false;
1133 }
1134 } else {
1135 struct stat buf;
1136 if (os::stat(default_cc_file, &buf) == 0) {
1137 warning("%s file is present but has been ignored. "
1138 "Run with -XX:CompileCommandFile=%s to load the file.",
1139 default_cc_file, default_cc_file);
1140 }
1141 }
1142 if (has_command(CompileCommandEnum::Print)) {
1143 if (PrintAssembly) {
1144 warning("CompileCommand and/or %s file contains 'print' commands, but PrintAssembly is also enabled", default_cc_file);
1145 }
1146 }
1147 return success;
1148 }
1149
1150 bool CompilerOracle::parse_compile_only(char* line) {
1151 if (line[0] == '\0') {
1152 return true;
1153 }
1154 ResourceMark rm;
1155 char error_buf[1024] = {0};
1156 LineCopy original(line);
1157 char* method_pattern;
1158 do {
1159 if (line[0] == '\0') {
1160 break;
1161 }
1162 method_pattern = strtok_r(line, ",", &line);
1163 if (method_pattern != nullptr) {
1164 TypedMethodOptionMatcher* matcher = TypedMethodOptionMatcher::parse_method_pattern(method_pattern, error_buf, sizeof(error_buf));
1165 if (matcher != nullptr) {
1166 register_command(matcher, CompileCommandEnum::CompileOnly, true);
1167 continue;
1168 }
1169 }
1170 ttyLocker ttyl;
1171 tty->print_cr("CompileOnly: An error occurred during parsing");
1172 if (*error_buf != '\0') {
1173 tty->print_cr("Error: %s", error_buf);
1174 }
1175 tty->print_cr("Line: '%s'", original.get());
1176 return false;
1177 } while (method_pattern != nullptr && line != nullptr);
1178 return true;
1179 }
1180
1181 CompileCommandEnum CompilerOracle::string_to_option(const char* name) {
1182 int bytes_read = 0;
1183 char errorbuf[1024] = {0};
1184 return match_option_name(name, &bytes_read, errorbuf, sizeof(errorbuf));
1185 }