1 /*
  2  * Copyright (c) 1998, 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_OPTO_RUNTIME_HPP
 26 #define SHARE_OPTO_RUNTIME_HPP
 27 
 28 #include "code/codeBlob.hpp"
 29 #include "opto/machnode.hpp"
 30 #include "opto/optoreg.hpp"
 31 #include "runtime/stubDeclarations.hpp"
 32 #include "runtime/vframe.hpp"
 33 
 34 //------------------------------OptoRuntime------------------------------------
 35 // Opto compiler runtime routines
 36 //
 37 // These are all generated from Ideal graphs.  They are called with the
 38 // Java calling convention.  Internally they call C++.  They are made once at
 39 // startup time and Opto compiles calls to them later.
 40 // Things are broken up into quads: the signature they will be called with,
 41 // the address of the generated code, the corresponding C++ code and an
 42 // nmethod.
 43 
 44 // The signature (returned by "xxx_Type()") is used at startup time by the
 45 // Generator to make the generated code "xxx_Java".  Opto compiles calls
 46 // to the generated code "xxx_Java".  When the compiled code gets executed,
 47 // it calls the C++ code "xxx_C".  The generated nmethod is saved in the
 48 // CodeCache.  Exception handlers use the nmethod to get the callee-save
 49 // register OopMaps.
 50 class CallInfo;
 51 
 52 //
 53 // NamedCounters are tagged counters which can be used for profiling
 54 // code in various ways.  Currently they are used by the lock coarsening code
 55 //
 56 
 57 class NamedCounter : public CHeapObj<mtCompiler> {
 58 public:
 59     enum CounterTag {
 60     NoTag,
 61     LockCounter,
 62     EliminatedLockCounter
 63   };
 64 
 65 private:
 66   const char *  _name;
 67   int           _count;
 68   CounterTag    _tag;
 69   NamedCounter* _next;
 70 
 71  public:
 72   NamedCounter(const char *n, CounterTag tag = NoTag):
 73     _name(n == nullptr ? nullptr : os::strdup(n)),
 74     _count(0),
 75     _tag(tag),
 76     _next(nullptr) {}
 77 
 78   ~NamedCounter() {
 79     if (_name != nullptr) {
 80       os::free((void*)_name);
 81     }
 82   }
 83 
 84   const char * name() const     { return _name; }
 85   int count() const             { return _count; }
 86   address addr()                { return (address)&_count; }
 87   CounterTag tag() const        { return _tag; }
 88   void set_tag(CounterTag tag)  { _tag = tag; }
 89 
 90   NamedCounter* next() const    { return _next; }
 91   void set_next(NamedCounter* next) {
 92     assert(_next == nullptr || next == nullptr, "already set");
 93     _next = next;
 94   }
 95 
 96 };
 97 
 98 typedef const TypeFunc*(*TypeFunc_generator)();
 99 
100 // define OptoStubId enum tags: uncommon_trap_id etc
101 
102 #define C2_BLOB_ID_ENUM_DECLARE(name, type) STUB_ID_NAME(name),
103 #define C2_STUB_ID_ENUM_DECLARE(name, f, t, r) STUB_ID_NAME(name),
104 #define C2_JVMTI_STUB_ID_ENUM_DECLARE(name) STUB_ID_NAME(name),
105 enum class OptoStubId :int {
106   NO_STUBID = -1,
107   C2_STUBS_DO(C2_BLOB_ID_ENUM_DECLARE, C2_STUB_ID_ENUM_DECLARE, C2_JVMTI_STUB_ID_ENUM_DECLARE)
108   NUM_STUBIDS
109 };
110 #undef C2_BLOB_ID_ENUM_DECLARE
111 #undef C2_STUB_ID_ENUM_DECLARE
112 #undef C2_JVMTI_STUB_ID_ENUM_DECLARE
113 
114 class OptoRuntime : public AllStatic {
115   friend class Matcher;  // allow access to stub names
116 
117  private:
118   // declare opto stub address/blob holder static fields
119 #define C2_BLOB_FIELD_DECLARE(name, type) \
120   static type        BLOB_FIELD_NAME(name);
121 #define C2_STUB_FIELD_NAME(name) _ ## name ## _Java
122 #define C2_STUB_FIELD_DECLARE(name, f, t, r) \
123   static address     C2_STUB_FIELD_NAME(name) ;
124 #define C2_JVMTI_STUB_FIELD_DECLARE(name) \
125   static address     STUB_FIELD_NAME(name);
126 
127   C2_STUBS_DO(C2_BLOB_FIELD_DECLARE, C2_STUB_FIELD_DECLARE, C2_JVMTI_STUB_FIELD_DECLARE)
128 
129 #undef C2_BLOB_FIELD_DECLARE
130 #undef C2_STUB_FIELD_NAME
131 #undef C2_STUB_FIELD_DECLARE
132 #undef C2_JVMTI_STUB_FIELD_DECLARE
133 
134   // static TypeFunc* data members
135   static const TypeFunc* _new_instance_Type;
136   static const TypeFunc* _new_array_Type;
137   static const TypeFunc* _new_array_nozero_Type;
138   static const TypeFunc* _multianewarray2_Type;
139   static const TypeFunc* _multianewarray3_Type;
140   static const TypeFunc* _multianewarray4_Type;
141   static const TypeFunc* _multianewarray5_Type;
142   static const TypeFunc* _multianewarrayN_Type;
143   static const TypeFunc* _complete_monitor_enter_Type;
144   static const TypeFunc* _complete_monitor_exit_Type;
145   static const TypeFunc* _monitor_notify_Type;
146   static const TypeFunc* _uncommon_trap_Type;
147   static const TypeFunc* _athrow_Type;
148   static const TypeFunc* _rethrow_Type;
149   static const TypeFunc* _Math_D_D_Type;
150   static const TypeFunc* _Math_DD_D_Type;
151   static const TypeFunc* _modf_Type;
152   static const TypeFunc* _l2f_Type;
153   static const TypeFunc* _void_long_Type;
154   static const TypeFunc* _void_void_Type;
155   static const TypeFunc* _jfr_write_checkpoint_Type;
156   static const TypeFunc* _flush_windows_Type;
157   static const TypeFunc* _fast_arraycopy_Type;
158   static const TypeFunc* _checkcast_arraycopy_Type;
159   static const TypeFunc* _generic_arraycopy_Type;
160   static const TypeFunc* _slow_arraycopy_Type;
161   static const TypeFunc* _unsafe_setmemory_Type;
162   static const TypeFunc* _array_fill_Type;
163   static const TypeFunc* _array_sort_Type;
164   static const TypeFunc* _array_partition_Type;
165   static const TypeFunc* _aescrypt_block_Type;
166   static const TypeFunc* _cipherBlockChaining_aescrypt_Type;
167   static const TypeFunc* _electronicCodeBook_aescrypt_Type;
168   static const TypeFunc* _counterMode_aescrypt_Type;
169   static const TypeFunc* _galoisCounterMode_aescrypt_Type;
170   static const TypeFunc* _digestBase_implCompress_with_sha3_Type;
171   static const TypeFunc* _digestBase_implCompress_without_sha3_Type;
172   static const TypeFunc* _digestBase_implCompressMB_with_sha3_Type;
173   static const TypeFunc* _digestBase_implCompressMB_without_sha3_Type;
174   static const TypeFunc* _double_keccak_Type;
175   static const TypeFunc* _multiplyToLen_Type;
176   static const TypeFunc* _montgomeryMultiply_Type;
177   static const TypeFunc* _montgomerySquare_Type;
178   static const TypeFunc* _squareToLen_Type;
179   static const TypeFunc* _mulAdd_Type;
180   static const TypeFunc* _bigIntegerShift_Type;
181   static const TypeFunc* _vectorizedMismatch_Type;
182   static const TypeFunc* _ghash_processBlocks_Type;
183   static const TypeFunc* _chacha20Block_Type;
184   static const TypeFunc* _kyberNtt_Type;
185   static const TypeFunc* _kyberInverseNtt_Type;
186   static const TypeFunc* _kyberNttMult_Type;
187   static const TypeFunc* _kyberAddPoly_2_Type;
188   static const TypeFunc* _kyberAddPoly_3_Type;
189   static const TypeFunc* _kyber12To16_Type;
190   static const TypeFunc* _kyberBarrettReduce_Type;
191   static const TypeFunc* _dilithiumAlmostNtt_Type;
192   static const TypeFunc* _dilithiumAlmostInverseNtt_Type;
193   static const TypeFunc* _dilithiumNttMult_Type;
194   static const TypeFunc* _dilithiumMontMulByConstant_Type;
195   static const TypeFunc* _dilithiumDecomposePoly_Type;
196   static const TypeFunc* _base64_encodeBlock_Type;
197   static const TypeFunc* _base64_decodeBlock_Type;
198   static const TypeFunc* _string_IndexOf_Type;
199   static const TypeFunc* _poly1305_processBlocks_Type;
200   static const TypeFunc* _intpoly_montgomeryMult_P256_Type;
201   static const TypeFunc* _intpoly_assign_Type;
202   static const TypeFunc* _updateBytesCRC32_Type;
203   static const TypeFunc* _updateBytesCRC32C_Type;
204   static const TypeFunc* _updateBytesAdler32_Type;
205   static const TypeFunc* _osr_end_Type;
206   static const TypeFunc* _register_finalizer_Type;
207 #if INCLUDE_JFR
208   static const TypeFunc* _class_id_load_barrier_Type;
209 #endif // INCLUDE_JFR
210 #if INCLUDE_JVMTI
211   static const TypeFunc* _notify_jvmti_vthread_Type;
212 #endif // INCLUDE_JVMTI
213   static const TypeFunc* _dtrace_method_entry_exit_Type;
214   static const TypeFunc* _dtrace_object_alloc_Type;
215 
216   // Stub names indexed by sharedStubId
217   static const char *_stub_names[];
218 
219   // define stubs
220   static address generate_stub(ciEnv* ci_env, TypeFunc_generator gen, address C_function, const char* name, int is_fancy_jump, bool pass_tls, bool return_pc);
221 
222   //
223   // Implementation of runtime methods
224   // =================================
225 
226   // Allocate storage for a Java instance.
227   static void new_instance_C(Klass* instance_klass, bool is_larval, JavaThread* current);
228 
229   // Allocate storage for a objArray or typeArray
230   static void new_array_C(Klass* array_klass, int len, oopDesc* init_val, JavaThread* current);
231   static void new_array_nozero_C(Klass* array_klass, int len, JavaThread* current);
232 
233   // Allocate storage for a multi-dimensional arrays
234   // Note: needs to be fixed for arbitrary number of dimensions
235   static void multianewarray2_C(Klass* klass, int len1, int len2, JavaThread* current);
236   static void multianewarray3_C(Klass* klass, int len1, int len2, int len3, JavaThread* current);
237   static void multianewarray4_C(Klass* klass, int len1, int len2, int len3, int len4, JavaThread* current);
238   static void multianewarray5_C(Klass* klass, int len1, int len2, int len3, int len4, int len5, JavaThread* current);
239   static void multianewarrayN_C(Klass* klass, arrayOopDesc* dims, JavaThread* current);
240 
241   // local methods passed as arguments to stub generator that forward
242   // control to corresponding JRT methods of SharedRuntime
243   static void slow_arraycopy_C(oopDesc* src,  jint src_pos,
244                                oopDesc* dest, jint dest_pos,
245                                jint length, JavaThread* thread);
246   static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* current);
247 
248 public:
249   static void monitor_notify_C(oopDesc* obj, JavaThread* current);
250   static void monitor_notifyAll_C(oopDesc* obj, JavaThread* current);
251 
252 private:
253 
254   // Implicit exception support
255   static void throw_null_exception_C(JavaThread* thread);
256 
257   // Exception handling
258   static address handle_exception_C       (JavaThread* current);
259   static address handle_exception_C_helper(JavaThread* current, nmethod*& nm);
260   static address rethrow_C                (oopDesc* exception, JavaThread *thread, address return_pc );
261   static void deoptimize_caller_frame     (JavaThread *thread);
262   static void deoptimize_caller_frame     (JavaThread *thread, bool doit);
263   static bool is_deoptimized_caller_frame (JavaThread *thread);
264 
265   // CodeBlob support
266   // ===================================================================
267 
268   static UncommonTrapBlob* generate_uncommon_trap_blob(void);
269   static ExceptionBlob* generate_exception_blob();
270 
271   static void register_finalizer_C(oopDesc* obj, JavaThread* current);
272 
273  public:
274   static void load_unknown_inline_C(flatArrayOopDesc* array, int index, JavaThread* current);
275   static void store_unknown_inline_C(instanceOopDesc* buffer, flatArrayOopDesc* array, int index, JavaThread* current);
276 
277   static bool is_callee_saved_register(MachRegisterNumbers reg);
278 
279   // One time only generate runtime code stubs. Returns true
280   // when runtime stubs have been generated successfully and
281   // false otherwise.
282   static bool generate(ciEnv* env);
283 
284   // Returns the name of a stub
285   static const char* stub_name(address entry);
286 
287   // Returns the name associated with a given stub id
288   static const char* stub_name(OptoStubId id) {
289     assert(id > OptoStubId::NO_STUBID && id < OptoStubId::NUM_STUBIDS, "stub id out of range");
290     return _stub_names[(int)id];
291   }
292 
293   // access to runtime stubs entry points for java code
294   static address new_instance_Java()                     { return _new_instance_Java; }
295   static address new_array_Java()                        { return _new_array_Java; }
296   static address new_array_nozero_Java()                 { return _new_array_nozero_Java; }
297   static address multianewarray2_Java()                  { return _multianewarray2_Java; }
298   static address multianewarray3_Java()                  { return _multianewarray3_Java; }
299   static address multianewarray4_Java()                  { return _multianewarray4_Java; }
300   static address multianewarray5_Java()                  { return _multianewarray5_Java; }
301   static address multianewarrayN_Java()                  { return _multianewarrayN_Java; }
302   static address complete_monitor_locking_Java()         { return _complete_monitor_locking_Java; }
303   static address monitor_notify_Java()                   { return _monitor_notify_Java; }
304   static address monitor_notifyAll_Java()                { return _monitor_notifyAll_Java; }
305 
306   static address slow_arraycopy_Java()                   { return _slow_arraycopy_Java; }
307   static address register_finalizer_Java()               { return _register_finalizer_Java; }
308   static address load_unknown_inline_Java()              { return _load_unknown_inline_Java; }
309   static address store_unknown_inline_Java()             { return _store_unknown_inline_Java; }
310 #if INCLUDE_JVMTI
311   static address notify_jvmti_vthread_start()            { return _notify_jvmti_vthread_start; }
312   static address notify_jvmti_vthread_end()              { return _notify_jvmti_vthread_end; }
313   static address notify_jvmti_vthread_mount()            { return _notify_jvmti_vthread_mount; }
314   static address notify_jvmti_vthread_unmount()          { return _notify_jvmti_vthread_unmount; }
315 #endif
316 
317   static UncommonTrapBlob* uncommon_trap_blob()                  { return _uncommon_trap_blob; }
318   static ExceptionBlob*    exception_blob()                      { return _exception_blob; }
319 
320   // Implicit exception support
321   static void throw_div0_exception_C      (JavaThread* thread);
322   static void throw_stack_overflow_error_C(JavaThread* thread);
323 
324   // Exception handling
325   static address rethrow_stub()             { return _rethrow_Java; }
326 
327 
328   // Type functions
329   // ======================================================
330 
331   static inline const TypeFunc* new_instance_Type() {
332     assert(_new_instance_Type != nullptr, "should be initialized");
333     return _new_instance_Type;
334   }
335 
336   static inline const TypeFunc* new_array_Type() {
337     assert(_new_array_Type != nullptr, "should be initialized");
338     return _new_array_Type;
339   }
340 
341   static inline const TypeFunc* new_array_nozero_Type() {
342     assert(_new_array_nozero_Type != nullptr, "should be initialized");
343     return _new_array_nozero_Type;
344   }
345 
346   static const TypeFunc* multianewarray_Type(int ndim); // multianewarray
347 
348   static inline const TypeFunc* multianewarray2_Type() {
349     assert(_multianewarray2_Type != nullptr, "should be initialized");
350     return _multianewarray2_Type;
351   }
352 
353   static inline const TypeFunc* multianewarray3_Type() {
354     assert(_multianewarray3_Type != nullptr, "should be initialized");
355     return _multianewarray3_Type;
356   }
357 
358   static inline const TypeFunc* multianewarray4_Type() {
359     assert(_multianewarray4_Type != nullptr, "should be initialized");
360     return _multianewarray4_Type;
361   }
362 
363   static inline const TypeFunc* multianewarray5_Type() {
364     assert(_multianewarray5_Type != nullptr, "should be initialized");
365     return _multianewarray5_Type;
366   }
367 
368   static inline const TypeFunc* multianewarrayN_Type() {
369     assert(_multianewarrayN_Type != nullptr, "should be initialized");
370     return _multianewarrayN_Type;
371   }
372 
373   static inline const TypeFunc* complete_monitor_enter_Type() {
374     assert(_complete_monitor_enter_Type != nullptr, "should be initialized");
375     return _complete_monitor_enter_Type;
376   }
377 
378   static inline const TypeFunc* complete_monitor_locking_Type() {
379     return complete_monitor_enter_Type();
380   }
381 
382   static inline const TypeFunc* complete_monitor_exit_Type() {
383     assert(_complete_monitor_exit_Type != nullptr, "should be initialized");
384     return _complete_monitor_exit_Type;
385   }
386 
387   static inline const TypeFunc* monitor_notify_Type() {
388     assert(_monitor_notify_Type != nullptr, "should be initialized");
389     return _monitor_notify_Type;
390   }
391 
392   static inline const TypeFunc* monitor_notifyAll_Type() {
393     return monitor_notify_Type();
394   }
395 
396   static inline const TypeFunc* uncommon_trap_Type() {
397     assert(_uncommon_trap_Type != nullptr, "should be initialized");
398     return _uncommon_trap_Type;
399   }
400 
401   static inline const TypeFunc* athrow_Type() {
402     assert(_athrow_Type != nullptr, "should be initialized");
403     return _athrow_Type;
404   }
405 
406   static inline const TypeFunc* rethrow_Type() {
407     assert(_rethrow_Type != nullptr, "should be initialized");
408     return _rethrow_Type;
409   }
410 
411   static inline const TypeFunc* Math_D_D_Type() {
412     assert(_Math_D_D_Type != nullptr, "should be initialized");
413     return _Math_D_D_Type;
414   }
415 
416   static inline const TypeFunc* Math_DD_D_Type() {
417     assert(_Math_DD_D_Type != nullptr, "should be initialized");
418     return _Math_DD_D_Type;
419   }
420 
421   static const TypeFunc* Math_Vector_Vector_Type(uint num_arg, const TypeVect* in_type, const TypeVect* out_type);
422 
423   static inline const TypeFunc* modf_Type() {
424     assert(_modf_Type != nullptr, "should be initialized");
425     return _modf_Type;
426   }
427 
428   static inline const TypeFunc* l2f_Type() {
429     assert(_l2f_Type != nullptr, "should be initialized");
430     return _l2f_Type;
431   }
432 
433   static inline const TypeFunc* void_long_Type() {
434     assert(_void_long_Type != nullptr, "should be initialized");
435     return _void_long_Type;
436   }
437 
438   static inline const TypeFunc* void_void_Type() {
439     assert(_void_void_Type != nullptr, "should be initialized");
440     return _void_void_Type;
441   }
442 
443   static const TypeFunc* jfr_write_checkpoint_Type() {
444     assert(_jfr_write_checkpoint_Type != nullptr, "should be initialized");
445     return _jfr_write_checkpoint_Type;
446   }
447 
448   static const TypeFunc* flush_windows_Type() {
449     assert(_flush_windows_Type != nullptr, "should be initialized");
450     return _flush_windows_Type;
451   }
452 
453   // arraycopy routine types
454   static inline const TypeFunc* fast_arraycopy_Type() {
455     assert(_fast_arraycopy_Type != nullptr, "should be initialized");
456     // This signature is simple:  Two base pointers and a size_t.
457     return _fast_arraycopy_Type;
458   }
459 
460   static inline const TypeFunc* checkcast_arraycopy_Type() {
461     assert(_checkcast_arraycopy_Type != nullptr, "should be initialized");
462     // An extension of fast_arraycopy_Type which adds type checking.
463     return _checkcast_arraycopy_Type;
464   }
465 
466   static inline const TypeFunc* generic_arraycopy_Type() {
467     assert(_generic_arraycopy_Type != nullptr, "should be initialized");
468     // This signature is like System.arraycopy, except that it returns status.
469     return _generic_arraycopy_Type;
470   }
471 
472   static inline const TypeFunc* slow_arraycopy_Type() {
473     assert(_slow_arraycopy_Type != nullptr, "should be initialized");
474     // This signature is exactly the same as System.arraycopy.
475     // There are no intptr_t (int/long) arguments.
476     return _slow_arraycopy_Type;
477   }   // the full routine
478 
479   static inline const TypeFunc* unsafe_setmemory_Type() {
480     assert(_unsafe_setmemory_Type != nullptr, "should be initialized");
481     return _unsafe_setmemory_Type;
482   }
483 
484 //  static const TypeFunc* digestBase_implCompress_Type(bool is_sha3);
485 //  static const TypeFunc* digestBase_implCompressMB_Type(bool is_sha3);
486 //  static const TypeFunc* double_keccak_Type();
487 
488   static inline const TypeFunc* array_fill_Type() {
489     assert(_array_fill_Type != nullptr, "should be initialized");
490     return _array_fill_Type;
491   }
492 
493   static inline const TypeFunc* array_sort_Type() {
494     assert(_array_sort_Type != nullptr, "should be initialized");
495     return _array_sort_Type;
496   }
497 
498   static inline const TypeFunc* array_partition_Type() {
499     assert(_array_partition_Type != nullptr, "should be initialized");
500     return _array_partition_Type;
501   }
502 
503   // for aescrypt encrypt/decrypt operations, just three pointers returning void (length is constant)
504   static inline const TypeFunc* aescrypt_block_Type() {
505     assert(_aescrypt_block_Type != nullptr, "should be initialized");
506     return _aescrypt_block_Type;
507   }
508 
509   // for cipherBlockChaining calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
510   static inline const TypeFunc* cipherBlockChaining_aescrypt_Type() {
511     assert(_cipherBlockChaining_aescrypt_Type != nullptr, "should be initialized");
512     return _cipherBlockChaining_aescrypt_Type;
513   }
514 
515   // for electronicCodeBook calls of aescrypt encrypt/decrypt, three pointers and a length, returning int
516   static inline const TypeFunc* electronicCodeBook_aescrypt_Type() {
517     assert(_electronicCodeBook_aescrypt_Type != nullptr, "should be initialized");
518     return _electronicCodeBook_aescrypt_Type;
519   }
520 
521   //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
522   static inline const TypeFunc* counterMode_aescrypt_Type() {
523     assert(_counterMode_aescrypt_Type != nullptr, "should be initialized");
524     return _counterMode_aescrypt_Type;
525   }
526 
527   //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
528   static inline const TypeFunc* galoisCounterMode_aescrypt_Type() {
529     assert(_galoisCounterMode_aescrypt_Type != nullptr, "should be initialized");
530     return _galoisCounterMode_aescrypt_Type;
531   }
532 
533   /*
534    * void implCompress(byte[] buf, int ofs)
535    */
536   static inline const TypeFunc* digestBase_implCompress_Type(bool is_sha3) {
537     assert((_digestBase_implCompress_with_sha3_Type != nullptr) &&
538            (_digestBase_implCompress_without_sha3_Type != nullptr), "should be initialized");
539     return is_sha3 ? _digestBase_implCompress_with_sha3_Type : _digestBase_implCompress_without_sha3_Type;
540   }
541 
542   /*
543    * int implCompressMultiBlock(byte[] b, int ofs, int limit)
544    */
545   static inline const TypeFunc* digestBase_implCompressMB_Type(bool is_sha3) {
546     assert((_digestBase_implCompressMB_with_sha3_Type != nullptr) &&
547            (_digestBase_implCompressMB_without_sha3_Type != nullptr), "should be initialized");
548     return is_sha3 ? _digestBase_implCompressMB_with_sha3_Type : _digestBase_implCompressMB_without_sha3_Type;
549   }
550 
551   static inline const TypeFunc* double_keccak_Type() {
552     assert(_double_keccak_Type != nullptr, "should be initialized");
553     return _double_keccak_Type;
554   }
555 
556   static inline const TypeFunc* multiplyToLen_Type() {
557     assert(_multiplyToLen_Type != nullptr, "should be initialized");
558     return _multiplyToLen_Type;
559   }
560 
561   static inline const TypeFunc* montgomeryMultiply_Type() {
562     assert(_montgomeryMultiply_Type != nullptr, "should be initialized");
563     return _montgomeryMultiply_Type;
564   }
565 
566   static inline const TypeFunc* montgomerySquare_Type() {
567     assert(_montgomerySquare_Type != nullptr, "should be initialized");
568     return _montgomerySquare_Type;
569   }
570 
571   static inline const TypeFunc* squareToLen_Type() {
572     assert(_squareToLen_Type != nullptr, "should be initialized");
573     return _squareToLen_Type;
574   }
575 
576   // for mulAdd calls, 2 pointers and 3 ints, returning int
577   static inline const TypeFunc* mulAdd_Type() {
578     assert(_mulAdd_Type != nullptr, "should be initialized");
579     return _mulAdd_Type;
580   }
581 
582   static inline const TypeFunc* bigIntegerShift_Type() {
583     assert(_bigIntegerShift_Type != nullptr, "should be initialized");
584     return _bigIntegerShift_Type;
585   }
586 
587   static inline const TypeFunc* vectorizedMismatch_Type() {
588     assert(_vectorizedMismatch_Type != nullptr, "should be initialized");
589     return _vectorizedMismatch_Type;
590   }
591 
592   // GHASH block processing
593   static inline const TypeFunc* ghash_processBlocks_Type() {
594     assert(_ghash_processBlocks_Type != nullptr, "should be initialized");
595     return _ghash_processBlocks_Type;
596   }
597 
598   // ChaCha20 Block function
599   static inline const TypeFunc* chacha20Block_Type() {
600     assert(_chacha20Block_Type != nullptr, "should be initialized");
601     return _chacha20Block_Type;
602   }
603 
604   static const TypeFunc* kyberNtt_Type() {
605     assert(_kyberNtt_Type != nullptr, "should be initialized");
606     return _kyberNtt_Type;
607   }
608 
609   static const TypeFunc* kyberInverseNtt_Type() {
610     assert(_kyberInverseNtt_Type != nullptr, "should be initialized");
611     return _kyberInverseNtt_Type;
612   }
613 
614   static const TypeFunc* kyberNttMult_Type() {
615     assert(_kyberNttMult_Type != nullptr, "should be initialized");
616     return _kyberNttMult_Type;
617   }
618 
619   static const TypeFunc* kyberAddPoly_2_Type() {
620     assert(_kyberAddPoly_2_Type != nullptr, "should be initialized");
621     return _kyberAddPoly_2_Type;
622   }
623 
624   static const TypeFunc* kyberAddPoly_3_Type() {
625     assert(_kyberAddPoly_3_Type != nullptr, "should be initialized");
626     return _kyberAddPoly_3_Type;
627   }
628 
629   static const TypeFunc* kyber12To16_Type() {
630     assert(_kyber12To16_Type != nullptr, "should be initialized");
631     return _kyber12To16_Type;
632   }
633 
634   static const TypeFunc* kyberBarrettReduce_Type() {
635     assert(_kyberBarrettReduce_Type != nullptr, "should be initialized");
636     return _kyberBarrettReduce_Type;
637   }
638 
639   static inline const TypeFunc* dilithiumAlmostNtt_Type() {
640     assert(_dilithiumAlmostNtt_Type != nullptr, "should be initialized");
641     return _dilithiumAlmostNtt_Type;
642   }
643 
644   static inline const TypeFunc* dilithiumAlmostInverseNtt_Type() {
645     assert(_dilithiumAlmostInverseNtt_Type != nullptr, "should be initialized");
646     return _dilithiumAlmostInverseNtt_Type;
647   }
648 
649   static inline const TypeFunc* dilithiumNttMult_Type() {
650     assert(_dilithiumNttMult_Type != nullptr, "should be initialized");
651     return _dilithiumNttMult_Type;
652   }
653 
654   static inline const TypeFunc* dilithiumMontMulByConstant_Type() {
655     assert(_dilithiumMontMulByConstant_Type != nullptr, "should be initialized");
656     return _dilithiumMontMulByConstant_Type;
657   }
658 
659   static inline const TypeFunc* dilithiumDecomposePoly_Type() {
660     assert(_dilithiumDecomposePoly_Type != nullptr, "should be initialized");
661     return _dilithiumDecomposePoly_Type;
662   }
663 
664   // Base64 encode function
665   static inline const TypeFunc* base64_encodeBlock_Type() {
666     assert(_base64_encodeBlock_Type != nullptr, "should be initialized");
667     return _base64_encodeBlock_Type;
668   }
669 
670   // Base64 decode function
671   static inline const TypeFunc* base64_decodeBlock_Type() {
672     assert(_base64_decodeBlock_Type != nullptr, "should be initialized");
673     return _base64_decodeBlock_Type;
674   }
675 
676   // String IndexOf function
677   static inline const TypeFunc* string_IndexOf_Type() {
678     assert(_string_IndexOf_Type != nullptr, "should be initialized");
679     return _string_IndexOf_Type;
680   }
681 
682   // Poly1305 processMultipleBlocks function
683   static inline const TypeFunc* poly1305_processBlocks_Type() {
684     assert(_poly1305_processBlocks_Type != nullptr, "should be initialized");
685     return _poly1305_processBlocks_Type;
686   }
687 
688   // MontgomeryIntegerPolynomialP256 multiply function
689   static inline const TypeFunc* intpoly_montgomeryMult_P256_Type() {
690     assert(_intpoly_montgomeryMult_P256_Type != nullptr, "should be initialized");
691     return _intpoly_montgomeryMult_P256_Type;
692   }
693 
694   // IntegerPolynomial constant time assignment function
695   static inline const TypeFunc* intpoly_assign_Type() {
696     assert(_intpoly_assign_Type != nullptr, "should be initialized");
697     return _intpoly_assign_Type;
698   }
699 
700   /**
701    * int updateBytesCRC32(int crc, byte* b, int len)
702    */
703   static inline const TypeFunc* updateBytesCRC32_Type() {
704     assert(_updateBytesCRC32_Type != nullptr, "should be initialized");
705     return _updateBytesCRC32_Type;
706   }
707 
708   /**
709    * int updateBytesCRC32C(int crc, byte* buf, int len, int* table)
710    */
711   static inline const TypeFunc* updateBytesCRC32C_Type() {
712     assert(_updateBytesCRC32C_Type != nullptr, "should be initialized");
713     return _updateBytesCRC32C_Type;
714   }
715 
716   /**
717    *  int updateBytesAdler32(int adler, bytes* b, int off, int len)
718    */
719   static inline const TypeFunc* updateBytesAdler32_Type() {
720     assert(_updateBytesAdler32_Type != nullptr, "should be initialized");
721     return _updateBytesAdler32_Type;
722   }
723 
724 
725   // leaf on stack replacement interpreter accessor types
726   static inline const TypeFunc* osr_end_Type() {
727     assert(_osr_end_Type != nullptr, "should be initialized");
728     return _osr_end_Type;
729   }
730 
731   static inline const TypeFunc* register_finalizer_Type() {
732     assert(_register_finalizer_Type != nullptr, "should be initialized");
733     return _register_finalizer_Type;
734   }
735 
736 #if INCLUDE_JFR
737   static inline const TypeFunc* class_id_load_barrier_Type() {
738     assert(_class_id_load_barrier_Type != nullptr, "should be initialized");
739     return _class_id_load_barrier_Type;
740   }
741 #endif // INCLUDE_JFR
742 
743   static const TypeFunc* load_unknown_inline_Type();
744   static const TypeFunc* store_unknown_inline_Type();
745 
746   static const TypeFunc* store_inline_type_fields_Type();
747   static const TypeFunc* pack_inline_type_Type();
748 
749 #if INCLUDE_JVMTI
750   static inline const TypeFunc* notify_jvmti_vthread_Type() {
751     assert(_notify_jvmti_vthread_Type != nullptr, "should be initialized");
752     return _notify_jvmti_vthread_Type;
753   }
754 #endif
755 
756   // Dtrace support. entry and exit probes have the same signature
757   static inline const TypeFunc* dtrace_method_entry_exit_Type() {
758     assert(_dtrace_method_entry_exit_Type != nullptr, "should be initialized");
759     return _dtrace_method_entry_exit_Type;
760   }
761 
762   static inline const TypeFunc* dtrace_object_alloc_Type() {
763     assert(_dtrace_object_alloc_Type != nullptr, "should be initialized");
764     return _dtrace_object_alloc_Type;
765   }
766 
767  private:
768  static NamedCounter * volatile _named_counters;
769 
770  public:
771  // helper function which creates a named counter labeled with the
772  // if they are available
773  static NamedCounter* new_named_counter(JVMState* jvms, NamedCounter::CounterTag tag);
774 
775  // dumps all the named counters
776  static void          print_named_counters();
777 
778  static void          initialize_types();
779 };
780 
781 #endif // SHARE_OPTO_RUNTIME_HPP