From 0df10bbd96df46f23a7f57e5b9455fea41b2b15b Mon Sep 17 00:00:00 2001 From: Andrew Dinn Date: Fri, 6 Sep 2024 13:57:13 +0000 Subject: [PATCH] 8339466: Enumerate shared stubs and define static fields and names via declarations Reviewed-by: kvn, fyang --- .../cpu/aarch64/sharedRuntime_aarch64.cpp | 34 +++++--- src/hotspot/cpu/arm/sharedRuntime_arm.cpp | 31 ++++--- src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp | 35 +++++--- src/hotspot/cpu/riscv/sharedRuntime_riscv.cpp | 34 +++++--- src/hotspot/cpu/s390/sharedRuntime_s390.cpp | 20 +++-- src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp | 32 ++++--- src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp | 33 ++++--- src/hotspot/cpu/zero/sharedRuntime_zero.cpp | 6 +- src/hotspot/share/runtime/sharedRuntime.cpp | 76 ++++++++-------- src/hotspot/share/runtime/sharedRuntime.hpp | 79 +++++++++++------ .../share/runtime/stubDeclarations.hpp | 86 +++++++++++++++++++ 11 files changed, 328 insertions(+), 138 deletions(-) create mode 100644 src/hotspot/share/runtime/stubDeclarations.hpp diff --git a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp index 901ae502999..3117c751498 100644 --- a/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp +++ b/src/hotspot/cpu/aarch64/sharedRuntime_aarch64.cpp @@ -2181,7 +2181,8 @@ void SharedRuntime::generate_deopt_blob() { pad += 512; // Increase the buffer size when compiling for JVMCI } #endif - CodeBuffer buffer("deopt_blob", 2048+pad, 1024); + const char* name = SharedRuntime::stub_name(SharedStubId::deopt_id); + CodeBuffer buffer(name, 2048+pad, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); int frame_size_in_words; OopMap* map = nullptr; @@ -2565,20 +2566,23 @@ uint SharedRuntime::out_preserve_stack_slots() { // Generate a special Compile2Runtime blob that saves all registers, // and setup oopmap. // -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { + assert(is_polling_page_id(id), "expected a polling page stub id"); + ResourceMark rm; OopMapSet *oop_maps = new OopMapSet(); OopMap* map; // Allocate space for the code. Setup code generation tools. - CodeBuffer buffer("handler_blob", 2048, 1024); + const char* name = SharedRuntime::stub_name(id); + CodeBuffer buffer(name, 2048, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); address start = __ pc(); address call_pc = nullptr; int frame_size_in_words; - bool cause_return = (poll_type == POLL_AT_RETURN); - RegisterSaver reg_save(poll_type == POLL_AT_VECTOR_LOOP /* save_vectors */); + bool cause_return = (id == SharedStubId::polling_page_return_handler_id); + RegisterSaver reg_save(id == SharedStubId::polling_page_vectors_safepoint_handler_id /* save_vectors */); // When the signal occurred, the LR was either signed and stored on the stack (in which // case it will be restored from the stack before being used) or unsigned and not stored @@ -2690,12 +2694,14 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t // but since this is generic code we don't know what they are and the caller // must do any gc of the args. // -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { assert (StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_resolve_id(id), "expected a resolve stub id"); // allocate space for the code ResourceMark rm; + const char* name = SharedRuntime::stub_name(id); CodeBuffer buffer(name, 1000, 512); MacroAssembler* masm = new MacroAssembler(&buffer); @@ -2787,7 +2793,11 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha // otherwise assume that stack unwinding will be initiated, so // caller saved registers were assumed volatile in the compiler. -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { + assert(is_throw_id(id), "expected a throw stub id"); + + const char* name = SharedRuntime::stub_name(id); + // Information about frame layout at time of blocking runtime call. // Note that we only have to preserve callee-saved registers since // the compilers are responsible for supplying a continuation point @@ -2896,7 +2906,8 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { int insts_size = 1024; int locs_size = 64; - CodeBuffer code("jfr_write_checkpoint", insts_size, locs_size); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_write_checkpoint_id); + CodeBuffer code(name, insts_size, locs_size); OopMapSet* oop_maps = new OopMapSet(); MacroAssembler* masm = new MacroAssembler(&code); @@ -2915,7 +2926,7 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { oop_maps->add_gc_map(the_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub("jfr_write_checkpoint", &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; @@ -2934,7 +2945,8 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { int insts_size = 1024; int locs_size = 64; - CodeBuffer code("jfr_return_lease", insts_size, locs_size); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_return_lease_id); + CodeBuffer code(name, insts_size, locs_size); OopMapSet* oop_maps = new OopMapSet(); MacroAssembler* masm = new MacroAssembler(&code); @@ -2953,7 +2965,7 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { oop_maps->add_gc_map(the_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub("jfr_return_lease", &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; diff --git a/src/hotspot/cpu/arm/sharedRuntime_arm.cpp b/src/hotspot/cpu/arm/sharedRuntime_arm.cpp index f07c1f8e53c..7648e5c5d92 100644 --- a/src/hotspot/cpu/arm/sharedRuntime_arm.cpp +++ b/src/hotspot/cpu/arm/sharedRuntime_arm.cpp @@ -1360,7 +1360,8 @@ uint SharedRuntime::out_preserve_stack_slots() { //------------------------------generate_deopt_blob---------------------------- void SharedRuntime::generate_deopt_blob() { ResourceMark rm; - CodeBuffer buffer("deopt_blob", 1024, 1024); + const char* name = SharedRuntime::stub_name(SharedStubId::deopt_id); + CodeBuffer buffer(name, 1024, 1024); int frame_size_in_words; OopMapSet* oop_maps; int reexecute_offset; @@ -1601,15 +1602,17 @@ void SharedRuntime::generate_deopt_blob() { // setup oopmap, and calls safepoint code to stop the compiled code for // a safepoint. // -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { assert(StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_polling_page_id(id), "expected a polling page stub id"); ResourceMark rm; - CodeBuffer buffer("handler_blob", 256, 256); + const char* name = SharedRuntime::stub_name(id); + CodeBuffer buffer(name, 256, 256); int frame_size_words; OopMapSet* oop_maps; - bool cause_return = (poll_type == POLL_AT_RETURN); + bool cause_return = (id == SharedStubId::polling_page_return_handler_id); MacroAssembler* masm = new MacroAssembler(&buffer); address start = __ pc(); @@ -1671,10 +1674,12 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t return SafepointBlob::create(&buffer, oop_maps, frame_size_words); } -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { assert(StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_resolve_id(id), "expected a resolve stub id"); ResourceMark rm; + const char* name = SharedRuntime::stub_name(id); CodeBuffer buffer(name, 1000, 512); int frame_size_words; OopMapSet *oop_maps; @@ -1733,7 +1738,11 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha // Continuation point for throwing of implicit exceptions that are not handled in // the current activation. Fabricates an exception oop and initiates normal // exception dispatching in this frame. -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { + assert(is_throw_id(id), "expected a throw stub id"); + + const char* name = SharedRuntime::stub_name(id); + int insts_size = 128; int locs_size = 32; @@ -1793,7 +1802,8 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { framesize // inclusive of return address }; - CodeBuffer code("jfr_write_checkpoint", 512, 64); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_write_checkpoint_id); + CodeBuffer code(name, 512, 64); MacroAssembler* masm = new MacroAssembler(&code); address start = __ pc(); @@ -1818,7 +1828,7 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { oop_maps->add_gc_map(frame_complete, map); RuntimeStub* stub = - RuntimeStub::new_runtime_stub(code.name(), + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), @@ -1836,7 +1846,8 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { framesize // inclusive of return address }; - CodeBuffer code("jfr_return_lease", 512, 64); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_return_lease_id); + CodeBuffer code(name, 512, 64); MacroAssembler* masm = new MacroAssembler(&code); address start = __ pc(); @@ -1858,7 +1869,7 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { oop_maps->add_gc_map(frame_complete, map); RuntimeStub* stub = - RuntimeStub::new_runtime_stub(code.name(), + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), diff --git a/src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp b/src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp index 981f1c7afd2..5cf5f7cf73e 100644 --- a/src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp +++ b/src/hotspot/cpu/ppc/sharedRuntime_ppc.cpp @@ -2856,7 +2856,8 @@ void SharedRuntime::generate_deopt_blob() { // Allocate space for the code ResourceMark rm; // Setup code generation tools - CodeBuffer buffer("deopt_blob", 2048, 1024); + const char* name = SharedRuntime::stub_name(SharedStubId::deopt_id); + CodeBuffer buffer(name, 2048, 1024); InterpreterMacroAssembler* masm = new InterpreterMacroAssembler(&buffer); Label exec_mode_initialized; int frame_size_in_words; @@ -3206,23 +3207,25 @@ void OptoRuntime::generate_uncommon_trap_blob() { #endif // COMPILER2 // Generate a special Compile2Runtime blob that saves all registers, and setup oopmap. -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { assert(StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_polling_page_id(id), "expected a polling page stub id"); ResourceMark rm; OopMapSet *oop_maps = new OopMapSet(); OopMap* map; // Allocate space for the code. Setup code generation tools. - CodeBuffer buffer("handler_blob", 2048, 1024); + const char* name = SharedRuntime::stub_name(id); + CodeBuffer buffer(name, 2048, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); address start = __ pc(); int frame_size_in_bytes = 0; RegisterSaver::ReturnPCLocation return_pc_location; - bool cause_return = (poll_type == POLL_AT_RETURN); + bool cause_return = (id == SharedStubId::polling_page_return_handler_id); if (cause_return) { // Nothing to do here. The frame has already been popped in MachEpilogNode. // Register LR already contains the return pc. @@ -3232,7 +3235,7 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t return_pc_location = RegisterSaver::return_pc_is_thread_saved_exception_pc; } - bool save_vectors = (poll_type == POLL_AT_VECTOR_LOOP); + bool save_vectors = (id == SharedStubId::polling_page_vectors_safepoint_handler_id); // Save registers, fpu state, and flags. Set R31 = return pc. map = RegisterSaver::push_frame_reg_args_and_save_live_registers(masm, @@ -3319,11 +3322,13 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t // but since this is generic code we don't know what they are and the caller // must do any gc of the args. // -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { + assert(is_resolve_id(id), "expected a resolve stub id"); // allocate space for the code ResourceMark rm; + const char* name = SharedRuntime::stub_name(id); CodeBuffer buffer(name, 1000, 512); MacroAssembler* masm = new MacroAssembler(&buffer); @@ -3421,7 +3426,11 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha // Note: the routine set_pc_not_at_call_for_caller in // SharedRuntime.cpp requires that this code be generated into a // RuntimeStub. -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { + assert(is_throw_id(id), "expected a throw stub id"); + + const char* name = SharedRuntime::stub_name(id); + ResourceMark rm; const char* timer_msg = "SharedRuntime generate_throw_exception"; TraceTime timer(timer_msg, TRACETIME_LOG(Info, startuptime)); @@ -3740,7 +3749,8 @@ void SharedRuntime::montgomery_square(jint *a_ints, jint *n_ints, // It returns a jobject handle to the event writer. // The handle is dereferenced and the return value is the event writer oop. RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { - CodeBuffer code("jfr_write_checkpoint", 512, 64); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_write_checkpoint_id); + CodeBuffer code(name, 512, 64); MacroAssembler* masm = new MacroAssembler(&code); Register tmp1 = R10_ARG8; @@ -3768,8 +3778,7 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { oop_maps->add_gc_map(calls_return_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub(code.name(), - &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; @@ -3777,7 +3786,8 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { // For c2: call to return a leased buffer. RuntimeStub* SharedRuntime::generate_jfr_return_lease() { - CodeBuffer code("jfr_return_lease", 512, 64); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_return_lease_id); + CodeBuffer code(name, 512, 64); MacroAssembler* masm = new MacroAssembler(&code); Register tmp1 = R10_ARG8; @@ -3803,8 +3813,7 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { oop_maps->add_gc_map(calls_return_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub(code.name(), - &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; diff --git a/src/hotspot/cpu/riscv/sharedRuntime_riscv.cpp b/src/hotspot/cpu/riscv/sharedRuntime_riscv.cpp index ffd904aed47..879fd922722 100644 --- a/src/hotspot/cpu/riscv/sharedRuntime_riscv.cpp +++ b/src/hotspot/cpu/riscv/sharedRuntime_riscv.cpp @@ -2057,7 +2057,8 @@ void SharedRuntime::generate_deopt_blob() { pad += 512; // Increase the buffer size when compiling for JVMCI } #endif - CodeBuffer buffer("deopt_blob", 2048 + pad, 1024); + const char* name = SharedRuntime::stub_name(SharedStubId::deopt_id); + CodeBuffer buffer(name, 2048 + pad, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); int frame_size_in_words = -1; OopMap* map = nullptr; @@ -2435,22 +2436,25 @@ uint SharedRuntime::out_preserve_stack_slots() { // Generate a special Compile2Runtime blob that saves all registers, // and setup oopmap. // -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { + assert(is_polling_page_id(id), "expected a polling page stub id"); + ResourceMark rm; OopMapSet *oop_maps = new OopMapSet(); assert_cond(oop_maps != nullptr); OopMap* map = nullptr; // Allocate space for the code. Setup code generation tools. - CodeBuffer buffer("handler_blob", 2048, 1024); + const char* name = SharedRuntime::stub_name(id); + CodeBuffer buffer(name, 2048, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); assert_cond(masm != nullptr); address start = __ pc(); address call_pc = nullptr; int frame_size_in_words = -1; - bool cause_return = (poll_type == POLL_AT_RETURN); - RegisterSaver reg_saver(poll_type == POLL_AT_VECTOR_LOOP /* save_vectors */); + bool cause_return = (id == SharedStubId::polling_page_return_handler_id); + RegisterSaver reg_saver(id == SharedStubId::polling_page_vectors_safepoint_handler_id /* save_vectors */); // Save Integer and Float registers. map = reg_saver.save_live_registers(masm, 0, &frame_size_in_words); @@ -2556,12 +2560,14 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t // but since this is generic code we don't know what they are and the caller // must do any gc of the args. // -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { assert(StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_resolve_id(id), "expected a resolve stub id"); // allocate space for the code ResourceMark rm; + const char* name = SharedRuntime::stub_name(id); CodeBuffer buffer(name, 1000, 512); MacroAssembler* masm = new MacroAssembler(&buffer); assert_cond(masm != nullptr); @@ -2652,7 +2658,11 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha // otherwise assume that stack unwinding will be initiated, so // caller saved registers were assumed volatile in the compiler. -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { + assert(is_throw_id(id), "expected a throw stub id"); + + const char* name = SharedRuntime::stub_name(id); + // Information about frame layout at time of blocking runtime call. // Note that we only have to preserve callee-saved registers since // the compilers are responsible for supplying a continuation point @@ -2759,7 +2769,8 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { int insts_size = 1024; int locs_size = 64; - CodeBuffer code("jfr_write_checkpoint", insts_size, locs_size); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_write_checkpoint_id); + CodeBuffer code(name, insts_size, locs_size); OopMapSet* oop_maps = new OopMapSet(); MacroAssembler* masm = new MacroAssembler(&code); @@ -2779,7 +2790,7 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { oop_maps->add_gc_map(the_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub("jfr_write_checkpoint", &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; @@ -2797,7 +2808,8 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { int insts_size = 1024; int locs_size = 64; - CodeBuffer code("jfr_return_lease", insts_size, locs_size); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_return_lease_id); + CodeBuffer code(name, insts_size, locs_size); OopMapSet* oop_maps = new OopMapSet(); MacroAssembler* masm = new MacroAssembler(&code); @@ -2816,7 +2828,7 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { oop_maps->add_gc_map(the_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub("jfr_return_lease", &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; diff --git a/src/hotspot/cpu/s390/sharedRuntime_s390.cpp b/src/hotspot/cpu/s390/sharedRuntime_s390.cpp index 364ef948d91..9954c78ce1e 100644 --- a/src/hotspot/cpu/s390/sharedRuntime_s390.cpp +++ b/src/hotspot/cpu/s390/sharedRuntime_s390.cpp @@ -2488,7 +2488,8 @@ void SharedRuntime::generate_deopt_blob() { // Allocate space for the code. ResourceMark rm; // Setup code generation tools. - CodeBuffer buffer("deopt_blob", 2048, 1024); + const char* name = SharedRuntime::stub_name(SharedStubId::deopt_id); + CodeBuffer buffer(name, 2048, 1024); InterpreterMacroAssembler* masm = new InterpreterMacroAssembler(&buffer); Label exec_mode_initialized; OopMap* map = nullptr; @@ -2834,23 +2835,25 @@ void OptoRuntime::generate_uncommon_trap_blob() { // // Generate a special Compile2Runtime blob that saves all registers, // and setup oopmap. -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { assert(StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_polling_page_id(id), "expected a polling page stub id"); ResourceMark rm; OopMapSet *oop_maps = new OopMapSet(); OopMap* map; // Allocate space for the code. Setup code generation tools. - CodeBuffer buffer("handler_blob", 2048, 1024); + const char* name = SharedRuntime::stub_name(id); + CodeBuffer buffer(name, 2048, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); unsigned int start_off = __ offset(); address call_pc = nullptr; int frame_size_in_bytes; - bool cause_return = (poll_type == POLL_AT_RETURN); + bool cause_return = (id == SharedStubId::polling_page_return_handler_id); // Make room for return address (or push it again) if (!cause_return) { __ z_lg(Z_R14, Address(Z_thread, JavaThread::saved_exception_pc_offset())); @@ -2935,12 +2938,14 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t // but since this is generic code we don't know what they are and the caller // must do any gc of the args. // -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { assert (StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_resolve_id(id), "expected a resolve stub id"); // allocate space for the code ResourceMark rm; + const char* name = SharedRuntime::stub_name(id); CodeBuffer buffer(name, 1000, 512); MacroAssembler* masm = new MacroAssembler(&buffer); @@ -3032,7 +3037,10 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha // SharedRuntime.cpp requires that this code be generated into a // RuntimeStub. -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { + assert(is_throw_id(id), "expected a throw stub id"); + + const char* name = SharedRuntime::stub_name(id); int insts_size = 256; int locs_size = 0; diff --git a/src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp b/src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp index 273bbcc6525..c6ab00cc9ee 100644 --- a/src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp +++ b/src/hotspot/cpu/x86/sharedRuntime_x86_32.cpp @@ -2062,7 +2062,8 @@ void SharedRuntime::generate_deopt_blob() { ResourceMark rm; // setup code generation tools // note: the buffer code size must account for StackShadowPages=50 - CodeBuffer buffer("deopt_blob", 1536, 1024); + const char* name = SharedRuntime::stub_name(SharedStubId::deopt_id); + CodeBuffer buffer(name, 1536, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); int frame_size_in_words; OopMap* map = nullptr; @@ -2403,13 +2404,14 @@ void SharedRuntime::generate_deopt_blob() { // setup oopmap, and calls safepoint code to stop the compiled code for // a safepoint. // -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { // Account for thread arg in our frame const int additional_words = 1; int frame_size_in_words; assert (StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_polling_page_id(id), "expected a polling page stub id"); ResourceMark rm; OopMapSet *oop_maps = new OopMapSet(); @@ -2417,14 +2419,15 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t // allocate space for the code // setup code generation tools - CodeBuffer buffer("handler_blob", 2048, 1024); + const char* name = SharedRuntime::stub_name(id); + CodeBuffer buffer(name, 2048, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); const Register java_thread = rdi; // callee-saved for VC++ address start = __ pc(); address call_pc = nullptr; - bool cause_return = (poll_type == POLL_AT_RETURN); - bool save_vectors = (poll_type == POLL_AT_VECTOR_LOOP); + bool cause_return = (id == SharedStubId::polling_page_return_handler_id); + bool save_vectors = (id == SharedStubId::polling_page_vectors_safepoint_handler_id); // If cause_return is true we are at a poll_return and there is // the return address on the stack to the caller on the nmethod @@ -2556,12 +2559,14 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t // but since this is generic code we don't know what they are and the caller // must do any gc of the args. // -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { assert (StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_resolve_id(id), "expected a resolve stub id"); // allocate space for the code ResourceMark rm; + const char* name = SharedRuntime::stub_name(id); CodeBuffer buffer(name, 1000, 512); MacroAssembler* masm = new MacroAssembler(&buffer); @@ -2662,7 +2667,10 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha // exceptions (e.g., NullPointerException or AbstractMethodError on entry) are // either at call sites or otherwise assume that stack unwinding will be initiated, // so caller saved registers were assumed volatile in the compiler. -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { + assert(is_throw_id(id), "expected a throw stub id"); + + const char* name = SharedRuntime::stub_name(id); // Information about frame layout at time of blocking runtime call. // Note that we only have to preserve callee-saved registers since @@ -2776,7 +2784,8 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { int insts_size = 1024; int locs_size = 64; - CodeBuffer code("jfr_write_checkpoint", insts_size, locs_size); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_write_checkpoint_id); + CodeBuffer code(name, insts_size, locs_size); OopMapSet* oop_maps = new OopMapSet(); MacroAssembler* masm = new MacroAssembler(&code); @@ -2795,7 +2804,7 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { oop_maps->add_gc_map(the_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub("jfr_write_checkpoint", &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; @@ -2817,7 +2826,8 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { int insts_size = 1024; int locs_size = 64; - CodeBuffer code("jfr_return_lease", insts_size, locs_size); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_return_lease_id); + CodeBuffer code(name, insts_size, locs_size); OopMapSet* oop_maps = new OopMapSet(); MacroAssembler* masm = new MacroAssembler(&code); @@ -2835,7 +2845,7 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { oop_maps->add_gc_map(the_pc - start, map); RuntimeStub* stub = // codeBlob framesize is in words (not VMRegImpl::slot_size) - RuntimeStub::new_runtime_stub("jfr_return_lease", &code, frame_complete, + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), oop_maps, false); return stub; diff --git a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp index 05ec85ef09a..4bd91f640fc 100644 --- a/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp +++ b/src/hotspot/cpu/x86/sharedRuntime_x86_64.cpp @@ -2623,7 +2623,8 @@ void SharedRuntime::generate_deopt_blob() { pad += 512; // Increase the buffer size when compiling for JVMCI } #endif - CodeBuffer buffer("deopt_blob", 2560+pad, 1024); + const char* name = SharedRuntime::stub_name(SharedStubId::deopt_id); + CodeBuffer buffer(name, 2560+pad, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); int frame_size_in_words; OopMap* map = nullptr; @@ -2981,23 +2982,25 @@ void SharedRuntime::generate_deopt_blob() { // Generate a special Compile2Runtime blob that saves all registers, // and setup oopmap. // -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { assert(StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_polling_page_id(id), "expected a polling page stub id"); ResourceMark rm; OopMapSet *oop_maps = new OopMapSet(); OopMap* map; // Allocate space for the code. Setup code generation tools. - CodeBuffer buffer("handler_blob", 2348, 1024); + const char* name = SharedRuntime::stub_name(id); + CodeBuffer buffer(name, 2348, 1024); MacroAssembler* masm = new MacroAssembler(&buffer); address start = __ pc(); address call_pc = nullptr; int frame_size_in_words; - bool cause_return = (poll_type == POLL_AT_RETURN); - bool save_wide_vectors = (poll_type == POLL_AT_VECTOR_LOOP); + bool cause_return = (id == SharedStubId::polling_page_return_handler_id); + bool save_wide_vectors = (id == SharedStubId::polling_page_vectors_safepoint_handler_id); // Make room for return address (or push it again) if (!cause_return) { @@ -3140,12 +3143,14 @@ SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_t // but since this is generic code we don't know what they are and the caller // must do any gc of the args. // -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { assert (StubRoutines::forward_exception_entry() != nullptr, "must be generated before"); + assert(is_resolve_id(id), "expected a resolve stub id"); // allocate space for the code ResourceMark rm; + const char* name = SharedRuntime::stub_name(id); CodeBuffer buffer(name, 1552, 512); MacroAssembler* masm = new MacroAssembler(&buffer); @@ -3232,7 +3237,11 @@ RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const cha // AbstractMethodError on entry) are either at call sites or // otherwise assume that stack unwinding will be initiated, so // caller saved registers were assumed volatile in the compiler. -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { + assert(is_throw_id(id), "expected a throw stub id"); + + const char* name = SharedRuntime::stub_name(id); + // Information about frame layout at time of blocking runtime call. // Note that we only have to preserve callee-saved registers since // the compilers are responsible for supplying a continuation point @@ -3591,7 +3600,8 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { framesize // inclusive of return address }; - CodeBuffer code("jfr_write_checkpoint", 1024, 64); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_write_checkpoint_id); + CodeBuffer code(name, 1024, 64); MacroAssembler* masm = new MacroAssembler(&code); address start = __ pc(); @@ -3616,7 +3626,7 @@ RuntimeStub* SharedRuntime::generate_jfr_write_checkpoint() { oop_maps->add_gc_map(frame_complete, map); RuntimeStub* stub = - RuntimeStub::new_runtime_stub(code.name(), + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), @@ -3635,7 +3645,8 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { framesize // inclusive of return address }; - CodeBuffer code("jfr_return_lease", 1024, 64); + const char* name = SharedRuntime::stub_name(SharedStubId::jfr_return_lease_id); + CodeBuffer code(name, 1024, 64); MacroAssembler* masm = new MacroAssembler(&code); address start = __ pc(); @@ -3657,7 +3668,7 @@ RuntimeStub* SharedRuntime::generate_jfr_return_lease() { oop_maps->add_gc_map(frame_complete, map); RuntimeStub* stub = - RuntimeStub::new_runtime_stub(code.name(), + RuntimeStub::new_runtime_stub(name, &code, frame_complete, (framesize >> (LogBytesPerWord - LogBytesPerInt)), diff --git a/src/hotspot/cpu/zero/sharedRuntime_zero.cpp b/src/hotspot/cpu/zero/sharedRuntime_zero.cpp index 454f8e5f632..18ceb9514d3 100644 --- a/src/hotspot/cpu/zero/sharedRuntime_zero.cpp +++ b/src/hotspot/cpu/zero/sharedRuntime_zero.cpp @@ -105,15 +105,15 @@ void SharedRuntime::generate_deopt_blob() { _deopt_blob = generate_empty_deopt_blob(); } -SafepointBlob* SharedRuntime::generate_handler_blob(address call_ptr, int poll_type) { +SafepointBlob* SharedRuntime::generate_handler_blob(SharedStubId id, address call_ptr) { return generate_empty_safepoint_blob(); } -RuntimeStub* SharedRuntime::generate_resolve_blob(address destination, const char* name) { +RuntimeStub* SharedRuntime::generate_resolve_blob(SharedStubId id, address destination) { return generate_empty_runtime_stub(); } -RuntimeStub* SharedRuntime::generate_throw_exception(const char* name, address runtime_entry) { +RuntimeStub* SharedRuntime::generate_throw_exception(SharedStubId id, address runtime_entry) { return generate_empty_runtime_stub(); } diff --git a/src/hotspot/share/runtime/sharedRuntime.cpp b/src/hotspot/share/runtime/sharedRuntime.cpp index f98d031a2cd..d9b38133f99 100644 --- a/src/hotspot/share/runtime/sharedRuntime.cpp +++ b/src/hotspot/share/runtime/sharedRuntime.cpp @@ -92,61 +92,61 @@ // Shared runtime stub routines reside in their own unique blob with a // single entry point -RuntimeStub* SharedRuntime::_wrong_method_blob; -RuntimeStub* SharedRuntime::_wrong_method_abstract_blob; -RuntimeStub* SharedRuntime::_ic_miss_blob; -RuntimeStub* SharedRuntime::_resolve_opt_virtual_call_blob; -RuntimeStub* SharedRuntime::_resolve_virtual_call_blob; -RuntimeStub* SharedRuntime::_resolve_static_call_blob; -DeoptimizationBlob* SharedRuntime::_deopt_blob; -SafepointBlob* SharedRuntime::_polling_page_vectors_safepoint_handler_blob; -SafepointBlob* SharedRuntime::_polling_page_safepoint_handler_blob; -SafepointBlob* SharedRuntime::_polling_page_return_handler_blob; - -RuntimeStub* SharedRuntime::_throw_AbstractMethodError_blob; -RuntimeStub* SharedRuntime::_throw_IncompatibleClassChangeError_blob; -RuntimeStub* SharedRuntime::_throw_NullPointerException_at_call_blob; -RuntimeStub* SharedRuntime::_throw_StackOverflowError_blob; -RuntimeStub* SharedRuntime::_throw_delayed_StackOverflowError_blob; - -#if INCLUDE_JFR -RuntimeStub* SharedRuntime::_jfr_write_checkpoint_blob = nullptr; -RuntimeStub* SharedRuntime::_jfr_return_lease_blob = nullptr; -#endif +#define SHARED_STUB_FIELD_DEFINE(name, type) \ + type SharedRuntime::BLOB_FIELD_NAME(name); + SHARED_STUBS_DO(SHARED_STUB_FIELD_DEFINE) +#undef SHARED_STUB_FIELD_DEFINE nmethod* SharedRuntime::_cont_doYield_stub; +#define SHARED_STUB_NAME_DECLARE(name, type) "Shared Runtime " # name "_blob", +const char *SharedRuntime::_stub_names[] = { + SHARED_STUBS_DO(SHARED_STUB_NAME_DECLARE) +}; + //----------------------------generate_stubs----------------------------------- void SharedRuntime::generate_initial_stubs() { // Build this early so it's available for the interpreter. _throw_StackOverflowError_blob = - generate_throw_exception("StackOverflowError throw_exception", + generate_throw_exception(SharedStubId::throw_StackOverflowError_id, CAST_FROM_FN_PTR(address, SharedRuntime::throw_StackOverflowError)); } void SharedRuntime::generate_stubs() { - _wrong_method_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method), "wrong_method_stub"); - _wrong_method_abstract_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_abstract), "wrong_method_abstract_stub"); - _ic_miss_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss), "ic_miss_stub"); - _resolve_opt_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C), "resolve_opt_virtual_call"); - _resolve_virtual_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C), "resolve_virtual_call"); - _resolve_static_call_blob = generate_resolve_blob(CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C), "resolve_static_call"); + _wrong_method_blob = + generate_resolve_blob(SharedStubId::wrong_method_id, + CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method)); + _wrong_method_abstract_blob = + generate_resolve_blob(SharedStubId::wrong_method_abstract_id, + CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_abstract)); + _ic_miss_blob = + generate_resolve_blob(SharedStubId::ic_miss_id, + CAST_FROM_FN_PTR(address, SharedRuntime::handle_wrong_method_ic_miss)); + _resolve_opt_virtual_call_blob = + generate_resolve_blob(SharedStubId::resolve_opt_virtual_call_id, + CAST_FROM_FN_PTR(address, SharedRuntime::resolve_opt_virtual_call_C)); + _resolve_virtual_call_blob = + generate_resolve_blob(SharedStubId::resolve_virtual_call_id, + CAST_FROM_FN_PTR(address, SharedRuntime::resolve_virtual_call_C)); + _resolve_static_call_blob = + generate_resolve_blob(SharedStubId::resolve_static_call_id, + CAST_FROM_FN_PTR(address, SharedRuntime::resolve_static_call_C)); _throw_delayed_StackOverflowError_blob = - generate_throw_exception("delayed StackOverflowError throw_exception", + generate_throw_exception(SharedStubId::throw_delayed_StackOverflowError_id, CAST_FROM_FN_PTR(address, SharedRuntime::throw_delayed_StackOverflowError)); _throw_AbstractMethodError_blob = - generate_throw_exception("AbstractMethodError throw_exception", + generate_throw_exception(SharedStubId::throw_AbstractMethodError_id, CAST_FROM_FN_PTR(address, SharedRuntime::throw_AbstractMethodError)); _throw_IncompatibleClassChangeError_blob = - generate_throw_exception("IncompatibleClassChangeError throw_exception", + generate_throw_exception(SharedStubId::throw_IncompatibleClassChangeError_id, CAST_FROM_FN_PTR(address, SharedRuntime::throw_IncompatibleClassChangeError)); _throw_NullPointerException_at_call_blob = - generate_throw_exception("NullPointerException at call throw_exception", + generate_throw_exception(SharedStubId::throw_NullPointerException_at_call_id, CAST_FROM_FN_PTR(address, SharedRuntime::throw_NullPointerException_at_call)); AdapterHandlerLibrary::initialize(); @@ -155,11 +155,17 @@ void SharedRuntime::generate_stubs() { // Vectors are generated only by C2 and JVMCI. bool support_wide = is_wide_vector(MaxVectorSize); if (support_wide) { - _polling_page_vectors_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_VECTOR_LOOP); + _polling_page_vectors_safepoint_handler_blob = + generate_handler_blob(SharedStubId::polling_page_vectors_safepoint_handler_id, + CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception)); } #endif // COMPILER2_OR_JVMCI - _polling_page_safepoint_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_LOOP); - _polling_page_return_handler_blob = generate_handler_blob(CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception), POLL_AT_RETURN); + _polling_page_safepoint_handler_blob = + generate_handler_blob(SharedStubId::polling_page_safepoint_handler_id, + CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception)); + _polling_page_return_handler_blob = + generate_handler_blob(SharedStubId::polling_page_return_handler_id, + CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception)); generate_deopt_blob(); } diff --git a/src/hotspot/share/runtime/sharedRuntime.hpp b/src/hotspot/share/runtime/sharedRuntime.hpp index 00a72f5db1e..f530c0ad2a8 100644 --- a/src/hotspot/share/runtime/sharedRuntime.hpp +++ b/src/hotspot/share/runtime/sharedRuntime.hpp @@ -30,6 +30,7 @@ #include "interpreter/linkResolver.hpp" #include "memory/allStatic.hpp" #include "memory/resourceArea.hpp" +#include "runtime/stubDeclarations.hpp" #include "utilities/macros.hpp" class AdapterHandlerEntry; @@ -42,37 +43,57 @@ class vframeStream; // Java exceptions), locking/unlocking mechanisms, statistical // information, etc. +// define SharedStubId enum tags: wrong_method_id, etc + +#define SHARED_STUB_ID_ENUM_DECLARE(name, type) STUB_ID_NAME(name), +enum class SharedStubId :int { + NO_STUBID = -1, + SHARED_STUBS_DO(SHARED_STUB_ID_ENUM_DECLARE) + NUM_STUBIDS +}; +#undef SHARED_STUB_ID_ENUM_DECLARE + class SharedRuntime: AllStatic { friend class VMStructs; private: - // Shared stub locations + // Declare shared stub fields +#define SHARED_STUB_FIELD_DECLARE(name, type) \ + static type BLOB_FIELD_NAME(name); + SHARED_STUBS_DO(SHARED_STUB_FIELD_DECLARE) +#undef SHARED_STUB_FIELD_DECLARE - static RuntimeStub* _wrong_method_blob; - static RuntimeStub* _wrong_method_abstract_blob; - static RuntimeStub* _ic_miss_blob; - static RuntimeStub* _resolve_opt_virtual_call_blob; - static RuntimeStub* _resolve_virtual_call_blob; - static RuntimeStub* _resolve_static_call_blob; - - static DeoptimizationBlob* _deopt_blob; - - static SafepointBlob* _polling_page_vectors_safepoint_handler_blob; - static SafepointBlob* _polling_page_safepoint_handler_blob; - static SafepointBlob* _polling_page_return_handler_blob; +#ifdef ASSERT + static bool is_resolve_id(SharedStubId id) { + return (id == SharedStubId::wrong_method_id || + id == SharedStubId::wrong_method_abstract_id || + id == SharedStubId::ic_miss_id || + id == SharedStubId::resolve_opt_virtual_call_id || + id == SharedStubId::resolve_virtual_call_id || + id == SharedStubId::resolve_static_call_id); + } + static bool is_polling_page_id(SharedStubId id) { + return (id == SharedStubId::polling_page_vectors_safepoint_handler_id || + id == SharedStubId::polling_page_safepoint_handler_id || + id == SharedStubId::polling_page_return_handler_id); + } + static bool is_throw_id(SharedStubId id) { + return (id == SharedStubId::throw_AbstractMethodError_id || + id == SharedStubId::throw_IncompatibleClassChangeError_id || + id == SharedStubId::throw_NullPointerException_at_call_id || + id == SharedStubId::throw_StackOverflowError_id || + id == SharedStubId::throw_delayed_StackOverflowError_id); + } +#endif + // cont_doYieldStub is not yet folded into the general model for + // shared stub/blob handling. It is actually a specially generated + // native wrapper for a specific native method, as also is it's + // counterpart the continuation do_enter method. static nmethod* _cont_doYield_stub; - static RuntimeStub* _throw_AbstractMethodError_blob; - static RuntimeStub* _throw_IncompatibleClassChangeError_blob; - static RuntimeStub* _throw_NullPointerException_at_call_blob; - static RuntimeStub* _throw_StackOverflowError_blob; - static RuntimeStub* _throw_delayed_StackOverflowError_blob; - -#if INCLUDE_JFR - static RuntimeStub* _jfr_write_checkpoint_blob; - static RuntimeStub* _jfr_return_lease_blob; -#endif + // Stub names indexed by SharedStubId + static const char *_stub_names[]; #ifndef PRODUCT // Counters @@ -80,10 +101,9 @@ class SharedRuntime: AllStatic { #endif // !PRODUCT private: - enum { POLL_AT_RETURN, POLL_AT_LOOP, POLL_AT_VECTOR_LOOP }; - static SafepointBlob* generate_handler_blob(address call_ptr, int poll_type); - static RuntimeStub* generate_resolve_blob(address destination, const char* name); - static RuntimeStub* generate_throw_exception(const char* name, address runtime_entry); + static SafepointBlob* generate_handler_blob(SharedStubId id, address call_ptr); + static RuntimeStub* generate_resolve_blob(SharedStubId id, address destination); + static RuntimeStub* generate_throw_exception(SharedStubId id, address runtime_entry); public: static void generate_initial_stubs(void); static void generate_stubs(void); @@ -97,6 +117,11 @@ class SharedRuntime: AllStatic { static RuntimeStub* generate_jfr_return_lease(); #endif + static const char *stub_name(SharedStubId id) { + assert(id > SharedStubId::NO_STUBID && id < SharedStubId::NUM_STUBIDS, "stub id out of range"); + return _stub_names[(int)id]; + } + // max bytes for each dtrace string parameter enum { max_dtrace_string_size = 256 }; diff --git a/src/hotspot/share/runtime/stubDeclarations.hpp b/src/hotspot/share/runtime/stubDeclarations.hpp new file mode 100644 index 00000000000..c9e946906f7 --- /dev/null +++ b/src/hotspot/share/runtime/stubDeclarations.hpp @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2024, Red Hat, Inc. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_RUNTIME_STUBDECLARATIONS_HPP +#define SHARE_RUNTIME_STUBDECLARATIONS_HPP + +#include "utilities/macros.hpp" + +// macros for generating definitions and declarations for shared, c1 +// and opto blob fields and associated stub ids + +// Different shared stubs can have different blob types and may +// include some JFR stubs +// +// n.b resolve, handler and throw stubs must remain grouped in the +// same order to allow id values to be range checked + +#if INCLUDE_JFR +// do_blob(name, type) +#define SHARED_JFR_STUBS_DO(do_blob) \ + do_blob(jfr_write_checkpoint, RuntimeStub*) \ + do_blob(jfr_return_lease, RuntimeStub*) \ + +#else +#define SHARED_JFR_STUBS_DO(do_blob) +#endif + +// do_blob(name, type) +#define SHARED_STUBS_DO(do_blob) \ + do_blob(deopt, DeoptimizationBlob*) \ + /* resolve stubs */ \ + do_blob(wrong_method, RuntimeStub*) \ + do_blob(wrong_method_abstract, RuntimeStub*) \ + do_blob(ic_miss, RuntimeStub*) \ + do_blob(resolve_opt_virtual_call, RuntimeStub*) \ + do_blob(resolve_virtual_call, RuntimeStub*) \ + do_blob(resolve_static_call, RuntimeStub*) \ + /* handler stubs */ \ + do_blob(polling_page_vectors_safepoint_handler, SafepointBlob*) \ + do_blob(polling_page_safepoint_handler, SafepointBlob*) \ + do_blob(polling_page_return_handler, SafepointBlob*) \ + /* throw stubs */ \ + do_blob(throw_AbstractMethodError, RuntimeStub*) \ + do_blob(throw_IncompatibleClassChangeError, RuntimeStub*) \ + do_blob(throw_NullPointerException_at_call, RuntimeStub*) \ + do_blob(throw_StackOverflowError, RuntimeStub*) \ + do_blob(throw_delayed_StackOverflowError, RuntimeStub*) \ + /* other stubs */ \ + SHARED_JFR_STUBS_DO(do_blob) \ + +// generate a stub id enum tag from a name + +#define STUB_ID_NAME(base) base##_id + +// generate a blob id enum tag from a name + +#define BLOB_ID_NAME(base) base##_id + +// generate a blob field name + +#define BLOB_FIELD_NAME(base) _##base##_blob + +#endif // SHARE_RUNTIME_STUBDECLARATIONS_HPP +