/* * 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 "compile" #include "cxxlog.h" #include "vm_log.h" #include "open/gc.h" #include "open/vm_ee.h" #include "open/vm_type_access.h" #include "open/vm_method_access.h" #include "open/vm_class_manipulation.h" #include "apr_strings.h" #include "lock_manager.h" #include "classloader.h" #include "exceptions.h" #include "native_overrides.h" #include "jit_intf_cpp.h" #include "em_intf.h" #include "heap.h" #include "vm_strings.h" #include "compile.h" #include "jit_runtime_support.h" #include "lil_code_generator.h" #include "stack_iterator.h" #include "interpreter.h" #include "jvmti_internal.h" #include "jvmti_break_intf.h" #include "cci.h" #include "vm_stats.h" #include "dump.h" #include "port_threadunsafe.h" extern bool parallel_jit; #define METHOD_NAME_BUF_SIZE 512 Global_Env* compile_handle_to_environment(Compile_Handle h) { return ((Compilation_Handle*)h)->env; } int get_index_of_jit(JIT *jit) { int idx; JIT **j; for (j = jit_compilers, idx = 0; *j; j++, idx++) { if (*j == jit) { return idx; } } return -999; } //get_index_of_jit //////////////////////////////////////////////////////////////////////// // begin CodeChunkInfo CodeChunkInfo::CodeChunkInfo() { _jit = 0; _method = 0; _id = 0; _relocatable = TRUE; _num_target_exception_handlers = 0; _target_exception_handlers = NULL; _heat = 0; _code_block = NULL; _jit_info_block = NULL; _code_block_size = 0; _jit_info_block_size = 0; _code_block_alignment = 0; _data_blocks = NULL; _next = NULL; #ifdef VM_STATS num_throws = 0; num_catches = 0; num_unwind_java_frames_gc = 0; num_unwind_java_frames_non_gc = 0; #endif } //CodeChunkInfo::CodeChunkInfo int CodeChunkInfo::get_jit_index() const { return get_index_of_jit(_jit); } unsigned CodeChunkInfo::get_num_target_exception_handlers() const { if (_id==0) { return _num_target_exception_handlers; } else { return _method->get_num_target_exception_handlers(_jit); } } Target_Exception_Handler_Ptr CodeChunkInfo::get_target_exception_handler_info(unsigned eh_num) const { if (_id==0) { return _target_exception_handlers[eh_num]; } else { return _method->get_target_exception_handler_info(_jit, eh_num); } } void CodeChunkInfo::print_name() const { assert(_method); const char* c = _method->get_class()->get_name()->bytes; const char* m = _method->get_name()->bytes; const char* d = _method->get_descriptor()->bytes; printf("%d:%d:%s.%s%s", get_jit_index(), get_id(), c, m, d); } //CodeChunkInfo::print_name void CodeChunkInfo::print_name(FILE *file) const { assert(_method); const char* c = _method->get_class()->get_name()->bytes; const char* m = _method->get_name()->bytes; const char* d = _method->get_descriptor()->bytes; fprintf(file, "%d:%d:%s.%s%s", get_jit_index(), get_id(), c, m, d); } //CodeChunkInfo::print_name void CodeChunkInfo::print_info(bool print_ellipses) const { size_t code_size = get_code_block_size(); print_name(); printf(", %d bytes%s\n", (unsigned)code_size, (print_ellipses? "..." : "")); } //CodeChunkInfo::print_info // end CodeChunkInfo //////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// // begin JIT management JIT *jit_compilers[] = {0, 0, 0, 0, 0, 0, 0}; void vm_add_jit(JIT *jit) { int max_jit_num = sizeof(jit_compilers) / sizeof(JIT *) - 2; if(jit_compilers[max_jit_num]) { LDIE(64, "Can't add new JIT"); return; } // Shift the jits for(int i = max_jit_num; i > 0; i--) { jit_compilers[i] = jit_compilers[i - 1]; } jit_compilers[0] = jit; assert(jit_compilers[max_jit_num + 1] == 0); } //vm_add_jit void vm_delete_all_jits() { JIT **jit; for(jit = jit_compilers; *jit; jit++) { delete (*jit); *jit = 0; } } //vm_delete_all_jits // end JIT management //////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // JNI Stubs static bool is_reference(Type_Info_Handle tih) { return type_info_is_reference(tih) || type_info_is_vector(tih); } //is_reference // Implementation note: don't use l2 (use l3, l4 instead if required) since its // space can be used in case of 64-bit return value. NativeCodePtr compile_create_lil_jni_stub(Method_Handle method, void* func, NativeStubOverride nso) { ASSERT_NO_INTERPRETER; const Class_Handle clss = method->get_class(); bool is_static = method->is_static(); bool is_synchronised = method->is_synchronized(); Method_Signature_Handle msh = method_get_signature(method); unsigned num_args = method->get_num_args(); Type_Info_Handle ret_tih = method_ret_type_get_type_info(msh); VM_Data_Type ret_type = type_info_get_type(ret_tih); unsigned i; unsigned num_ref_args = 0; // among original args, does not include jclass for static methods for(i=0; inum_accesses); assert(cs); #endif //VM_STATS // Do stub override here if (nso) cs = nso(cs, method); assert(cs); // Increment stats (number of nonoverridden calls) #ifdef VM_STATS cs = lil_parse_onto_end(cs, "inc [%0i:pint];", &((Method*)method)->num_slow_accesses); assert(cs); #endif // Push M2nFrame cs = lil_parse_onto_end(cs, "push_m2n %0i, %1i, handles; locals 3;", method, (POINTER_SIZE_INT)FRAME_JNI); assert(cs); // Allocate space for handles unsigned number_of_object_handles = num_ref_args + (is_static ? 1 : 0); cs = oh_gen_allocate_handles(cs, number_of_object_handles, "l0", "l1"); assert(cs); //***** Part 2: Initialize object handles if (is_static) { void *jlc = clss->get_class_handle(); cs = lil_parse_onto_end(cs, //"ld l1,[%0i:pint];" "ld l1,[%0i:ref];", jlc); assert(cs); cs = oh_gen_init_handle(cs, "l0", 0, "l1", false); assert(cs); } else { cs = oh_gen_init_handle(cs, "l0", 0, "i0", true); } // The remaining handles are for the proper arguments (not including this) // Loop over the arguments, skipping 0th argument for instance methods. If argument is a reference, generate code unsigned hn = 1; for(i=(is_static?0:1); iTI; if (ti->isEnabled() && ti->get_global_capability(DebugUtilsTI::TI_GC_ENABLE_METHOD_ENTRY)) { cs = lil_parse_onto_end(cs, "out platform:pint:void;" "o0=%0i:pint;" "call %1i;", (jmethodID)method, jvmti_process_method_entry_event); assert(cs); } //***** Part 4: Enable GC cs = lil_parse_onto_end(cs, "out platform::void;" "call %0i;", hythread_suspend_enable); assert(cs); //***** Part 5: Set up arguments // Setup outputs, set JNIEnv, set class/this handle cs = lil_parse_onto_end(cs, "out jni:%0j;" "l1=ts;" "ld o0,[l1 + %1i:pint];" "o1=l0+%2i;", method, (POINTER_SIZE_INT)APR_OFFSETOF(VM_thread, jni_env), oh_get_handle_offset(0)); assert(cs); // Loop over arguments proper, setting rest of outputs unsigned int arg_base = 1 + (is_static ? 1 : 0); hn = 1; for(i=(is_static?0:1); imanaged_null, arg_base+i, handle_offset, arg_base+i); #endif // REFS_RUNTIME_OR_COMPRESSED REFS_RUNTIME_SWITCH_ELSE #ifdef REFS_RUNTIME_OR_UNCOMPRESSED cs = lil_parse_onto_end(cs, "jc i%0i=0:ref,%n;" "o%1i=l0+%2i;" "j %o;" ":%g;" "o%3i=0;" ":%g;", i, arg_base+i, handle_offset, arg_base+i); #endif // REFS_RUNTIME_OR_UNCOMPRESSED REFS_RUNTIME_SWITCH_ENDIF hn++; } else { cs = lil_parse_onto_end(cs, "o%0i=i%1i;", arg_base+i, i); } assert(cs); } //***** Part 6: Call cs = lil_parse_onto_end(cs, "call %0i;", func); assert(cs); //***** Part 7: Save return, widening if necessary switch (ret_type) { case VM_DATA_TYPE_VOID: break; case VM_DATA_TYPE_INT32: cs = lil_parse_onto_end(cs, "l1=r;"); break; case VM_DATA_TYPE_BOOLEAN: cs = lil_parse_onto_end(cs, "l1=zx1 r;"); break; case VM_DATA_TYPE_INT16: cs = lil_parse_onto_end(cs, "l1=sx2 r;"); break; case VM_DATA_TYPE_INT8: cs = lil_parse_onto_end(cs, "l1=sx1 r;"); break; case VM_DATA_TYPE_CHAR: cs = lil_parse_onto_end(cs, "l1=zx2 r;"); break; default: cs = lil_parse_onto_end(cs, "l1=r;"); break; } assert(cs); //***** Part 8: Disable GC cs = lil_parse_onto_end(cs, "out platform::void;" "call %0i;", hythread_suspend_disable); assert(cs); // Exception offsets POINTER_SIZE_INT eoo = (POINTER_SIZE_INT)&((VM_thread*)0)->thread_exception.exc_object; POINTER_SIZE_INT eco = (POINTER_SIZE_INT)&((VM_thread*)0)->thread_exception.exc_class; //***** Call JVMTI MethodExit if (ti->isEnabled() && ti->get_global_capability(DebugUtilsTI::TI_GC_ENABLE_METHOD_EXIT)) { cs = lil_parse_onto_end(cs, "out platform:pint,g1,g8:void;" "l2=ts;" "ld l2,[l2+%0i:ref];" "jc l2!=0,_mex_exn_raised;" "l2=ts;" "ld l2,[l2+%1i:ref];" "jc l2!=0,_mex_exn_raised;" "o1=%2i:g1;" "o2=l1:g8;" "j _mex_exn_cont;" ":_mex_exn_raised;" "o1=%3i:g1;" "o2=0:g8;" ":_mex_exn_cont;" "o0=%4i:pint;" "call %5i;", eoo, eco, (POINTER_SIZE_INT)JNI_FALSE, (POINTER_SIZE_INT)JNI_TRUE, (jmethodID)method, jvmti_process_method_exit_event); assert(cs); } //***** Part 9: Synchronize if (is_synchronised) { if (is_static) { cs = lil_parse_onto_end(cs, "out stdcall:pint:pint;" "o0=%0i;" "call %1i;" "out stdcall:pint:void;" "o0=r;" "call %2i;", clss, lil_npc_to_fp(vm_helper_get_addr(VM_RT_CLASS_2_JLC)), lil_npc_to_fp(vm_helper_get_addr(VM_RT_MONITOR_EXIT))); } else { cs = lil_parse_onto_end(cs, "ld l0,[l0+%0i:ref];" "out stdcall:ref:void; o0=l0; call %1i;", oh_get_handle_offset(0), lil_npc_to_fp(vm_helper_get_addr(VM_RT_MONITOR_EXIT))); } assert(cs); } //***** Part 10: Unhandle the return if it is a reference if (is_reference(ret_tih)) { cs = lil_parse_onto_end(cs, "jc l1=0,ret_done;" "ld l1,[l1+0:ref];" ":ret_done;"); #ifdef REFS_RUNTIME_OR_COMPRESSED REFS_RUNTIME_SWITCH_IF cs = lil_parse_onto_end(cs, "jc l1!=0,done_translating_ret;" "l1=%0i:ref;" ":done_translating_ret;", VM_Global_State::loader_env->managed_null); REFS_RUNTIME_SWITCH_ENDIF #endif // REFS_RUNTIME_OR_UNCOMPRESSED assert(cs); } //***** Part 11: Rethrow exception cs = lil_parse_onto_end(cs, "l0=ts;" "ld l2,[l0+%0i:ref];" "jc l2!=0,_exn_raised;" "ld l2,[l0+%1i:ref];" "jc l2=0,_no_exn;" ":_exn_raised;" "m2n_save_all;" "out platform::void;" "call.noret %2i;" ":_no_exn;", eoo, eco, exn_rethrow); assert(cs); //***** Part 12: Restore return variable, pop_m2n, return if (ret_type != VM_DATA_TYPE_VOID) { cs = lil_parse_onto_end(cs, "r=l1;"); assert(cs); } cs = lil_parse_onto_end(cs, "pop_m2n;" "ret;"); assert(cs); //***** Now generate code assert(lil_is_valid(cs)); NativeCodePtr addr = LilCodeGenerator::get_platform()->compile(cs, clss->get_class_loader()->GetCodePool()); #ifndef NDEBUG char buf[100]; apr_snprintf(buf, sizeof(buf)-1, "jni_stub.%s::%s", clss->get_name()->bytes, method->get_name()->bytes); DUMP_STUB(addr, buf, lil_cs_get_code_size(cs)); #endif #ifdef VM_STATS VM_Statistics::get_vm_stats().jni_stub_bytes += lil_cs_get_code_size(cs); #endif lil_free_code_stub(cs); return addr; } // compile_create_lil_jni_stub ////////////////////////////////////////////////////////////////////////// // PInvoke Stubs ///////////////////////////////////////////////////////////////// // begin Support for stub override code sequences static int get_override_index(Method* method) { const char* clss_name = method->get_class()->get_name()->bytes; const char* meth_name = method->get_name()->bytes; const char* meth_desc = method->get_descriptor()->bytes; for (int i = 0; i < sizeof_stub_override_entries; i++) { if ((strcmp(clss_name, stub_override_entries[i].class_name) == 0) && (strcmp(meth_name, stub_override_entries[i].method_name) == 0) && (strcmp(meth_desc, stub_override_entries[i].descriptor) == 0)) { return i; } } return -1; } bool needs_override(Method *method) { int idx = get_override_index(method); if (idx < 0) return false; Override_Generator *override_generator = stub_override_entries[idx].override_generator; return (override_generator != NULL); } // end Support for stub override code sequences ///////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// // Direct Call Support // 20040113: This is deprecated and will go away soon #define REWRITE_INVALID_TYPE 0 #define REWRITE_PATCH_COMPILE_ME_STUB 1 #define REWRITE_PATCH_CALLER 2 #define REWRITE_PATCH_OLD_CODE_TO_REWRITER 3 ////////////////////////////////////////////////////////////////////////// // Compilation of Methods static NativeCodePtr compile_create_jni_stub(Method_Handle method, GenericFunctionPointer func, NativeStubOverride nso) { return compile_create_lil_jni_stub(method, (void*)func, nso); } //compile_create_jni_stub static JIT_Result compile_prepare_native_method(Method* method) { TRACE("compile_prepare_native_method (" << method->get_name()->bytes << ")"); #ifdef VM_STATS VM_Statistics::get_vm_stats().num_native_methods++; #endif assert(method->is_native()); GenericFunctionPointer func = classloader_find_native(method); if (!func) return JIT_FAILURE; // Calling callback for NativeMethodBind event jvmti_process_native_method_bind_event( (jmethodID) method, (NativeCodePtr)func, (NativeCodePtr*)&func); Class* cl = method->get_class(); NativeStubOverride nso = nso_find_method_override(VM_Global_State::loader_env, cl->get_name(), method->get_name(), method->get_descriptor()); NativeCodePtr stub = compile_create_jni_stub(method, func, nso); if (!stub) return JIT_FAILURE; method->lock(); method->set_code_addr(stub); method->unlock(); return JIT_SUCCESS; } // compile_prepare_native_method JIT_Result compile_do_compilation_jit(Method* method, JIT* jit) { // Time stamp for counting the total compilation time apr_time_t start; Global_Env * vm_env = VM_Global_State::loader_env; assert(method); assert(jit); if (!parallel_jit) { vm_env->p_jit_a_method_lock->_lock(); // MikhailF reports that each JIT in recompilation chain has its own // JIT* pointer. // If in addition to recompilation chains one adds recompilation loops, // this check can be skipped, or main_code_chunk_id should be // modified. if (NULL != method->get_chunk_info_no_create_mt(jit, CodeChunkInfo::main_code_chunk_id)) { vm_env->p_jit_a_method_lock->_unlock(); return JIT_SUCCESS; } } OpenMethodExecutionParams flags = {0}; jvmti_get_compilation_flags(&flags); flags.exe_insert_write_barriers = gc_requires_barriers(); Compilation_Handle ch; ch.env = VM_Global_State::loader_env; ch.jit = jit; start = apr_time_now(); TRACE("compile_do_compilation_jit(): calling jit->compile_method_with_params() for method " << method ); JIT_Result res = jit->compile_method_with_params(&ch, method, flags); TRACE("compile_do_compilation_jit(): returned from jit->compile_method_with_params() for method " << method ); UNSAFE_REGION_START // Non-atomic increment of statistic counter // Conversion from microseconds to milliseconds vm_env->total_compilation_time += ((apr_time_now() - start)/1000); UNSAFE_REGION_END if (JIT_SUCCESS != res) { if (!parallel_jit) { vm_env->p_jit_a_method_lock->_unlock(); } return res; } method->lock(); for (CodeChunkInfo* cci = method->get_first_JIT_specific_info(); cci; cci = cci->_next) { if (cci->get_jit() == jit) { compile_flush_generated_code_block((U_8*)cci->get_code_block_addr(), cci->get_code_block_size()); // We assume the main chunk starts from entry point if (cci->get_id() == CodeChunkInfo::main_code_chunk_id) { method->set_code_addr(cci->get_code_block_addr()); } } } // Commit the compilation by setting the method's code address method->set_state(Method::ST_Compiled); method->do_jit_recompiled_method_callbacks(); method->apply_vtable_patches(); method->unlock(); if (!parallel_jit) { vm_env->p_jit_a_method_lock->_unlock(); } // Find TI environment DebugUtilsTI *ti = vm_env->TI; // Call TI callbacks if (jvmti_should_report_event(JVMTI_EVENT_COMPILED_METHOD_LOAD) && ti->getPhase() == JVMTI_PHASE_LIVE) { jvmti_send_chunks_compiled_method_load_event(method); } return JIT_SUCCESS; } // Create an exception from a given type and a message. // Set cause to the current thread exception. static void compile_raise_exception(const char* name, const char* message, Method* method) { assert(hythread_is_suspend_enabled()); jthrowable old_exc = exn_get(); exn_clear(); const char* c = method->get_class()->get_name()->bytes; const char* m = method->get_name()->bytes; const char* d = method->get_descriptor()->bytes; size_t sz = 3 + // a space, a dot, and a terminator strlen(message) + method->get_class()->get_name()->len + method->get_name()->len + method->get_descriptor()->len; char* msg_raw = (char*)STD_MALLOC(sz); assert(msg_raw); sprintf(msg_raw, "%s%s.%s%s", message, c, m, d); assert(strlen(msg_raw) < sz); jthrowable new_exc = exn_create(name, msg_raw, old_exc); exn_raise_object(new_exc); STD_FREE(msg_raw); } static JIT_Result compile_do_compilation(Method* method) { ASSERT_RAISE_AREA; assert(hythread_is_suspend_enabled()); tmn_suspend_disable(); class_initialize(method->get_class()); tmn_suspend_enable(); method->lock(); if (exn_raised()) { method->unlock(); return JIT_FAILURE; } else if (method->get_state() == Method::ST_Compiled) { method->unlock(); return JIT_SUCCESS; } else if (method->get_state()==Method::ST_NotCompiled && exn_raised()) { method->unlock(); return JIT_FAILURE; } else if(!check_available_stack_size(0x8000)) { method->unlock(); return JIT_FAILURE; } if (method->is_native()) { JIT_Result res = compile_prepare_native_method(method); if (res == JIT_SUCCESS) { compile_flush_generated_code(); method->set_state(Method::ST_Compiled); method->do_jit_recompiled_method_callbacks(); method->apply_vtable_patches(); } else { method->set_state(Method::ST_NotCompiled); compile_raise_exception("java/lang/UnsatisfiedLinkError", "Cannot load native ", method); } method->unlock(); return res; } else { // Call an execution manager to compile the method. // An execution manager is safe to call from multiple threads. method->unlock(); return VM_Global_State::loader_env->em_interface->CompileMethod(method); } } NativeCodePtr compile_me(Method* method) { ASSERT_RAISE_AREA; ASSERT_NO_INTERPRETER; TRACE("compile_me " << method); GcFrame gc; compile_protect_arguments(method, &gc); if (exn_raised()) { return NULL; } tmn_suspend_enable(); if (method->is_abstract()) { compile_raise_exception("java/lang/AbstractMethodError", "", method); tmn_suspend_disable(); return NULL; } DebugUtilsTI *ti = VM_Global_State::loader_env->TI; JIT_Result res = compile_do_compilation(method); if (res != JIT_SUCCESS) { INFO2("compile", "Cannot compile " << method); if (!exn_raised()) { compile_raise_exception("java/lang/InternalError", "Cannot compile ", method); } tmn_suspend_disable(); return NULL; } tmn_suspend_disable(); NativeCodePtr entry_point = method->get_code_addr(); INFO2("compile.code", "Compiled method " << method << ", entry " << entry_point); if (method->get_pending_breakpoints() != 0) jvmti_set_pending_breakpoints(method); if(ti->isEnabled() && ti->is_single_step_enabled() && !method->is_native()) { jvmti_thread_t jvmti_thread = jthread_self_jvmti(); assert(jvmti_thread); jvmti_set_single_step_breakpoints_for_method(ti, jvmti_thread, method); } return entry_point; } // compile_me // Adding dynamic generated code info to global list // Is used in JVMTI and native frames interface DynamicCode* compile_get_dynamic_code_list(void) { return VM_Global_State::loader_env->dcList; } // Adding dynamic generated code info to global list void compile_add_dynamic_generated_code_chunk(const char* name, bool free_name, const void* address, size_t length) { DynamicCode *dc = (DynamicCode *)STD_MALLOC(sizeof(DynamicCode)); assert(dc); dc->name = name; dc->free_name = free_name; dc->address = address; dc->length = length; // Synchronizing access to dynamic code list LMAutoUnlock dcll(VM_Global_State::loader_env->p_dclist_lock); DynamicCode** pdcList = &VM_Global_State::loader_env->dcList; dc->next = *pdcList; *pdcList = dc; } void compile_clear_dynamic_code_list(DynamicCode* list) { while (list) { DynamicCode* next = list->next; if (list->free_name) STD_FREE((void *)list->name); STD_FREE(list); list = next; } } VMEXPORT void vm_compiled_method_load(Method_Handle method, U_32 codeSize, void* codeAddr, U_32 mapLength, AddrLocation* addrLocationMap, void* compileInfo, Method_Handle outer_method) { assert(method); assert(outer_method); outer_method->add_inline_info_entry(method, codeSize, codeAddr, mapLength, addrLocationMap); // Find TI environment DebugUtilsTI *ti = VM_Global_State::loader_env->TI; // Call TI callbacks if (jvmti_should_report_event(JVMTI_EVENT_COMPILED_METHOD_LOAD) && ti->getPhase() == JVMTI_PHASE_LIVE) { jvmti_send_region_compiled_method_load_event(method, codeSize, codeAddr, mapLength, addrLocationMap, NULL); } }