8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_RUNTIME_SHAREDRUNTIME_HPP
26 #define SHARE_RUNTIME_SHAREDRUNTIME_HPP
27
28 #include "code/codeBlob.hpp"
29 #include "code/vmreg.hpp"
30 #include "interpreter/linkResolver.hpp"
31 #include "memory/allStatic.hpp"
32 #include "memory/resourceArea.hpp"
33 #include "runtime/stubDeclarations.hpp"
34 #include "utilities/macros.hpp"
35
36 class AdapterHandlerEntry;
37 class AdapterFingerPrint;
38 class vframeStream;
39
40 // Runtime is the base class for various runtime interfaces
41 // (InterpreterRuntime, CompilerRuntime, etc.). It provides
42 // shared functionality such as exception forwarding (C++ to
43 // Java exceptions), locking/unlocking mechanisms, statistical
44 // information, etc.
45
46 // define SharedStubId enum tags: wrong_method_id, etc
47
48 #define SHARED_STUB_ID_ENUM_DECLARE(name, type) STUB_ID_NAME(name),
49 enum class SharedStubId :int {
50 NO_STUBID = -1,
51 SHARED_STUBS_DO(SHARED_STUB_ID_ENUM_DECLARE)
52 NUM_STUBIDS
53 };
54 #undef SHARED_STUB_ID_ENUM_DECLARE
55
56 class SharedRuntime: AllStatic {
57 private:
58 // Declare shared stub fields
97 // Counters
98 static int64_t _nof_megamorphic_calls; // total # of megamorphic calls (through vtable)
99 #endif // !PRODUCT
100
101 private:
102 static SafepointBlob* generate_handler_blob(SharedStubId id, address call_ptr);
103 static RuntimeStub* generate_resolve_blob(SharedStubId id, address destination);
104 static RuntimeStub* generate_throw_exception(SharedStubId id, address runtime_entry);
105 public:
106 static void generate_initial_stubs(void);
107 static void generate_stubs(void);
108 #if INCLUDE_JFR
109 static void generate_jfr_stubs(void);
110 // For c2: c_rarg0 is junk, call to runtime to write a checkpoint.
111 // It returns a jobject handle to the event writer.
112 // The handle is dereferenced and the return value is the event writer oop.
113 static RuntimeStub* generate_jfr_write_checkpoint();
114 // For c2: call to runtime to return a buffer lease.
115 static RuntimeStub* generate_jfr_return_lease();
116 #endif
117
118 static const char *stub_name(SharedStubId id) {
119 assert(id > SharedStubId::NO_STUBID && id < SharedStubId::NUM_STUBIDS, "stub id out of range");
120 return _stub_names[(int)id];
121 }
122
123 // max bytes for each dtrace string parameter
124 enum { max_dtrace_string_size = 256 };
125
126 // The following arithmetic routines are used on platforms that do
127 // not have machine instructions to implement their functionality.
128 // Do not remove these.
129
130 // long arithmetics
131 static jlong lmul(jlong y, jlong x);
132 static jlong ldiv(jlong y, jlong x);
133 static jlong lrem(jlong y, jlong x);
134
135 // float and double remainder
136 static jfloat frem(jfloat x, jfloat y);
447 // by the time we reach the blob there is compiled code available. This allows
448 // the blob to pass the incoming stack pointer (the sender sp) in a known
449 // location for the interpreter to record. This is used by the frame code
450 // to correct the sender code to match up with the stack pointer when the
451 // thread left the compiled code. In addition it allows the interpreter
452 // to remove the space the c2i adapter allocated to do its argument conversion.
453
454 // Although a c2i blob will always run interpreted even if compiled code is
455 // present if we see that compiled code is present the compiled call site
456 // will be patched/re-resolved so that later calls will run compiled.
457
458 // Additionally a c2i blob need to have a unverified entry because it can be reached
459 // in situations where the call site is an inlined cache site and may go megamorphic.
460
461 // A i2c adapter is simpler than the c2i adapter. This is because it is assumed
462 // that the interpreter before it does any call dispatch will record the current
463 // stack pointer in the interpreter frame. On return it will restore the stack
464 // pointer as needed. This means the i2c adapter code doesn't need any special
465 // handshaking path with compiled code to keep the stack walking correct.
466
467 static AdapterHandlerEntry* generate_i2c2i_adapters(MacroAssembler *_masm,
468 int total_args_passed,
469 int max_arg,
470 const BasicType *sig_bt,
471 const VMRegPair *regs,
472 AdapterFingerPrint* fingerprint);
473
474 static void gen_i2c_adapter(MacroAssembler *_masm,
475 int total_args_passed,
476 int comp_args_on_stack,
477 const BasicType *sig_bt,
478 const VMRegPair *regs);
479
480 // OSR support
481
482 // OSR_migration_begin will extract the jvm state from an interpreter
483 // frame (locals, monitors) and store the data in a piece of C heap
484 // storage. This then allows the interpreter frame to be removed from the
485 // stack and the OSR nmethod to be called. That method is called with a
486 // pointer to the C heap storage. This pointer is the return value from
487 // OSR_migration_begin.
488
489 static intptr_t* OSR_migration_begin(JavaThread *thread);
490
491 // OSR_migration_end is a trivial routine. It is called after the compiled
492 // method has extracted the jvm state from the C heap that OSR_migration_begin
548
549 // Resolving of calls
550 static address get_resolved_entry (JavaThread* current, methodHandle callee_method);
551 static address resolve_static_call_C (JavaThread* current);
552 static address resolve_virtual_call_C (JavaThread* current);
553 static address resolve_opt_virtual_call_C(JavaThread* current);
554
555 // arraycopy, the non-leaf version. (See StubRoutines for all the leaf calls.)
556 static void slow_arraycopy_C(oopDesc* src, jint src_pos,
557 oopDesc* dest, jint dest_pos,
558 jint length, JavaThread* thread);
559
560 // handle ic miss with caller being compiled code
561 // wrong method handling (inline cache misses)
562 static address handle_wrong_method(JavaThread* current);
563 static address handle_wrong_method_abstract(JavaThread* current);
564 static address handle_wrong_method_ic_miss(JavaThread* current);
565
566 static address handle_unsafe_access(JavaThread* thread, address next_pc);
567
568 #ifndef PRODUCT
569
570 // Collect and print inline cache miss statistics
571 private:
572 enum { maxICmiss_count = 100 };
573 static int _ICmiss_index; // length of IC miss histogram
574 static int _ICmiss_count[maxICmiss_count]; // miss counts
575 static address _ICmiss_at[maxICmiss_count]; // miss addresses
576 static void trace_ic_miss(address at);
577
578 public:
579 static uint _ic_miss_ctr; // total # of IC misses
580 static uint _wrong_method_ctr;
581 static uint _resolve_static_ctr;
582 static uint _resolve_virtual_ctr;
583 static uint _resolve_opt_virtual_ctr;
584 static uint _implicit_null_throws;
585 static uint _implicit_div0_throws;
586
587 static uint _jbyte_array_copy_ctr; // Slow-path byte array copy
588 static uint _jshort_array_copy_ctr; // Slow-path short array copy
589 static uint _jint_array_copy_ctr; // Slow-path int array copy
590 static uint _jlong_array_copy_ctr; // Slow-path long array copy
591 static uint _oop_array_copy_ctr; // Slow-path oop array copy
592 static uint _checkcast_array_copy_ctr; // Slow-path oop array copy, with cast
593 static uint _unsafe_array_copy_ctr; // Slow-path includes alignment checks
594 static uint _generic_array_copy_ctr; // Slow-path includes type decoding
595 static uint _slow_array_copy_ctr; // Slow-path failed out to a method call
596
597 static uint _unsafe_set_memory_ctr; // Slow-path includes alignment checks
598
599 static uint _new_instance_ctr; // 'new' object requires GC
600 static uint _new_array_ctr; // 'new' array requires GC
601 static uint _multi2_ctr, _multi3_ctr, _multi4_ctr, _multi5_ctr;
602 static uint _find_handler_ctr; // find exception handler
603 static uint _rethrow_ctr; // rethrow exception
607 static uint _mon_exit_ctr; // monitor exit slow
608 static uint _partial_subtype_ctr; // SubRoutines::partial_subtype_check
609
610 // Statistics code
611 // stats for "normal" compiled calls (non-interface)
612 static int64_t _nof_normal_calls; // total # of calls
613 static int64_t _nof_inlined_calls; // total # of inlined normal calls
614 static int64_t _nof_static_calls; // total # of calls to static methods or super methods (invokespecial)
615 static int64_t _nof_inlined_static_calls; // total # of inlined static calls
616 // stats for compiled interface calls
617 static int64_t _nof_interface_calls; // total # of compiled calls
618 static int64_t _nof_inlined_interface_calls; // total # of inlined interface calls
619
620 public: // for compiler
621 static address nof_normal_calls_addr() { return (address)&_nof_normal_calls; }
622 static address nof_inlined_calls_addr() { return (address)&_nof_inlined_calls; }
623 static address nof_static_calls_addr() { return (address)&_nof_static_calls; }
624 static address nof_inlined_static_calls_addr() { return (address)&_nof_inlined_static_calls; }
625 static address nof_interface_calls_addr() { return (address)&_nof_interface_calls; }
626 static address nof_inlined_interface_calls_addr() { return (address)&_nof_inlined_interface_calls; }
627 static void print_call_statistics(uint64_t comp_total);
628 static void print_ic_miss_histogram();
629
630 #endif // PRODUCT
631
632 static void print_statistics() PRODUCT_RETURN;
633 };
634
635
636 // ---------------------------------------------------------------------------
637 // Implementation of AdapterHandlerLibrary
638 //
639 // This library manages argument marshaling adapters and native wrappers.
640 // There are 2 flavors of adapters: I2C and C2I.
641 //
642 // The I2C flavor takes a stock interpreted call setup, marshals the
643 // arguments for a Java-compiled call, and jumps to Rmethod-> code()->
644 // code_begin(). It is broken to call it without an nmethod assigned.
645 // The usual behavior is to lift any register arguments up out of the
646 // stack and possibly re-pack the extra arguments to be contiguous.
647 // I2C adapters will save what the interpreter's stack pointer will be
648 // after arguments are popped, then adjust the interpreter's frame
649 // size to force alignment and possibly to repack the arguments.
650 // After re-packing, it jumps to the compiled code start. There are
651 // no safepoints in this adapter code and a GC cannot happen while
652 // marshaling is in progress.
653 //
654 // The C2I flavor takes a stock compiled call setup plus the target method in
655 // Rmethod, marshals the arguments for an interpreted call and jumps to
656 // Rmethod->_i2i_entry. On entry, the interpreted frame has not yet been
657 // setup. Compiled frames are fixed-size and the args are likely not in the
658 // right place. Hence all the args will likely be copied into the
659 // interpreter's frame, forcing that frame to grow. The compiled frame's
660 // outgoing stack args will be dead after the copy.
661 //
662 // Native wrappers, like adapters, marshal arguments. Unlike adapters they
663 // also perform an official frame push & pop. They have a call to the native
664 // routine in their middles and end in a return (instead of ending in a jump).
665 // The native wrappers are stored in real nmethods instead of the BufferBlobs
666 // used by the adapters. The code generation happens here because it's very
667 // similar to what the adapters have to do.
668
669 class AdapterHandlerEntry : public CHeapObj<mtCode> {
670 friend class AdapterHandlerLibrary;
671
672 private:
673 AdapterFingerPrint* _fingerprint;
674 address _i2c_entry;
675 address _c2i_entry;
676 address _c2i_unverified_entry;
677 address _c2i_no_clinit_check_entry;
678
679 #ifdef ASSERT
680 // Captures code and signature used to generate this adapter when
681 // verifying adapter equivalence.
682 unsigned char* _saved_code;
683 int _saved_code_length;
684 #endif
685
686 AdapterHandlerEntry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry,
687 address c2i_unverified_entry,
688 address c2i_no_clinit_check_entry) :
689 _fingerprint(fingerprint),
690 _i2c_entry(i2c_entry),
691 _c2i_entry(c2i_entry),
692 _c2i_unverified_entry(c2i_unverified_entry),
693 _c2i_no_clinit_check_entry(c2i_no_clinit_check_entry)
694 #ifdef ASSERT
695 , _saved_code_length(0)
696 #endif
697 { }
698
699 ~AdapterHandlerEntry();
700
701 public:
702 address get_i2c_entry() const { return _i2c_entry; }
703 address get_c2i_entry() const { return _c2i_entry; }
704 address get_c2i_unverified_entry() const { return _c2i_unverified_entry; }
705 address get_c2i_no_clinit_check_entry() const { return _c2i_no_clinit_check_entry; }
706
707 address base_address();
708 void relocate(address new_base);
709
710 AdapterFingerPrint* fingerprint() const { return _fingerprint; }
711
712 #ifdef ASSERT
713 // Used to verify that code generated for shared adapters is equivalent
714 void save_code (unsigned char* code, int length);
715 bool compare_code(AdapterHandlerEntry* other);
716 #endif
717
718 //virtual void print_on(outputStream* st) const; DO NOT USE
719 void print_adapter_on(outputStream* st) const;
720 };
721
722 class AdapterHandlerLibrary: public AllStatic {
723 friend class SharedRuntime;
724 private:
725 static BufferBlob* _buffer; // the temporary code buffer in CodeCache
726 static AdapterHandlerEntry* _abstract_method_handler;
727 static AdapterHandlerEntry* _no_arg_handler;
728 static AdapterHandlerEntry* _int_arg_handler;
729 static AdapterHandlerEntry* _obj_arg_handler;
730 static AdapterHandlerEntry* _obj_int_arg_handler;
731 static AdapterHandlerEntry* _obj_obj_arg_handler;
732
733 static BufferBlob* buffer_blob();
734 static void initialize();
735 static AdapterHandlerEntry* create_adapter(AdapterBlob*& new_adapter,
736 int total_args_passed,
737 BasicType* sig_bt,
738 bool allocate_code_blob);
739 static AdapterHandlerEntry* get_simple_adapter(const methodHandle& method);
740 public:
741
742 static AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint,
743 address i2c_entry,
744 address c2i_entry,
745 address c2i_unverified_entry,
746 address c2i_no_clinit_check_entry = nullptr);
747 static void create_native_wrapper(const methodHandle& method);
748 static AdapterHandlerEntry* get_adapter(const methodHandle& method);
749
750 static void print_handler(const CodeBlob* b) { print_handler_on(tty, b); }
751 static void print_handler_on(outputStream* st, const CodeBlob* b);
752 static bool contains(const CodeBlob* b);
753 #ifndef PRODUCT
754 static void print_statistics();
755 #endif // PRODUCT
756
757 };
758
759 #endif // SHARE_RUNTIME_SHAREDRUNTIME_HPP
|
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_RUNTIME_SHAREDRUNTIME_HPP
26 #define SHARE_RUNTIME_SHAREDRUNTIME_HPP
27
28 #include "classfile/compactHashtable.hpp"
29 #include "code/codeBlob.hpp"
30 #include "code/vmreg.hpp"
31 #include "interpreter/linkResolver.hpp"
32 #include "memory/allStatic.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "runtime/stubDeclarations.hpp"
35 #include "utilities/macros.hpp"
36
37 class AdapterHandlerEntry;
38 class AdapterFingerPrint;
39 class vframeStream;
40 class MetaspaceClosure;
41
42 // Runtime is the base class for various runtime interfaces
43 // (InterpreterRuntime, CompilerRuntime, etc.). It provides
44 // shared functionality such as exception forwarding (C++ to
45 // Java exceptions), locking/unlocking mechanisms, statistical
46 // information, etc.
47
48 // define SharedStubId enum tags: wrong_method_id, etc
49
50 #define SHARED_STUB_ID_ENUM_DECLARE(name, type) STUB_ID_NAME(name),
51 enum class SharedStubId :int {
52 NO_STUBID = -1,
53 SHARED_STUBS_DO(SHARED_STUB_ID_ENUM_DECLARE)
54 NUM_STUBIDS
55 };
56 #undef SHARED_STUB_ID_ENUM_DECLARE
57
58 class SharedRuntime: AllStatic {
59 private:
60 // Declare shared stub fields
99 // Counters
100 static int64_t _nof_megamorphic_calls; // total # of megamorphic calls (through vtable)
101 #endif // !PRODUCT
102
103 private:
104 static SafepointBlob* generate_handler_blob(SharedStubId id, address call_ptr);
105 static RuntimeStub* generate_resolve_blob(SharedStubId id, address destination);
106 static RuntimeStub* generate_throw_exception(SharedStubId id, address runtime_entry);
107 public:
108 static void generate_initial_stubs(void);
109 static void generate_stubs(void);
110 #if INCLUDE_JFR
111 static void generate_jfr_stubs(void);
112 // For c2: c_rarg0 is junk, call to runtime to write a checkpoint.
113 // It returns a jobject handle to the event writer.
114 // The handle is dereferenced and the return value is the event writer oop.
115 static RuntimeStub* generate_jfr_write_checkpoint();
116 // For c2: call to runtime to return a buffer lease.
117 static RuntimeStub* generate_jfr_return_lease();
118 #endif
119 static void init_adapter_library();
120
121 static const char *stub_name(SharedStubId id) {
122 assert(id > SharedStubId::NO_STUBID && id < SharedStubId::NUM_STUBIDS, "stub id out of range");
123 return _stub_names[(int)id];
124 }
125
126 // max bytes for each dtrace string parameter
127 enum { max_dtrace_string_size = 256 };
128
129 // The following arithmetic routines are used on platforms that do
130 // not have machine instructions to implement their functionality.
131 // Do not remove these.
132
133 // long arithmetics
134 static jlong lmul(jlong y, jlong x);
135 static jlong ldiv(jlong y, jlong x);
136 static jlong lrem(jlong y, jlong x);
137
138 // float and double remainder
139 static jfloat frem(jfloat x, jfloat y);
450 // by the time we reach the blob there is compiled code available. This allows
451 // the blob to pass the incoming stack pointer (the sender sp) in a known
452 // location for the interpreter to record. This is used by the frame code
453 // to correct the sender code to match up with the stack pointer when the
454 // thread left the compiled code. In addition it allows the interpreter
455 // to remove the space the c2i adapter allocated to do its argument conversion.
456
457 // Although a c2i blob will always run interpreted even if compiled code is
458 // present if we see that compiled code is present the compiled call site
459 // will be patched/re-resolved so that later calls will run compiled.
460
461 // Additionally a c2i blob need to have a unverified entry because it can be reached
462 // in situations where the call site is an inlined cache site and may go megamorphic.
463
464 // A i2c adapter is simpler than the c2i adapter. This is because it is assumed
465 // that the interpreter before it does any call dispatch will record the current
466 // stack pointer in the interpreter frame. On return it will restore the stack
467 // pointer as needed. This means the i2c adapter code doesn't need any special
468 // handshaking path with compiled code to keep the stack walking correct.
469
470 static void generate_i2c2i_adapters(MacroAssembler *_masm,
471 int total_args_passed,
472 int max_arg,
473 const BasicType *sig_bt,
474 const VMRegPair *regs,
475 AdapterHandlerEntry* handler);
476
477 static void gen_i2c_adapter(MacroAssembler *_masm,
478 int total_args_passed,
479 int comp_args_on_stack,
480 const BasicType *sig_bt,
481 const VMRegPair *regs);
482
483 // OSR support
484
485 // OSR_migration_begin will extract the jvm state from an interpreter
486 // frame (locals, monitors) and store the data in a piece of C heap
487 // storage. This then allows the interpreter frame to be removed from the
488 // stack and the OSR nmethod to be called. That method is called with a
489 // pointer to the C heap storage. This pointer is the return value from
490 // OSR_migration_begin.
491
492 static intptr_t* OSR_migration_begin(JavaThread *thread);
493
494 // OSR_migration_end is a trivial routine. It is called after the compiled
495 // method has extracted the jvm state from the C heap that OSR_migration_begin
551
552 // Resolving of calls
553 static address get_resolved_entry (JavaThread* current, methodHandle callee_method);
554 static address resolve_static_call_C (JavaThread* current);
555 static address resolve_virtual_call_C (JavaThread* current);
556 static address resolve_opt_virtual_call_C(JavaThread* current);
557
558 // arraycopy, the non-leaf version. (See StubRoutines for all the leaf calls.)
559 static void slow_arraycopy_C(oopDesc* src, jint src_pos,
560 oopDesc* dest, jint dest_pos,
561 jint length, JavaThread* thread);
562
563 // handle ic miss with caller being compiled code
564 // wrong method handling (inline cache misses)
565 static address handle_wrong_method(JavaThread* current);
566 static address handle_wrong_method_abstract(JavaThread* current);
567 static address handle_wrong_method_ic_miss(JavaThread* current);
568
569 static address handle_unsafe_access(JavaThread* thread, address next_pc);
570
571 private:
572 static PerfTickCounters* _perf_resolve_opt_virtual_total_time;
573 static PerfTickCounters* _perf_resolve_virtual_total_time;
574 static PerfTickCounters* _perf_resolve_static_total_time;
575 static PerfTickCounters* _perf_handle_wrong_method_total_time;
576 static PerfTickCounters* _perf_ic_miss_total_time;
577 public:
578 static uint _ic_miss_ctr; // total # of IC misses
579 static uint _wrong_method_ctr;
580 static uint _resolve_static_ctr;
581 static uint _resolve_virtual_ctr;
582 static uint _resolve_opt_virtual_ctr;
583
584 static void print_counters_on(outputStream* st);
585
586 #ifndef PRODUCT
587
588 // Collect and print inline cache miss statistics
589 private:
590 enum { maxICmiss_count = 100 };
591 static int _ICmiss_index; // length of IC miss histogram
592 static int _ICmiss_count[maxICmiss_count]; // miss counts
593 static address _ICmiss_at[maxICmiss_count]; // miss addresses
594 static void trace_ic_miss(address at);
595
596 public:
597 static uint _implicit_null_throws;
598 static uint _implicit_div0_throws;
599
600 static uint _jbyte_array_copy_ctr; // Slow-path byte array copy
601 static uint _jshort_array_copy_ctr; // Slow-path short array copy
602 static uint _jint_array_copy_ctr; // Slow-path int array copy
603 static uint _jlong_array_copy_ctr; // Slow-path long array copy
604 static uint _oop_array_copy_ctr; // Slow-path oop array copy
605 static uint _checkcast_array_copy_ctr; // Slow-path oop array copy, with cast
606 static uint _unsafe_array_copy_ctr; // Slow-path includes alignment checks
607 static uint _generic_array_copy_ctr; // Slow-path includes type decoding
608 static uint _slow_array_copy_ctr; // Slow-path failed out to a method call
609
610 static uint _unsafe_set_memory_ctr; // Slow-path includes alignment checks
611
612 static uint _new_instance_ctr; // 'new' object requires GC
613 static uint _new_array_ctr; // 'new' array requires GC
614 static uint _multi2_ctr, _multi3_ctr, _multi4_ctr, _multi5_ctr;
615 static uint _find_handler_ctr; // find exception handler
616 static uint _rethrow_ctr; // rethrow exception
620 static uint _mon_exit_ctr; // monitor exit slow
621 static uint _partial_subtype_ctr; // SubRoutines::partial_subtype_check
622
623 // Statistics code
624 // stats for "normal" compiled calls (non-interface)
625 static int64_t _nof_normal_calls; // total # of calls
626 static int64_t _nof_inlined_calls; // total # of inlined normal calls
627 static int64_t _nof_static_calls; // total # of calls to static methods or super methods (invokespecial)
628 static int64_t _nof_inlined_static_calls; // total # of inlined static calls
629 // stats for compiled interface calls
630 static int64_t _nof_interface_calls; // total # of compiled calls
631 static int64_t _nof_inlined_interface_calls; // total # of inlined interface calls
632
633 public: // for compiler
634 static address nof_normal_calls_addr() { return (address)&_nof_normal_calls; }
635 static address nof_inlined_calls_addr() { return (address)&_nof_inlined_calls; }
636 static address nof_static_calls_addr() { return (address)&_nof_static_calls; }
637 static address nof_inlined_static_calls_addr() { return (address)&_nof_inlined_static_calls; }
638 static address nof_interface_calls_addr() { return (address)&_nof_interface_calls; }
639 static address nof_inlined_interface_calls_addr() { return (address)&_nof_inlined_interface_calls; }
640
641 static void print_call_statistics_on(outputStream* st);
642 static void print_ic_miss_histogram_on(outputStream* st);
643 #endif // PRODUCT
644
645 static void print_statistics() PRODUCT_RETURN;
646 };
647
648
649 // ---------------------------------------------------------------------------
650 // Implementation of AdapterHandlerLibrary
651 //
652 // This library manages argument marshaling adapters and native wrappers.
653 // There are 2 flavors of adapters: I2C and C2I.
654 //
655 // The I2C flavor takes a stock interpreted call setup, marshals the
656 // arguments for a Java-compiled call, and jumps to Rmethod-> code()->
657 // code_begin(). It is broken to call it without an nmethod assigned.
658 // The usual behavior is to lift any register arguments up out of the
659 // stack and possibly re-pack the extra arguments to be contiguous.
660 // I2C adapters will save what the interpreter's stack pointer will be
661 // after arguments are popped, then adjust the interpreter's frame
662 // size to force alignment and possibly to repack the arguments.
663 // After re-packing, it jumps to the compiled code start. There are
664 // no safepoints in this adapter code and a GC cannot happen while
665 // marshaling is in progress.
666 //
667 // The C2I flavor takes a stock compiled call setup plus the target method in
668 // Rmethod, marshals the arguments for an interpreted call and jumps to
669 // Rmethod->_i2i_entry. On entry, the interpreted frame has not yet been
670 // setup. Compiled frames are fixed-size and the args are likely not in the
671 // right place. Hence all the args will likely be copied into the
672 // interpreter's frame, forcing that frame to grow. The compiled frame's
673 // outgoing stack args will be dead after the copy.
674 //
675 // Native wrappers, like adapters, marshal arguments. Unlike adapters they
676 // also perform an official frame push & pop. They have a call to the native
677 // routine in their middles and end in a return (instead of ending in a jump).
678 // The native wrappers are stored in real nmethods instead of the BufferBlobs
679 // used by the adapters. The code generation happens here because it's very
680 // similar to what the adapters have to do.
681
682 class AdapterHandlerEntry : public MetaspaceObj {
683 friend class AdapterHandlerLibrary;
684
685 private:
686 AdapterFingerPrint* _fingerprint;
687 address _i2c_entry;
688 address _c2i_entry;
689 address _c2i_unverified_entry;
690 address _c2i_no_clinit_check_entry;
691 bool _linked;
692
693 #ifdef ASSERT
694 // Captures code and signature used to generate this adapter when
695 // verifying adapter equivalence.
696 unsigned char* _saved_code;
697 int _saved_code_length;
698 #endif
699
700 AdapterHandlerEntry(AdapterFingerPrint* fingerprint, address i2c_entry, address c2i_entry,
701 address c2i_unverified_entry,
702 address c2i_no_clinit_check_entry) :
703 _fingerprint(fingerprint),
704 _i2c_entry(i2c_entry),
705 _c2i_entry(c2i_entry),
706 _c2i_unverified_entry(c2i_unverified_entry),
707 _c2i_no_clinit_check_entry(c2i_no_clinit_check_entry),
708 _linked(false)
709 #ifdef ASSERT
710 , _saved_code_length(0)
711 #endif
712 { }
713
714 ~AdapterHandlerEntry();
715
716 public:
717 static AdapterHandlerEntry* allocate(AdapterFingerPrint* fingerprint,
718 address i2c_entry,
719 address c2i_entry,
720 address c2i_unverified_entry,
721 address c2i_no_clinit_check_entry)
722 {
723 return new (mtCode) AdapterHandlerEntry(fingerprint, i2c_entry, c2i_entry, c2i_unverified_entry, c2i_no_clinit_check_entry);
724 }
725
726 static void deallocate(AdapterHandlerEntry *handler) {
727 handler->~AdapterHandlerEntry();
728 }
729
730 void set_entry_points(address i2c_entry, address c2i_entry, address c2i_unverified_entry, address c2i_no_clinit_check_entry, bool linked = true) {
731 _i2c_entry = i2c_entry;
732 _c2i_entry = c2i_entry;
733 _c2i_unverified_entry = c2i_unverified_entry;
734 _c2i_no_clinit_check_entry = c2i_no_clinit_check_entry;
735 _linked = linked;
736 }
737
738 address get_i2c_entry() const { return _i2c_entry; }
739 address get_c2i_entry() const { return _c2i_entry; }
740 address get_c2i_unverified_entry() const { return _c2i_unverified_entry; }
741 address get_c2i_no_clinit_check_entry() const { return _c2i_no_clinit_check_entry; }
742
743 bool is_linked() const { return _linked; }
744 address base_address();
745 void relocate(address new_base);
746
747 AdapterFingerPrint* fingerprint() const { return _fingerprint; }
748
749 #ifdef ASSERT
750 // Used to verify that code generated for shared adapters is equivalent
751 void save_code (unsigned char* code, int length);
752 bool compare_code(AdapterHandlerEntry* other);
753 #endif
754
755 //virtual void print_on(outputStream* st) const; DO NOT USE
756 void print_adapter_on(outputStream* st) const;
757
758 void metaspace_pointers_do(MetaspaceClosure* it);
759 int size() const {return (int)heap_word_size(sizeof(AdapterHandlerEntry)); }
760 MetaspaceObj::Type type() const { return AdapterHandlerEntryType; }
761
762 void remove_unshareable_info() NOT_CDS_RETURN;
763 void restore_unshareable_info(TRAPS) NOT_CDS_RETURN;
764 };
765
766 #if INCLUDE_CDS
767 class ArchivedAdapterTable;
768 #endif // INCLUDE_CDS
769
770 class AdapterHandlerLibrary: public AllStatic {
771 friend class SharedRuntime;
772 private:
773 static BufferBlob* _buffer; // the temporary code buffer in CodeCache
774 static AdapterHandlerEntry* _abstract_method_handler;
775 static AdapterHandlerEntry* _no_arg_handler;
776 static AdapterHandlerEntry* _int_arg_handler;
777 static AdapterHandlerEntry* _obj_arg_handler;
778 static AdapterHandlerEntry* _obj_int_arg_handler;
779 static AdapterHandlerEntry* _obj_obj_arg_handler;
780 #if INCLUDE_CDS
781 static ArchivedAdapterTable _archived_adapter_handler_table;
782 #endif // INCLUDE_CDS
783 static BufferBlob* buffer_blob();
784 static void initialize();
785 static AdapterHandlerEntry* create_simple_adapter(AdapterBlob*& new_adapter,
786 int total_args_passed,
787 BasicType* sig_bt);
788 static AdapterHandlerEntry* get_simple_adapter(const methodHandle& method);
789 static bool lookup_aot_cache(AdapterHandlerEntry* handler, CodeBuffer* buffer);
790 static AdapterHandlerEntry* create_adapter(AdapterBlob*& new_adapter,
791 AdapterFingerPrint* fingerprint,
792 int total_args_passed,
793 BasicType* sig_bt,
794 bool is_transient);
795 #ifndef PRODUCT
796 static void print_adapter_handler_info(AdapterHandlerEntry* handler, AdapterBlob* adapter_blob);
797 #endif // PRODUCT
798 public:
799
800 static AdapterHandlerEntry* new_entry(AdapterFingerPrint* fingerprint,
801 address i2c_entry = nullptr,
802 address c2i_entry = nullptr,
803 address c2i_unverified_entry = nullptr,
804 address c2i_no_clinit_check_entry = nullptr);
805 static void create_native_wrapper(const methodHandle& method);
806 static AdapterHandlerEntry* get_adapter(const methodHandle& method);
807 static AdapterHandlerEntry* lookup(AdapterFingerPrint* fp);
808 static bool generate_adapter_code(AdapterBlob*& adapter_blob,
809 AdapterHandlerEntry* handler,
810 int total_args_passed,
811 BasicType* sig_bt,
812 bool is_transient);
813
814 static void print_handler(const CodeBlob* b) { print_handler_on(tty, b); }
815 static void print_handler_on(outputStream* st, const CodeBlob* b);
816 static bool contains(const CodeBlob* b);
817 static const char* name(AdapterFingerPrint* fingerprint);
818 static uint32_t id(AdapterFingerPrint* fingerprint);
819 #ifndef PRODUCT
820 static void print_statistics_on(outputStream* st);
821 #endif // PRODUCT
822
823 static bool is_abstract_method_adapter(AdapterHandlerEntry* adapter);
824
825 static bool link_adapter_handler(AdapterHandlerEntry* handler, AdapterBlob*& adapter_blob) NOT_CDS_RETURN_(false);
826 static void archive_adapter_table() NOT_CDS_RETURN;
827 static void serialize_shared_table_header(SerializeClosure* soc) NOT_CDS_RETURN;
828 };
829
830 #endif // SHARE_RUNTIME_SHAREDRUNTIME_HPP
|