0N/A

1879N/A#include "precompiled.hpp"

1879N/A#include "classfile/vmSymbols.hpp"

1879N/A#include "memory/oopFactory.hpp"

1879N/A#include "oops/oop.inline.hpp"

1879N/A#include "runtime/handles.inline.hpp"

1879N/A#include "utilities/xmlstream.hpp"

0N/A

0N/A

2062N/ASymbol* vmSymbols::_symbols[vmSymbols::SID_LIMIT];

0N/A

2062N/ASymbol* vmSymbols::_type_signatures[T_VOID+1] = { NULL /*, NULL...*/ };

0N/A

2062N/Ainline int compare_symbol(Symbol* a, Symbol* b) {

0N/A if (a == b) return 0;

0N/A // follow the natural address order:

0N/A return (address)a > (address)b ? +1 : -1;

0N/A}

0N/A

0N/Astatic vmSymbols::SID vm_symbol_index[vmSymbols::SID_LIMIT];

0N/Aextern "C" {

0N/A static int compare_vmsymbol_sid(const void* void_a, const void* void_b) {

2062N/A Symbol* a = vmSymbols::symbol_at(*((vmSymbols::SID*) void_a));

2062N/A Symbol* b = vmSymbols::symbol_at(*((vmSymbols::SID*) void_b));

0N/A return compare_symbol(a, b);

0N/A }

0N/A}

0N/A

0N/A#ifndef PRODUCT

0N/A#define VM_SYMBOL_ENUM_NAME_BODY(name, string) #name "\0"

0N/Astatic const char* vm_symbol_enum_names =

0N/A VM_SYMBOLS_DO(VM_SYMBOL_ENUM_NAME_BODY, VM_ALIAS_IGNORE)

0N/A "\0";

0N/Astatic const char* vm_symbol_enum_name(vmSymbols::SID sid) {

0N/A const char* string = &vm_symbol_enum_names[0];

0N/A int skip = (int)sid - (int)vmSymbols::FIRST_SID;

0N/A for (; skip != 0; skip--) {

0N/A size_t skiplen = strlen(string);

0N/A if (skiplen == 0) return "<unknown>"; // overflow

0N/A string += skiplen+1;

0N/A }

0N/A return string;

0N/A}

0N/A#endif //PRODUCT

0N/A

0N/A#define VM_SYMBOL_BODY(name, string) string "\0"

0N/Astatic const char* vm_symbol_bodies = VM_SYMBOLS_DO(VM_SYMBOL_BODY, VM_ALIAS_IGNORE);

0N/A

0N/Avoid vmSymbols::initialize(TRAPS) {

0N/A assert((int)SID_LIMIT <= (1<<log2_SID_LIMIT), "must fit in this bitfield");

0N/A assert((int)SID_LIMIT*5 > (1<<log2_SID_LIMIT), "make the bitfield smaller, please");

1133N/A assert(vmIntrinsics::FLAG_LIMIT <= (1 << vmIntrinsics::log2_FLAG_LIMIT), "must fit in this bitfield");

0N/A

0N/A if (!UseSharedSpaces) {

0N/A const char* string = &vm_symbol_bodies[0];

0N/A for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {

3650N/A Symbol* sym = SymbolTable::new_permanent_symbol(string, CHECK);

0N/A _symbols[index] = sym;

0N/A string += strlen(string); // skip string body

0N/A string += 1; // skip trailing null

0N/A }

0N/A

0N/A _type_signatures[T_BYTE] = byte_signature();

0N/A _type_signatures[T_CHAR] = char_signature();

0N/A _type_signatures[T_DOUBLE] = double_signature();

0N/A _type_signatures[T_FLOAT] = float_signature();

0N/A _type_signatures[T_INT] = int_signature();

0N/A _type_signatures[T_LONG] = long_signature();

0N/A _type_signatures[T_SHORT] = short_signature();

0N/A _type_signatures[T_BOOLEAN] = bool_signature();

0N/A _type_signatures[T_VOID] = void_signature();

0N/A // no single signatures for T_OBJECT or T_ARRAY

0N/A }

0N/A

0N/A#ifdef ASSERT

0N/A // Check for duplicates:

0N/A for (int i1 = (int)FIRST_SID; i1 < (int)SID_LIMIT; i1++) {

2062N/A Symbol* sym = symbol_at((SID)i1);

0N/A for (int i2 = (int)FIRST_SID; i2 < i1; i2++) {

0N/A if (symbol_at((SID)i2) == sym) {

0N/A tty->print("*** Duplicate VM symbol SIDs %s(%d) and %s(%d): \"",

0N/A vm_symbol_enum_name((SID)i2), i2,

0N/A vm_symbol_enum_name((SID)i1), i1);

0N/A sym->print_symbol_on(tty);

0N/A tty->print_cr("\"");

0N/A }

0N/A }

0N/A }

0N/A#endif //ASSERT

0N/A

0N/A // Create an index for find_id:

0N/A {

0N/A for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {

0N/A vm_symbol_index[index] = (SID)index;

0N/A }

0N/A int num_sids = SID_LIMIT-FIRST_SID;

0N/A qsort(&vm_symbol_index[FIRST_SID], num_sids, sizeof(vm_symbol_index[0]),

0N/A compare_vmsymbol_sid);

0N/A }

0N/A

0N/A#ifdef ASSERT

0N/A {

0N/A // Spot-check correspondence between strings, symbols, and enums:

0N/A assert(_symbols[NO_SID] == NULL, "must be");

0N/A const char* str = "java/lang/Object";

3650N/A TempNewSymbol jlo = SymbolTable::new_permanent_symbol(str, CHECK);

2062N/A assert(strncmp(str, (char*)jlo->base(), jlo->utf8_length()) == 0, "");

2062N/A assert(jlo == java_lang_Object(), "");

0N/A SID sid = VM_SYMBOL_ENUM_NAME(java_lang_Object);

2062N/A assert(find_sid(jlo) == sid, "");

2062N/A assert(symbol_at(sid) == jlo, "");

0N/A

0N/A // Make sure find_sid produces the right answer in each case.

0N/A for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {

2062N/A Symbol* sym = symbol_at((SID)index);

0N/A sid = find_sid(sym);

0N/A assert(sid == (SID)index, "symbol index works");

0N/A // Note: If there are duplicates, this assert will fail.

0N/A // A "Duplicate VM symbol" message will have already been printed.

0N/A }

0N/A

0N/A // The string "format" happens (at the moment) not to be a vmSymbol,

0N/A // though it is a method name in java.lang.String.

0N/A str = "format";

3650N/A TempNewSymbol fmt = SymbolTable::new_permanent_symbol(str, CHECK);

2062N/A sid = find_sid(fmt);

0N/A assert(sid == NO_SID, "symbol index works (negative test)");

0N/A }

0N/A#endif

0N/A}

0N/A

0N/A

0N/A#ifndef PRODUCT

0N/Aconst char* vmSymbols::name_for(vmSymbols::SID sid) {

0N/A if (sid == NO_SID)

0N/A return "NO_SID";

0N/A const char* string = &vm_symbol_bodies[0];

0N/A for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {

0N/A if (index == (int)sid)

0N/A return string;

0N/A string += strlen(string); // skip string body

0N/A string += 1; // skip trailing null

0N/A }

0N/A return "BAD_SID";

0N/A}

0N/A#endif

0N/A

0N/A

0N/A

2062N/Avoid vmSymbols::symbols_do(SymbolClosure* f) {

0N/A for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {

2062N/A f->do_symbol(&_symbols[index]);

0N/A }

0N/A for (int i = 0; i < T_VOID+1; i++) {

2062N/A f->do_symbol(&_type_signatures[i]);

0N/A }

0N/A}

0N/A

2062N/Avoid vmSymbols::serialize(SerializeOopClosure* soc) {

2062N/A soc->do_region((u_char*)&_symbols[FIRST_SID],

2062N/A (SID_LIMIT - FIRST_SID) * sizeof(_symbols[0]));

2062N/A soc->do_region((u_char*)_type_signatures, sizeof(_type_signatures));

2062N/A}

0N/A

2062N/A

2062N/ABasicType vmSymbols::signature_type(Symbol* s) {

0N/A assert(s != NULL, "checking");

0N/A for (int i = T_BOOLEAN; i < T_VOID+1; i++) {

0N/A if (s == _type_signatures[i]) {

0N/A return (BasicType)i;

0N/A }

0N/A }

0N/A return T_OBJECT;

0N/A}

0N/A

0N/A

0N/Astatic int mid_hint = (int)vmSymbols::FIRST_SID+1;

0N/A

0N/A#ifndef PRODUCT

0N/Astatic int find_sid_calls, find_sid_probes;

0N/A#endif

0N/A

2062N/AvmSymbols::SID vmSymbols::find_sid(Symbol* symbol) {

0N/A // Handle the majority of misses by a bounds check.

0N/A // Then, use a binary search over the index.

0N/A // Expected trip count is less than log2_SID_LIMIT, about eight.

0N/A // This is slow but acceptable, given that calls are not

0N/A // dynamically common. (methodOop::intrinsic_id has a cache.)

0N/A NOT_PRODUCT(find_sid_calls++);

0N/A int min = (int)FIRST_SID, max = (int)SID_LIMIT - 1;

0N/A SID sid = NO_SID, sid1;

0N/A int cmp1;

0N/A sid1 = vm_symbol_index[min];

0N/A cmp1 = compare_symbol(symbol, symbol_at(sid1));

0N/A if (cmp1 <= 0) { // before the first

0N/A if (cmp1 == 0) sid = sid1;

0N/A } else {

0N/A sid1 = vm_symbol_index[max];

0N/A cmp1 = compare_symbol(symbol, symbol_at(sid1));

0N/A if (cmp1 >= 0) { // after the last

0N/A if (cmp1 == 0) sid = sid1;

0N/A } else {

0N/A // After checking the extremes, do a binary search.

0N/A ++min; --max; // endpoints are done

0N/A int mid = mid_hint; // start at previous success

0N/A while (max >= min) {

0N/A assert(mid >= min && mid <= max, "");

0N/A NOT_PRODUCT(find_sid_probes++);

0N/A sid1 = vm_symbol_index[mid];

0N/A cmp1 = compare_symbol(symbol, symbol_at(sid1));

0N/A if (cmp1 == 0) {

0N/A mid_hint = mid;

0N/A sid = sid1;

0N/A break;

0N/A }

0N/A if (cmp1 < 0)

0N/A max = mid - 1; // symbol < symbol_at(sid)

0N/A else

0N/A min = mid + 1;

0N/A

0N/A // Pick a new probe point:

0N/A mid = (max + min) / 2;

0N/A }

0N/A }

0N/A }

0N/A

0N/A#ifdef ASSERT

0N/A // Perform the exhaustive self-check the first 1000 calls,

0N/A // and every 100 calls thereafter.

0N/A static int find_sid_check_count = -2000;

0N/A if ((uint)++find_sid_check_count > (uint)100) {

0N/A if (find_sid_check_count > 0) find_sid_check_count = 0;

0N/A

0N/A // Make sure this is the right answer, using linear search.

0N/A // (We have already proven that there are no duplicates in the list.)

0N/A SID sid2 = NO_SID;

0N/A for (int index = (int)FIRST_SID; index < (int)SID_LIMIT; index++) {

2062N/A Symbol* sym2 = symbol_at((SID)index);

0N/A if (sym2 == symbol) {

0N/A sid2 = (SID)index;

0N/A break;

0N/A }

0N/A }

0N/A // Unless it's a duplicate, assert that the sids are the same.

0N/A if (_symbols[sid] != _symbols[sid2]) {

0N/A assert(sid == sid2, "binary same as linear search");

0N/A }

0N/A }

0N/A#endif //ASSERT

0N/A

0N/A return sid;

0N/A}

0N/A

2203N/AvmSymbols::SID vmSymbols::find_sid(const char* symbol_name) {

2203N/A Symbol* symbol = SymbolTable::probe(symbol_name, (int) strlen(symbol_name));

2203N/A if (symbol == NULL) return NO_SID;

2203N/A return find_sid(symbol);

2203N/A}

2203N/A

1133N/Astatic vmIntrinsics::ID wrapper_intrinsic(BasicType type, bool unboxing) {

1133N/A#define TYPE2(type, unboxing) ((int)(type)*2 + ((unboxing) ? 1 : 0))

1133N/A switch (TYPE2(type, unboxing)) {

1133N/A#define BASIC_TYPE_CASE(type, box, unbox) \

1133N/A case TYPE2(type, false): return vmIntrinsics::box; \

1133N/A case TYPE2(type, true): return vmIntrinsics::unbox

1133N/A BASIC_TYPE_CASE(T_BOOLEAN, _Boolean_valueOf, _booleanValue);

1133N/A BASIC_TYPE_CASE(T_BYTE, _Byte_valueOf, _byteValue);

1133N/A BASIC_TYPE_CASE(T_CHAR, _Character_valueOf, _charValue);

1133N/A BASIC_TYPE_CASE(T_SHORT, _Short_valueOf, _shortValue);

1133N/A BASIC_TYPE_CASE(T_INT, _Integer_valueOf, _intValue);

1133N/A BASIC_TYPE_CASE(T_LONG, _Long_valueOf, _longValue);

1133N/A BASIC_TYPE_CASE(T_FLOAT, _Float_valueOf, _floatValue);

1133N/A BASIC_TYPE_CASE(T_DOUBLE, _Double_valueOf, _doubleValue);

1133N/A#undef BASIC_TYPE_CASE

1133N/A }

1133N/A#undef TYPE2

1133N/A return vmIntrinsics::_none;

1133N/A}

1133N/A

1133N/AvmIntrinsics::ID vmIntrinsics::for_boxing(BasicType type) {

1133N/A return wrapper_intrinsic(type, false);

1133N/A}

1133N/AvmIntrinsics::ID vmIntrinsics::for_unboxing(BasicType type) {

1133N/A return wrapper_intrinsic(type, true);

1133N/A}

1133N/A

1138N/AvmIntrinsics::ID vmIntrinsics::for_raw_conversion(BasicType src, BasicType dest) {

1138N/A#define SRC_DEST(s,d) (((int)(s) << 4) + (int)(d))

1138N/A switch (SRC_DEST(src, dest)) {

1138N/A case SRC_DEST(T_INT, T_FLOAT): return vmIntrinsics::_intBitsToFloat;

1138N/A case SRC_DEST(T_FLOAT, T_INT): return vmIntrinsics::_floatToRawIntBits;

1138N/A

1138N/A case SRC_DEST(T_LONG, T_DOUBLE): return vmIntrinsics::_longBitsToDouble;

1138N/A case SRC_DEST(T_DOUBLE, T_LONG): return vmIntrinsics::_doubleToRawLongBits;

1138N/A }

1138N/A#undef SRC_DEST

1138N/A

1138N/A return vmIntrinsics::_none;

1138N/A}

1138N/A

0N/A

0N/A#define VM_INTRINSIC_INITIALIZE(id, klass, name, sig, flags) #id "\0"

0N/Astatic const char* vm_intrinsic_name_bodies =

0N/A VM_INTRINSICS_DO(VM_INTRINSIC_INITIALIZE,

0N/A VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);

0N/A

0N/Astatic const char* vm_intrinsic_name_table[vmIntrinsics::ID_LIMIT];

0N/A

0N/Aconst char* vmIntrinsics::name_at(vmIntrinsics::ID id) {

0N/A const char** nt = &vm_intrinsic_name_table[0];

0N/A if (nt[_none] == NULL) {

0N/A char* string = (char*) &vm_intrinsic_name_bodies[0];

0N/A for (int index = FIRST_ID; index < ID_LIMIT; index++) {

0N/A nt[index] = string;

0N/A string += strlen(string); // skip string body

0N/A string += 1; // skip trailing null

0N/A }

0N/A assert(!strcmp(nt[_hashCode], "_hashCode"), "lined up");

0N/A nt[_none] = "_none";

0N/A }

0N/A if ((uint)id < (uint)ID_LIMIT)

0N/A return vm_intrinsic_name_table[(uint)id];

0N/A else

0N/A return "(unknown intrinsic)";

0N/A}

0N/A

0N/Ainline bool match_F_R(jshort flags) {

0N/A const int req = 0;

0N/A const int neg = JVM_ACC_STATIC | JVM_ACC_SYNCHRONIZED;

0N/A return (flags & (req | neg)) == req;

0N/A}

1080N/Ainline bool match_F_Y(jshort flags) {

1080N/A const int req = JVM_ACC_SYNCHRONIZED;

1080N/A const int neg = JVM_ACC_STATIC;

1080N/A return (flags & (req | neg)) == req;

1080N/A}

0N/Ainline bool match_F_RN(jshort flags) {

0N/A const int req = JVM_ACC_NATIVE;

0N/A const int neg = JVM_ACC_STATIC | JVM_ACC_SYNCHRONIZED;

0N/A return (flags & (req | neg)) == req;

0N/A}

0N/Ainline bool match_F_S(jshort flags) {

0N/A const int req = JVM_ACC_STATIC;

0N/A const int neg = JVM_ACC_SYNCHRONIZED;

0N/A return (flags & (req | neg)) == req;

0N/A}

0N/Ainline bool match_F_SN(jshort flags) {

0N/A const int req = JVM_ACC_STATIC | JVM_ACC_NATIVE;

0N/A const int neg = JVM_ACC_SYNCHRONIZED;

0N/A return (flags & (req | neg)) == req;

0N/A}

45N/Ainline bool match_F_RNY(jshort flags) {

45N/A const int req = JVM_ACC_NATIVE | JVM_ACC_SYNCHRONIZED;

45N/A const int neg = JVM_ACC_STATIC;

45N/A return (flags & (req | neg)) == req;

45N/A}

0N/A

1133N/A#define ID3(x, y, z) (( jlong)(z) + \

1133N/A ((jlong)(y) << vmSymbols::log2_SID_LIMIT) + \

1133N/A ((jlong)(x) << (2*vmSymbols::log2_SID_LIMIT)) )

0N/A#define SID_ENUM(n) vmSymbols::VM_SYMBOL_ENUM_NAME(n)

0N/A

1133N/AvmIntrinsics::ID vmIntrinsics::find_id_impl(vmSymbols::SID holder,

1133N/A vmSymbols::SID name,

1133N/A vmSymbols::SID sig,

1133N/A jshort flags) {

0N/A assert((int)vmSymbols::SID_LIMIT <= (1<<vmSymbols::log2_SID_LIMIT), "must fit");

0N/A

0N/A // Let the C compiler build the decision tree.

0N/A

0N/A#define VM_INTRINSIC_CASE(id, klass, name, sig, fcode) \

0N/A case ID3(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig)): \

0N/A if (!match_##fcode(flags)) break; \

0N/A return id;

0N/A

0N/A switch (ID3(holder, name, sig)) {

0N/A VM_INTRINSICS_DO(VM_INTRINSIC_CASE,

0N/A VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);

0N/A }

0N/A return vmIntrinsics::_none;

0N/A

0N/A#undef VM_INTRINSIC_CASE

0N/A}

0N/A

0N/A

0N/Aconst char* vmIntrinsics::short_name_as_C_string(vmIntrinsics::ID id, char* buf, int buflen) {

0N/A const char* str = name_at(id);

0N/A#ifndef PRODUCT

0N/A const char* kname = vmSymbols::name_for(class_for(id));

0N/A const char* mname = vmSymbols::name_for(name_for(id));

0N/A const char* sname = vmSymbols::name_for(signature_for(id));

0N/A const char* fname = "";

0N/A switch (flags_for(id)) {

1080N/A case F_Y: fname = "synchronized "; break;

0N/A case F_RN: fname = "native "; break;

0N/A case F_SN: fname = "native static "; break;

0N/A case F_S: fname = "static "; break;

45N/A case F_RNY:fname = "native synchronized "; break;

0N/A }

0N/A const char* kptr = strrchr(kname, '/');

0N/A if (kptr != NULL) kname = kptr + 1;

0N/A int len = jio_snprintf(buf, buflen, "%s: %s%s.%s%s",

0N/A str, fname, kname, mname, sname);

0N/A if (len < buflen)

0N/A str = buf;

0N/A#endif //PRODUCT

0N/A return str;

0N/A}

0N/A

0N/A

1133N/A

1133N/A#define ID4(x, y, z, f) ((ID3(x, y, z) << vmIntrinsics::log2_FLAG_LIMIT) | (jlong) (f))

1133N/A

1133N/Astatic const jlong intrinsic_info_array[vmIntrinsics::ID_LIMIT+1] = {

1133N/A#define VM_INTRINSIC_INFO(ignore_id, klass, name, sig, fcode) \

1133N/A ID4(SID_ENUM(klass), SID_ENUM(name), SID_ENUM(sig), vmIntrinsics::fcode),

1133N/A

1133N/A 0, VM_INTRINSICS_DO(VM_INTRINSIC_INFO,

1133N/A VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE)

1133N/A 0

1133N/A#undef VM_INTRINSIC_INFO

1133N/A};

1133N/A

1133N/Ainline jlong intrinsic_info(vmIntrinsics::ID id) {

1133N/A return intrinsic_info_array[vmIntrinsics::ID_from((int)id)];

1133N/A}

0N/A

0N/AvmSymbols::SID vmIntrinsics::class_for(vmIntrinsics::ID id) {

1133N/A jlong info = intrinsic_info(id);

1133N/A int shift = 2*vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);

1133N/A assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1021, "");

1133N/A return vmSymbols::SID( (info >> shift) & mask );

0N/A}

0N/A

0N/AvmSymbols::SID vmIntrinsics::name_for(vmIntrinsics::ID id) {

1133N/A jlong info = intrinsic_info(id);

1133N/A int shift = vmSymbols::log2_SID_LIMIT + log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);

1133N/A assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1022, "");

1133N/A return vmSymbols::SID( (info >> shift) & mask );

0N/A}

0N/A

0N/AvmSymbols::SID vmIntrinsics::signature_for(vmIntrinsics::ID id) {

1133N/A jlong info = intrinsic_info(id);

1133N/A int shift = log2_FLAG_LIMIT, mask = right_n_bits(vmSymbols::log2_SID_LIMIT);

1133N/A assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 1023, "");

1133N/A return vmSymbols::SID( (info >> shift) & mask );

0N/A}

0N/A

0N/AvmIntrinsics::Flags vmIntrinsics::flags_for(vmIntrinsics::ID id) {

1133N/A jlong info = intrinsic_info(id);

1133N/A int shift = 0, mask = right_n_bits(log2_FLAG_LIMIT);

1133N/A assert(((ID4(1021,1022,1023,15) >> shift) & mask) == 15, "");

1133N/A return Flags( (info >> shift) & mask );

0N/A}

0N/A

0N/A

0N/A#ifndef PRODUCT

0N/A

2062N/Astatic bool match_method(methodOop m, Symbol* n, Symbol* s) {

0N/A return (m->name() == n &&

0N/A m->signature() == s);

0N/A}

0N/A

2062N/Astatic vmIntrinsics::ID match_method_with_klass(methodOop m, Symbol* mk) {

0N/A#define VM_INTRINSIC_MATCH(id, klassname, namepart, sigpart, flags) \

2062N/A { Symbol* k = vmSymbols::klassname(); \

0N/A if (mk == k) { \

2062N/A Symbol* n = vmSymbols::namepart(); \

2062N/A Symbol* s = vmSymbols::sigpart(); \

0N/A if (match_method(m, n, s)) \

0N/A return vmIntrinsics::id; \

0N/A } }

0N/A VM_INTRINSICS_DO(VM_INTRINSIC_MATCH,

0N/A VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_SYMBOL_IGNORE, VM_ALIAS_IGNORE);

0N/A return vmIntrinsics::_none;

0N/A#undef VM_INTRINSIC_MATCH

0N/A}

0N/A

0N/Avoid vmIntrinsics::verify_method(ID actual_id, methodOop m) {

2062N/A Symbol* mk = Klass::cast(m->method_holder())->name();

0N/A ID declared_id = match_method_with_klass(m, mk);

0N/A

0N/A if (declared_id == actual_id) return; // success

0N/A

0N/A if (declared_id == _none && actual_id != _none && mk == vmSymbols::java_lang_StrictMath()) {

0N/A // Here are a few special cases in StrictMath not declared in vmSymbols.hpp.

0N/A switch (actual_id) {

0N/A case _min:

0N/A case _max:

0N/A case _dsqrt:

0N/A declared_id = match_method_with_klass(m, vmSymbols::java_lang_Math());

0N/A if (declared_id == actual_id) return; // acceptable alias

0N/A break;

0N/A }

0N/A }

0N/A

0N/A const char* declared_name = name_at(declared_id);

0N/A const char* actual_name = name_at(actual_id);

0N/A methodHandle mh = m;

0N/A m = NULL;

0N/A ttyLocker ttyl;

0N/A if (xtty != NULL) {

0N/A xtty->begin_elem("intrinsic_misdeclared actual='%s' declared='%s'",

0N/A actual_name, declared_name);

0N/A xtty->method(mh);

0N/A xtty->end_elem("");

0N/A }

0N/A if (PrintMiscellaneous && (WizardMode || Verbose)) {

0N/A tty->print_cr("*** misidentified method; %s(%d) should be %s(%d):",

0N/A declared_name, declared_id, actual_name, actual_id);

45N/A mh()->print_short_name(tty);

0N/A tty->cr();

0N/A }

0N/A}

0N/A#endif //PRODUCT