Index: vm/include/jit_runtime_support.h =================================================================== --- vm/include/jit_runtime_support.h (revision 583684) +++ vm/include/jit_runtime_support.h (working copy) @@ -29,7 +29,7 @@ * of those function. * * If changes are made to enum VM_RT_SUPPORT below, the list of - * JIT support functions in vm_stats.cpp must also be changed. + * descriptions in tr_helper_info.cpp must also be changed. */ #ifdef __cplusplus @@ -39,6 +39,9 @@ typedef enum VM_RT_SUPPORT { +/** Void id marker */ + VM_RT_UNKNOWN=0, + /** * Object creation routines. */ @@ -701,6 +704,14 @@ } VM_RT_SUPPORT; +/** +* VM RT helpers have different calling conventions. +*/ +enum HELPER_CALLING_CONVENTION { + CALLING_CONVENTION_DRL = 0, + CALLING_CONVENTION_STDCALL, + CALLING_CONVENTION_CDECL, +}; /** * VM RT helpers can be interrupted differently. @@ -746,10 +757,18 @@ /** * Checks if helper is a suspension point */ - VMEXPORT HELPER_INTERRUPTIBILITY_KIND vm_helper_get_interruptibility_kind(VM_RT_SUPPORT f); +VMEXPORT HELPER_CALLING_CONVENTION vm_helper_get_calling_convention(VM_RT_SUPPORT f); +VMEXPORT const char* vm_helper_get_name(VM_RT_SUPPORT id); +/** +* Returns Id of runtime helper by its string representation. +* Name comparison is case-insensitive. +* If the helperName is unknown, then VM_RT_UNKNOWN is returned. +*/ +VMEXPORT VM_RT_SUPPORT vm_helper_get_by_name(const char* name); + #ifdef __cplusplus } #endif // __cplusplus Index: vm/vmcore/include/vm_stats.h =================================================================== --- vm/vmcore/include/vm_stats.h (revision 583684) +++ vm/vmcore/include/vm_stats.h (working copy) @@ -241,7 +241,6 @@ uint64 total_hot_statics_bytes; uint64 total_hot_vtable_bytes; - SimpleHashtable rt_function_map; SimpleHashtable rt_function_requests; SimpleHashtable rt_function_calls; Index: vm/vmcore/src/jit/rt_helper_info.cpp =================================================================== --- vm/vmcore/src/jit/rt_helper_info.cpp (revision 0) +++ vm/vmcore/src/jit/rt_helper_info.cpp (revision 0) @@ -0,0 +1,313 @@ +/* +* Licensed to the Apache Software Foundation (ASF) under one or more +* contributor license agreements. See the NOTICE file distributed with +* this work for additional information regarding copyright ownership. +* The ASF licenses this file to You under the Apache License, Version 2.0 +* (the "License"); you may not use this file except in compliance with +* the License. You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#define LOG_DOMAIN "vm.helpers" +#include "cxxlog.h" +#include "jit_runtime_support.h" +#include + +#ifndef _WIN32 + #define strcmpi strcasecmp +#endif + +// TODO: consider including calling convention and interruptibility_kind info here as well? +struct JIT_RT_Function_Entry { + VM_RT_SUPPORT function; + const char *function_name; + int number_of_args; +}; +// Only name is used currently, so just keep it directly +typedef std::map HelperInfoMap; + +static JIT_RT_Function_Entry _jit_rt_function_entries_base[] = { + {VM_RT_UNKNOWN, "VM_RT_UNKNOWN", 0}, + {VM_RT_NEW_RESOLVED_USING_VTABLE_AND_SIZE, "VM_RT_NEW_RESOLVED_USING_VTABLE_AND_SIZE", 2}, + {VM_RT_NEW_VECTOR_USING_VTABLE, "VM_RT_NEW_VECTOR_USING_VTABLE", 2}, + {VM_RT_MULTIANEWARRAY_RESOLVED, "VM_RT_MULTIANEWARRAY_RESOLVED", 8}, + {VM_RT_LDC_STRING, "VM_RT_LDC_STRING", 2}, + + {VM_RT_THROW, "VM_RT_THROW", 1}, + {VM_RT_THROW_LAZY, "VM_RT_THROW_LAZY", 8}, + {VM_RT_IDX_OUT_OF_BOUNDS, "VM_RT_IDX_OUT_OF_BOUNDS", 0}, + {VM_RT_NULL_PTR_EXCEPTION, "VM_RT_NULL_PTR_EXCEPTION", 0}, + {VM_RT_DIVIDE_BY_ZERO_EXCEPTION, "VM_RT_DIVIDE_BY_ZERO_EXCEPTION", 0}, + {VM_RT_ARRAY_STORE_EXCEPTION, "VM_RT_ARRAY_STORE_EXCEPTION", 0}, + {VM_RT_THROW_LINKING_EXCEPTION, "VM_RT_THROW_LINKING_EXCEPTION", 0}, + {VM_RT_THROW_SET_STACK_TRACE, "VM_RT_THROW_SET_STACK_TRACE", 1}, + + {VM_RT_MONITOR_ENTER, "VM_RT_MONITOR_ENTER", 1}, + {VM_RT_MONITOR_ENTER_NON_NULL, "VM_RT_MONITOR_ENTER_NON_NULL", 1}, + {VM_RT_MONITOR_EXIT, "VM_RT_MONITOR_EXIT", 1}, + {VM_RT_MONITOR_EXIT_NON_NULL, "VM_RT_MONITOR_EXIT_NON_NULL", 1}, + {VM_RT_MONITOR_ENTER_STATIC, "VM_RT_MONITOR_ENTER_STATIC", 1}, + {VM_RT_MONITOR_EXIT_STATIC, "VM_RT_MONITOR_EXIT_STATIC", 1}, + + {VM_RT_CHECKCAST, "VM_RT_CHECKCAST", 2}, + {VM_RT_INSTANCEOF, "VM_RT_INSTANCEOF", 2}, + {VM_RT_AASTORE, "VM_RT_AASTORE", 3}, + {VM_RT_AASTORE_TEST, "VM_RT_AASTORE_TEST", 2}, + {VM_RT_GET_INTERFACE_VTABLE_VER0, "VM_RT_GET_INTERFACE_VTABLE_VER0", 2}, + + {VM_RT_INITIALIZE_CLASS, "VM_RT_INITIALIZE_CLASS", 1}, + + {VM_RT_GC_HEAP_WRITE_REF, "VM_RT_GC_HEAP_WRITE_REF", 3}, + {VM_RT_GC_SAFE_POINT, "VM_RT_GC_SAFE_POINT", 0}, + {VM_RT_GC_GET_TLS_BASE, "VM_RT_GET_TLS_BASE", 0}, + + {VM_RT_JVMTI_METHOD_ENTER_CALLBACK, "VM_RT_JVMTI_METHOD_ENTER_CALLBACK", 1}, + {VM_RT_JVMTI_METHOD_EXIT_CALLBACK, "VM_RT_JVMTI_METHOD_EXIT_CALLBACK", 2}, + {VM_RT_JVMTI_FIELD_ACCESS_CALLBACK, "VM_RT_JVMTI_FIELD_ACCESS__CALLBACK", 4}, + {VM_RT_JVMTI_FIELD_MODIFICATION_CALLBACK, "VM_RT_JVMTI_FIELD_MODIFICATION_CALLBACK", 5}, + + {VM_RT_NEWOBJ_WITHRESOLVE, "VM_RT_NEWOBJ_WITHRESOLVE", 2}, + {VM_RT_NEWARRAY_WITHRESOLVE, "VM_RT_NEWARRAY_WITHRESOLVE", 3}, + {VM_RT_GET_NONSTATIC_FIELD_OFFSET_WITHRESOLVE, "VM_RT_GET_NONSTATIC_FIELD_OFFSET_WITHRESOLVE", 2}, + {VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE, "VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE", 2}, + {VM_RT_CHECKCAST_WITHRESOLVE, "VM_RT_CHECKCAST_WITHRESOLVE", 3}, + {VM_RT_INSTANCEOF_WITHRESOLVE, "VM_RT_INSTANCEOF_WITHRESOLVE", 3}, + {VM_RT_GET_INVOKESTATIC_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKESTATIC_ADDR_WITHRESOLVE", 2}, + {VM_RT_GET_INVOKEINTERFACE_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKEINTERFACE_ADDR_WITHRESOLVE", 3}, + {VM_RT_GET_INVOKEVIRTUAL_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKEVIRTUAL_ADDR_WITHRESOLVE", 3}, + {VM_RT_GET_INVOKE_SPECIAL_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKE_SPECIAL_ADDR_WITHRESOLVE", 2}, + {VM_RT_INITIALIZE_CLASS_WITHRESOLVE, "VM_RT_INITIALIZE_CLASS_WITHRESOLVE", 2}, + + + {VM_RT_F2I, "VM_RT_F2I", 1}, + {VM_RT_F2L, "VM_RT_F2L", 1}, + {VM_RT_D2I, "VM_RT_D2I", 1}, + {VM_RT_D2L, "VM_RT_D2L", 1}, + {VM_RT_LSHL, "VM_RT_LSHL", 2}, + {VM_RT_LSHR, "VM_RT_LSHR", 2}, + {VM_RT_LUSHR, "VM_RT_LUSHR", 2}, + {VM_RT_LMUL, "VM_RT_LMUL", 2}, +#ifdef VM_LONG_OPT + {VM_RT_LMUL_CONST_MULTIPLIER, "VM_RT_LMUL_CONST_MULTIPLIER", 2}, +#endif // VM_LONG_OPT + {VM_RT_LREM, "VM_RT_LREM", 2}, + {VM_RT_LDIV, "VM_RT_LDIV", 2}, + {VM_RT_ULDIV, "VM_RT_ULDIV", 2}, + {VM_RT_CONST_LDIV, "VM_RT_CONST_LDIV", 2}, + {VM_RT_CONST_LREM, "VM_RT_CONST_LREM", 2}, + {VM_RT_IMUL, "VM_RT_IMUL", 2}, + {VM_RT_IREM, "VM_RT_IREM", 2}, + {VM_RT_IDIV, "VM_RT_IDIV", 2}, + {VM_RT_FREM, "VM_RT_FREM", 2}, + {VM_RT_FDIV, "VM_RT_FDIV", 2}, + {VM_RT_DREM, "VM_RT_DREM", 2}, + {VM_RT_DDIV, "VM_RT_DDIV", 2}, + + {VM_RT_CHAR_ARRAYCOPY_NO_EXC, "VM_RT_CHAR_ARRAYCOPY_NO_EXC", 5}, + + {VM_RT_WRITE_BARRIER_FASTCALL, "VM_RT_WRITE_BARRIER_FASTCALL", 2}, +}; + +static JIT_RT_Function_Entry *jit_rt_function_entries = &(_jit_rt_function_entries_base[0]); +static int num_jit_rt_function_entries = sizeof(_jit_rt_function_entries_base) / sizeof(_jit_rt_function_entries_base[0]); + +static HelperInfoMap* init_helper_map() { + // TODO: Use proper MM + HelperInfoMap *map = new HelperInfoMap(); + for (int i = 0; i < num_jit_rt_function_entries; i++) { + VM_RT_SUPPORT hid = jit_rt_function_entries[i].function; + const char *fn_name = jit_rt_function_entries[i].function_name; + assert(map->find(hid) == map->end()); + map->insert(HelperInfoMap::value_type(hid, fn_name)); + } + assert(map->size() == num_jit_rt_function_entries); + return map; +} + +static HelperInfoMap *helper_map = init_helper_map(); + +VMEXPORT +const char* vm_helper_get_name(VM_RT_SUPPORT id) { + HelperInfoMap::const_iterator it = helper_map->find(id); + if (helper_map->end() != it) { + assert(it->second); + return it->second; + } else { + ASSERT(false, "Unexpected helper id " << id); + return "unknown"; + } +} + +VMEXPORT +VM_RT_SUPPORT vm_helper_get_by_name(const char* name) { + for (int i = 0; i < num_jit_rt_function_entries; i++) { + if( !strcmpi(name, jit_rt_function_entries[i].function_name)) { + return jit_rt_function_entries[i].function; + } + } + return VM_RT_UNKNOWN; +} + +/** +* Checks if helper is a suspension point +*/ +VMEXPORT +HELPER_INTERRUPTIBILITY_KIND vm_helper_get_interruptibility_kind(VM_RT_SUPPORT f) +{ + switch(f) { + case VM_RT_MULTIANEWARRAY_RESOLVED: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_LDC_STRING: + return INTERRUPTIBLE_ALWAYS; + // Exceptions + case VM_RT_THROW: + case VM_RT_THROW_SET_STACK_TRACE: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_THROW_LAZY: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_IDX_OUT_OF_BOUNDS: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_NULL_PTR_EXCEPTION: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_DIVIDE_BY_ZERO_EXCEPTION: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_ARRAY_STORE_EXCEPTION: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_THROW_LINKING_EXCEPTION: + return INTERRUPTIBLE_ALWAYS; + // Type tests + case VM_RT_CHECKCAST: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_INSTANCEOF: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_AASTORE: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_AASTORE_TEST: + return INTERRUPTIBLE_ALWAYS; + // Misc + case VM_RT_GET_INTERFACE_VTABLE_VER0: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_INITIALIZE_CLASS: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_GC_SAFE_POINT: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_GC_GET_TLS_BASE: + return INTERRUPTIBLE_NEVER; + // JVMTI + case VM_RT_JVMTI_METHOD_ENTER_CALLBACK: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_JVMTI_METHOD_EXIT_CALLBACK: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_JVMTI_FIELD_ACCESS_CALLBACK: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_JVMTI_FIELD_MODIFICATION_CALLBACK: + return INTERRUPTIBLE_ALWAYS; + // Non-VM + case VM_RT_F2I: + return INTERRUPTIBLE_NEVER; + case VM_RT_F2L: + return INTERRUPTIBLE_NEVER; + case VM_RT_D2I: + return INTERRUPTIBLE_NEVER; + case VM_RT_D2L: + return INTERRUPTIBLE_NEVER; + case VM_RT_LSHL: + return INTERRUPTIBLE_NEVER; + case VM_RT_LSHR: + return INTERRUPTIBLE_NEVER; + case VM_RT_LUSHR: + return INTERRUPTIBLE_NEVER; + case VM_RT_LMUL: +#ifdef VM_LONG_OPT + case VM_RT_LMUL_CONST_MULTIPLIER: +#endif + return INTERRUPTIBLE_NEVER; + case VM_RT_LREM: + return INTERRUPTIBLE_NEVER; + case VM_RT_LDIV: + return INTERRUPTIBLE_NEVER; + case VM_RT_ULDIV: + return INTERRUPTIBLE_NEVER; + case VM_RT_CONST_LDIV: + return INTERRUPTIBLE_NEVER; + case VM_RT_CONST_LREM: + return INTERRUPTIBLE_NEVER; + case VM_RT_IMUL: + return INTERRUPTIBLE_NEVER; + case VM_RT_IREM: + return INTERRUPTIBLE_NEVER; + case VM_RT_IDIV: + return INTERRUPTIBLE_NEVER; + case VM_RT_FREM: + return INTERRUPTIBLE_NEVER; + case VM_RT_FDIV: + return INTERRUPTIBLE_NEVER; + case VM_RT_DREM: + return INTERRUPTIBLE_NEVER; + case VM_RT_DDIV: + return INTERRUPTIBLE_NEVER; + case VM_RT_NEWOBJ_WITHRESOLVE: + case VM_RT_NEWARRAY_WITHRESOLVE: + case VM_RT_INITIALIZE_CLASS_WITHRESOLVE: + case VM_RT_GET_NONSTATIC_FIELD_OFFSET_WITHRESOLVE: + case VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE: + case VM_RT_CHECKCAST_WITHRESOLVE: + case VM_RT_INSTANCEOF_WITHRESOLVE: + case VM_RT_GET_INVOKESTATIC_ADDR_WITHRESOLVE: + case VM_RT_GET_INVOKEINTERFACE_ADDR_WITHRESOLVE: + case VM_RT_GET_INVOKEVIRTUAL_ADDR_WITHRESOLVE: + case VM_RT_GET_INVOKE_SPECIAL_ADDR_WITHRESOLVE: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_NEW_RESOLVED_USING_VTABLE_AND_SIZE: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_NEW_VECTOR_USING_VTABLE: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_WRITE_BARRIER_FASTCALL: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_MONITOR_ENTER: + case VM_RT_MONITOR_ENTER_NON_NULL: + return INTERRUPTIBLE_SOMETIMES; + + case VM_RT_MONITOR_ENTER_STATIC: + return INTERRUPTIBLE_SOMETIMES; + case VM_RT_MONITOR_EXIT: + case VM_RT_MONITOR_EXIT_NON_NULL: + return INTERRUPTIBLE_SOMETIMES; + + case VM_RT_MONITOR_EXIT_STATIC: + return INTERRUPTIBLE_SOMETIMES; + case VM_RT_CHAR_ARRAYCOPY_NO_EXC: + return INTERRUPTIBLE_ALWAYS; + case VM_RT_GC_HEAP_WRITE_REF: + return INTERRUPTIBLE_NEVER; + default: + ASSERT(false, "Unexpected helper id " << f); + return INTERRUPTIBLE_SOMETIMES; + } +} + +VMEXPORT +HELPER_CALLING_CONVENTION vm_helper_get_calling_convention(VM_RT_SUPPORT id) { + switch(id) { + case VM_RT_MULTIANEWARRAY_RESOLVED: + case VM_RT_GC_HEAP_WRITE_REF: + return CALLING_CONVENTION_CDECL; + case VM_RT_LSHL: + case VM_RT_LSHR: + case VM_RT_LUSHR: + case VM_RT_THROW_LAZY: + case VM_RT_THROW_LINKING_EXCEPTION: + return CALLING_CONVENTION_DRL; + case VM_RT_UNKNOWN: + ASSERT(false, "Unexpected helper id " << id); + default: + return CALLING_CONVENTION_STDCALL; + } +} Property changes on: vm\vmcore\src\jit\rt_helper_info.cpp ___________________________________________________________________ Name: svn:eol-style + native Index: vm/vmcore/src/jit/jit_runtime_support.cpp =================================================================== --- vm/vmcore/src/jit/jit_runtime_support.cpp (revision 583684) +++ vm/vmcore/src/jit/jit_runtime_support.cpp (working copy) @@ -2486,145 +2486,6 @@ //**********************************************************************// -/** - * Checks if helper is a suspension point - */ - -VMEXPORT HELPER_INTERRUPTIBILITY_KIND vm_helper_get_interruptibility_kind(VM_RT_SUPPORT f) -{ -switch(f) { - case VM_RT_MULTIANEWARRAY_RESOLVED: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_LDC_STRING: - return INTERRUPTIBLE_ALWAYS; - // Exceptions - case VM_RT_THROW: - case VM_RT_THROW_SET_STACK_TRACE: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_THROW_LAZY: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_IDX_OUT_OF_BOUNDS: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_NULL_PTR_EXCEPTION: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_DIVIDE_BY_ZERO_EXCEPTION: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_ARRAY_STORE_EXCEPTION: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_THROW_LINKING_EXCEPTION: - return INTERRUPTIBLE_ALWAYS; - // Type tests - case VM_RT_CHECKCAST: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_INSTANCEOF: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_AASTORE: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_AASTORE_TEST: - return INTERRUPTIBLE_ALWAYS; - // Misc - case VM_RT_GET_INTERFACE_VTABLE_VER0: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_INITIALIZE_CLASS: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_GC_SAFE_POINT: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_GC_GET_TLS_BASE: - return INTERRUPTIBLE_NEVER; - // JVMTI - case VM_RT_JVMTI_METHOD_ENTER_CALLBACK: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_JVMTI_METHOD_EXIT_CALLBACK: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_JVMTI_FIELD_ACCESS_CALLBACK: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_JVMTI_FIELD_MODIFICATION_CALLBACK: - return INTERRUPTIBLE_ALWAYS; - // Non-VM - case VM_RT_F2I: - return INTERRUPTIBLE_NEVER; - case VM_RT_F2L: - return INTERRUPTIBLE_NEVER; - case VM_RT_D2I: - return INTERRUPTIBLE_NEVER; - case VM_RT_D2L: - return INTERRUPTIBLE_NEVER; - case VM_RT_LSHL: - return INTERRUPTIBLE_NEVER; - case VM_RT_LSHR: - return INTERRUPTIBLE_NEVER; - case VM_RT_LUSHR: - return INTERRUPTIBLE_NEVER; - case VM_RT_LMUL: -#ifdef VM_LONG_OPT - case VM_RT_LMUL_CONST_MULTIPLIER: -#endif - return INTERRUPTIBLE_NEVER; - case VM_RT_LREM: - return INTERRUPTIBLE_NEVER; - case VM_RT_LDIV: - return INTERRUPTIBLE_NEVER; - case VM_RT_ULDIV: - return INTERRUPTIBLE_NEVER; - case VM_RT_CONST_LDIV: - return INTERRUPTIBLE_NEVER; - case VM_RT_CONST_LREM: - return INTERRUPTIBLE_NEVER; - case VM_RT_IMUL: - return INTERRUPTIBLE_NEVER; - case VM_RT_IREM: - return INTERRUPTIBLE_NEVER; - case VM_RT_IDIV: - return INTERRUPTIBLE_NEVER; - case VM_RT_FREM: - return INTERRUPTIBLE_NEVER; - case VM_RT_FDIV: - return INTERRUPTIBLE_NEVER; - case VM_RT_DREM: - return INTERRUPTIBLE_NEVER; - case VM_RT_DDIV: - return INTERRUPTIBLE_NEVER; - case VM_RT_NEWOBJ_WITHRESOLVE: - case VM_RT_NEWARRAY_WITHRESOLVE: - case VM_RT_INITIALIZE_CLASS_WITHRESOLVE: - case VM_RT_GET_NONSTATIC_FIELD_OFFSET_WITHRESOLVE: - case VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE: - case VM_RT_CHECKCAST_WITHRESOLVE: - case VM_RT_INSTANCEOF_WITHRESOLVE: - case VM_RT_GET_INVOKESTATIC_ADDR_WITHRESOLVE: - case VM_RT_GET_INVOKEINTERFACE_ADDR_WITHRESOLVE: - case VM_RT_GET_INVOKEVIRTUAL_ADDR_WITHRESOLVE: - case VM_RT_GET_INVOKE_SPECIAL_ADDR_WITHRESOLVE: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_NEW_RESOLVED_USING_VTABLE_AND_SIZE: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_NEW_VECTOR_USING_VTABLE: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_WRITE_BARRIER_FASTCALL: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_MONITOR_ENTER: - case VM_RT_MONITOR_ENTER_NON_NULL: - return INTERRUPTIBLE_SOMETIMES; - - case VM_RT_MONITOR_ENTER_STATIC: - return INTERRUPTIBLE_SOMETIMES; - case VM_RT_MONITOR_EXIT: - case VM_RT_MONITOR_EXIT_NON_NULL: - return INTERRUPTIBLE_SOMETIMES; - - case VM_RT_MONITOR_EXIT_STATIC: - return INTERRUPTIBLE_SOMETIMES; - case VM_RT_CHAR_ARRAYCOPY_NO_EXC: - return INTERRUPTIBLE_ALWAYS; - case VM_RT_GC_HEAP_WRITE_REF: - return INTERRUPTIBLE_NEVER; - default: - ASSERT(false, "Unexpected helper id" << f); - return INTERRUPTIBLE_SOMETIMES; - } -} - - ///////////////////////////////////////////////////////////// // begin Java object allocation Index: vm/vmcore/src/util/vm_stats.cpp =================================================================== --- vm/vmcore/src/util/vm_stats.cpp (revision 583684) +++ vm/vmcore/src/util/vm_stats.cpp (working copy) @@ -38,101 +38,8 @@ bool vm_print_total_stats = false; int vm_print_total_stats_level = 0; -// 20030425 The list of JIT support functions below must be kept in synch with the enum VM_RT_SUPPORT in jit_runtime_support.h. -typedef struct JIT_RT_Function_Entry { - VM_RT_SUPPORT function; - char *function_name; - int number_of_args; -} JIT_RT_Function_Entry; - -static JIT_RT_Function_Entry _jit_rt_function_entries_base[] = { - {VM_RT_NEW_RESOLVED_USING_VTABLE_AND_SIZE, "VM_RT_NEW_RESOLVED_USING_VTABLE_AND_SIZE", 2}, - {VM_RT_NEW_VECTOR_USING_VTABLE, "VM_RT_NEW_VECTOR_USING_VTABLE", 2}, - {VM_RT_MULTIANEWARRAY_RESOLVED, "VM_RT_MULTIANEWARRAY_RESOLVED", 8}, - {VM_RT_LDC_STRING, "VM_RT_LDC_STRING", 2}, - - {VM_RT_THROW, "VM_RT_THROW", 1}, - {VM_RT_THROW_LAZY, "VM_RT_THROW_LAZY", 8}, - {VM_RT_IDX_OUT_OF_BOUNDS, "VM_RT_IDX_OUT_OF_BOUNDS", 0}, - {VM_RT_NULL_PTR_EXCEPTION, "VM_RT_NULL_PTR_EXCEPTION", 0}, - {VM_RT_DIVIDE_BY_ZERO_EXCEPTION, "VM_RT_DIVIDE_BY_ZERO_EXCEPTION", 0}, - {VM_RT_ARRAY_STORE_EXCEPTION, "VM_RT_ARRAY_STORE_EXCEPTION", 0}, - {VM_RT_THROW_LINKING_EXCEPTION, "VM_RT_THROW_LINKING_EXCEPTION", 0}, - {VM_RT_THROW_SET_STACK_TRACE, "VM_RT_THROW_SET_STACK_TRACE", 1}, - - {VM_RT_MONITOR_ENTER, "VM_RT_MONITOR_ENTER", 1}, - {VM_RT_MONITOR_ENTER_NON_NULL, "VM_RT_MONITOR_ENTER_NON_NULL", 1}, - {VM_RT_MONITOR_EXIT, "VM_RT_MONITOR_EXIT", 1}, - {VM_RT_MONITOR_EXIT_NON_NULL, "VM_RT_MONITOR_EXIT_NON_NULL", 1}, - {VM_RT_MONITOR_ENTER_STATIC, "VM_RT_MONITOR_ENTER_STATIC", 1}, - {VM_RT_MONITOR_EXIT_STATIC, "VM_RT_MONITOR_EXIT_STATIC", 1}, - - {VM_RT_CHECKCAST, "VM_RT_CHECKCAST", 2}, - {VM_RT_INSTANCEOF, "VM_RT_INSTANCEOF", 2}, - {VM_RT_AASTORE, "VM_RT_AASTORE", 3}, - {VM_RT_AASTORE_TEST, "VM_RT_AASTORE_TEST", 2}, - {VM_RT_GET_INTERFACE_VTABLE_VER0, "VM_RT_GET_INTERFACE_VTABLE_VER0", 2}, - - {VM_RT_INITIALIZE_CLASS, "VM_RT_INITIALIZE_CLASS", 1}, - - {VM_RT_GC_HEAP_WRITE_REF, "VM_RT_GC_HEAP_WRITE_REF", 3}, - {VM_RT_GC_SAFE_POINT, "VM_RT_GC_SAFE_POINT", 0}, - {VM_RT_GC_GET_TLS_BASE, "VM_RT_GET_TLS_BASE", 0}, - - {VM_RT_JVMTI_METHOD_ENTER_CALLBACK, "VM_RT_JVMTI_METHOD_ENTER_CALLBACK", 1}, - {VM_RT_JVMTI_METHOD_EXIT_CALLBACK, "VM_RT_JVMTI_METHOD_EXIT_CALLBACK", 2}, - {VM_RT_JVMTI_FIELD_ACCESS_CALLBACK, "VM_RT_JVMTI_FIELD_ACCESS__CALLBACK", 4}, - {VM_RT_JVMTI_FIELD_MODIFICATION_CALLBACK, "VM_RT_JVMTI_FIELD_MODIFICATION_CALLBACK", 5}, - - {VM_RT_NEWOBJ_WITHRESOLVE, "VM_RT_NEWOBJ_WITHRESOLVE", 2}, - {VM_RT_NEWARRAY_WITHRESOLVE, "VM_RT_NEWARRAY_WITHRESOLVE", 3}, - {VM_RT_GET_NONSTATIC_FIELD_OFFSET_WITHRESOLVE, "VM_RT_GET_NONSTATIC_FIELD_OFFSET_WITHRESOLVE", 2}, - {VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE, "VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE", 2}, - {VM_RT_CHECKCAST_WITHRESOLVE, "VM_RT_CHECKCAST_WITHRESOLVE", 3}, - {VM_RT_INSTANCEOF_WITHRESOLVE, "VM_RT_INSTANCEOF_WITHRESOLVE", 3}, - {VM_RT_GET_INVOKESTATIC_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKESTATIC_ADDR_WITHRESOLVE", 2}, - {VM_RT_GET_INVOKEINTERFACE_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKEINTERFACE_ADDR_WITHRESOLVE", 3}, - {VM_RT_GET_INVOKEVIRTUAL_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKEVIRTUAL_ADDR_WITHRESOLVE", 3}, - {VM_RT_GET_INVOKE_SPECIAL_ADDR_WITHRESOLVE, "VM_RT_GET_INVOKE_SPECIAL_ADDR_WITHRESOLVE", 2}, - {VM_RT_INITIALIZE_CLASS_WITHRESOLVE, "VM_RT_INITIALIZE_CLASS_WITHRESOLVE", 2}, - - - {VM_RT_F2I, "VM_RT_F2I", 1}, - {VM_RT_F2L, "VM_RT_F2L", 1}, - {VM_RT_D2I, "VM_RT_D2I", 1}, - {VM_RT_D2L, "VM_RT_D2L", 1}, - {VM_RT_LSHL, "VM_RT_LSHL", 2}, - {VM_RT_LSHR, "VM_RT_LSHR", 2}, - {VM_RT_LUSHR, "VM_RT_LUSHR", 2}, - {VM_RT_LMUL, "VM_RT_LMUL", 2}, -#ifdef VM_LONG_OPT - {VM_RT_LMUL_CONST_MULTIPLIER, "VM_RT_LMUL_CONST_MULTIPLIER", 2}, -#endif // VM_LONG_OPT - {VM_RT_LREM, "VM_RT_LREM", 2}, - {VM_RT_LDIV, "VM_RT_LDIV", 2}, - {VM_RT_ULDIV, "VM_RT_ULDIV", 2}, - {VM_RT_CONST_LDIV, "VM_RT_CONST_LDIV", 2}, - {VM_RT_CONST_LREM, "VM_RT_CONST_LREM", 2}, - {VM_RT_IMUL, "VM_RT_IMUL", 2}, - {VM_RT_IREM, "VM_RT_IREM", 2}, - {VM_RT_IDIV, "VM_RT_IDIV", 2}, - {VM_RT_FREM, "VM_RT_FREM", 2}, - {VM_RT_FDIV, "VM_RT_FDIV", 2}, - {VM_RT_DREM, "VM_RT_DREM", 2}, - {VM_RT_DDIV, "VM_RT_DDIV", 2}, - - {VM_RT_CHAR_ARRAYCOPY_NO_EXC, "VM_RT_CHAR_ARRAYCOPY_NO_EXC", 5}, - - {VM_RT_WRITE_BARRIER_FASTCALL, "VM_RT_WRITE_BARRIER_FASTCALL", 2}, -}; - -static JIT_RT_Function_Entry *jit_rt_function_entries = &(_jit_rt_function_entries_base[0]); -static int sizeof_jit_rt_function_entries = sizeof(_jit_rt_function_entries_base) / sizeof(_jit_rt_function_entries_base[0]); - - VM_Statistics::VM_Statistics() - : rt_function_map(56), - rt_function_requests(56), + : rt_function_requests(56), rt_function_calls(56) { num_exceptions = 0; @@ -325,17 +232,6 @@ total_hot_statics_bytes = 0; total_hot_vtable_bytes = 0; - // Enter the JIT RT support functions into a -> map. - for (int i = 0; i < sizeof_jit_rt_function_entries; i++) { - char *fn_name; - int num_args; - VM_RT_SUPPORT fn_number = jit_rt_function_entries[i].function; - assert( !rt_function_map.lookup((void *)fn_number, &num_args, (void **)&fn_name) ); - fn_name = jit_rt_function_entries[i].function_name; - num_args = jit_rt_function_entries[i].number_of_args; - rt_function_map.add((void *)fn_number, num_args, fn_name); - } - apr_pool_create(&vm_stats_pool, 0); } //VM_Statistics::VM_Statistics @@ -604,10 +500,7 @@ quick_sort(pair_array, 0, num_entries-1); for (i = 0; i < num_entries; i++) { VM_RT_SUPPORT fn_number = (VM_RT_SUPPORT)((POINTER_SIZE_INT)(pair_array[i]->key)); - int num_args = 0; - char *fn_name = NULL; - bool UNUSED found = rt_function_map.lookup((void *)fn_number, &num_args, (void **)&fn_name); - assert(found); // else changes were made to the enum VM_RT_SUPPORT in jit_runtime_support.h. + const char *fn_name = vm_helper_get_name(fn_number); printf("%11d :::: %s\n", pair_array[i]->value, fn_name); } STD_FREE(pair_array); @@ -623,10 +516,7 @@ quick_sort(pair_array, 0, num_entries-1); for (i = 0; i < num_entries; i++) { VM_RT_SUPPORT fn_number = (VM_RT_SUPPORT)((POINTER_SIZE_INT)(pair_array[i]->key)); - int num_args = 0; - char *fn_name = NULL; - bool found = rt_function_map.lookup((void *)fn_number, &num_args, (void **)&fn_name); - assert(found); // else changes were made to the enum VM_RT_SUPPORT in jit_runtime_support.h. + const char *fn_name = vm_helper_get_name(fn_number); printf("%11d :::: %s\n", pair_array[i]->value, fn_name); } printf("\n");