79 #include "runtime/vframe.inline.hpp"
80 #include "runtime/vframeArray.hpp"
81 #include "runtime/vm_version.hpp"
82 #include "utilities/copy.hpp"
83 #include "utilities/dtrace.hpp"
84 #include "utilities/events.hpp"
85 #include "utilities/exceptions.hpp"
86 #include "utilities/globalDefinitions.hpp"
87 #include "utilities/hashTable.hpp"
88 #include "utilities/macros.hpp"
89 #include "utilities/xmlstream.hpp"
90 #ifdef COMPILER1
91 #include "c1/c1_Runtime1.hpp"
92 #endif
93 #ifdef COMPILER2
94 #include "opto/runtime.hpp"
95 #endif
96 #if INCLUDE_JFR
97 #include "jfr/jfr.inline.hpp"
98 #endif
99
100 // Shared runtime stub routines reside in their own unique blob with a
101 // single entry point
102
103
104 #define SHARED_STUB_FIELD_DEFINE(name, type) \
105 type* SharedRuntime::BLOB_FIELD_NAME(name);
106 SHARED_STUBS_DO(SHARED_STUB_FIELD_DEFINE)
107 #undef SHARED_STUB_FIELD_DEFINE
108
109 nmethod* SharedRuntime::_cont_doYield_stub;
110
111 #if 0
112 // TODO tweak global stub name generation to match this
113 #define SHARED_STUB_NAME_DECLARE(name, type) "Shared Runtime " # name "_blob",
114 const char *SharedRuntime::_stub_names[] = {
115 SHARED_STUBS_DO(SHARED_STUB_NAME_DECLARE)
116 };
117 #endif
118
160 generate_throw_exception(StubId::shared_throw_NullPointerException_at_call_id,
161 CAST_FROM_FN_PTR(address, SharedRuntime::throw_NullPointerException_at_call));
162
163 #if COMPILER2_OR_JVMCI
164 // Vectors are generated only by C2 and JVMCI.
165 bool support_wide = is_wide_vector(MaxVectorSize);
166 if (support_wide) {
167 _polling_page_vectors_safepoint_handler_blob =
168 generate_handler_blob(StubId::shared_polling_page_vectors_safepoint_handler_id,
169 CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception));
170 }
171 #endif // COMPILER2_OR_JVMCI
172 _polling_page_safepoint_handler_blob =
173 generate_handler_blob(StubId::shared_polling_page_safepoint_handler_id,
174 CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception));
175 _polling_page_return_handler_blob =
176 generate_handler_blob(StubId::shared_polling_page_return_handler_id,
177 CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception));
178
179 generate_deopt_blob();
180 }
181
182 void SharedRuntime::init_adapter_library() {
183 AdapterHandlerLibrary::initialize();
184 }
185
186 #if INCLUDE_JFR
187 //------------------------------generate jfr runtime stubs ------
188 void SharedRuntime::generate_jfr_stubs() {
189 ResourceMark rm;
190 const char* timer_msg = "SharedRuntime generate_jfr_stubs";
191 TraceTime timer(timer_msg, TRACETIME_LOG(Info, startuptime));
192
193 _jfr_write_checkpoint_blob = generate_jfr_write_checkpoint();
194 _jfr_return_lease_blob = generate_jfr_return_lease();
195 }
196
197 #endif // INCLUDE_JFR
198
199 #include <math.h>
|
79 #include "runtime/vframe.inline.hpp"
80 #include "runtime/vframeArray.hpp"
81 #include "runtime/vm_version.hpp"
82 #include "utilities/copy.hpp"
83 #include "utilities/dtrace.hpp"
84 #include "utilities/events.hpp"
85 #include "utilities/exceptions.hpp"
86 #include "utilities/globalDefinitions.hpp"
87 #include "utilities/hashTable.hpp"
88 #include "utilities/macros.hpp"
89 #include "utilities/xmlstream.hpp"
90 #ifdef COMPILER1
91 #include "c1/c1_Runtime1.hpp"
92 #endif
93 #ifdef COMPILER2
94 #include "opto/runtime.hpp"
95 #endif
96 #if INCLUDE_JFR
97 #include "jfr/jfr.inline.hpp"
98 #endif
99 #if INCLUDE_SHENANDOAHGC
100 #include "gc/shenandoah/shenandoahRuntime.hpp"
101 #endif
102
103 // Shared runtime stub routines reside in their own unique blob with a
104 // single entry point
105
106
107 #define SHARED_STUB_FIELD_DEFINE(name, type) \
108 type* SharedRuntime::BLOB_FIELD_NAME(name);
109 SHARED_STUBS_DO(SHARED_STUB_FIELD_DEFINE)
110 #undef SHARED_STUB_FIELD_DEFINE
111
112 nmethod* SharedRuntime::_cont_doYield_stub;
113
114 #if 0
115 // TODO tweak global stub name generation to match this
116 #define SHARED_STUB_NAME_DECLARE(name, type) "Shared Runtime " # name "_blob",
117 const char *SharedRuntime::_stub_names[] = {
118 SHARED_STUBS_DO(SHARED_STUB_NAME_DECLARE)
119 };
120 #endif
121
163 generate_throw_exception(StubId::shared_throw_NullPointerException_at_call_id,
164 CAST_FROM_FN_PTR(address, SharedRuntime::throw_NullPointerException_at_call));
165
166 #if COMPILER2_OR_JVMCI
167 // Vectors are generated only by C2 and JVMCI.
168 bool support_wide = is_wide_vector(MaxVectorSize);
169 if (support_wide) {
170 _polling_page_vectors_safepoint_handler_blob =
171 generate_handler_blob(StubId::shared_polling_page_vectors_safepoint_handler_id,
172 CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception));
173 }
174 #endif // COMPILER2_OR_JVMCI
175 _polling_page_safepoint_handler_blob =
176 generate_handler_blob(StubId::shared_polling_page_safepoint_handler_id,
177 CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception));
178 _polling_page_return_handler_blob =
179 generate_handler_blob(StubId::shared_polling_page_return_handler_id,
180 CAST_FROM_FN_PTR(address, SafepointSynchronize::handle_polling_page_exception));
181
182 generate_deopt_blob();
183
184 #if INCLUDE_SHENANDOAHGC
185 if (UseShenandoahGC) {
186 ResourceMark rm;
187 _shenandoah_keepalive_none_blob =
188 generate_gc_slow_call_blob(StubId::shared_shenandoah_keepalive_none_id,
189 CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_barrier_pre),
190 /* has_return = */ false, /* save_registers = */ false, /* save_vectors = */ false);
191 _shenandoah_keepalive_gp_blob =
192 generate_gc_slow_call_blob(StubId::shared_shenandoah_keepalive_gp_id,
193 CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_barrier_pre),
194 /* has_return = */ false, /* save_registers = */ true, /* save_vectors = */ false);
195 _shenandoah_keepalive_all_blob =
196 generate_gc_slow_call_blob(StubId::shared_shenandoah_keepalive_all_id,
197 CAST_FROM_FN_PTR(address, ShenandoahRuntime::write_barrier_pre),
198 /* has_return = */ false, /* save_registers = */ true, /* save_vectors = */ true);
199
200 _shenandoah_lrb_strong_none_blob =
201 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_strong_none_id,
202 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_strong),
203 /* has_return = */ true, /* save_registers = */ false, /* save_vectors = */ false);
204 _shenandoah_lrb_strong_gp_blob =
205 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_strong_gp_id,
206 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_strong),
207 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ false);
208 _shenandoah_lrb_strong_all_blob =
209 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_strong_all_id,
210 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_strong),
211 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ true);
212
213 _shenandoah_lrb_strong_narrow_none_blob =
214 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_strong_narrow_none_id,
215 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_strong_narrow),
216 /* has_return = */ true, /* save_registers = */ false, /* save_vectors = */ false);
217 _shenandoah_lrb_strong_narrow_gp_blob =
218 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_strong_narrow_gp_id,
219 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_strong_narrow),
220 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ false);
221 _shenandoah_lrb_strong_narrow_all_blob =
222 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_strong_narrow_all_id,
223 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_strong_narrow),
224 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ true);
225
226 _shenandoah_lrb_weak_none_blob =
227 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_weak_none_id,
228 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak),
229 /* has_return = */ true, /* save_registers = */ false, /* save_vectors = */ false);
230 _shenandoah_lrb_weak_gp_blob =
231 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_weak_gp_id,
232 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak),
233 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ false);
234 _shenandoah_lrb_weak_all_blob =
235 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_weak_all_id,
236 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak),
237 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ true);
238
239 _shenandoah_lrb_weak_narrow_none_blob =
240 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_weak_narrow_none_id,
241 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak_narrow),
242 /* has_return = */ true, /* save_registers = */ false, /* save_vectors = */ false);
243 _shenandoah_lrb_weak_narrow_gp_blob =
244 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_weak_narrow_gp_id,
245 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak_narrow),
246 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ false);
247 _shenandoah_lrb_weak_narrow_all_blob =
248 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_weak_narrow_all_id,
249 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_weak_narrow),
250 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ true);
251
252 _shenandoah_lrb_phantom_none_blob =
253 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_phantom_none_id,
254 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_phantom),
255 /* has_return = */ true, /* save_registers = */ false, /* save_vectors = */ false);
256 _shenandoah_lrb_phantom_gp_blob =
257 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_phantom_gp_id,
258 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_phantom),
259 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ false);
260 _shenandoah_lrb_phantom_all_blob =
261 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_phantom_all_id,
262 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_phantom),
263 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ true);
264
265 _shenandoah_lrb_phantom_narrow_none_blob =
266 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_phantom_narrow_none_id,
267 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_phantom_narrow),
268 /* has_return = */ true, /* save_registers = */ false, /* save_vectors = */ false);
269 _shenandoah_lrb_phantom_narrow_gp_blob =
270 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_phantom_narrow_gp_id,
271 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_phantom_narrow),
272 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ false);
273 _shenandoah_lrb_phantom_narrow_all_blob =
274 generate_gc_slow_call_blob(StubId::shared_shenandoah_lrb_phantom_narrow_all_id,
275 CAST_FROM_FN_PTR(address, ShenandoahRuntime::load_reference_barrier_phantom_narrow),
276 /* has_return = */ true, /* save_registers = */ true, /* save_vectors = */ true);
277 }
278 #endif
279 }
280
281 void SharedRuntime::init_adapter_library() {
282 AdapterHandlerLibrary::initialize();
283 }
284
285 #if INCLUDE_JFR
286 //------------------------------generate jfr runtime stubs ------
287 void SharedRuntime::generate_jfr_stubs() {
288 ResourceMark rm;
289 const char* timer_msg = "SharedRuntime generate_jfr_stubs";
290 TraceTime timer(timer_msg, TRACETIME_LOG(Info, startuptime));
291
292 _jfr_write_checkpoint_blob = generate_jfr_write_checkpoint();
293 _jfr_return_lease_blob = generate_jfr_return_lease();
294 }
295
296 #endif // INCLUDE_JFR
297
298 #include <math.h>
|