1 /*
   2  * Copyright (c) 1998, 2025, 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 "classfile/symbolTable.hpp"
  26 #include "compiler/compilerDirectives.hpp"
  27 #include "compiler/compilerOracle.hpp"
  28 #include "compiler/methodMatcher.hpp"
  29 #include "jvm.h"
  30 #include "memory/allocation.inline.hpp"
  31 #include "memory/oopFactory.hpp"
  32 #include "memory/resourceArea.hpp"
  33 #include "oops/klass.hpp"
  34 #include "oops/method.inline.hpp"
  35 #include "oops/symbol.hpp"
  36 #include "opto/phasetype.hpp"
  37 #include "opto/traceAutoVectorizationTag.hpp"
  38 #include "opto/traceMergeStoresTag.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 
 125 // A filter for quick lookup if an option is set
 126 static bool option_filter[static_cast<int>(CompileCommandEnum::Unknown) + 1] = { 0 };
 127 
 128 static void command_set_in_filter(CompileCommandEnum option) {
 129   assert(option != CompileCommandEnum::Unknown, "sanity");
 130   assert(option2type(option) != OptionType::Unknown, "sanity");
 131 
 132   if ((option != CompileCommandEnum::DontInline) &&
 133       (option != CompileCommandEnum::Inline) &&
 134       (option != CompileCommandEnum::Log)) {
 135     any_set = true;
 136   }
 137   option_filter[static_cast<int>(option)] = true;
 138 }
 139 
 140 static bool has_command(CompileCommandEnum option) {
 141   return option_filter[static_cast<int>(option)];
 142 }
 143 
 144 class TypedMethodOptionMatcher : public MethodMatcher {
 145  private:
 146   TypedMethodOptionMatcher* _next;
 147   CompileCommandEnum _option;
 148  public:
 149 
 150   union {
 151     bool bool_value;
 152     intx intx_value;
 153     uintx uintx_value;
 154     double double_value;
 155     ccstr ccstr_value;
 156   } _u;
 157 
 158   TypedMethodOptionMatcher() : MethodMatcher(),
 159     _next(nullptr),
 160     _option(CompileCommandEnum::Unknown) {
 161       memset(&_u, 0, sizeof(_u));
 162   }
 163 
 164   ~TypedMethodOptionMatcher();
 165   static TypedMethodOptionMatcher* parse_method_pattern(char*& line, char* errorbuf, const int buf_size);
 166   TypedMethodOptionMatcher* match(const methodHandle &method, CompileCommandEnum option);
 167 
 168   void init(CompileCommandEnum option, TypedMethodOptionMatcher* next) {
 169     _next = next;
 170     _option = option;
 171   }
 172 
 173   void init_matcher(Symbol* class_name, Mode class_mode,
 174                     Symbol* method_name, Mode method_mode,
 175                     Symbol* signature) {
 176     MethodMatcher::init(class_name, class_mode, method_name, method_mode, signature);
 177   }
 178 
 179   void set_next(TypedMethodOptionMatcher* next) {_next = next; }
 180   TypedMethodOptionMatcher* next() { return _next; }
 181   CompileCommandEnum option() { return _option; }
 182   template<typename T> T value();
 183   template<typename T> void set_value(T value);
 184   void print();
 185   void print_all();
 186   TypedMethodOptionMatcher* clone();
 187 };
 188 
 189 // A few templated accessors instead of a full template class.
 190 template<> intx TypedMethodOptionMatcher::value<intx>() {
 191   return _u.intx_value;
 192 }
 193 
 194 template<> uintx TypedMethodOptionMatcher::value<uintx>() {
 195   return _u.uintx_value;
 196 }
 197 
 198 template<> bool TypedMethodOptionMatcher::value<bool>() {
 199   return _u.bool_value;
 200 }
 201 
 202 template<> double TypedMethodOptionMatcher::value<double>() {
 203   return _u.double_value;
 204 }
 205 
 206 template<> ccstr TypedMethodOptionMatcher::value<ccstr>() {
 207   return _u.ccstr_value;
 208 }
 209 
 210 template<> void TypedMethodOptionMatcher::set_value(intx value) {
 211   _u.intx_value = value;
 212 }
 213 
 214 template<> void TypedMethodOptionMatcher::set_value(uintx value) {
 215   _u.uintx_value = value;
 216 }
 217 
 218 template<> void TypedMethodOptionMatcher::set_value(double value) {
 219   _u.double_value = value;
 220 }
 221 
 222 template<> void TypedMethodOptionMatcher::set_value(bool value) {
 223   _u.bool_value = value;
 224 }
 225 
 226 template<> void TypedMethodOptionMatcher::set_value(ccstr value) {
 227   _u.ccstr_value = (ccstr)os::strdup_check_oom(value);
 228 }
 229 
 230 void TypedMethodOptionMatcher::print() {
 231   ttyLocker ttyl;
 232   print_base(tty);
 233   const char* name = option2name(_option);
 234   enum OptionType type = option2type(_option);
 235   switch (type) {
 236     case OptionType::Intx:
 237     tty->print_cr(" intx %s = %zd", name, value<intx>());
 238     break;
 239     case OptionType::Uintx:
 240     tty->print_cr(" uintx %s = %zu", name, value<uintx>());
 241     break;
 242     case OptionType::Bool:
 243     tty->print_cr(" bool %s = %s", name, value<bool>() ? "true" : "false");
 244     break;
 245     case OptionType::Double:
 246     tty->print_cr(" double %s = %f", name, value<double>());
 247     break;
 248     case OptionType::Ccstr:
 249     case OptionType::Ccstrlist:
 250     tty->print_cr(" const char* %s = '%s'", name, value<ccstr>());
 251     break;
 252   default:
 253     ShouldNotReachHere();
 254   }
 255 }
 256 
 257 void TypedMethodOptionMatcher::print_all() {
 258    print();
 259    if (_next != nullptr) {
 260      tty->print(" ");
 261      _next->print_all();
 262    }
 263  }
 264 
 265 TypedMethodOptionMatcher* TypedMethodOptionMatcher::clone() {
 266   TypedMethodOptionMatcher* m = new TypedMethodOptionMatcher();
 267   m->_class_mode = _class_mode;
 268   m->_class_name = _class_name;
 269   m->_method_mode = _method_mode;
 270   m->_method_name = _method_name;
 271   m->_signature = _signature;
 272   // Need to ref count the symbols
 273   if (_class_name != nullptr) {
 274     _class_name->increment_refcount();
 275   }
 276   if (_method_name != nullptr) {
 277     _method_name->increment_refcount();
 278   }
 279   if (_signature != nullptr) {
 280     _signature->increment_refcount();
 281   }
 282   return m;
 283 }
 284 
 285 TypedMethodOptionMatcher::~TypedMethodOptionMatcher() {
 286   enum OptionType type = option2type(_option);
 287   if (type == OptionType::Ccstr || type == OptionType::Ccstrlist) {
 288     ccstr v = value<ccstr>();
 289     os::free((void*)v);
 290   }
 291 }
 292 
 293 TypedMethodOptionMatcher* TypedMethodOptionMatcher::parse_method_pattern(char*& line, char* errorbuf, const int buf_size) {
 294   assert(*errorbuf == '\0', "Dont call here with error_msg already set");
 295   const char* error_msg = nullptr;
 296   TypedMethodOptionMatcher* tom = new TypedMethodOptionMatcher();
 297   MethodMatcher::parse_method_pattern(line, error_msg, tom);
 298   if (error_msg != nullptr) {
 299     jio_snprintf(errorbuf, buf_size, error_msg);
 300     delete tom;
 301     return nullptr;
 302   }
 303   return tom;
 304 }
 305 
 306 TypedMethodOptionMatcher* TypedMethodOptionMatcher::match(const methodHandle& method, CompileCommandEnum option) {
 307   TypedMethodOptionMatcher* current = this;
 308   while (current != nullptr) {
 309     if (current->_option == option) {
 310       if (current->matches(method)) {
 311         return current;
 312       }
 313     }
 314     current = current->next();
 315   }
 316   return nullptr;
 317 }
 318 
 319 template<typename T>
 320 static void register_command(TypedMethodOptionMatcher* matcher,
 321                              CompileCommandEnum option,
 322                              T value) {
 323   assert(matcher != option_list, "No circular lists please");
 324   if (option == CompileCommandEnum::Log && !LogCompilation) {
 325     tty->print_cr("Warning:  +LogCompilation must be enabled in order for individual methods to be logged with ");
 326     tty->print_cr("          CompileCommand=log,<method pattern>");
 327   }
 328   assert(CompilerOracle::option_matches_type(option, value), "Value must match option type");
 329 
 330   if (option == CompileCommandEnum::Blackhole && !UnlockExperimentalVMOptions) {
 331     warning("Blackhole compile option is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions");
 332     // Delete matcher as we don't keep it
 333     delete matcher;
 334     return;
 335   }
 336 
 337   matcher->init(option, option_list);
 338   matcher->set_value<T>(value);
 339   option_list = matcher;
 340   command_set_in_filter(option);
 341 
 342   if (!CompilerOracle::be_quiet()) {
 343     // Print out the successful registration of a compile command
 344     ttyLocker ttyl;
 345     tty->print("CompileCommand: %s ", option2name(option));
 346     matcher->print();
 347   }
 348 
 349   return;
 350 }
 351 
 352 template<typename T>
 353 bool CompilerOracle::has_option_value(const methodHandle& method, CompileCommandEnum option, T& value) {
 354   assert(option_matches_type(option, value), "Value must match option type");
 355   if (!has_command(option)) {
 356     return false;
 357   }
 358   if (option_list != nullptr) {
 359     TypedMethodOptionMatcher* m = option_list->match(method, option);
 360     if (m != nullptr) {
 361       value = m->value<T>();
 362       return true;
 363     }
 364   }
 365   return false;
 366 }
 367 
 368 static bool resolve_inlining_predicate(CompileCommandEnum option, const methodHandle& method) {
 369   assert(option == CompileCommandEnum::Inline || option == CompileCommandEnum::DontInline, "Sanity");
 370   bool v1 = false;
 371   bool v2 = false;
 372   bool has_inline = CompilerOracle::has_option_value(method, CompileCommandEnum::Inline, v1);
 373   bool has_dnotinline = CompilerOracle::has_option_value(method, CompileCommandEnum::DontInline, v2);
 374   if (has_inline && has_dnotinline) {
 375     if (v1 && v2) {
 376       // Conflict options detected
 377       // Find the last one for that method and return the predicate accordingly
 378       // option_list lists options in reverse order. So the first option we find is the last which was specified.
 379       CompileCommandEnum last_one = CompileCommandEnum::Unknown;
 380       TypedMethodOptionMatcher* current = option_list;
 381       while (current != nullptr) {
 382         last_one = current->option();
 383         if (last_one == CompileCommandEnum::Inline || last_one == CompileCommandEnum::DontInline) {
 384           if (current->matches(method)) {
 385             return last_one == option;
 386           }
 387         }
 388         current = current->next();
 389       }
 390       ShouldNotReachHere();
 391       return false;
 392     } else {
 393       // No conflicts
 394       return option == CompileCommandEnum::Inline ? v1 : v2;
 395     }
 396   } else {
 397     if (option == CompileCommandEnum::Inline) {
 398       return has_inline ? v1 : false;
 399     } else {
 400       return has_dnotinline ? v2 : false;
 401     }
 402   }
 403 }
 404 
 405 static bool check_predicate(CompileCommandEnum option, const methodHandle& method) {
 406   // Special handling for Inline and DontInline since conflict options may be specified
 407   if (option == CompileCommandEnum::Inline || option == CompileCommandEnum::DontInline) {
 408     return resolve_inlining_predicate(option, method);
 409   }
 410 
 411   bool value = false;
 412   if (CompilerOracle::has_option_value(method, option, value)) {
 413     return value;
 414   }
 415   return false;
 416 }
 417 
 418 bool CompilerOracle::has_any_command_set() {
 419   return any_set;
 420 }
 421 
 422 // Explicit instantiation for all OptionTypes supported.
 423 template bool CompilerOracle::has_option_value<intx>(const methodHandle& method, CompileCommandEnum option, intx& value);
 424 template bool CompilerOracle::has_option_value<uintx>(const methodHandle& method, CompileCommandEnum option, uintx& value);
 425 template bool CompilerOracle::has_option_value<bool>(const methodHandle& method, CompileCommandEnum option, bool& value);
 426 template bool CompilerOracle::has_option_value<ccstr>(const methodHandle& method, CompileCommandEnum option, ccstr& value);
 427 template bool CompilerOracle::has_option_value<double>(const methodHandle& method, CompileCommandEnum option, double& value);
 428 
 429 template<typename T>
 430 bool CompilerOracle::option_matches_type(CompileCommandEnum option, T& value) {
 431   enum OptionType option_type = option2type(option);
 432   if (option_type == OptionType::Unknown) {
 433     return false; // Can't query options with type Unknown.
 434   }
 435   if (option_type == OptionType::Ccstrlist) {
 436     option_type = OptionType::Ccstr; // CCstrList type options are stored as Ccstr
 437   }
 438   return (get_type_for<T>() == option_type);
 439 }
 440 
 441 template bool CompilerOracle::option_matches_type<intx>(CompileCommandEnum option, intx& value);
 442 template bool CompilerOracle::option_matches_type<uintx>(CompileCommandEnum option, uintx& value);
 443 template bool CompilerOracle::option_matches_type<bool>(CompileCommandEnum option, bool& value);
 444 template bool CompilerOracle::option_matches_type<ccstr>(CompileCommandEnum option, ccstr& value);
 445 template bool CompilerOracle::option_matches_type<double>(CompileCommandEnum option, double& value);
 446 
 447 bool CompilerOracle::has_option(const methodHandle& method, CompileCommandEnum option) {
 448   bool value = false;
 449   has_option_value(method, option, value);
 450   return value;
 451 }
 452 
 453 bool CompilerOracle::should_exclude(const methodHandle& method) {
 454   if (check_predicate(CompileCommandEnum::Exclude, method)) {
 455     return true;
 456   }
 457   if (has_command(CompileCommandEnum::CompileOnly)) {
 458     return !check_predicate(CompileCommandEnum::CompileOnly, method);
 459   }
 460   return false;
 461 }
 462 
 463 bool CompilerOracle::should_inline(const methodHandle& method) {
 464   return (check_predicate(CompileCommandEnum::Inline, method));
 465 }
 466 
 467 bool CompilerOracle::should_not_inline(const methodHandle& method) {
 468   return check_predicate(CompileCommandEnum::DontInline, method) || check_predicate(CompileCommandEnum::Exclude, method);
 469 }
 470 
 471 bool CompilerOracle::should_print(const methodHandle& method) {
 472   return check_predicate(CompileCommandEnum::Print, method);
 473 }
 474 
 475 bool CompilerOracle::should_print_methods() {
 476   return has_command(CompileCommandEnum::Print);
 477 }
 478 
 479 // Tells whether there are any methods to collect memory statistics for
 480 bool CompilerOracle::should_collect_memstat() {
 481   return has_command(CompileCommandEnum::MemStat) || has_command(CompileCommandEnum::MemLimit);
 482 }
 483 
 484 bool CompilerOracle::should_log(const methodHandle& method) {
 485   if (!LogCompilation) return false;
 486   if (!has_command(CompileCommandEnum::Log)) {
 487     return true;  // by default, log all
 488   }
 489   return (check_predicate(CompileCommandEnum::Log, method));
 490 }
 491 
 492 bool CompilerOracle::should_break_at(const methodHandle& method) {
 493   return check_predicate(CompileCommandEnum::Break, method);
 494 }
 495 
 496 void CompilerOracle::tag_blackhole_if_possible(const methodHandle& method) {
 497   if (!check_predicate(CompileCommandEnum::Blackhole, method)) {
 498     return;
 499   }
 500   guarantee(UnlockExperimentalVMOptions, "Checked during initial parsing");
 501   if (method->result_type() != T_VOID) {
 502     warning("Blackhole compile option only works for methods with void type: %s",
 503             method->name_and_sig_as_C_string());
 504     return;
 505   }
 506   if (!method->is_empty_method()) {
 507     warning("Blackhole compile option only works for empty methods: %s",
 508             method->name_and_sig_as_C_string());
 509     return;
 510   }
 511   if (!method->is_static()) {
 512     warning("Blackhole compile option only works for static methods: %s",
 513             method->name_and_sig_as_C_string());
 514     return;
 515   }
 516   if (method->intrinsic_id() == vmIntrinsics::_blackhole) {
 517     return;
 518   }
 519   if (method->intrinsic_id() != vmIntrinsics::_none) {
 520     warning("Blackhole compile option only works for methods that do not have intrinsic set: %s, %s",
 521             method->name_and_sig_as_C_string(), vmIntrinsics::name_at(method->intrinsic_id()));
 522     return;
 523   }
 524   method->set_intrinsic_id(vmIntrinsics::_blackhole);
 525 }
 526 
 527 static CompileCommandEnum match_option_name(const char* line, int* bytes_read, char* errorbuf, int bufsize) {
 528   assert(ARRAY_SIZE(option_names) == static_cast<int>(CompileCommandEnum::Count), "option_names size mismatch");
 529 
 530   *bytes_read = 0;
 531   char option_buf[256];
 532   int matches = sscanf(line, "%255[a-zA-Z0-9]%n", option_buf, bytes_read);
 533   if (matches > 0 && strcasecmp(option_buf, "unknown") != 0) {
 534     for (uint i = 0; i < ARRAY_SIZE(option_names); i++) {
 535       if (strcasecmp(option_buf, option_names[i]) == 0) {
 536         return static_cast<CompileCommandEnum>(i);
 537       }
 538     }
 539   }
 540   jio_snprintf(errorbuf, bufsize, "Unrecognized option '%s'", option_buf);
 541   return CompileCommandEnum::Unknown;
 542 }
 543 
 544 // match exactly and don't mess with errorbuf
 545 CompileCommandEnum CompilerOracle::parse_option_name(const char* line) {
 546   for (uint i = 0; i < ARRAY_SIZE(option_names); i++) {
 547     if (strcasecmp(line, option_names[i]) == 0) {
 548       return static_cast<CompileCommandEnum>(i);
 549     }
 550   }
 551   return CompileCommandEnum::Unknown;
 552 }
 553 
 554 enum OptionType CompilerOracle::parse_option_type(const char* type_str) {
 555   for (uint i = 0; i < ARRAY_SIZE(optiontype_names); i++) {
 556     if (strcasecmp(type_str, optiontype_names[i]) == 0) {
 557       return static_cast<enum OptionType>(i);
 558     }
 559   }
 560   return OptionType::Unknown;
 561 }
 562 
 563 static void print_tip() { // CMH Update info
 564   tty->cr();
 565   tty->print_cr("Usage: '-XX:CompileCommand=<option>,<method pattern>' - to set boolean option to true");
 566   tty->print_cr("Usage: '-XX:CompileCommand=<option>,<method pattern>,<value>'");
 567   tty->print_cr("Use:   '-XX:CompileCommand=help' for more information and to list all option.");
 568   tty->cr();
 569 }
 570 
 571 static void print_option(CompileCommandEnum option, const char* name, enum OptionType type) {
 572   if (type != OptionType::Unknown) {
 573     tty->print_cr("    %s (%s)", name, optiontype2name(type));
 574   }
 575 }
 576 
 577 static void print_commands() {
 578   tty->cr();
 579   tty->print_cr("All available options:");
 580 #define enum_of_options(option, name, ctype) print_option(CompileCommandEnum::option, name, OptionType::ctype);
 581   COMPILECOMMAND_OPTIONS(enum_of_options)
 582 #undef enum_of_options
 583   tty->cr();
 584 }
 585 
 586 static void usage() {
 587   tty->cr();
 588   tty->print_cr("The CompileCommand option enables the user of the JVM to control specific");
 589   tty->print_cr("behavior of the dynamic compilers.");
 590   tty->cr();
 591   tty->print_cr("Compile commands has this general form:");
 592   tty->print_cr("-XX:CompileCommand=<option><method pattern><value>");
 593   tty->print_cr("    Sets <option> to the specified value for methods matching <method pattern>");
 594   tty->print_cr("    All options are typed");
 595   tty->cr();
 596   tty->print_cr("-XX:CompileCommand=<option><method pattern>");
 597   tty->print_cr("    Sets <option> to true for methods matching <method pattern>");
 598   tty->print_cr("    Only applies to boolean options.");
 599   tty->cr();
 600   tty->print_cr("-XX:CompileCommand=quiet");
 601   tty->print_cr("    Silence the compile command output");
 602   tty->cr();
 603   tty->print_cr("-XX:CompileCommand=help");
 604   tty->print_cr("    Prints this help text");
 605   tty->cr();
 606   print_commands();
 607   tty->cr();
 608     tty->print_cr("Method patterns has the format:");
 609   tty->print_cr("  package/Class.method()");
 610   tty->cr();
 611   tty->print_cr("For backward compatibility this form is also allowed:");
 612   tty->print_cr("  package.Class::method()");
 613   tty->cr();
 614   tty->print_cr("The signature can be separated by an optional whitespace or comma:");
 615   tty->print_cr("  package/Class.method ()");
 616   tty->cr();
 617   tty->print_cr("The class and method identifier can be used together with leading or");
 618   tty->print_cr("trailing *'s for wildcard matching:");
 619   tty->print_cr("  *ackage/Clas*.*etho*()");
 620   tty->cr();
 621   tty->print_cr("It is possible to use more than one CompileCommand on the command line:");
 622   tty->print_cr("  -XX:CompileCommand=exclude,java/*.* -XX:CompileCommand=log,java*.*");
 623   tty->cr();
 624   tty->print_cr("The CompileCommands can be loaded from a file with the flag");
 625   tty->print_cr("-XX:CompileCommandFile=<file> or be added to the file '.hotspot_compiler'");
 626   tty->print_cr("Use the same format in the file as the argument to the CompileCommand flag.");
 627   tty->print_cr("Add one command on each line.");
 628   tty->print_cr("  exclude java/*.*");
 629   tty->print_cr("  option java/*.* ReplayInline");
 630   tty->cr();
 631   tty->print_cr("The following commands have conflicting behavior: 'exclude', 'inline', 'dontinline',");
 632   tty->print_cr("and 'compileonly'. There is no priority of commands. Applying (a subset of) these");
 633   tty->print_cr("commands to the same method results in undefined behavior.");
 634   tty->cr();
 635   tty->print_cr("The 'exclude' command excludes methods from top-level compilations as well as");
 636   tty->print_cr("from inlining, whereas the 'compileonly' command only excludes methods from");
 637   tty->print_cr("top-level compilations (i.e. they can still be inlined into other compilation units).");
 638   tty->cr();
 639 };
 640 
 641 static int skip_whitespace(char* &line) {
 642   // Skip any leading spaces
 643   int whitespace_read = 0;
 644   sscanf(line, "%*[ \t]%n", &whitespace_read);
 645   line += whitespace_read;
 646   return whitespace_read;
 647 }
 648 
 649 static void skip_comma(char* &line) {
 650   // Skip any leading spaces
 651   if (*line == ',') {
 652     line++;
 653   }
 654 }
 655 
 656 static bool parseMemLimit(const char* line, intx& value, int& bytes_read, char* errorbuf, const int buf_size) {
 657   // Format:
 658   // "<memory size>['~' <suboption>]"
 659   // <memory size> can have units, e.g. M
 660   // <suboption> one of "crash" "stop", if omitted, "stop" is implied.
 661   //
 662   // Examples:
 663   // -XX:CompileCommand='memlimit,*.*,20m'
 664   // -XX:CompileCommand='memlimit,*.*,20m~stop'
 665   // -XX:CompileCommand='memlimit,Option::toString,1m~crash'
 666   //
 667   // The resulting intx carries the size and whether we are to stop or crash:
 668   // - neg. value means crash
 669   // - pos. value (default) means stop
 670   size_t s = 0;
 671   char* end;
 672   if (!parse_integer<size_t>(line, &end, &s)) {
 673     jio_snprintf(errorbuf, buf_size, "MemLimit: invalid value");
 674     return false;
 675   }
 676   bytes_read = (int)(end - line);
 677 
 678   intx v = (intx)s;
 679   if ((*end) != '\0') {
 680     if (strncasecmp(end, "~crash", 6) == 0) {
 681       v = -v;
 682       bytes_read += 6;
 683     } else if (strncasecmp(end, "~stop", 5) == 0) {
 684       // ok, this is the default
 685       bytes_read += 5;
 686     } else {
 687       jio_snprintf(errorbuf, buf_size, "MemLimit: invalid option");
 688       return false;
 689     }
 690   }
 691   value = v;
 692   return true;
 693 }
 694 
 695 static bool parseMemStat(const char* line, uintx& value, int& bytes_read, char* errorbuf, const int buf_size) {
 696 
 697 #define IF_ENUM_STRING(S, CMD)                \
 698   if (strncasecmp(line, S, strlen(S)) == 0) { \
 699     bytes_read += (int)strlen(S);             \
 700     CMD                                       \
 701     return true;                              \
 702   }
 703 
 704   IF_ENUM_STRING("collect", {
 705     value = (uintx)MemStatAction::collect;
 706   });
 707   IF_ENUM_STRING("print", {
 708     value = (uintx)MemStatAction::print;
 709   });
 710 #undef IF_ENUM_STRING
 711 
 712   jio_snprintf(errorbuf, buf_size, "MemStat: invalid option");
 713 
 714   return false;
 715 }
 716 
 717 static void scan_value(enum OptionType type, char* line, int& total_bytes_read,
 718         TypedMethodOptionMatcher* matcher, CompileCommandEnum option, char* errorbuf, const int buf_size) {
 719   int bytes_read = 0;
 720   const char* ccname = option2name(option);
 721   const char* type_str = optiontype2name(type);
 722   int skipped = skip_whitespace(line);
 723   total_bytes_read += skipped;
 724   if (type == OptionType::Intx) {
 725     intx value;
 726     bool success = false;
 727     if (option == CompileCommandEnum::MemLimit) {
 728       // Special parsing for MemLimit
 729       success = parseMemLimit(line, value, bytes_read, errorbuf, buf_size);
 730     } else {
 731       // Is it a raw number?
 732       success = sscanf(line, "%zd%n", &value, &bytes_read) == 1;
 733     }
 734     if (success) {
 735       total_bytes_read += bytes_read;
 736       line += bytes_read;
 737       register_command(matcher, option, value);
 738       return;
 739     } else {
 740       jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
 741     }
 742   } else if (type == OptionType::Uintx) {
 743     uintx value;
 744     bool success = false;
 745     if (option == CompileCommandEnum::MemStat) {
 746       // Special parsing for MemStat
 747       success = parseMemStat(line, value, bytes_read, errorbuf, buf_size);
 748     } else {
 749       // parse as raw number
 750       success = sscanf(line, "%zu%n", &value, &bytes_read) == 1;
 751     }
 752     if (success) {
 753       total_bytes_read += bytes_read;
 754       line += bytes_read;
 755       register_command(matcher, option, value);
 756     } else {
 757       jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
 758     }
 759   } else if (type == OptionType::Ccstr) {
 760     ResourceMark rm;
 761     char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
 762     if (sscanf(line, "%255[_a-zA-Z0-9]%n", value, &bytes_read) == 1) {
 763       total_bytes_read += bytes_read;
 764       line += bytes_read;
 765       register_command(matcher, option, (ccstr) value);
 766       return;
 767     } else {
 768       jio_snprintf(errorbuf, buf_size, "Value cannot be read for option '%s' of type '%s'", ccname, type_str);
 769     }
 770   } else if (type == OptionType::Ccstrlist) {
 771     // Accumulates several strings into one. The internal type is ccstr.
 772     ResourceMark rm;
 773     char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
 774     char* next_value = value;
 775     if (sscanf(line, "%255[_a-zA-Z0-9+\\-]%n", next_value, &bytes_read) == 1) {
 776       total_bytes_read += bytes_read;
 777       line += bytes_read;
 778       next_value += bytes_read + 1;
 779       char* end_value = next_value - 1;
 780       while (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9+\\-]%n", next_value, &bytes_read) == 1) {
 781         total_bytes_read += bytes_read;
 782         line += bytes_read;
 783         *end_value = ' '; // override '\0'
 784         next_value += bytes_read;
 785         end_value = next_value-1;
 786       }
 787 
 788       if (option == CompileCommandEnum::ControlIntrinsic || option == CompileCommandEnum::DisableIntrinsic) {
 789         ControlIntrinsicValidator validator(value, (option == CompileCommandEnum::DisableIntrinsic));
 790 
 791         if (!validator.is_valid()) {
 792           jio_snprintf(errorbuf, buf_size, "Unrecognized intrinsic detected in %s: %s", option2name(option), validator.what());
 793         }
 794       }
 795 #if !defined(PRODUCT) && defined(COMPILER2)
 796       else if (option == CompileCommandEnum::TraceAutoVectorization) {
 797         TraceAutoVectorizationTagValidator validator(value, true);
 798 
 799         if (!validator.is_valid()) {
 800           jio_snprintf(errorbuf, buf_size, "Unrecognized tag name in %s: %s", option2name(option), validator.what());
 801         }
 802       } else if (option == CompileCommandEnum::TraceMergeStores) {
 803         TraceMergeStores::TagValidator 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 }