1 /* 2 * Copyright (c) 1999, 2025, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 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_C1_C1_RUNTIME1_HPP 26 #define SHARE_C1_C1_RUNTIME1_HPP 27 28 #include "c1/c1_FrameMap.hpp" 29 #include "code/stubs.hpp" 30 #include "interpreter/interpreter.hpp" 31 #include "memory/allStatic.hpp" 32 #include "runtime/stubDeclarations.hpp" 33 34 class StubAssembler; 35 36 // The Runtime1 holds all assembly stubs and VM 37 // runtime routines needed by code code generated 38 // by the Compiler1. 39 40 class StubAssemblerCodeGenClosure: public Closure { 41 public: 42 virtual OopMapSet* generate_code(StubAssembler* sasm) = 0; 43 }; 44 45 // define C1StubId enum tags: unwind_exception_id etc 46 47 #define C1_STUB_ID_ENUM_DECLARE(name) STUB_ID_NAME(name), 48 enum class C1StubId :int { 49 NO_STUBID = -1, 50 C1_STUBS_DO(C1_STUB_ID_ENUM_DECLARE) 51 NUM_STUBIDS 52 }; 53 #undef C1_STUB_ID_ENUM_DECLARE 54 55 class Runtime1: public AllStatic { 56 friend class ArrayCopyStub; 57 58 public: 59 // statistics 60 #ifndef PRODUCT 61 static uint _generic_arraycopystub_cnt; 62 static uint _arraycopy_slowcase_cnt; 63 static uint _arraycopy_checkcast_cnt; 64 static uint _arraycopy_checkcast_attempt_cnt; 65 static uint _new_type_array_slowcase_cnt; 66 static uint _new_object_array_slowcase_cnt; 67 static uint _new_null_free_array_slowcase_cnt; 68 static uint _new_instance_slowcase_cnt; 69 static uint _new_multi_array_slowcase_cnt; 70 static uint _load_flat_array_slowcase_cnt; 71 static uint _store_flat_array_slowcase_cnt; 72 static uint _substitutability_check_slowcase_cnt; 73 static uint _buffer_inline_args_slowcase_cnt; 74 static uint _buffer_inline_args_no_receiver_slowcase_cnt; 75 static uint _monitorenter_slowcase_cnt; 76 static uint _monitorexit_slowcase_cnt; 77 static uint _patch_code_slowcase_cnt; 78 static uint _throw_range_check_exception_count; 79 static uint _throw_index_exception_count; 80 static uint _throw_div0_exception_count; 81 static uint _throw_null_pointer_exception_count; 82 static uint _throw_class_cast_exception_count; 83 static uint _throw_incompatible_class_change_error_count; 84 static uint _throw_illegal_monitor_state_exception_count; 85 static uint _throw_identity_exception_count; 86 static uint _throw_count; 87 #endif 88 89 private: 90 static CodeBlob* _blobs[(int)C1StubId::NUM_STUBIDS]; 91 static const char* _blob_names[]; 92 static void buffer_inline_args_impl(JavaThread* current, Method* m, bool allocate_receiver); 93 94 // stub generation 95 public: 96 static CodeBlob* generate_blob(BufferBlob* buffer_blob, C1StubId id, const char* name, bool expect_oop_map, StubAssemblerCodeGenClosure *cl); 97 static void generate_blob_for(BufferBlob* blob, C1StubId id); 98 static OopMapSet* generate_code_for(C1StubId id, StubAssembler* sasm); 99 private: 100 static OopMapSet* generate_exception_throw(StubAssembler* sasm, address target, bool has_argument); 101 static OopMapSet* generate_handle_exception(C1StubId id, StubAssembler* sasm); 102 static void generate_unwind_exception(StubAssembler *sasm); 103 static OopMapSet* generate_patching(StubAssembler* sasm, address target); 104 105 static OopMapSet* generate_stub_call(StubAssembler* sasm, Register result, address entry, 106 Register arg1 = noreg, Register arg2 = noreg, Register arg3 = noreg); 107 108 // runtime entry points 109 static void new_instance (JavaThread* current, Klass* klass); 110 static void new_instance_no_inline(JavaThread* current, Klass* klass); 111 static void new_type_array (JavaThread* current, Klass* klass, jint length); 112 static void new_object_array(JavaThread* current, Klass* klass, jint length); 113 static void new_null_free_array(JavaThread* current, Klass* klass, jint length); 114 static void new_multi_array (JavaThread* current, Klass* klass, int rank, jint* dims); 115 static void load_flat_array(JavaThread* current, flatArrayOopDesc* array, int index); 116 static void store_flat_array(JavaThread* current, flatArrayOopDesc* array, int index, oopDesc* value); 117 static int substitutability_check(JavaThread* current, oopDesc* left, oopDesc* right); 118 static void buffer_inline_args(JavaThread* current, Method* method); 119 static void buffer_inline_args_no_receiver(JavaThread* current, Method* method); 120 121 static address counter_overflow(JavaThread* current, int bci, Method* method); 122 123 static void unimplemented_entry(JavaThread* current, C1StubId id); 124 125 static address exception_handler_for_pc(JavaThread* current); 126 127 static void throw_range_check_exception(JavaThread* current, int index, arrayOopDesc* a); 128 static void throw_index_exception(JavaThread* current, int index); 129 static void throw_div0_exception(JavaThread* current); 130 static void throw_null_pointer_exception(JavaThread* current); 131 static void throw_class_cast_exception(JavaThread* current, oopDesc* object); 132 static void throw_incompatible_class_change_error(JavaThread* current); 133 static void throw_illegal_monitor_state_exception(JavaThread* current); 134 static void throw_identity_exception(JavaThread* current, oopDesc* object); 135 static void throw_array_store_exception(JavaThread* current, oopDesc* object); 136 137 static void monitorenter(JavaThread* current, oopDesc* obj, BasicObjectLock* lock); 138 static void monitorexit (JavaThread* current, BasicObjectLock* lock); 139 140 static void deoptimize(JavaThread* current, jint trap_request); 141 142 static int access_field_patching(JavaThread* current); 143 static int move_klass_patching(JavaThread* current); 144 static int move_mirror_patching(JavaThread* current); 145 static int move_appendix_patching(JavaThread* current); 146 147 static void patch_code(JavaThread* current, C1StubId stub_id); 148 149 public: 150 // initialization 151 static void initialize(BufferBlob* blob); 152 static void initialize_pd(); 153 154 // return offset in words 155 static uint runtime_blob_current_thread_offset(frame f); 156 157 // stubs 158 static CodeBlob* blob_for (C1StubId id); 159 static address entry_for(C1StubId id) { return blob_for(id)->code_begin(); } 160 static const char* name_for (C1StubId id); 161 static const char* name_for_address(address entry); 162 163 // platform might add runtime names. 164 static const char* pd_name_for_address(address entry); 165 166 // method tracing 167 static void trace_block_entry(jint block_id); 168 169 #ifndef PRODUCT 170 static address throw_count_address() { return (address)&_throw_count; } 171 static address arraycopy_count_address(BasicType type); 172 #endif 173 174 // directly accessible leaf routine 175 static int is_instance_of(oopDesc* mirror, oopDesc* obj); 176 177 static void predicate_failed_trap(JavaThread* current); 178 179 static void check_abort_on_vm_exception(oopDesc* ex); 180 181 static void print_statistics() PRODUCT_RETURN; 182 }; 183 184 #endif // SHARE_C1_C1_RUNTIME1_HPP