mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-27 14:54:52 +02:00
8135068: Extract method matchers from CompilerOracle
Ecapsulate code to enable reuse Reviewed-by: roland, kvn
This commit is contained in:
Nils Eliasson
parent
ff77d8762c
commit
5ca8983920
17 changed files with 1072 additions and 523 deletions
|
|
@ -24,149 +24,17 @@
|
|||
|
||||
#include "precompiled.hpp"
|
||||
#include "compiler/compilerOracle.hpp"
|
||||
#include "compiler/methodMatcher.hpp"
|
||||
#include "memory/allocation.inline.hpp"
|
||||
#include "memory/oopFactory.hpp"
|
||||
#include "memory/resourceArea.hpp"
|
||||
#include "oops/klass.hpp"
|
||||
#include "oops/method.hpp"
|
||||
#include "oops/oop.inline.hpp"
|
||||
#include "oops/symbol.hpp"
|
||||
#include "runtime/handles.inline.hpp"
|
||||
#include "runtime/jniHandles.hpp"
|
||||
#include "runtime/os.hpp"
|
||||
|
||||
class MethodMatcher : public CHeapObj<mtCompiler> {
|
||||
public:
|
||||
enum Mode {
|
||||
Exact,
|
||||
Prefix = 1,
|
||||
Suffix = 2,
|
||||
Substring = Prefix | Suffix,
|
||||
Any,
|
||||
Unknown = -1
|
||||
};
|
||||
|
||||
protected:
|
||||
Symbol* _class_name;
|
||||
Symbol* _method_name;
|
||||
Symbol* _signature;
|
||||
Mode _class_mode;
|
||||
Mode _method_mode;
|
||||
MethodMatcher* _next;
|
||||
|
||||
static bool match(Symbol* candidate, Symbol* match, Mode match_mode);
|
||||
|
||||
Symbol* class_name() const { return _class_name; }
|
||||
Symbol* method_name() const { return _method_name; }
|
||||
Symbol* signature() const { return _signature; }
|
||||
|
||||
public:
|
||||
MethodMatcher(Symbol* class_name, Mode class_mode,
|
||||
Symbol* method_name, Mode method_mode,
|
||||
Symbol* signature, MethodMatcher* next);
|
||||
MethodMatcher(Symbol* class_name, Symbol* method_name, MethodMatcher* next);
|
||||
|
||||
// utility method
|
||||
MethodMatcher* find(methodHandle method) {
|
||||
Symbol* class_name = method->method_holder()->name();
|
||||
Symbol* method_name = method->name();
|
||||
for (MethodMatcher* current = this; current != NULL; current = current->_next) {
|
||||
if (match(class_name, current->class_name(), current->_class_mode) &&
|
||||
match(method_name, current->method_name(), current->_method_mode) &&
|
||||
(current->signature() == NULL || current->signature() == method->signature())) {
|
||||
return current;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool match(methodHandle method) {
|
||||
return find(method) != NULL;
|
||||
}
|
||||
|
||||
MethodMatcher* next() const { return _next; }
|
||||
|
||||
static void print_symbol(Symbol* h, Mode mode) {
|
||||
ResourceMark rm;
|
||||
|
||||
if (mode == Suffix || mode == Substring || mode == Any) {
|
||||
tty->print("*");
|
||||
}
|
||||
if (mode != Any) {
|
||||
h->print_symbol_on(tty);
|
||||
}
|
||||
if (mode == Prefix || mode == Substring) {
|
||||
tty->print("*");
|
||||
}
|
||||
}
|
||||
|
||||
void print_base() {
|
||||
print_symbol(class_name(), _class_mode);
|
||||
tty->print(".");
|
||||
print_symbol(method_name(), _method_mode);
|
||||
if (signature() != NULL) {
|
||||
signature()->print_symbol_on(tty);
|
||||
}
|
||||
}
|
||||
|
||||
virtual void print() {
|
||||
print_base();
|
||||
tty->cr();
|
||||
}
|
||||
};
|
||||
|
||||
MethodMatcher::MethodMatcher(Symbol* class_name, Symbol* method_name, MethodMatcher* next) {
|
||||
_class_name = class_name;
|
||||
_method_name = method_name;
|
||||
_next = next;
|
||||
_class_mode = MethodMatcher::Exact;
|
||||
_method_mode = MethodMatcher::Exact;
|
||||
_signature = NULL;
|
||||
}
|
||||
|
||||
|
||||
MethodMatcher::MethodMatcher(Symbol* class_name, Mode class_mode,
|
||||
Symbol* method_name, Mode method_mode,
|
||||
Symbol* signature, MethodMatcher* next):
|
||||
_class_mode(class_mode)
|
||||
, _method_mode(method_mode)
|
||||
, _next(next)
|
||||
, _class_name(class_name)
|
||||
, _method_name(method_name)
|
||||
, _signature(signature) {
|
||||
}
|
||||
|
||||
bool MethodMatcher::match(Symbol* candidate, Symbol* match, Mode match_mode) {
|
||||
if (match_mode == Any) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (match_mode == Exact) {
|
||||
return candidate == match;
|
||||
}
|
||||
|
||||
ResourceMark rm;
|
||||
const char * candidate_string = candidate->as_C_string();
|
||||
const char * match_string = match->as_C_string();
|
||||
|
||||
switch (match_mode) {
|
||||
case Prefix:
|
||||
return strstr(candidate_string, match_string) == candidate_string;
|
||||
|
||||
case Suffix: {
|
||||
size_t clen = strlen(candidate_string);
|
||||
size_t mlen = strlen(match_string);
|
||||
return clen >= mlen && strcmp(candidate_string + clen - mlen, match_string) == 0;
|
||||
}
|
||||
|
||||
case Substring:
|
||||
return strstr(candidate_string, match_string) != NULL;
|
||||
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
enum OptionType {
|
||||
IntxType,
|
||||
UintxType,
|
||||
|
|
@ -202,114 +70,6 @@ template<> OptionType get_type_for<double>() {
|
|||
return DoubleType;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static const T copy_value(const T value) {
|
||||
return value;
|
||||
}
|
||||
|
||||
template<> const ccstr copy_value<ccstr>(const ccstr value) {
|
||||
return (const ccstr)os::strdup_check_oom(value);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class TypedMethodOptionMatcher : public MethodMatcher {
|
||||
const char* _option;
|
||||
OptionType _type;
|
||||
const T _value;
|
||||
|
||||
public:
|
||||
TypedMethodOptionMatcher(Symbol* class_name, Mode class_mode,
|
||||
Symbol* method_name, Mode method_mode,
|
||||
Symbol* signature, const char* opt,
|
||||
const T value, MethodMatcher* next) :
|
||||
MethodMatcher(class_name, class_mode, method_name, method_mode, signature, next),
|
||||
_type(get_type_for<T>()), _value(copy_value<T>(value)) {
|
||||
_option = os::strdup_check_oom(opt);
|
||||
}
|
||||
|
||||
~TypedMethodOptionMatcher() {
|
||||
os::free((void*)_option);
|
||||
}
|
||||
|
||||
TypedMethodOptionMatcher* match(methodHandle method, const char* opt) {
|
||||
TypedMethodOptionMatcher* current = this;
|
||||
while (current != NULL) {
|
||||
current = (TypedMethodOptionMatcher*)current->find(method);
|
||||
if (current == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
if (strcmp(current->_option, opt) == 0) {
|
||||
return current;
|
||||
}
|
||||
current = current->next();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TypedMethodOptionMatcher* next() {
|
||||
return (TypedMethodOptionMatcher*)_next;
|
||||
}
|
||||
|
||||
OptionType get_type(void) {
|
||||
return _type;
|
||||
};
|
||||
|
||||
T value() { return _value; }
|
||||
|
||||
void print() {
|
||||
ttyLocker ttyl;
|
||||
print_base();
|
||||
tty->print(" %s", _option);
|
||||
tty->print(" <unknown option type>");
|
||||
tty->cr();
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
void TypedMethodOptionMatcher<intx>::print() {
|
||||
ttyLocker ttyl;
|
||||
print_base();
|
||||
tty->print(" intx %s", _option);
|
||||
tty->print(" = " INTX_FORMAT, _value);
|
||||
tty->cr();
|
||||
};
|
||||
|
||||
template<>
|
||||
void TypedMethodOptionMatcher<uintx>::print() {
|
||||
ttyLocker ttyl;
|
||||
print_base();
|
||||
tty->print(" uintx %s", _option);
|
||||
tty->print(" = " UINTX_FORMAT, _value);
|
||||
tty->cr();
|
||||
};
|
||||
|
||||
template<>
|
||||
void TypedMethodOptionMatcher<bool>::print() {
|
||||
ttyLocker ttyl;
|
||||
print_base();
|
||||
tty->print(" bool %s", _option);
|
||||
tty->print(" = %s", _value ? "true" : "false");
|
||||
tty->cr();
|
||||
};
|
||||
|
||||
template<>
|
||||
void TypedMethodOptionMatcher<ccstr>::print() {
|
||||
ttyLocker ttyl;
|
||||
print_base();
|
||||
tty->print(" const char* %s", _option);
|
||||
tty->print(" = '%s'", _value);
|
||||
tty->cr();
|
||||
};
|
||||
|
||||
template<>
|
||||
void TypedMethodOptionMatcher<double>::print() {
|
||||
ttyLocker ttyl;
|
||||
print_base();
|
||||
tty->print(" double %s", _option);
|
||||
tty->print(" = %f", _value);
|
||||
tty->cr();
|
||||
};
|
||||
|
||||
// this must parallel the command_names below
|
||||
enum OracleCommand {
|
||||
UnknownCommand = -1,
|
||||
|
|
@ -342,8 +102,198 @@ static const char * command_names[] = {
|
|||
};
|
||||
|
||||
class MethodMatcher;
|
||||
static MethodMatcher* lists[OracleCommandCount] = { 0, };
|
||||
class TypedMethodOptionMatcher;
|
||||
|
||||
static BasicMatcher* lists[OracleCommandCount] = { 0, };
|
||||
static TypedMethodOptionMatcher* option_list = NULL;
|
||||
|
||||
class TypedMethodOptionMatcher : public MethodMatcher {
|
||||
private:
|
||||
TypedMethodOptionMatcher* _next;
|
||||
const char* _option;
|
||||
OptionType _type;
|
||||
public:
|
||||
|
||||
union {
|
||||
bool bool_value;
|
||||
intx intx_value;
|
||||
uintx uintx_value;
|
||||
double double_value;
|
||||
ccstr ccstr_value;
|
||||
} _u;
|
||||
|
||||
TypedMethodOptionMatcher() : MethodMatcher(),
|
||||
_next(NULL),
|
||||
_type(UnknownType) {
|
||||
_option = NULL;
|
||||
memset(&_u, 0, sizeof(_u));
|
||||
}
|
||||
|
||||
static TypedMethodOptionMatcher* parse_method_pattern(char*& line, const char*& error_msg);
|
||||
TypedMethodOptionMatcher* match(methodHandle method, const char* opt, OptionType type);
|
||||
|
||||
void init(const char* opt, OptionType type, TypedMethodOptionMatcher* next) {
|
||||
_next = next;
|
||||
_type = type;
|
||||
_option = os::strdup_check_oom(opt);
|
||||
}
|
||||
|
||||
void set_next(TypedMethodOptionMatcher* next) {_next = next; }
|
||||
TypedMethodOptionMatcher* next() { return _next; }
|
||||
OptionType type() { return _type; }
|
||||
template<typename T> T value();
|
||||
template<typename T> void set_value(T value);
|
||||
void print();
|
||||
void print_all();
|
||||
TypedMethodOptionMatcher* clone();
|
||||
~TypedMethodOptionMatcher();
|
||||
};
|
||||
|
||||
// A few templated accessors instead of a full template class.
|
||||
template<> intx TypedMethodOptionMatcher::value<intx>() {
|
||||
return _u.intx_value;
|
||||
}
|
||||
|
||||
template<> uintx TypedMethodOptionMatcher::value<uintx>() {
|
||||
return _u.uintx_value;
|
||||
}
|
||||
|
||||
template<> bool TypedMethodOptionMatcher::value<bool>() {
|
||||
return _u.bool_value;
|
||||
}
|
||||
|
||||
template<> double TypedMethodOptionMatcher::value<double>() {
|
||||
return _u.double_value;
|
||||
}
|
||||
|
||||
template<> ccstr TypedMethodOptionMatcher::value<ccstr>() {
|
||||
return _u.ccstr_value;
|
||||
}
|
||||
|
||||
template<> void TypedMethodOptionMatcher::set_value(intx value) {
|
||||
_u.intx_value = value;
|
||||
}
|
||||
|
||||
template<> void TypedMethodOptionMatcher::set_value(uintx value) {
|
||||
_u.uintx_value = value;
|
||||
}
|
||||
|
||||
template<> void TypedMethodOptionMatcher::set_value(double value) {
|
||||
_u.double_value = value;
|
||||
}
|
||||
|
||||
template<> void TypedMethodOptionMatcher::set_value(bool value) {
|
||||
_u.bool_value = value;
|
||||
}
|
||||
|
||||
template<> void TypedMethodOptionMatcher::set_value(ccstr value) {
|
||||
_u.ccstr_value = (const ccstr)os::strdup_check_oom(value);
|
||||
}
|
||||
|
||||
void TypedMethodOptionMatcher::print() {
|
||||
ttyLocker ttyl;
|
||||
print_base(tty);
|
||||
switch (_type) {
|
||||
case IntxType:
|
||||
tty->print_cr(" intx %s = " INTX_FORMAT, _option, value<intx>());
|
||||
break;
|
||||
case UintxType:
|
||||
tty->print_cr(" uintx %s = " UINTX_FORMAT, _option, value<uintx>());
|
||||
break;
|
||||
case BoolType:
|
||||
tty->print_cr(" bool %s = %s", _option, value<bool>() ? "true" : "false");
|
||||
break;
|
||||
case DoubleType:
|
||||
tty->print_cr(" double %s = %f", _option, value<double>());
|
||||
break;
|
||||
case CcstrType:
|
||||
tty->print_cr(" const char* %s = '%s'", _option, value<ccstr>());
|
||||
break;
|
||||
default:
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
}
|
||||
|
||||
void TypedMethodOptionMatcher::print_all() {
|
||||
print();
|
||||
if (_next != NULL) {
|
||||
tty->print(" ");
|
||||
_next->print_all();
|
||||
}
|
||||
}
|
||||
|
||||
TypedMethodOptionMatcher* TypedMethodOptionMatcher::clone() {
|
||||
TypedMethodOptionMatcher* m = new TypedMethodOptionMatcher();
|
||||
m->_class_mode = _class_mode;
|
||||
m->_class_name = _class_name;
|
||||
m->_method_mode = _method_mode;
|
||||
m->_method_name = _method_name;
|
||||
m->_signature = _signature;
|
||||
// Need to ref count the symbols
|
||||
if (_class_name != NULL) {
|
||||
_class_name->increment_refcount();
|
||||
}
|
||||
if (_method_name != NULL) {
|
||||
_method_name->increment_refcount();
|
||||
}
|
||||
if (_signature != NULL) {
|
||||
_signature->increment_refcount();
|
||||
}
|
||||
return m;
|
||||
}
|
||||
|
||||
TypedMethodOptionMatcher::~TypedMethodOptionMatcher() {
|
||||
if (_option != NULL) {
|
||||
os::free((void*)_option);
|
||||
}
|
||||
if (_class_name != NULL) {
|
||||
_class_name->decrement_refcount();
|
||||
}
|
||||
if (_method_name != NULL) {
|
||||
_method_name->decrement_refcount();
|
||||
}
|
||||
if (_signature != NULL) {
|
||||
_signature->decrement_refcount();
|
||||
}
|
||||
}
|
||||
|
||||
TypedMethodOptionMatcher* TypedMethodOptionMatcher::parse_method_pattern(char*& line, const char*& error_msg) {
|
||||
assert(error_msg == NULL, "Dont call here with error_msg already set");
|
||||
TypedMethodOptionMatcher* tom = new TypedMethodOptionMatcher();
|
||||
MethodMatcher::parse_method_pattern(line, error_msg, tom);
|
||||
if (error_msg != NULL) {
|
||||
delete tom;
|
||||
return NULL;
|
||||
}
|
||||
return tom;
|
||||
}
|
||||
|
||||
TypedMethodOptionMatcher* TypedMethodOptionMatcher::match(methodHandle method, const char* opt, OptionType type) {
|
||||
TypedMethodOptionMatcher* current = this;
|
||||
while (current != NULL) {
|
||||
// Fastest compare first.
|
||||
if (current->type() == type) {
|
||||
if (strcmp(current->_option, opt) == 0) {
|
||||
if (current->matches(method)) {
|
||||
return current;
|
||||
}
|
||||
}
|
||||
}
|
||||
current = current->next();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static void add_option_string(TypedMethodOptionMatcher* matcher,
|
||||
const char* option,
|
||||
T value) {
|
||||
assert(matcher != option_list, "No circular lists please");
|
||||
matcher->init(option, get_type_for<T>(), option_list);
|
||||
matcher->set_value<T>(value);
|
||||
option_list = matcher;
|
||||
return;
|
||||
}
|
||||
|
||||
static bool check_predicate(OracleCommand command, methodHandle method) {
|
||||
return ((lists[command] != NULL) &&
|
||||
|
|
@ -351,51 +301,27 @@ static bool check_predicate(OracleCommand command, methodHandle method) {
|
|||
lists[command]->match(method));
|
||||
}
|
||||
|
||||
|
||||
static MethodMatcher* add_predicate(OracleCommand command,
|
||||
Symbol* class_name, MethodMatcher::Mode c_mode,
|
||||
Symbol* method_name, MethodMatcher::Mode m_mode,
|
||||
Symbol* signature) {
|
||||
static void add_predicate(OracleCommand command, BasicMatcher* bm) {
|
||||
assert(command != OptionCommand, "must use add_option_string");
|
||||
if (command == LogCommand && !LogCompilation && lists[LogCommand] == NULL)
|
||||
if (command == LogCommand && !LogCompilation && lists[LogCommand] == NULL) {
|
||||
tty->print_cr("Warning: +LogCompilation must be enabled in order for individual methods to be logged.");
|
||||
lists[command] = new MethodMatcher(class_name, c_mode, method_name, m_mode, signature, lists[command]);
|
||||
return lists[command];
|
||||
}
|
||||
}
|
||||
bm->set_next(lists[command]);
|
||||
lists[command] = bm;
|
||||
|
||||
template<typename T>
|
||||
static MethodMatcher* add_option_string(Symbol* class_name, MethodMatcher::Mode c_mode,
|
||||
Symbol* method_name, MethodMatcher::Mode m_mode,
|
||||
Symbol* signature,
|
||||
const char* option,
|
||||
T value) {
|
||||
lists[OptionCommand] = new TypedMethodOptionMatcher<T>(class_name, c_mode, method_name, m_mode,
|
||||
signature, option, value, lists[OptionCommand]);
|
||||
return lists[OptionCommand];
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static bool get_option_value(methodHandle method, const char* option, T& value) {
|
||||
TypedMethodOptionMatcher<T>* m;
|
||||
if (lists[OptionCommand] != NULL
|
||||
&& (m = ((TypedMethodOptionMatcher<T>*)lists[OptionCommand])->match(method, option)) != NULL
|
||||
&& m->get_type() == get_type_for<T>()) {
|
||||
value = m->value();
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool CompilerOracle::has_option_string(methodHandle method, const char* option) {
|
||||
bool value = false;
|
||||
get_option_value(method, option, value);
|
||||
return value;
|
||||
return;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool CompilerOracle::has_option_value(methodHandle method, const char* option, T& value) {
|
||||
return ::get_option_value(method, option, value);
|
||||
if (option_list != NULL) {
|
||||
TypedMethodOptionMatcher* m = option_list->match(method, option, get_type_for<T>());
|
||||
if (m != NULL) {
|
||||
value = m->value<T>();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Explicit instantiation for all OptionTypes supported.
|
||||
|
|
@ -405,6 +331,12 @@ template bool CompilerOracle::has_option_value<bool>(methodHandle method, const
|
|||
template bool CompilerOracle::has_option_value<ccstr>(methodHandle method, const char* option, ccstr& value);
|
||||
template bool CompilerOracle::has_option_value<double>(methodHandle method, const char* option, double& value);
|
||||
|
||||
bool CompilerOracle::has_option_string(methodHandle method, const char* option) {
|
||||
bool value = false;
|
||||
has_option_value(method, option, value);
|
||||
return value;
|
||||
}
|
||||
|
||||
bool CompilerOracle::should_exclude(methodHandle method, bool& quietly) {
|
||||
quietly = true;
|
||||
if (lists[ExcludeCommand] != NULL) {
|
||||
|
|
@ -420,19 +352,18 @@ bool CompilerOracle::should_exclude(methodHandle method, bool& quietly) {
|
|||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool CompilerOracle::should_inline(methodHandle method) {
|
||||
return (check_predicate(InlineCommand, method));
|
||||
}
|
||||
|
||||
|
||||
// Check both DontInlineCommand and ExcludeCommand here
|
||||
// - consistent behavior for all compilers
|
||||
bool CompilerOracle::should_not_inline(methodHandle method) {
|
||||
return (check_predicate(DontInlineCommand, method));
|
||||
return check_predicate(DontInlineCommand, method) || check_predicate(ExcludeCommand, method);
|
||||
}
|
||||
|
||||
|
||||
bool CompilerOracle::should_print(methodHandle method) {
|
||||
return (check_predicate(PrintCommand, method));
|
||||
return check_predicate(PrintCommand, method);
|
||||
}
|
||||
|
||||
bool CompilerOracle::should_print_methods() {
|
||||
|
|
@ -445,12 +376,10 @@ bool CompilerOracle::should_log(methodHandle method) {
|
|||
return (check_predicate(LogCommand, method));
|
||||
}
|
||||
|
||||
|
||||
bool CompilerOracle::should_break_at(methodHandle method) {
|
||||
return check_predicate(BreakCommand, method);
|
||||
}
|
||||
|
||||
|
||||
static OracleCommand parse_command_name(const char * line, int* bytes_read) {
|
||||
assert(ARRAY_SIZE(command_names) == OracleCommandCount,
|
||||
"command_names size mismatch");
|
||||
|
|
@ -516,84 +445,12 @@ static void usage() {
|
|||
tty->cr();
|
||||
};
|
||||
|
||||
// The JVM specification defines the allowed characters.
|
||||
// Tokens that are disallowed by the JVM specification can have
|
||||
// a meaning to the parser so we need to include them here.
|
||||
// The parser does not enforce all rules of the JVMS - a successful parse
|
||||
// does not mean that it is an allowed name. Illegal names will
|
||||
// be ignored since they never can match a class or method.
|
||||
//
|
||||
// '\0' and 0xf0-0xff are disallowed in constant string values
|
||||
// 0x20 ' ', 0x09 '\t' and, 0x2c ',' are used in the matching
|
||||
// 0x5b '[' and 0x5d ']' can not be used because of the matcher
|
||||
// 0x28 '(' and 0x29 ')' are used for the signature
|
||||
// 0x2e '.' is always replaced before the matching
|
||||
// 0x2f '/' is only used in the class name as package separator
|
||||
|
||||
#define RANGEBASE "\x1\x2\x3\x4\x5\x6\x7\x8\xa\xb\xc\xd\xe\xf" \
|
||||
"\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" \
|
||||
"\x21\x22\x23\x24\x25\x26\x27\x2a\x2b\x2c\x2d" \
|
||||
"\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f" \
|
||||
"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f" \
|
||||
"\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5c\x5e\x5f" \
|
||||
"\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f" \
|
||||
"\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f" \
|
||||
"\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f" \
|
||||
"\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f" \
|
||||
"\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf" \
|
||||
"\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf" \
|
||||
"\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf" \
|
||||
"\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf" \
|
||||
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef"
|
||||
|
||||
#define RANGE0 "[*" RANGEBASE "]"
|
||||
#define RANGESLASH "[*" RANGEBASE "/]"
|
||||
|
||||
static MethodMatcher::Mode check_mode(char name[], const char*& error_msg) {
|
||||
int match = MethodMatcher::Exact;
|
||||
while (name[0] == '*') {
|
||||
match |= MethodMatcher::Suffix;
|
||||
// Copy remaining string plus NUL to the beginning
|
||||
memmove(name, name + 1, strlen(name + 1) + 1);
|
||||
}
|
||||
|
||||
if (strcmp(name, "*") == 0) return MethodMatcher::Any;
|
||||
|
||||
size_t len = strlen(name);
|
||||
while (len > 0 && name[len - 1] == '*') {
|
||||
match |= MethodMatcher::Prefix;
|
||||
name[--len] = '\0';
|
||||
}
|
||||
|
||||
if (strstr(name, "*") != NULL) {
|
||||
error_msg = " Embedded * not allowed";
|
||||
return MethodMatcher::Unknown;
|
||||
}
|
||||
return (MethodMatcher::Mode)match;
|
||||
}
|
||||
|
||||
static bool scan_line(const char * line,
|
||||
char class_name[], MethodMatcher::Mode* c_mode,
|
||||
char method_name[], MethodMatcher::Mode* m_mode,
|
||||
int* bytes_read, const char*& error_msg) {
|
||||
*bytes_read = 0;
|
||||
error_msg = NULL;
|
||||
if (2 == sscanf(line, "%*[ \t]%255" RANGESLASH "%*[ ]" "%255" RANGE0 "%n", class_name, method_name, bytes_read)) {
|
||||
*c_mode = check_mode(class_name, error_msg);
|
||||
*m_mode = check_mode(method_name, error_msg);
|
||||
return *c_mode != MethodMatcher::Unknown && *m_mode != MethodMatcher::Unknown;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Scan next flag and value in line, return MethodMatcher object on success, NULL on failure.
|
||||
// On failure, error_msg contains description for the first error.
|
||||
// For future extensions: set error_msg on first error.
|
||||
static MethodMatcher* scan_flag_and_value(const char* type, const char* line, int& total_bytes_read,
|
||||
Symbol* c_name, MethodMatcher::Mode c_match,
|
||||
Symbol* m_name, MethodMatcher::Mode m_match,
|
||||
Symbol* signature,
|
||||
char* errorbuf, const int buf_size) {
|
||||
static void scan_flag_and_value(const char* type, const char* line, int& total_bytes_read,
|
||||
TypedMethodOptionMatcher* matcher,
|
||||
char* errorbuf, const int buf_size) {
|
||||
total_bytes_read = 0;
|
||||
int bytes_read = 0;
|
||||
char flag[256];
|
||||
|
|
@ -608,7 +465,8 @@ static MethodMatcher* scan_flag_and_value(const char* type, const char* line, in
|
|||
intx value;
|
||||
if (sscanf(line, "%*[ \t]" INTX_FORMAT "%n", &value, &bytes_read) == 1) {
|
||||
total_bytes_read += bytes_read;
|
||||
return add_option_string(c_name, c_match, m_name, m_match, signature, flag, value);
|
||||
add_option_string(matcher, flag, value);
|
||||
return;
|
||||
} else {
|
||||
jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s ", flag, type);
|
||||
}
|
||||
|
|
@ -616,7 +474,8 @@ static MethodMatcher* scan_flag_and_value(const char* type, const char* line, in
|
|||
uintx value;
|
||||
if (sscanf(line, "%*[ \t]" UINTX_FORMAT "%n", &value, &bytes_read) == 1) {
|
||||
total_bytes_read += bytes_read;
|
||||
return add_option_string(c_name, c_match, m_name, m_match, signature, flag, value);
|
||||
add_option_string(matcher, flag, value);
|
||||
return;
|
||||
} else {
|
||||
jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
|
||||
}
|
||||
|
|
@ -625,7 +484,8 @@ static MethodMatcher* scan_flag_and_value(const char* type, const char* line, in
|
|||
char* value = NEW_RESOURCE_ARRAY(char, strlen(line) + 1);
|
||||
if (sscanf(line, "%*[ \t]%255[_a-zA-Z0-9]%n", value, &bytes_read) == 1) {
|
||||
total_bytes_read += bytes_read;
|
||||
return add_option_string(c_name, c_match, m_name, m_match, signature, flag, (ccstr)value);
|
||||
add_option_string(matcher, flag, (ccstr)value);
|
||||
return;
|
||||
} else {
|
||||
jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
|
||||
}
|
||||
|
|
@ -646,7 +506,8 @@ static MethodMatcher* scan_flag_and_value(const char* type, const char* line, in
|
|||
next_value += bytes_read;
|
||||
end_value = next_value-1;
|
||||
}
|
||||
return add_option_string(c_name, c_match, m_name, m_match, signature, flag, (ccstr)value);
|
||||
add_option_string(matcher, flag, (ccstr)value);
|
||||
return;
|
||||
} else {
|
||||
jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
|
||||
}
|
||||
|
|
@ -655,10 +516,12 @@ static MethodMatcher* scan_flag_and_value(const char* type, const char* line, in
|
|||
if (sscanf(line, "%*[ \t]%255[a-zA-Z]%n", value, &bytes_read) == 1) {
|
||||
if (strcmp(value, "true") == 0) {
|
||||
total_bytes_read += bytes_read;
|
||||
return add_option_string(c_name, c_match, m_name, m_match, signature, flag, true);
|
||||
add_option_string(matcher, flag, true);
|
||||
return;
|
||||
} else if (strcmp(value, "false") == 0) {
|
||||
total_bytes_read += bytes_read;
|
||||
return add_option_string(c_name, c_match, m_name, m_match, signature, flag, false);
|
||||
add_option_string(matcher, flag, false);
|
||||
return;
|
||||
} else {
|
||||
jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
|
||||
}
|
||||
|
|
@ -673,7 +536,8 @@ static MethodMatcher* scan_flag_and_value(const char* type, const char* line, in
|
|||
char value[512] = "";
|
||||
jio_snprintf(value, sizeof(value), "%s.%s", buffer[0], buffer[1]);
|
||||
total_bytes_read += bytes_read;
|
||||
return add_option_string(c_name, c_match, m_name, m_match, signature, flag, atof(value));
|
||||
add_option_string(matcher, flag, atof(value));
|
||||
return;
|
||||
} else {
|
||||
jio_snprintf(errorbuf, buf_size, " Value cannot be read for flag %s of type %s", flag, type);
|
||||
}
|
||||
|
|
@ -683,7 +547,7 @@ static MethodMatcher* scan_flag_and_value(const char* type, const char* line, in
|
|||
} else {
|
||||
jio_snprintf(errorbuf, buf_size, " Flag name for type %s should be alphanumeric ", type);
|
||||
}
|
||||
return NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
int skip_whitespace(char* line) {
|
||||
|
|
@ -693,31 +557,20 @@ int skip_whitespace(char* line) {
|
|||
return whitespace_read;
|
||||
}
|
||||
|
||||
void CompilerOracle::print_parse_error(const char*& error_msg, char* original_line) {
|
||||
assert(error_msg != NULL, "Must have error_message");
|
||||
|
||||
ttyLocker ttyl;
|
||||
tty->print_cr("CompileCommand: An error occurred during parsing");
|
||||
tty->print_cr("Line: %s", original_line);
|
||||
tty->print_cr("Error: %s", error_msg);
|
||||
CompilerOracle::print_tip();
|
||||
}
|
||||
|
||||
void CompilerOracle::parse_from_line(char* line) {
|
||||
if (line[0] == '\0') return;
|
||||
if (line[0] == '#') return;
|
||||
|
||||
bool have_colon = (strstr(line, "::") != NULL);
|
||||
for (char* lp = line; *lp != '\0'; lp++) {
|
||||
// Allow '.' to separate the class name from the method name.
|
||||
// This is the preferred spelling of methods:
|
||||
// exclude java/lang/String.indexOf(I)I
|
||||
// Allow ',' for spaces (eases command line quoting).
|
||||
// exclude,java/lang/String.indexOf
|
||||
// For backward compatibility, allow space as separator also.
|
||||
// exclude java/lang/String indexOf
|
||||
// exclude,java/lang/String,indexOf
|
||||
// For easy cut-and-paste of method names, allow VM output format
|
||||
// as produced by Method::print_short_name:
|
||||
// exclude java.lang.String::indexOf
|
||||
// For simple implementation convenience here, convert them all to space.
|
||||
if (have_colon) {
|
||||
if (*lp == '.') *lp = '/'; // dots build the package prefix
|
||||
if (*lp == ':') *lp = ' ';
|
||||
}
|
||||
if (*lp == ',' || *lp == '.') *lp = ' ';
|
||||
}
|
||||
|
||||
char* original_line = line;
|
||||
int bytes_read;
|
||||
OracleCommand command = parse_command_name(line, &bytes_read);
|
||||
|
|
@ -742,109 +595,86 @@ void CompilerOracle::parse_from_line(char* line) {
|
|||
return;
|
||||
}
|
||||
|
||||
MethodMatcher::Mode c_match = MethodMatcher::Exact;
|
||||
MethodMatcher::Mode m_match = MethodMatcher::Exact;
|
||||
char class_name[256];
|
||||
char method_name[256];
|
||||
char sig[1024];
|
||||
char errorbuf[1024];
|
||||
const char* error_msg = NULL; // description of first error that appears
|
||||
MethodMatcher* match = NULL;
|
||||
const char* error_msg = NULL;
|
||||
if (command == OptionCommand) {
|
||||
// Look for trailing options.
|
||||
//
|
||||
// Two types of trailing options are
|
||||
// supported:
|
||||
//
|
||||
// (1) CompileCommand=option,Klass::method,flag
|
||||
// (2) CompileCommand=option,Klass::method,type,flag,value
|
||||
//
|
||||
// Type (1) is used to enable a boolean flag for a method.
|
||||
//
|
||||
// Type (2) is used to support options with a value. Values can have the
|
||||
// the following types: intx, uintx, bool, ccstr, ccstrlist, and double.
|
||||
//
|
||||
// For future extensions: extend scan_flag_and_value()
|
||||
|
||||
if (scan_line(line, class_name, &c_match, method_name, &m_match, &bytes_read, error_msg)) {
|
||||
EXCEPTION_MARK;
|
||||
Symbol* c_name = SymbolTable::new_symbol(class_name, CHECK);
|
||||
Symbol* m_name = SymbolTable::new_symbol(method_name, CHECK);
|
||||
Symbol* signature = NULL;
|
||||
|
||||
line += bytes_read;
|
||||
|
||||
// there might be a signature following the method.
|
||||
// signatures always begin with ( so match that by hand
|
||||
line += skip_whitespace(line);
|
||||
if (1 == sscanf(line, "(%254[[);/" RANGEBASE "]%n", sig + 1, &bytes_read)) {
|
||||
sig[0] = '(';
|
||||
line += bytes_read;
|
||||
signature = SymbolTable::new_symbol(sig, CHECK);
|
||||
char option[256]; // stores flag for Type (1) and type of Type (2)
|
||||
line++; // skip the ','
|
||||
TypedMethodOptionMatcher* archetype = TypedMethodOptionMatcher::parse_method_pattern(line, error_msg);
|
||||
if (archetype == NULL) {
|
||||
assert(error_msg != NULL, "Must have error_message");
|
||||
print_parse_error(error_msg, original_line);
|
||||
return;
|
||||
}
|
||||
|
||||
if (command == OptionCommand) {
|
||||
// Look for trailing options.
|
||||
//
|
||||
// Two types of trailing options are
|
||||
// supported:
|
||||
//
|
||||
// (1) CompileCommand=option,Klass::method,flag
|
||||
// (2) CompileCommand=option,Klass::method,type,flag,value
|
||||
//
|
||||
// Type (1) is used to enable a boolean flag for a method.
|
||||
//
|
||||
// Type (2) is used to support options with a value. Values can have the
|
||||
// the following types: intx, uintx, bool, ccstr, ccstrlist, and double.
|
||||
//
|
||||
// For future extensions: extend scan_flag_and_value()
|
||||
char option[256]; // stores flag for Type (1) and type of Type (2)
|
||||
line += skip_whitespace(line);
|
||||
|
||||
line += skip_whitespace(line);
|
||||
while (sscanf(line, "%255[a-zA-Z0-9]%n", option, &bytes_read) == 1) {
|
||||
if (match != NULL && !_quiet) {
|
||||
// Print out the last match added
|
||||
ttyLocker ttyl;
|
||||
tty->print("CompileCommand: %s ", command_names[command]);
|
||||
match->print();
|
||||
// This is unnecessarily complex. Should retire multi-option lines and skip while loop
|
||||
while (sscanf(line, "%255[a-zA-Z0-9]%n", option, &bytes_read) == 1) {
|
||||
line += bytes_read;
|
||||
|
||||
// typed_matcher is used as a blueprint for each option, deleted at the end
|
||||
TypedMethodOptionMatcher* typed_matcher = archetype->clone();
|
||||
if (strcmp(option, "intx") == 0
|
||||
|| strcmp(option, "uintx") == 0
|
||||
|| strcmp(option, "bool") == 0
|
||||
|| strcmp(option, "ccstr") == 0
|
||||
|| strcmp(option, "ccstrlist") == 0
|
||||
|| strcmp(option, "double") == 0
|
||||
) {
|
||||
char errorbuf[1024] = {0};
|
||||
// Type (2) option: parse flag name and value.
|
||||
scan_flag_and_value(option, line, bytes_read, typed_matcher, errorbuf, sizeof(errorbuf));
|
||||
if (*errorbuf != '\0') {
|
||||
error_msg = errorbuf;
|
||||
print_parse_error(error_msg, original_line);
|
||||
return;
|
||||
}
|
||||
line += bytes_read;
|
||||
} else {
|
||||
// Type (1) option
|
||||
add_option_string(typed_matcher, option, true);
|
||||
}
|
||||
if (typed_matcher != NULL && !_quiet) {
|
||||
// Print out the last match added
|
||||
assert(error_msg == NULL, "No error here");
|
||||
ttyLocker ttyl;
|
||||
tty->print("CompileCommand: %s ", command_names[command]);
|
||||
typed_matcher->print();
|
||||
}
|
||||
line += skip_whitespace(line);
|
||||
} // while(
|
||||
delete archetype;
|
||||
} else { // not an OptionCommand)
|
||||
assert(error_msg == NULL, "Don't call here with error_msg already set");
|
||||
|
||||
if (strcmp(option, "intx") == 0
|
||||
|| strcmp(option, "uintx") == 0
|
||||
|| strcmp(option, "bool") == 0
|
||||
|| strcmp(option, "ccstr") == 0
|
||||
|| strcmp(option, "ccstrlist") == 0
|
||||
|| strcmp(option, "double") == 0
|
||||
) {
|
||||
|
||||
// Type (2) option: parse flag name and value.
|
||||
match = scan_flag_and_value(option, line, bytes_read,
|
||||
c_name, c_match, m_name, m_match, signature,
|
||||
errorbuf, sizeof(errorbuf));
|
||||
if (match == NULL) {
|
||||
error_msg = errorbuf;
|
||||
break;
|
||||
}
|
||||
line += bytes_read;
|
||||
} else {
|
||||
// Type (1) option
|
||||
match = add_option_string(c_name, c_match, m_name, m_match, signature, option, true);
|
||||
}
|
||||
line += skip_whitespace(line);
|
||||
} // while(
|
||||
} else {
|
||||
match = add_predicate(command, c_name, c_match, m_name, m_match, signature);
|
||||
}
|
||||
}
|
||||
|
||||
ttyLocker ttyl;
|
||||
if (error_msg != NULL) {
|
||||
// an error has happened
|
||||
tty->print_cr("CompileCommand: An error occured during parsing");
|
||||
tty->print_cr(" \"%s\"", original_line);
|
||||
BasicMatcher* matcher = BasicMatcher::parse_method_pattern(line, error_msg);
|
||||
if (error_msg != NULL) {
|
||||
tty->print_cr("%s", error_msg);
|
||||
assert(matcher == NULL, "consistency");
|
||||
print_parse_error(error_msg, original_line);
|
||||
return;
|
||||
}
|
||||
CompilerOracle::print_tip();
|
||||
|
||||
} else {
|
||||
// check for remaining characters
|
||||
bytes_read = 0;
|
||||
sscanf(line, "%*[ \t]%n", &bytes_read);
|
||||
if (line[bytes_read] != '\0') {
|
||||
tty->print_cr("CompileCommand: Bad pattern");
|
||||
tty->print_cr(" \"%s\"", original_line);
|
||||
tty->print_cr(" Unrecognized text %s after command ", line);
|
||||
CompilerOracle::print_tip();
|
||||
} else if (match != NULL && !_quiet) {
|
||||
add_predicate(command, matcher);
|
||||
if (!_quiet) {
|
||||
ttyLocker ttyl;
|
||||
tty->print("CompileCommand: %s ", command_names[command]);
|
||||
match->print();
|
||||
matcher->print(tty);
|
||||
tty->cr();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1045,10 +875,12 @@ void CompilerOracle::parse_compile_only(char * line) {
|
|||
Symbol* m_name = SymbolTable::new_symbol(methodName, CHECK);
|
||||
Symbol* signature = NULL;
|
||||
|
||||
add_predicate(CompileOnlyCommand, c_name, c_match, m_name, m_match, signature);
|
||||
BasicMatcher* bm = new BasicMatcher();
|
||||
bm->init(c_name, c_match, m_name, m_match, signature);
|
||||
add_predicate(CompileOnlyCommand, bm);
|
||||
if (PrintVMOptions) {
|
||||
tty->print("CompileOnly: compileonly ");
|
||||
lists[CompileOnlyCommand]->print();
|
||||
lists[CompileOnlyCommand]->print_all(tty);
|
||||
}
|
||||
|
||||
className = NULL;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue