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* _multianewarray2_Type;
138   static const TypeFunc* _multianewarray3_Type;
139   static const TypeFunc* _multianewarray4_Type;
140   static const TypeFunc* _multianewarray5_Type;
141   static const TypeFunc* _multianewarrayN_Type;
142   static const TypeFunc* _complete_monitor_enter_Type;
143   static const TypeFunc* _complete_monitor_exit_Type;
144   static const TypeFunc* _monitor_notify_Type;
145   static const TypeFunc* _uncommon_trap_Type;
146   static const TypeFunc* _athrow_Type;
147   static const TypeFunc* _rethrow_Type;
148   static const TypeFunc* _Math_D_D_Type;
149   static const TypeFunc* _Math_DD_D_Type;
150   static const TypeFunc* _modf_Type;
151   static const TypeFunc* _l2f_Type;
152   static const TypeFunc* _void_long_Type;
153   static const TypeFunc* _void_void_Type;
154   static const TypeFunc* _jfr_write_checkpoint_Type;
155   static const TypeFunc* _flush_windows_Type;
156   static const TypeFunc* _fast_arraycopy_Type;
157   static const TypeFunc* _checkcast_arraycopy_Type;
158   static const TypeFunc* _generic_arraycopy_Type;
159   static const TypeFunc* _slow_arraycopy_Type;
160   static const TypeFunc* _unsafe_setmemory_Type;
161   static const TypeFunc* _array_fill_Type;
162   static const TypeFunc* _array_sort_Type;
163   static const TypeFunc* _array_partition_Type;
164   static const TypeFunc* _aescrypt_block_Type;
165   static const TypeFunc* _cipherBlockChaining_aescrypt_Type;
166   static const TypeFunc* _electronicCodeBook_aescrypt_Type;
167   static const TypeFunc* _counterMode_aescrypt_Type;
168   static const TypeFunc* _galoisCounterMode_aescrypt_Type;
169   static const TypeFunc* _digestBase_implCompress_with_sha3_Type;
170   static const TypeFunc* _digestBase_implCompress_without_sha3_Type;
171   static const TypeFunc* _digestBase_implCompressMB_with_sha3_Type;
172   static const TypeFunc* _digestBase_implCompressMB_without_sha3_Type;
173   static const TypeFunc* _multiplyToLen_Type;
174   static const TypeFunc* _montgomeryMultiply_Type;
175   static const TypeFunc* _montgomerySquare_Type;
176   static const TypeFunc* _squareToLen_Type;
177   static const TypeFunc* _mulAdd_Type;
178   static const TypeFunc* _bigIntegerShift_Type;
179   static const TypeFunc* _vectorizedMismatch_Type;
180   static const TypeFunc* _ghash_processBlocks_Type;
181   static const TypeFunc* _chacha20Block_Type;
182   static const TypeFunc* _base64_encodeBlock_Type;
183   static const TypeFunc* _base64_decodeBlock_Type;
184   static const TypeFunc* _string_IndexOf_Type;
185   static const TypeFunc* _poly1305_processBlocks_Type;
186   static const TypeFunc* _intpoly_montgomeryMult_P256_Type;
187   static const TypeFunc* _intpoly_assign_Type;
188   static const TypeFunc* _updateBytesCRC32_Type;
189   static const TypeFunc* _updateBytesCRC32C_Type;
190   static const TypeFunc* _updateBytesAdler32_Type;
191   static const TypeFunc* _osr_end_Type;
192   static const TypeFunc* _register_finalizer_Type;
193 #if INCLUDE_JFR
194   static const TypeFunc* _class_id_load_barrier_Type;
195 #endif // INCLUDE_JFR
196 #if INCLUDE_JVMTI
197   static const TypeFunc* _notify_jvmti_vthread_Type;
198 #endif // INCLUDE_JVMTI
199   static const TypeFunc* _dtrace_method_entry_exit_Type;
200   static const TypeFunc* _dtrace_object_alloc_Type;
201 
202   // Stub names indexed by sharedStubId
203   static const char *_stub_names[];
204 
205   // define stubs
206   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);
207 
208   //
209   // Implementation of runtime methods
210   // =================================
211 
212   // Allocate storage for a Java instance.
213   static void new_instance_C(Klass* instance_klass, JavaThread* current);
214 
215   // Allocate storage for a objArray or typeArray
216   static void new_array_C(Klass* array_klass, int len, JavaThread* current);
217   static void new_array_nozero_C(Klass* array_klass, int len, JavaThread* current);
218 
219   // Allocate storage for a multi-dimensional arrays
220   // Note: needs to be fixed for arbitrary number of dimensions
221   static void multianewarray2_C(Klass* klass, int len1, int len2, JavaThread* current);
222   static void multianewarray3_C(Klass* klass, int len1, int len2, int len3, JavaThread* current);
223   static void multianewarray4_C(Klass* klass, int len1, int len2, int len3, int len4, JavaThread* current);
224   static void multianewarray5_C(Klass* klass, int len1, int len2, int len3, int len4, int len5, JavaThread* current);
225   static void multianewarrayN_C(Klass* klass, arrayOopDesc* dims, JavaThread* current);
226 
227   // local methods passed as arguments to stub generator that forward
228   // control to corresponding JRT methods of SharedRuntime
229   static void slow_arraycopy_C(oopDesc* src,  jint src_pos,
230                                oopDesc* dest, jint dest_pos,
231                                jint length, JavaThread* thread);
232   static void complete_monitor_locking_C(oopDesc* obj, BasicLock* lock, JavaThread* current);
233 
234 public:
235   static void monitor_notify_C(oopDesc* obj, JavaThread* current);
236   static void monitor_notifyAll_C(oopDesc* obj, JavaThread* current);
237 
238 private:
239 
240   // Implicit exception support
241   static void throw_null_exception_C(JavaThread* thread);
242 
243   // Exception handling
244   static address handle_exception_C       (JavaThread* current);
245   static address handle_exception_C_helper(JavaThread* current, nmethod*& nm);
246   static address rethrow_C                (oopDesc* exception, JavaThread *thread, address return_pc );
247   static void deoptimize_caller_frame     (JavaThread *thread);
248   static void deoptimize_caller_frame     (JavaThread *thread, bool doit);
249   static bool is_deoptimized_caller_frame (JavaThread *thread);
250 
251   // CodeBlob support
252   // ===================================================================
253 
254   static void generate_uncommon_trap_blob(void);
255   static void generate_exception_blob();
256 
257   static void register_finalizer_C(oopDesc* obj, JavaThread* current);
258 
259  public:
260 
261   static bool is_callee_saved_register(MachRegisterNumbers reg);
262 
263   // One time only generate runtime code stubs. Returns true
264   // when runtime stubs have been generated successfully and
265   // false otherwise.
266   static bool generate(ciEnv* env);
267 
268   // Returns the name of a stub
269   static const char* stub_name(address entry);
270 
271   // Returns the name associated with a given stub id
272   static const char* stub_name(OptoStubId id) {
273     assert(id > OptoStubId::NO_STUBID && id < OptoStubId::NUM_STUBIDS, "stub id out of range");
274     return _stub_names[(int)id];
275   }
276 
277   // access to runtime stubs entry points for java code
278   static address new_instance_Java()                     { return _new_instance_Java; }
279   static address new_array_Java()                        { return _new_array_Java; }
280   static address new_array_nozero_Java()                 { return _new_array_nozero_Java; }
281   static address multianewarray2_Java()                  { return _multianewarray2_Java; }
282   static address multianewarray3_Java()                  { return _multianewarray3_Java; }
283   static address multianewarray4_Java()                  { return _multianewarray4_Java; }
284   static address multianewarray5_Java()                  { return _multianewarray5_Java; }
285   static address multianewarrayN_Java()                  { return _multianewarrayN_Java; }
286   static address complete_monitor_locking_Java()         { return _complete_monitor_locking_Java; }
287   static address monitor_notify_Java()                   { return _monitor_notify_Java; }
288   static address monitor_notifyAll_Java()                { return _monitor_notifyAll_Java; }
289 
290   static address slow_arraycopy_Java()                   { return _slow_arraycopy_Java; }
291   static address register_finalizer_Java()               { return _register_finalizer_Java; }
292 #if INCLUDE_JVMTI
293   static address notify_jvmti_vthread_start()            { return _notify_jvmti_vthread_start; }
294   static address notify_jvmti_vthread_end()              { return _notify_jvmti_vthread_end; }
295   static address notify_jvmti_vthread_mount()            { return _notify_jvmti_vthread_mount; }
296   static address notify_jvmti_vthread_unmount()          { return _notify_jvmti_vthread_unmount; }
297 #endif
298 
299   static UncommonTrapBlob* uncommon_trap_blob()                  { return _uncommon_trap_blob; }
300   static ExceptionBlob*    exception_blob()                      { return _exception_blob; }
301 
302   // Implicit exception support
303   static void throw_div0_exception_C      (JavaThread* thread);
304   static void throw_stack_overflow_error_C(JavaThread* thread);
305 
306   // Exception handling
307   static address rethrow_stub()             { return _rethrow_Java; }
308 
309 
310   // Type functions
311   // ======================================================
312 
313   static inline const TypeFunc* new_instance_Type() {
314     assert(_new_instance_Type != nullptr, "should be initialized");
315     return _new_instance_Type;
316   }
317 
318   static inline const TypeFunc* new_array_Type() {
319     assert(_new_array_Type != nullptr, "should be initialized");
320     return _new_array_Type;
321   }
322 
323   static inline const TypeFunc* new_array_nozero_Type() {
324     return new_array_Type();
325   }
326 
327   static const TypeFunc* multianewarray_Type(int ndim); // multianewarray
328 
329   static inline const TypeFunc* multianewarray2_Type() {
330     assert(_multianewarray2_Type != nullptr, "should be initialized");
331     return _multianewarray2_Type;
332   }
333 
334   static inline const TypeFunc* multianewarray3_Type() {
335     assert(_multianewarray3_Type != nullptr, "should be initialized");
336     return _multianewarray3_Type;
337   }
338 
339   static inline const TypeFunc* multianewarray4_Type() {
340     assert(_multianewarray4_Type != nullptr, "should be initialized");
341     return _multianewarray4_Type;
342   }
343 
344   static inline const TypeFunc* multianewarray5_Type() {
345     assert(_multianewarray5_Type != nullptr, "should be initialized");
346     return _multianewarray5_Type;
347   }
348 
349   static inline const TypeFunc* multianewarrayN_Type() {
350     assert(_multianewarrayN_Type != nullptr, "should be initialized");
351     return _multianewarrayN_Type;
352   }
353 
354   static inline const TypeFunc* complete_monitor_enter_Type() {
355     assert(_complete_monitor_enter_Type != nullptr, "should be initialized");
356     return _complete_monitor_enter_Type;
357   }
358 
359   static inline const TypeFunc* complete_monitor_locking_Type() {
360     return complete_monitor_enter_Type();
361   }
362 
363   static inline const TypeFunc* complete_monitor_exit_Type() {
364     assert(_complete_monitor_exit_Type != nullptr, "should be initialized");
365     return _complete_monitor_exit_Type;
366   }
367 
368   static inline const TypeFunc* monitor_notify_Type() {
369     assert(_monitor_notify_Type != nullptr, "should be initialized");
370     return _monitor_notify_Type;
371   }
372 
373   static inline const TypeFunc* monitor_notifyAll_Type() {
374     return monitor_notify_Type();
375   }
376 
377   static inline const TypeFunc* uncommon_trap_Type() {
378     assert(_uncommon_trap_Type != nullptr, "should be initialized");
379     return _uncommon_trap_Type;
380   }
381 
382   static inline const TypeFunc* athrow_Type() {
383     assert(_athrow_Type != nullptr, "should be initialized");
384     return _athrow_Type;
385   }
386 
387   static inline const TypeFunc* rethrow_Type() {
388     assert(_rethrow_Type != nullptr, "should be initialized");
389     return _rethrow_Type;
390   }
391 
392   static inline const TypeFunc* Math_D_D_Type() {
393     assert(_Math_D_D_Type != nullptr, "should be initialized");
394     return _Math_D_D_Type;
395   }
396 
397   static inline const TypeFunc* Math_DD_D_Type() {
398     assert(_Math_DD_D_Type != nullptr, "should be initialized");
399     return _Math_DD_D_Type;
400   }
401 
402   static const TypeFunc* Math_Vector_Vector_Type(uint num_arg, const TypeVect* in_type, const TypeVect* out_type);
403 
404   static inline const TypeFunc* modf_Type() {
405     assert(_modf_Type != nullptr, "should be initialized");
406     return _modf_Type;
407   }
408 
409   static inline const TypeFunc* l2f_Type() {
410     assert(_l2f_Type != nullptr, "should be initialized");
411     return _l2f_Type;
412   }
413 
414   static inline const TypeFunc* void_long_Type() {
415     assert(_void_long_Type != nullptr, "should be initialized");
416     return _void_long_Type;
417   }
418 
419   static inline const TypeFunc* void_void_Type() {
420     assert(_void_void_Type != nullptr, "should be initialized");
421     return _void_void_Type;
422   }
423 
424   static const TypeFunc* jfr_write_checkpoint_Type() {
425     assert(_jfr_write_checkpoint_Type != nullptr, "should be initialized");
426     return _jfr_write_checkpoint_Type;
427   }
428 
429   static const TypeFunc* flush_windows_Type() {
430     assert(_flush_windows_Type != nullptr, "should be initialized");
431     return _flush_windows_Type;
432   }
433 
434   // arraycopy routine types
435   static inline const TypeFunc* fast_arraycopy_Type() {
436     assert(_fast_arraycopy_Type != nullptr, "should be initialized");
437     // This signature is simple:  Two base pointers and a size_t.
438     return _fast_arraycopy_Type;
439   }
440 
441   static inline const TypeFunc* checkcast_arraycopy_Type() {
442     assert(_checkcast_arraycopy_Type != nullptr, "should be initialized");
443     // An extension of fast_arraycopy_Type which adds type checking.
444     return _checkcast_arraycopy_Type;
445   }
446 
447   static inline const TypeFunc* generic_arraycopy_Type() {
448     assert(_generic_arraycopy_Type != nullptr, "should be initialized");
449     // This signature is like System.arraycopy, except that it returns status.
450     return _generic_arraycopy_Type;
451   }
452 
453   static inline const TypeFunc* slow_arraycopy_Type() {
454     assert(_slow_arraycopy_Type != nullptr, "should be initialized");
455     // This signature is exactly the same as System.arraycopy.
456     // There are no intptr_t (int/long) arguments.
457     return _slow_arraycopy_Type;
458   }   // the full routine
459 
460   static inline const TypeFunc* unsafe_setmemory_Type() {
461     assert(_unsafe_setmemory_Type != nullptr, "should be initialized");
462     return _unsafe_setmemory_Type;
463   }
464 
465   static inline const TypeFunc* array_fill_Type() {
466     assert(_array_fill_Type != nullptr, "should be initialized");
467     return _array_fill_Type;
468   }
469 
470   static inline const TypeFunc* array_sort_Type() {
471     assert(_array_sort_Type != nullptr, "should be initialized");
472     return _array_sort_Type;
473   }
474 
475   static inline const TypeFunc* array_partition_Type() {
476     assert(_array_partition_Type != nullptr, "should be initialized");
477     return _array_partition_Type;
478   }
479 
480   // for aescrypt encrypt/decrypt operations, just three pointers returning void (length is constant)
481   static inline const TypeFunc* aescrypt_block_Type() {
482     assert(_aescrypt_block_Type != nullptr, "should be initialized");
483     return _aescrypt_block_Type;
484   }
485 
486   // for cipherBlockChaining calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
487   static inline const TypeFunc* cipherBlockChaining_aescrypt_Type() {
488     assert(_cipherBlockChaining_aescrypt_Type != nullptr, "should be initialized");
489     return _cipherBlockChaining_aescrypt_Type;
490   }
491 
492   // for electronicCodeBook calls of aescrypt encrypt/decrypt, three pointers and a length, returning int
493   static inline const TypeFunc* electronicCodeBook_aescrypt_Type() {
494     assert(_electronicCodeBook_aescrypt_Type != nullptr, "should be initialized");
495     return _electronicCodeBook_aescrypt_Type;
496   }
497 
498   //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
499   static inline const TypeFunc* counterMode_aescrypt_Type() {
500     assert(_counterMode_aescrypt_Type != nullptr, "should be initialized");
501     return _counterMode_aescrypt_Type;
502   }
503 
504   //for counterMode calls of aescrypt encrypt/decrypt, four pointers and a length, returning int
505   static inline const TypeFunc* galoisCounterMode_aescrypt_Type() {
506     assert(_galoisCounterMode_aescrypt_Type != nullptr, "should be initialized");
507     return _galoisCounterMode_aescrypt_Type;
508   }
509 
510   /*
511    * void implCompress(byte[] buf, int ofs)
512    */
513   static inline const TypeFunc* digestBase_implCompress_Type(bool is_sha3) {
514     assert((_digestBase_implCompress_with_sha3_Type != nullptr) &&
515            (_digestBase_implCompress_without_sha3_Type != nullptr), "should be initialized");
516     return is_sha3 ? _digestBase_implCompress_with_sha3_Type : _digestBase_implCompress_without_sha3_Type;
517   }
518 
519   /*
520    * int implCompressMultiBlock(byte[] b, int ofs, int limit)
521    */
522   static inline const TypeFunc* digestBase_implCompressMB_Type(bool is_sha3) {
523     assert((_digestBase_implCompressMB_with_sha3_Type != nullptr) &&
524            (_digestBase_implCompressMB_without_sha3_Type != nullptr), "should be initialized");
525     return is_sha3 ? _digestBase_implCompressMB_with_sha3_Type : _digestBase_implCompressMB_without_sha3_Type;
526   }
527 
528   static inline const TypeFunc* multiplyToLen_Type() {
529     assert(_multiplyToLen_Type != nullptr, "should be initialized");
530     return _multiplyToLen_Type;
531   }
532 
533   static inline const TypeFunc* montgomeryMultiply_Type() {
534     assert(_montgomeryMultiply_Type != nullptr, "should be initialized");
535     return _montgomeryMultiply_Type;
536   }
537 
538   static inline const TypeFunc* montgomerySquare_Type() {
539     assert(_montgomerySquare_Type != nullptr, "should be initialized");
540     return _montgomerySquare_Type;
541   }
542 
543   static inline const TypeFunc* squareToLen_Type() {
544     assert(_squareToLen_Type != nullptr, "should be initialized");
545     return _squareToLen_Type;
546   }
547 
548   // for mulAdd calls, 2 pointers and 3 ints, returning int
549   static inline const TypeFunc* mulAdd_Type() {
550     assert(_mulAdd_Type != nullptr, "should be initialized");
551     return _mulAdd_Type;
552   }
553 
554   static inline const TypeFunc* bigIntegerShift_Type() {
555     assert(_bigIntegerShift_Type != nullptr, "should be initialized");
556     return _bigIntegerShift_Type;
557   }
558 
559   static inline const TypeFunc* vectorizedMismatch_Type() {
560     assert(_vectorizedMismatch_Type != nullptr, "should be initialized");
561     return _vectorizedMismatch_Type;
562   }
563 
564   // GHASH block processing
565   static inline const TypeFunc* ghash_processBlocks_Type() {
566     assert(_ghash_processBlocks_Type != nullptr, "should be initialized");
567     return _ghash_processBlocks_Type;
568   }
569 
570   // ChaCha20 Block function
571   static inline const TypeFunc* chacha20Block_Type() {
572     assert(_chacha20Block_Type != nullptr, "should be initialized");
573     return _chacha20Block_Type;
574   }
575 
576   // Base64 encode function
577   static inline const TypeFunc* base64_encodeBlock_Type() {
578     assert(_base64_encodeBlock_Type != nullptr, "should be initialized");
579     return _base64_encodeBlock_Type;
580   }
581 
582   // Base64 decode function
583   static inline const TypeFunc* base64_decodeBlock_Type() {
584     assert(_base64_decodeBlock_Type != nullptr, "should be initialized");
585     return _base64_decodeBlock_Type;
586   }
587 
588   // String IndexOf function
589   static inline const TypeFunc* string_IndexOf_Type() {
590     assert(_string_IndexOf_Type != nullptr, "should be initialized");
591     return _string_IndexOf_Type;
592   }
593 
594   // Poly1305 processMultipleBlocks function
595   static inline const TypeFunc* poly1305_processBlocks_Type() {
596     assert(_poly1305_processBlocks_Type != nullptr, "should be initialized");
597     return _poly1305_processBlocks_Type;
598   }
599 
600   // MontgomeryIntegerPolynomialP256 multiply function
601   static inline const TypeFunc* intpoly_montgomeryMult_P256_Type() {
602     assert(_intpoly_montgomeryMult_P256_Type != nullptr, "should be initialized");
603     return _intpoly_montgomeryMult_P256_Type;
604   }
605 
606   // IntegerPolynomial constant time assignment function
607   static inline const TypeFunc* intpoly_assign_Type() {
608     assert(_intpoly_assign_Type != nullptr, "should be initialized");
609     return _intpoly_assign_Type;
610   }
611 
612   /**
613    * int updateBytesCRC32(int crc, byte* b, int len)
614    */
615   static inline const TypeFunc* updateBytesCRC32_Type() {
616     assert(_updateBytesCRC32_Type != nullptr, "should be initialized");
617     return _updateBytesCRC32_Type;
618   }
619 
620   /**
621    * int updateBytesCRC32C(int crc, byte* buf, int len, int* table)
622    */
623   static inline const TypeFunc* updateBytesCRC32C_Type() {
624     assert(_updateBytesCRC32C_Type != nullptr, "should be initialized");
625     return _updateBytesCRC32C_Type;
626   }
627 
628   /**
629    *  int updateBytesAdler32(int adler, bytes* b, int off, int len)
630    */
631   static inline const TypeFunc* updateBytesAdler32_Type() {
632     assert(_updateBytesAdler32_Type != nullptr, "should be initialized");
633     return _updateBytesAdler32_Type;
634   }
635 
636 
637   // leaf on stack replacement interpreter accessor types
638   static inline const TypeFunc* osr_end_Type() {
639     assert(_osr_end_Type != nullptr, "should be initialized");
640     return _osr_end_Type;
641   }
642 
643   static inline const TypeFunc* register_finalizer_Type() {
644     assert(_register_finalizer_Type != nullptr, "should be initialized");
645     return _register_finalizer_Type;
646   }
647 
648 #if INCLUDE_JFR
649   static inline const TypeFunc* class_id_load_barrier_Type() {
650     assert(_class_id_load_barrier_Type != nullptr, "should be initialized");
651     return _class_id_load_barrier_Type;
652   }
653 #endif // INCLUDE_JFR
654 
655 #if INCLUDE_JVMTI
656   static inline const TypeFunc* notify_jvmti_vthread_Type() {
657     assert(_notify_jvmti_vthread_Type != nullptr, "should be initialized");
658     return _notify_jvmti_vthread_Type;
659   }
660 #endif
661 
662   // Dtrace support. entry and exit probes have the same signature
663   static inline const TypeFunc* dtrace_method_entry_exit_Type() {
664     assert(_dtrace_method_entry_exit_Type != nullptr, "should be initialized");
665     return _dtrace_method_entry_exit_Type;
666   }
667 
668   static inline const TypeFunc* dtrace_object_alloc_Type() {
669     assert(_dtrace_object_alloc_Type != nullptr, "should be initialized");
670     return _dtrace_object_alloc_Type;
671   }
672 
673  private:
674  static NamedCounter * volatile _named_counters;
675 
676  public:
677  // helper function which creates a named counter labeled with the
678  // if they are available
679  static NamedCounter* new_named_counter(JVMState* jvms, NamedCounter::CounterTag tag);
680 
681  // dumps all the named counters
682  static void          print_named_counters();
683 
684  static void          initialize_types();
685 };
686 
687 #endif // SHARE_OPTO_RUNTIME_HPP