1 /*
   2  * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2025, Red Hat, Inc. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  *
  24  */
  25 
  26 #ifndef SHARE_RUNTIME_STUBDECLARATIONS_HPP
  27 #define SHARE_RUNTIME_STUBDECLARATIONS_HPP
  28 
  29 #include "utilities/macros.hpp"
  30 
  31 // macros for generating definitions and declarations for shared, c1
  32 // and opto blob fields and associated stub ids
  33 
  34 // Different shared stubs can have different blob types and may
  35 // include some JFR stubs
  36 //
  37 // n.b resolve, handler and throw stubs must remain grouped in the
  38 // same order to allow id values to be range checked
  39 
  40 #if INCLUDE_JFR
  41 // do_blob(name, type)
  42 #define SHARED_JFR_STUBS_DO(do_blob)                                   \
  43   do_blob(jfr_write_checkpoint, RuntimeStub*)                          \
  44   do_blob(jfr_return_lease, RuntimeStub*)                              \
  45 
  46 #else
  47 #define SHARED_JFR_STUBS_DO(do_blob)
  48 #endif
  49 
  50 // client macro to operate on shared stubs
  51 //
  52 // do_blob(name, type)
  53 #define SHARED_STUBS_DO(do_blob)                                       \
  54   do_blob(deopt, DeoptimizationBlob*)                                  \
  55   /* resolve stubs */                                                  \
  56   do_blob(wrong_method, RuntimeStub*)                                  \
  57   do_blob(wrong_method_abstract, RuntimeStub*)                         \
  58   do_blob(ic_miss, RuntimeStub*)                                       \
  59   do_blob(resolve_opt_virtual_call, RuntimeStub*)                      \
  60   do_blob(resolve_virtual_call, RuntimeStub*)                          \
  61   do_blob(resolve_static_call, RuntimeStub*)                           \
  62   /* handler stubs */                                                  \
  63   do_blob(polling_page_vectors_safepoint_handler, SafepointBlob*)      \
  64   do_blob(polling_page_safepoint_handler, SafepointBlob*)              \
  65   do_blob(polling_page_return_handler, SafepointBlob*)                 \
  66   /* throw stubs */                                                    \
  67   do_blob(throw_AbstractMethodError, RuntimeStub*)                     \
  68   do_blob(throw_IncompatibleClassChangeError, RuntimeStub*)            \
  69   do_blob(throw_NullPointerException_at_call, RuntimeStub*)            \
  70   do_blob(throw_StackOverflowError, RuntimeStub*)                      \
  71   do_blob(throw_delayed_StackOverflowError, RuntimeStub*)              \
  72   /* other stubs */                                                    \
  73   SHARED_JFR_STUBS_DO(do_blob)                                         \
  74 
  75 // C1 stubs are always generated in a generic CodeBlob
  76 
  77 #ifdef COMPILER1
  78 // client macro to operate on c1 stubs
  79 //
  80 // do_blob(name)
  81 #define C1_STUBS_DO(do_blob)                                           \
  82   do_blob(dtrace_object_alloc)                                         \
  83   do_blob(unwind_exception)                                            \
  84   do_blob(forward_exception)                                           \
  85   do_blob(throw_range_check_failed)       /* throws ArrayIndexOutOfBoundsException */ \
  86   do_blob(throw_index_exception)          /* throws IndexOutOfBoundsException */ \
  87   do_blob(throw_div0_exception)                                        \
  88   do_blob(throw_null_pointer_exception)                                \
  89   do_blob(register_finalizer)                                          \
  90   do_blob(new_instance)                                                \
  91   do_blob(fast_new_instance)                                           \
  92   do_blob(fast_new_instance_init_check)                                \
  93   do_blob(new_type_array)                                              \
  94   do_blob(new_object_array)                                            \
  95   do_blob(new_multi_array)                                             \
  96   do_blob(handle_exception_nofpu)         /* optimized version that does not preserve fpu registers */ \
  97   do_blob(handle_exception)                                            \
  98   do_blob(handle_exception_from_callee)                                \
  99   do_blob(throw_array_store_exception)                                 \
 100   do_blob(throw_class_cast_exception)                                  \
 101   do_blob(throw_incompatible_class_change_error)                       \
 102   do_blob(slow_subtype_check)                                          \
 103   do_blob(is_instance_of)                                              \
 104   do_blob(monitorenter)                                                \
 105   do_blob(monitorenter_nofpu)             /* optimized version that does not preserve fpu registers */ \
 106   do_blob(monitorexit)                                                 \
 107   do_blob(monitorexit_nofpu)              /* optimized version that does not preserve fpu registers */ \
 108   do_blob(deoptimize)                                                  \
 109   do_blob(access_field_patching)                                       \
 110   do_blob(load_klass_patching)                                         \
 111   do_blob(load_mirror_patching)                                        \
 112   do_blob(load_appendix_patching)                                      \
 113   do_blob(fpu2long_stub)                                               \
 114   do_blob(counter_overflow)                                            \
 115   do_blob(predicate_failed_trap)                                       \
 116 
 117 #else
 118 #define C1_STUBS_DO(do_blob)
 119 #endif
 120 
 121 // Opto stubs can be stored as entries with just an address or as
 122 // blobs of different types. The former may include some JVMTI stubs.
 123 //
 124 // n.b. blobs and stub defines are generated in the order defined by
 125 // C2_STUBS_DO, allowing dependencies from any givem stub on its
 126 // predecessors to be guaranteed. That explains the initial placement
 127 // of the blob declarations and intermediate placement of the jvmti
 128 // stubs.
 129 
 130 #ifdef COMPILER2
 131 // do_jvmti_stub(name)
 132 #if INCLUDE_JVMTI
 133 #define C2_JVMTI_STUBS_DO(do_jvmti_stub)                               \
 134   do_jvmti_stub(notify_jvmti_vthread_start)                            \
 135   do_jvmti_stub(notify_jvmti_vthread_end)                              \
 136   do_jvmti_stub(notify_jvmti_vthread_mount)                            \
 137   do_jvmti_stub(notify_jvmti_vthread_unmount)                          \
 138 
 139 #else
 140 #define C2_JVMTI_STUBS_DO(do_jvmti_stub)
 141 #endif // INCLUDE_JVMTI
 142 
 143 // client macro to operate on c2 stubs
 144 //
 145 // do_blob(name, type)
 146 // do_stub(name, fancy_jump, pass_tls, return_pc)
 147 // do_jvmti_stub(name)
 148 //
 149 // n.b. non-jvmti stubs may employ a special type of jump (0, 1 or 2)
 150 // and require access to TLS and the return pc. jvmti stubs always
 151 // employ jump 0, and require no special access
 152 #define C2_STUBS_DO(do_blob, do_stub, do_jvmti_stub)                   \
 153   do_blob(uncommon_trap, UncommonTrapBlob*)                            \
 154   do_blob(exception, ExceptionBlob*)                                   \
 155   do_stub(new_instance, 0, true, false)                                \
 156   do_stub(new_array, 0, true, false)                                   \
 157   do_stub(new_array_nozero, 0, true, false)                            \
 158   do_stub(multianewarray2, 0, true, false)                             \
 159   do_stub(multianewarray3, 0, true, false)                             \
 160   do_stub(multianewarray4, 0, true, false)                             \
 161   do_stub(multianewarray5, 0, true, false)                             \
 162   do_stub(multianewarrayN, 0, true, false)                             \
 163   C2_JVMTI_STUBS_DO(do_jvmti_stub)                                     \
 164   do_stub(complete_monitor_locking, 0, false, false)                   \
 165   do_stub(monitor_notify, 0, false, false)                             \
 166   do_stub(monitor_notifyAll, 0, false, false)                          \
 167   do_stub(rethrow, 2, true, true)                                      \
 168   do_stub(slow_arraycopy, 0, false, false)                             \
 169   do_stub(register_finalizer, 0, false, false)                         \
 170   do_stub(class_init_barrier, 0, false, false)                         \
 171 
 172 #else
 173 #define C2_STUBS_DO(do_blob, do_stub, do_jvmti_stub)
 174 #endif
 175 
 176 // Stub Generator Blobs and Stubs Overview
 177 //
 178 // StubGenerator stubs do not require their own individual blob. They
 179 // are generated in batches into one of five distinct BufferBlobs:
 180 //
 181 // 1) PreUniverse stubs
 182 // 2) Initial stubs
 183 // 3) Continuation stubs
 184 // 4) Compiler stubs
 185 // 5) Final stubs
 186 //
 187 // Creation of each successive BufferBlobs is staged to ensure that
 188 // specific VM subsystems required by those stubs are suitably
 189 // initialized before generated code attempt to reference data or
 190 // addresses exported by those subsystems. The sequencing of
 191 // initialization must be taken into account when adding a new stub
 192 // declaration.
 193 //
 194 // StubGenerator stubs are declared using template macros, one set of
 195 // declarations per blob (see below), with arch-specific stubs for any
 196 // gven blob declared after generic stubs for that blob. Blobs are
 197 // created in a fixed order during startup, which is reflected in the
 198 // order of the declaration set. Stubs within a blob are currently
 199 // created in an order determined by the arch-specific generator code
 200 // which may not reflect the order of stub declarations. It is not
 201 // straightforward to enforce a strict ordering. not least because
 202 // arch-specific stub creation may need to be interleaved with generic
 203 // stub creation.
 204 //
 205 // Blob and stub declaration templates are used to generate a variety
 206 // of C++ code elements needed to manage stubs.
 207 //
 208 // Blob identifiers:
 209 //
 210 // public enum StubGenBlobId is generated to identify each of the
 211 // StubGenerator blobs in blob declaration order. This enum is
 212 // provided for use by client code to identify a specific blob. For a
 213 // blob declared with name <blob_name> the associated enum value is
 214 // StubGenBlobId::<blob_name>_id.
 215 //
 216 // Global stub identifiers:
 217 //
 218 // public enum StubGenStubId is generated to identify all declared
 219 // stubs across all blobs, sorted first by blob declaration order and
 220 // then within a blob by stub declaration order, generic stubs before
 221 // arch-specific stubs. This enum is provided for use by client code
 222 // to identify a specific stub, independent of the blob it belongs to.
 223 // For a stub declared with name <stub_name> the associated enum value
 224 // is StubGenStubId::<stub_name>_id.
 225 //
 226 // Blob-local stub identifiers:
 227 //
 228 // For each blob <blob_name>, public enum StubGenStubId_<blob_name> is
 229 // generated to enumerate all stubs within the blob in stub
 230 // declaration order, generic stubs before arch-specific stubs. This
 231 // enum is provided only in a non-product build and is intended for
 232 // internal use by class StubRoutines to validate stub declarations.
 233 // For a stub declared with name <stub_name> belonging to blob
 234 // <blob_name> the associated enum value is
 235 // StubGenStubId::<blob_name>_<stub_name>_id.
 236 //
 237 // Stub names and associated getters:
 238 //
 239 // Two private static fields are generated to hold the names of the
 240 // four generated blobs and all the generated stubs.
 241 //
 242 //  const char* StubRoutines::_blob_names[];
 243 //  const char* StubRoutines::_stub_names[];
 244 //
 245 // The entry in _blob_names for a blob declared with name <blob_name>
 246 // will be "<blob_name>".
 247 //
 248 // The entry in _stub_names for a stub declared with name <stub_name>
 249 // will be "<stub_name>".
 250 //
 251 // Corresponding public static lookup methods are generated to allow
 252 // names to be looked up by blob or global stub id.
 253 //
 254 //  const char* StubRoutines::get_blob_name(StubGenBlobId id)
 255 //  const char* StubRoutines::get_stub_name(StubGenStubId id)
 256 //
 257 // These name lookup methods should be used by generic and
 258 // cpu-specific client code to ensure that blobs and stubs are
 259 // identified consistently.
 260 //
 261 // Blob code buffer sizes:
 262 //
 263 // An enumeration enum platform_dependent_constants is generated in
 264 // the architecture specific StubRoutines header. For each blob named
 265 // <nnn> an associated enum tag is generated which defines the
 266 // relevant size
 267 //
 268 //  _<nnn>_stubs_code_size      = <size>,
 269 //
 270 // For example,
 271 //
 272 // enum platform_dependent_constants {
 273 //   _preuniverse_stubs_code_size  =   500,
 274 //   _initial_stubs_code_size      = 10000,
 275 //   _continuation_stubs_code_size =  2000,
 276 //   . . .
 277 //
 278 // Blob fields and associated getters:
 279 //
 280 // For each blob named <nnn> a private field declaration will be
 281 // generated: static field address StubRoutines::_<nnn>_stubs_code and
 282 // a declaration provided to initialise it to nullptr. A corresponding
 283 // public getter method address StubRoutines::_<nnn>_stubs_code() will
 284 // be generated.
 285 //
 286 // Blob initialization routines:
 287 //
 288 // For each blob named <nnn> an initalization function is defined
 289 // which allows clients to schedule blob and stub generation during
 290 // JVM bootstrap:
 291 //
 292 // void <nnn>_stubs_init() { StubRoutines::initialize_<nnn>_stubs(); }
 293 //
 294 // A declaration and definition of each underlying implementation
 295 // method StubRoutines::initialize_<nnn>_stubs() is also generated.
 296 //
 297 // Stub entry points and associated getters:
 298 //
 299 // Some generated stubs require their main entry point and, possibly,
 300 // auxiliary entry points to be stored in fields declared either as
 301 // members of class SharedRuntime. For stubs that are specific to a
 302 // given cpu, the field needs to be declared in an arch-specific inner
 303 // class of SharedRuntime.
 304 //
 305 // For a generic stub named <nnn> the corresponding main entry usually
 306 // has the same name: static field address StubRoutines::_<nnn> modulo
 307 // an _ prefix.  An associated getter method is also generated, again
 308 // normally using the same name: address StubRoutines::<nnn>() e.g.
 309 //
 310 //  class StubRoutines {
 311 //    . . .
 312 //    static address _aescrypt_encryptBlock;
 313 //    . . .
 314 //    address aescrypt_encryptBlock() { return _aescrypt_encryptBlock; }
 315 //
 316 // Multiple fields and getters may be generated where a stub has more
 317 // than one entry point, each provided with their own unique field and
 318 // getter name e.g.
 319 //
 320 //    . . .
 321 //    static address _call_stub;
 322 //    static address _call_stub_return_address;
 323 //    . . .
 324 //    static address call_stub_entry() { return _call_stub; }
 325 //    static address call_stub_return_address() { return _call_stub_return_address; }
 326 //
 327 // In special cases a stub may declare a (compile-time) fixed size
 328 // array of entries, in which case an address array field is
 329 // generated,along with a getter that accepts an index as argument:
 330 //
 331 //    . . .
 332 //   static address _lookup_secondary_supers_table[Klass::SECONDARY_SUPERS_TABLE_SIZE];
 333 //   . . .
 334 //   static address lookup_secondary_supers_table(int i);
 335 //
 336 // CPU-specific stub entry points and associated getters:
 337 //
 338 // For an arch-specific stub with name <nnn> belonging to architecture
 339 // <arch> private field address StubRoutines::<arch>::_<nnn> is
 340 // generated to hold the entry address. An associated public getter
 341 // method address StubRoutines::<arch>::<nnn>() is also generated e.g.
 342 //
 343 //  class StubRoutines {
 344 //    . . .
 345 //    class x86 {
 346 //      . . .
 347 //      static address _f2i_fixup;
 348 //      . . .
 349 //      static address f2i_fixup() { return _f2i_fixup; }
 350 //      static void set_f2i_fixup(address a) { _f2i_fixup = a; }
 351 //
 352 
 353 
 354 //--------------------------------------------------
 355 // Stub Generator Blob, Stub and Entry Declarations
 356 // -------------------------------------------------
 357 //
 358 // The formal declarations of blobs, stubs and entries provided below
 359 // are used to schedule application of template macros that either
 360 // declare or define the C++ code we need to manage those blobs, stubs
 361 // and entries.
 362 //
 363 // All ports employ the same blobs. However, the organization of the
 364 // stubs and entry points in a blob can vary from one port to the
 365 // next. A template macro is provided to specify the details of each
 366 // blob, including generic and arch-specific variations.
 367 //
 368 // If you want to define a new stub or entry then you can do so by
 369 // adding suitable declarations within the scope of the relevant blob.
 370 // For the blob with name BLOB_NAME add your declarations to macro
 371 // STUBGEN_<BLOB_NAME>_STUBS_DO. Generic stubs and entries are
 372 // declared using the do_stub, do_entry and do_entry_init and
 373 // array_entry templates (see below for full details). The do_blob
 374 // and end_blob templates should never need to be modified.
 375 //
 376 // Some stubs and their associated entries are architecture-specific.
 377 // They need to be declared in the architecture-specific header file
 378 // src/cpu/<arch>stubDecolaration_<arch>.cpp. For the blob with name
 379 // BLOB_NAME the correspnding declarations macro are provided by macro
 380 // STUBGEN_<BLOB_NAME>_STUBS_ARCH_DO. Arch-specific stubs and entries
 381 // are declared using the do_stub, do_arch_entry and
 382 // do_arch_entry_init templates (see below for details). An
 383 // architecure also needs to specify architecture parameters used when
 384 // creating each blob. These are defined using the do_arch_blob
 385 // template (see below).
 386 //
 387 // Note, the client macro STUBGEN_ALL_DO is provided to allow client
 388 // code to iterate over all blob, stub or entry declarations. It has
 389 // only been split into separate per-blob generic submacros,
 390 // STUBGEN_<BLOB_NAME>_BLOBS_DO and arch-specific per-blob submacros
 391 // STUBGEN_<BLOB_NAME>_BLOBS_ARCH_DO for convenience, to make it
 392 // easier to manage definitions. The blob_specific sub-macros should
 393 // not be called directly by client code (in class StubRoutines and
 394 // StubGenerator),
 395 //
 396 // A client wishing to generate blob, stub or entry code elements is
 397 // expected to pass template macros as arguments to STUBGEN_ALL_DO.
 398 // This will schedule code generation code for whatever C++ code
 399 // elements are required to implement a declaration or definition
 400 // relevant to each blob, stub or entry. Alternatively, a client can
 401 // operate on a subset of the declarations by calling macros
 402 // STUBGEN_BLOBS_DO, STUBGEN_STUBS_DO, STUBGEN_BLOBS_STUBS_DO,
 403 // STUBGEN_ENTRIES_DO and STUBGEN_ARCH_ENTRIES_DO.
 404 //
 405 // The do_blob and end_blob templates receive a blob name as argument.
 406 //
 407 // do_blob(blob_name)
 408 // end_blob(blob_name)
 409 //
 410 // do_blob is primarily used to define a global enum tag for a blob
 411 // and an associated constant string name, both for use by client
 412 // code.
 413 //
 414 // end_blob is provided for use in combination with do_blob to to open
 415 // and close a blob-local enum type identifying all stubs within a
 416 // given blob. This enum is private to the stub management code and
 417 // used to validate correct use of stubs within a given blob.
 418 //
 419 // The do_stub template receives a blob name and stub name as argument.
 420 //
 421 // do_stub(blob_name, stub_name)
 422 //
 423 // do_stub is primarily used to define a global enum tag for a stub
 424 // and a constant string name, both for use by client code. It is also
 425 // used to declare a tag within the blob-local enum type used to
 426 // validate correct use of stubs within their declared blob. Finally,
 427 // it is also used to declare a name for each stub.
 428 //
 429 // The do_entry and do_entry_array templates receive 4 or 5 arguments
 430 //
 431 // do_entry(blob_name, stub_name, field_name, getter_name)
 432 //
 433 // do_entry_init(blob_name, stub_name, field_name, getter_name, init_function)
 434 //
 435 // do_entry_array(blob_name, stub_name, field_name, getter_name, count)
 436 //
 437 // do_entry is used to declare or define a static field of class
 438 // StubRoutines with type address that stores a specific entry point
 439 // for a given stub. n.b. the number of entries associated with a stub
 440 // is often one but it can be more than one and, in a few special
 441 // cases, it is zero. do_entry is also used to declare and define an
 442 // associated getter method for the field. do_entry is used to declare
 443 // fields that should be initialized to nullptr.
 444 //
 445 // do_entry_init is used when the field needs to be initialized a
 446 // specific function or method .
 447 //
 448 // do_entry_array is used for the special case where a stub employs an
 449 // array to store multiple entries which are stored at generate time
 450 // and subsequently accessed using an associated index (e.g. the
 451 // secondary supers table stub which has 63 qassociated entries).
 452 // Note that this distinct from the case where a stub generates
 453 // multiple entries each of them stored in its own named field with
 454 // its own named getter. In the latter case multiple do_entry or
 455 // do_entry_init declarations are associated with the stub.
 456 //
 457 // blob_name and stub_name are the names of the blob and stub to which
 458 // the entry belongs.
 459 //
 460 // field_name is prefixed with a leading '_' to produce the name of
 461 // the field used to store an entry address for the stub. For stubs
 462 // with one entry field_name is normally, but not always, the same as
 463 // stub_name.  Obviously when a stub has multiple entries secondary
 464 // names must be different to stub_name. For normal entry declarations
 465 // the field type is address. For do_entry_array declarations the field
 466 // type is an address[] whose size is defined by then parameter.
 467 //
 468 // getter_name is the name of a getter that is generated to allow
 469 // access to the field. It is normally, but not always, the same as
 470 // stub_name. For normal entry declarations the getter signature is
 471 // (void).  For do_entry_array declarations the getter signature is
 472 // (int).
 473 //
 474 // init_function is the name of an function or method which should be
 475 // assigned to the field as a default value (n.b. fields declared
 476 // using do_entry are intialised to nullptr, array fields declared
 477 // using do_entry_array have their elements initalized to nullptr).
 478 //
 479 // Architecture-specific blob details need to be specified using the
 480 // do_arch_blob template
 481 //
 482 // do_arch_blob(blob_name, size)
 483 //
 484 // Currently, the do_arch_blob macro is only used to define the size
 485 // of the code buffer into which blob-specific stub code is to be
 486 // generated.
 487 //
 488 // Architecture-specific entries need to be declared using the
 489 // do_arch_entry template
 490 //
 491 // do_arch_entry(arch, blob_name, stub_name, field_name, getter_name)
 492 //
 493 // do_arch_entry_init(arch, blob_name, stub_name, field_name,
 494 //                    getter_name, init_function)
 495 //
 496 // The only difference between these templates and the generic ones is
 497 // that they receive an extra argument which identifies the current
 498 // architecture e.g. x86, aarch64 etc.
 499 //
 500 // Currently there is no support for a do_arch_array_entry template.
 501 
 502 // Include arch-specific stub and entry declarations and make sure the
 503 // relevant template macros have been defined
 504 
 505 #include CPU_HEADER(stubDeclarations)
 506 
 507 #ifndef STUBGEN_PREUNIVERSE_BLOBS_ARCH_DO
 508 #error "Arch-specific directory failed to declare required initial stubs and entries"
 509 #endif
 510 
 511 #ifndef STUBGEN_INITIAL_BLOBS_ARCH_DO
 512 #error "Arch-specific directory failed to declare required initial stubs and entries"
 513 #endif
 514 
 515 #ifndef STUBGEN_CONTINUATION_BLOBS_ARCH_DO
 516 #error "Arch-specific directory failed to declare required continuation stubs and entries"
 517 #endif
 518 
 519 #ifndef STUBGEN_COMPILER_BLOBS_ARCH_DO
 520 #error "Arch-specific directory failed to declare required compiler stubs and entries"
 521 #endif
 522 
 523 #ifndef STUBGEN_FINAL_BLOBS_ARCH_DO
 524 #error "Arch-specific directory failed to declare required final stubs and entries"
 525 #endif
 526 
 527 // Iterator macros to apply templates to all relevant blobs, stubs and
 528 // entries. Clients should use STUBGEN_ALL_DO, STUBGEN_BLOBS_DO,
 529 // STUBGEN_STUBS_DO, STUBGEN_BLOBS_STUBS_DO, STUBGEN_ENTRIES_DO,
 530 // STUBGEN_ARCH_BLOBS_DO and STUBGEN_ARCH_ENTRIES_DO.
 531 //
 532 // n.b. Client macros appear after the STUBGEN_<BLOB_NAME>_BLOBS_DO
 533 // submacros which follow next. These submacros are not intended to be
 534 // called directly. They serve to define the main client macro
 535 // STUBGEN_ALL_DO and, from there, the other more specific client
 536 // macros. n.b. multiple, 'per-blob' submacros are used to declare
 537 // each group of stubs and entries, because that makes it simpler to
 538 // lookup and update related elements. If you need to update these
 539 // submacros to change the list of stubs or entries be sure to locate
 540 // stubs within the correct blob and locate entry declarations
 541 // immediately after their associated stub declaration.
 542 
 543 #define STUBGEN_PREUNIVERSE_BLOBS_DO(do_blob, end_blob,                 \
 544                                      do_stub,                           \
 545                                      do_entry, do_entry_init,           \
 546                                      do_entry_array,                    \
 547                                      do_arch_blob,                      \
 548                                      do_arch_entry, do_arch_entry_init) \
 549   do_blob(preuniverse)                                                  \
 550   do_stub(preuniverse, fence)                                           \
 551   do_entry(preuniverse, fence, fence_entry, fence_entry)                \
 552   do_stub(preuniverse, atomic_add)                                      \
 553   do_entry(preuniverse, atomic_add, atomic_add_entry, atomic_add_entry) \
 554   do_stub(preuniverse, atomic_xchg)                                     \
 555   do_entry(preuniverse, atomic_xchg, atomic_xchg_entry,                 \
 556            atomic_xchg_entry)                                           \
 557   do_stub(preuniverse, atomic_cmpxchg)                                  \
 558   do_entry(preuniverse, atomic_cmpxchg, atomic_cmpxchg_entry,           \
 559            atomic_cmpxchg_entry)                                        \
 560   do_stub(preuniverse, atomic_cmpxchg_long)                             \
 561   do_entry(preuniverse, atomic_cmpxchg_long, atomic_cmpxchg_long_entry, \
 562            atomic_cmpxchg_long_entry)                                   \
 563   /* merge in stubs and entries declared in arch header */              \
 564   STUBGEN_PREUNIVERSE_BLOBS_ARCH_DO(do_stub, do_arch_blob,              \
 565                                     do_arch_entry, do_arch_entry_init)  \
 566   end_blob(preuniverse)                                                 \
 567 
 568 #define STUBGEN_INITIAL_BLOBS_DO(do_blob, end_blob,                     \
 569                                  do_stub,                               \
 570                                  do_entry, do_entry_init,               \
 571                                  do_entry_array,                        \
 572                                  do_arch_blob,                          \
 573                                  do_arch_entry, do_arch_entry_init)     \
 574   do_blob(initial)                                                      \
 575   do_stub(initial, call_stub)                                           \
 576   do_entry(initial, call_stub, call_stub_entry, call_stub_entry)        \
 577   do_entry(initial, call_stub, call_stub_return_address,                \
 578            call_stub_return_address)                                    \
 579   do_stub(initial, forward_exception)                                   \
 580   do_entry(initial, forward_exception, forward_exception_entry,         \
 581            forward_exception_entry)                                     \
 582   do_stub(initial, catch_exception)                                     \
 583   do_entry(initial, catch_exception, catch_exception_entry,             \
 584            catch_exception_entry)                                       \
 585   do_stub(initial, updateBytesCRC32)                                    \
 586   do_entry(initial, updateBytesCRC32, updateBytesCRC32,                 \
 587            updateBytesCRC32)                                            \
 588   do_stub(initial, updateBytesCRC32C)                                   \
 589   do_entry(initial, updateBytesCRC32C, updateBytesCRC32C,               \
 590            updateBytesCRC32C)                                           \
 591   do_stub(initial, f2hf)                                                \
 592   do_entry(initial, f2hf, f2hf, f2hf_adr)                               \
 593   do_stub(initial, hf2f)                                                \
 594   do_entry(initial, hf2f, hf2f, hf2f_adr)                               \
 595   do_stub(initial, dexp)                                                \
 596   do_entry(initial, dexp, dexp, dexp)                                   \
 597   do_stub(initial, dlog)                                                \
 598   do_entry(initial, dlog, dlog, dlog)                                   \
 599   do_stub(initial, dlog10)                                              \
 600   do_entry(initial, dlog10, dlog10, dlog10)                             \
 601   do_stub(initial, dpow)                                                \
 602   do_entry(initial, dpow, dpow, dpow)                                   \
 603   do_stub(initial, dsin)                                                \
 604   do_entry(initial, dsin, dsin, dsin)                                   \
 605   do_stub(initial, dcos)                                                \
 606   do_entry(initial, dcos, dcos, dcos)                                   \
 607   do_stub(initial, dtan)                                                \
 608   do_entry(initial, dtan, dtan, dtan)                                   \
 609   do_stub(initial, dtanh)                                               \
 610   do_entry(initial, dtanh, dtanh, dtanh)                                \
 611   do_stub(initial, dcbrt)                                               \
 612   do_entry(initial, dcbrt, dcbrt, dcbrt)                                \
 613   do_stub(initial, fmod)                                                \
 614   do_entry(initial, fmod, fmod, fmod)                                   \
 615   /* following generic entries should really be x86_32 only */          \
 616   do_stub(initial, dlibm_sin_cos_huge)                                  \
 617   do_entry(initial, dlibm_sin_cos_huge, dlibm_sin_cos_huge,             \
 618            dlibm_sin_cos_huge)                                          \
 619   do_stub(initial, dlibm_reduce_pi04l)                                  \
 620   do_entry(initial, dlibm_reduce_pi04l, dlibm_reduce_pi04l,             \
 621            dlibm_reduce_pi04l)                                          \
 622   do_stub(initial, dlibm_tan_cot_huge)                                  \
 623   do_entry(initial, dlibm_tan_cot_huge, dlibm_tan_cot_huge,             \
 624            dlibm_tan_cot_huge)                                          \
 625   /* merge in stubs and entries declared in arch header */              \
 626   STUBGEN_INITIAL_BLOBS_ARCH_DO(do_stub, do_arch_blob,                  \
 627                                 do_arch_entry, do_arch_entry_init)      \
 628   end_blob(initial)                                                     \
 629 
 630 
 631 #define STUBGEN_CONTINUATION_BLOBS_DO(do_blob, end_blob,                \
 632                                       do_stub,                          \
 633                                       do_entry, do_entry_init,          \
 634                                       do_entry_array,                   \
 635                                       do_arch_blob,                     \
 636                                       do_arch_entry, do_arch_entry_init) \
 637   do_blob(continuation)                                                 \
 638   do_stub(continuation, cont_thaw)                                      \
 639   do_entry(continuation, cont_thaw, cont_thaw, cont_thaw)               \
 640   do_stub(continuation, cont_preempt)                                   \
 641   do_entry(continuation, cont_prempt, cont_preempt_stub,                \
 642            cont_preempt_stub)                                           \
 643   do_stub(continuation, cont_returnBarrier)                             \
 644   do_entry(continuation, cont_returnBarrier, cont_returnBarrier,        \
 645            cont_returnBarrier)                                          \
 646   do_stub(continuation, cont_returnBarrierExc)                          \
 647   do_entry(continuation, cont_returnBarrierExc, cont_returnBarrierExc,  \
 648            cont_returnBarrierExc)                                       \
 649   /* merge in stubs and entries declared in arch header */              \
 650   STUBGEN_CONTINUATION_BLOBS_ARCH_DO(do_stub,  do_arch_blob,            \
 651                                      do_arch_entry, do_arch_entry_init) \
 652   end_blob(continuation)                                                \
 653 
 654 
 655 #define STUBGEN_COMPILER_BLOBS_DO(do_blob, end_blob,                    \
 656                                   do_stub,                              \
 657                                   do_entry, do_entry_init,              \
 658                                   do_entry_array,                       \
 659                                   do_arch_blob,                         \
 660                                   do_arch_entry, do_arch_entry_init)    \
 661   do_blob(compiler)                                                     \
 662   do_stub(compiler, array_sort)                                         \
 663   do_entry(compiler, array_sort, array_sort, select_arraysort_function) \
 664   do_stub(compiler, array_partition)                                    \
 665   do_entry(compiler, array_partition, array_partition,                  \
 666            select_array_partition_function)                             \
 667   do_stub(compiler, aescrypt_encryptBlock)                              \
 668   do_entry(compiler, aescrypt_encryptBlock, aescrypt_encryptBlock,      \
 669            aescrypt_encryptBlock)                                       \
 670   do_stub(compiler, aescrypt_decryptBlock)                              \
 671   do_entry(compiler, aescrypt_decryptBlock, aescrypt_decryptBlock,      \
 672            aescrypt_decryptBlock)                                       \
 673   do_stub(compiler, cipherBlockChaining_encryptAESCrypt)                \
 674   do_entry(compiler, cipherBlockChaining_encryptAESCrypt,               \
 675            cipherBlockChaining_encryptAESCrypt,                         \
 676            cipherBlockChaining_encryptAESCrypt)                         \
 677   do_stub(compiler, cipherBlockChaining_decryptAESCrypt)                \
 678   do_entry(compiler, cipherBlockChaining_decryptAESCrypt,               \
 679            cipherBlockChaining_decryptAESCrypt,                         \
 680            cipherBlockChaining_decryptAESCrypt)                         \
 681   do_stub(compiler, electronicCodeBook_encryptAESCrypt)                 \
 682   do_entry(compiler, electronicCodeBook_encryptAESCrypt,                \
 683            electronicCodeBook_encryptAESCrypt,                          \
 684            electronicCodeBook_encryptAESCrypt)                          \
 685   do_stub(compiler, electronicCodeBook_decryptAESCrypt)                 \
 686   do_entry(compiler, electronicCodeBook_decryptAESCrypt,                \
 687            electronicCodeBook_decryptAESCrypt,                          \
 688            electronicCodeBook_decryptAESCrypt)                          \
 689   do_stub(compiler, counterMode_AESCrypt)                               \
 690   do_entry(compiler, counterMode_AESCrypt, counterMode_AESCrypt,        \
 691            counterMode_AESCrypt)                                        \
 692   do_stub(compiler, galoisCounterMode_AESCrypt)                         \
 693   do_entry(compiler, galoisCounterMode_AESCrypt,                        \
 694            galoisCounterMode_AESCrypt, galoisCounterMode_AESCrypt)      \
 695   do_stub(compiler, ghash_processBlocks)                                \
 696   do_entry(compiler, ghash_processBlocks, ghash_processBlocks,          \
 697            ghash_processBlocks)                                         \
 698   do_stub(compiler, chacha20Block)                                      \
 699   do_entry(compiler, chacha20Block, chacha20Block, chacha20Block)       \
 700   do_stub(compiler, kyberNtt)                                           \
 701   do_entry(compiler, kyberNtt, kyberNtt, kyberNtt)                      \
 702   do_stub(compiler, kyberInverseNtt)                                    \
 703   do_entry(compiler, kyberInverseNtt, kyberInverseNtt, kyberInverseNtt) \
 704   do_stub(compiler, kyberNttMult)                                       \
 705   do_entry(compiler, kyberNttMult, kyberNttMult, kyberNttMult)          \
 706   do_stub(compiler, kyberAddPoly_2)                                     \
 707   do_entry(compiler, kyberAddPoly_2, kyberAddPoly_2, kyberAddPoly_2)    \
 708   do_stub(compiler, kyberAddPoly_3)                                     \
 709   do_entry(compiler, kyberAddPoly_3, kyberAddPoly_3, kyberAddPoly_3)    \
 710   do_stub(compiler, kyber12To16)                                        \
 711   do_entry(compiler, kyber12To16, kyber12To16, kyber12To16)             \
 712   do_stub(compiler, kyberBarrettReduce)                                 \
 713   do_entry(compiler, kyberBarrettReduce, kyberBarrettReduce,            \
 714            kyberBarrettReduce)                                          \
 715   do_stub(compiler, dilithiumAlmostNtt)                                 \
 716   do_entry(compiler, dilithiumAlmostNtt,                                \
 717            dilithiumAlmostNtt, dilithiumAlmostNtt)                      \
 718   do_stub(compiler, dilithiumAlmostInverseNtt)                          \
 719   do_entry(compiler, dilithiumAlmostInverseNtt,                         \
 720            dilithiumAlmostInverseNtt, dilithiumAlmostInverseNtt)        \
 721   do_stub(compiler, dilithiumNttMult)                                   \
 722   do_entry(compiler, dilithiumNttMult,                                  \
 723            dilithiumNttMult, dilithiumNttMult)                          \
 724   do_stub(compiler, dilithiumMontMulByConstant)                         \
 725   do_entry(compiler, dilithiumMontMulByConstant,                        \
 726            dilithiumMontMulByConstant, dilithiumMontMulByConstant)      \
 727   do_stub(compiler, dilithiumDecomposePoly)                             \
 728   do_entry(compiler, dilithiumDecomposePoly,                            \
 729            dilithiumDecomposePoly, dilithiumDecomposePoly)              \
 730   do_stub(compiler, data_cache_writeback)                               \
 731   do_entry(compiler, data_cache_writeback, data_cache_writeback,        \
 732            data_cache_writeback)                                        \
 733   do_stub(compiler, data_cache_writeback_sync)                          \
 734   do_entry(compiler, data_cache_writeback_sync,                         \
 735            data_cache_writeback_sync, data_cache_writeback_sync)        \
 736   do_stub(compiler, base64_encodeBlock)                                 \
 737   do_entry(compiler, base64_encodeBlock, base64_encodeBlock,            \
 738            base64_encodeBlock)                                          \
 739   do_stub(compiler, base64_decodeBlock)                                 \
 740   do_entry(compiler, base64_decodeBlock, base64_decodeBlock,            \
 741            base64_decodeBlock)                                          \
 742   do_stub(compiler, poly1305_processBlocks)                             \
 743   do_entry(compiler, poly1305_processBlocks, poly1305_processBlocks,    \
 744            poly1305_processBlocks)                                      \
 745   do_stub(compiler, intpoly_montgomeryMult_P256)                        \
 746   do_entry(compiler, intpoly_montgomeryMult_P256,                       \
 747            intpoly_montgomeryMult_P256, intpoly_montgomeryMult_P256)    \
 748   do_stub(compiler, intpoly_assign)                                     \
 749   do_entry(compiler, intpoly_assign, intpoly_assign, intpoly_assign)    \
 750   do_stub(compiler, md5_implCompress)                                   \
 751   do_entry(compiler, md5_implCompress, md5_implCompress,                \
 752            md5_implCompress)                                            \
 753   do_stub(compiler, md5_implCompressMB)                                 \
 754   do_entry(compiler, md5_implCompressMB, md5_implCompressMB,            \
 755            md5_implCompressMB)                                          \
 756   do_stub(compiler, sha1_implCompress)                                  \
 757   do_entry(compiler, sha1_implCompress, sha1_implCompress,              \
 758            sha1_implCompress)                                           \
 759   do_stub(compiler, sha1_implCompressMB)                                \
 760   do_entry(compiler, sha1_implCompressMB, sha1_implCompressMB,          \
 761            sha1_implCompressMB)                                         \
 762   do_stub(compiler, sha256_implCompress)                                \
 763   do_entry(compiler, sha256_implCompress, sha256_implCompress,          \
 764            sha256_implCompress)                                         \
 765   do_stub(compiler, sha256_implCompressMB)                              \
 766   do_entry(compiler, sha256_implCompressMB, sha256_implCompressMB,      \
 767            sha256_implCompressMB)                                       \
 768   do_stub(compiler, sha512_implCompress)                                \
 769   do_entry(compiler, sha512_implCompress, sha512_implCompress,          \
 770            sha512_implCompress)                                         \
 771   do_stub(compiler, sha512_implCompressMB)                              \
 772   do_entry(compiler, sha512_implCompressMB, sha512_implCompressMB,      \
 773            sha512_implCompressMB)                                       \
 774   do_stub(compiler, sha3_implCompress)                                  \
 775   do_entry(compiler, sha3_implCompress, sha3_implCompress,              \
 776            sha3_implCompress)                                           \
 777   do_stub(compiler, double_keccak)                                      \
 778   do_entry(compiler, double_keccak, double_keccak, double_keccak)       \
 779   do_stub(compiler, sha3_implCompressMB)                                \
 780   do_entry(compiler, sha3_implCompressMB, sha3_implCompressMB,          \
 781            sha3_implCompressMB)                                         \
 782   do_stub(compiler, updateBytesAdler32)                                 \
 783   do_entry(compiler, updateBytesAdler32, updateBytesAdler32,            \
 784            updateBytesAdler32)                                          \
 785   do_stub(compiler, multiplyToLen)                                      \
 786   do_entry(compiler, multiplyToLen, multiplyToLen, multiplyToLen)       \
 787   do_stub(compiler, squareToLen)                                        \
 788   do_entry(compiler, squareToLen, squareToLen, squareToLen)             \
 789   do_stub(compiler, mulAdd)                                             \
 790   do_entry(compiler, mulAdd, mulAdd, mulAdd)                            \
 791   do_stub(compiler, montgomeryMultiply)                                 \
 792   do_entry(compiler, montgomeryMultiply, montgomeryMultiply,            \
 793            montgomeryMultiply)                                          \
 794   do_stub(compiler, montgomerySquare)                                   \
 795   do_entry(compiler, montgomerySquare, montgomerySquare,                \
 796            montgomerySquare)                                            \
 797   do_stub(compiler, bigIntegerRightShiftWorker)                         \
 798   do_entry(compiler, bigIntegerRightShiftWorker,                        \
 799            bigIntegerRightShiftWorker, bigIntegerRightShift)            \
 800   do_stub(compiler, bigIntegerLeftShiftWorker)                          \
 801   do_entry(compiler, bigIntegerLeftShiftWorker,                         \
 802            bigIntegerLeftShiftWorker, bigIntegerLeftShift)              \
 803   /* merge in stubs and entries declared in arch header */              \
 804   STUBGEN_COMPILER_BLOBS_ARCH_DO(do_stub,  do_arch_blob,                \
 805                                      do_arch_entry, do_arch_entry_init) \
 806   end_blob(compiler)                                                    \
 807 
 808 
 809 #define STUBGEN_FINAL_BLOBS_DO(do_blob, end_blob,                       \
 810                                do_stub,                                 \
 811                                do_entry, do_entry_init,                 \
 812                                do_entry_array,                          \
 813                                do_arch_blob,                            \
 814                                do_arch_entry, do_arch_entry_init)       \
 815   do_blob(final)                                                        \
 816   do_stub(final, verify_oop)                                            \
 817   do_entry(final, verify_oop, verify_oop_subroutine_entry,              \
 818            verify_oop_subroutine_entry)                                 \
 819   do_stub(final, jbyte_arraycopy)                                       \
 820   do_entry_init(final, jbyte_arraycopy, jbyte_arraycopy,                \
 821                 jbyte_arraycopy, StubRoutines::jbyte_copy)              \
 822   do_stub(final, jshort_arraycopy)                                      \
 823   do_entry_init(final, jshort_arraycopy, jshort_arraycopy,              \
 824                 jshort_arraycopy, StubRoutines::jshort_copy)            \
 825   do_stub(final, jint_arraycopy)                                        \
 826   do_entry_init(final, jint_arraycopy, jint_arraycopy,                  \
 827                 jint_arraycopy, StubRoutines::jint_copy)                \
 828   do_stub(final, jlong_arraycopy)                                       \
 829   do_entry_init(final, jlong_arraycopy, jlong_arraycopy,                \
 830                 jlong_arraycopy, StubRoutines::jlong_copy)              \
 831   do_stub(final, oop_arraycopy)                                         \
 832   do_entry_init(final, oop_arraycopy, oop_arraycopy,                    \
 833                 oop_arraycopy_entry, StubRoutines::oop_copy)            \
 834   do_stub(final, oop_arraycopy_uninit)                                  \
 835   do_entry_init(final, oop_arraycopy_uninit, oop_arraycopy_uninit,      \
 836                 oop_arraycopy_uninit_entry,                             \
 837                 StubRoutines::oop_copy_uninit)                          \
 838   do_stub(final, jbyte_disjoint_arraycopy)                              \
 839   do_entry_init(final, jbyte_disjoint_arraycopy,                        \
 840                 jbyte_disjoint_arraycopy, jbyte_disjoint_arraycopy,     \
 841                 StubRoutines::jbyte_copy)                               \
 842   do_stub(final, jshort_disjoint_arraycopy)                             \
 843   do_entry_init(final, jshort_disjoint_arraycopy,                       \
 844                 jshort_disjoint_arraycopy, jshort_disjoint_arraycopy,   \
 845                 StubRoutines::jshort_copy)                              \
 846   do_stub(final, jint_disjoint_arraycopy)                               \
 847   do_entry_init(final, jint_disjoint_arraycopy,                         \
 848                 jint_disjoint_arraycopy, jint_disjoint_arraycopy,       \
 849                 StubRoutines::jint_copy)                                \
 850   do_stub(final, jlong_disjoint_arraycopy)                              \
 851   do_entry_init(final, jlong_disjoint_arraycopy,                        \
 852                 jlong_disjoint_arraycopy, jlong_disjoint_arraycopy,     \
 853                 StubRoutines::jlong_copy)                               \
 854   do_stub(final, oop_disjoint_arraycopy)                                \
 855   do_entry_init(final, oop_disjoint_arraycopy, oop_disjoint_arraycopy,  \
 856                 oop_disjoint_arraycopy_entry, StubRoutines::oop_copy)   \
 857   do_stub(final, oop_disjoint_arraycopy_uninit)                         \
 858   do_entry_init(final, oop_disjoint_arraycopy_uninit,                   \
 859                 oop_disjoint_arraycopy_uninit,                          \
 860                 oop_disjoint_arraycopy_uninit_entry,                    \
 861                 StubRoutines::oop_copy_uninit)                          \
 862   do_stub(final, arrayof_jbyte_arraycopy)                               \
 863   do_entry_init(final, arrayof_jbyte_arraycopy,                         \
 864                 arrayof_jbyte_arraycopy, arrayof_jbyte_arraycopy,       \
 865                 StubRoutines::arrayof_jbyte_copy)                       \
 866   do_stub(final, arrayof_jshort_arraycopy)                              \
 867   do_entry_init(final, arrayof_jshort_arraycopy,                        \
 868                 arrayof_jshort_arraycopy, arrayof_jshort_arraycopy,     \
 869                 StubRoutines::arrayof_jshort_copy)                      \
 870   do_stub(final, arrayof_jint_arraycopy)                                \
 871   do_entry_init(final, arrayof_jint_arraycopy, arrayof_jint_arraycopy,  \
 872                 arrayof_jint_arraycopy,                                 \
 873                 StubRoutines::arrayof_jint_copy)                        \
 874   do_stub(final, arrayof_jlong_arraycopy)                               \
 875   do_entry_init(final, arrayof_jlong_arraycopy,                         \
 876                 arrayof_jlong_arraycopy, arrayof_jlong_arraycopy,       \
 877                 StubRoutines::arrayof_jlong_copy)                       \
 878   do_stub(final, arrayof_oop_arraycopy)                                 \
 879   do_entry_init(final, arrayof_oop_arraycopy, arrayof_oop_arraycopy,    \
 880                 arrayof_oop_arraycopy, StubRoutines::arrayof_oop_copy)  \
 881   do_stub(final, arrayof_oop_arraycopy_uninit)                          \
 882   do_entry_init(final, arrayof_oop_arraycopy_uninit,                    \
 883                 arrayof_oop_arraycopy_uninit,                           \
 884                 arrayof_oop_arraycopy_uninit,                           \
 885                 StubRoutines::arrayof_oop_copy_uninit)                  \
 886   do_stub(final, arrayof_jbyte_disjoint_arraycopy)                      \
 887   do_entry_init(final, arrayof_jbyte_disjoint_arraycopy,                \
 888                 arrayof_jbyte_disjoint_arraycopy,                       \
 889                 arrayof_jbyte_disjoint_arraycopy,                       \
 890                 StubRoutines::arrayof_jbyte_copy)                       \
 891   do_stub(final, arrayof_jshort_disjoint_arraycopy)                     \
 892   do_entry_init(final, arrayof_jshort_disjoint_arraycopy,               \
 893                 arrayof_jshort_disjoint_arraycopy,                      \
 894                 arrayof_jshort_disjoint_arraycopy,                      \
 895                 StubRoutines::arrayof_jshort_copy)                      \
 896   do_stub(final, arrayof_jint_disjoint_arraycopy)                       \
 897   do_entry_init(final, arrayof_jint_disjoint_arraycopy,                 \
 898                 arrayof_jint_disjoint_arraycopy,                        \
 899                 arrayof_jint_disjoint_arraycopy,                        \
 900                 StubRoutines::arrayof_jint_copy)                        \
 901   do_stub(final, arrayof_jlong_disjoint_arraycopy)                      \
 902   do_entry_init(final, arrayof_jlong_disjoint_arraycopy,                \
 903                 arrayof_jlong_disjoint_arraycopy,                       \
 904                 arrayof_jlong_disjoint_arraycopy,                       \
 905                 StubRoutines::arrayof_jlong_copy)                       \
 906   do_stub(final, arrayof_oop_disjoint_arraycopy)                        \
 907   do_entry_init(final, arrayof_oop_disjoint_arraycopy,                  \
 908                 arrayof_oop_disjoint_arraycopy,                         \
 909                 arrayof_oop_disjoint_arraycopy_entry,                   \
 910                 StubRoutines::arrayof_oop_copy)                         \
 911   do_stub(final, arrayof_oop_disjoint_arraycopy_uninit)                 \
 912   do_entry_init(final, arrayof_oop_disjoint_arraycopy_uninit,           \
 913                 arrayof_oop_disjoint_arraycopy_uninit,                  \
 914                 arrayof_oop_disjoint_arraycopy_uninit_entry,            \
 915                 StubRoutines::arrayof_oop_copy_uninit)                  \
 916   do_stub(final, checkcast_arraycopy)                                   \
 917   do_entry(final, checkcast_arraycopy, checkcast_arraycopy,             \
 918            checkcast_arraycopy_entry)                                   \
 919   do_stub(final, checkcast_arraycopy_uninit)                            \
 920   do_entry(final, checkcast_arraycopy_uninit,                           \
 921            checkcast_arraycopy_uninit,                                  \
 922            checkcast_arraycopy_uninit_entry)                            \
 923   do_stub(final, unsafe_arraycopy)                                      \
 924   do_entry(final, unsafe_arraycopy, unsafe_arraycopy, unsafe_arraycopy) \
 925   do_stub(final, generic_arraycopy)                                     \
 926   do_entry(final, generic_arraycopy, generic_arraycopy,                 \
 927            generic_arraycopy)                                           \
 928   do_stub(final, unsafe_setmemory)                                      \
 929   do_entry(final, unsafe_setmemory, unsafe_setmemory, unsafe_setmemory) \
 930   do_stub(final, jbyte_fill)                                            \
 931   do_entry(final, jbyte_fill, jbyte_fill, jbyte_fill)                   \
 932   do_stub(final, jshort_fill)                                           \
 933   do_entry(final, jshort_fill, jshort_fill, jshort_fill)                \
 934   do_stub(final, jint_fill)                                             \
 935   do_entry(final, jint_fill, jint_fill, jint_fill)                      \
 936   do_stub(final, arrayof_jbyte_fill)                                    \
 937   do_entry(final, arrayof_jbyte_fill, arrayof_jbyte_fill,               \
 938            arrayof_jbyte_fill)                                          \
 939   do_stub(final, arrayof_jshort_fill)                                   \
 940   do_entry(final, arrayof_jshort_fill, arrayof_jshort_fill,             \
 941            arrayof_jshort_fill)                                         \
 942   do_stub(final, arrayof_jint_fill)                                     \
 943   do_entry(final, arrayof_jint_fill, arrayof_jint_fill,                 \
 944            arrayof_jint_fill)                                           \
 945   do_stub(final, method_entry_barrier)                                  \
 946   do_entry(final, method_entry_barrier, method_entry_barrier,           \
 947            method_entry_barrier)                                        \
 948   do_stub(final, vectorizedMismatch) /* only used by x86! */            \
 949   do_entry(final, vectorizedMismatch, vectorizedMismatch,               \
 950            vectorizedMismatch)                                          \
 951   do_stub(final, upcall_stub_exception_handler)                         \
 952   do_entry(final, upcall_stub_exception_handler,                        \
 953            upcall_stub_exception_handler,                               \
 954            upcall_stub_exception_handler)                               \
 955   do_stub(final, upcall_stub_load_target)                               \
 956   do_entry(final, upcall_stub_load_target, upcall_stub_load_target,     \
 957            upcall_stub_load_target)                                     \
 958   do_stub(final, lookup_secondary_supers_table)                         \
 959   do_entry_array(final, lookup_secondary_supers_table,                  \
 960                  lookup_secondary_supers_table_stubs,                   \
 961                  lookup_secondary_supers_table_stub,                    \
 962                  Klass::SECONDARY_SUPERS_TABLE_SIZE)                    \
 963   do_stub(final, lookup_secondary_supers_table_slow_path)               \
 964   do_entry(final, lookup_secondary_supers_table_slow_path,              \
 965            lookup_secondary_supers_table_slow_path_stub,                \
 966            lookup_secondary_supers_table_slow_path_stub)                \
 967   /* merge in stubs and entries declared in arch header */              \
 968   STUBGEN_FINAL_BLOBS_ARCH_DO(do_stub,  do_arch_blob,                   \
 969                               do_arch_entry, do_arch_entry_init)        \
 970   end_blob(final)                                                       \
 971 
 972 
 973 // Convenience macros for use by template implementations
 974 
 975 #define STUB_ID_NAME(base) base##_id
 976 
 977 // emit a runtime or stubgen stub field name
 978 
 979 #define STUB_FIELD_NAME(base) _##base
 980 
 981 // emit a runtime blob field name
 982 
 983 #define BLOB_FIELD_NAME(base) _##base##_blob
 984 
 985 // emit a stubgen blob field name
 986 
 987 #define STUBGEN_BLOB_FIELD_NAME(base) _ ## base ## _stubs_code
 988 
 989 // Convenience templates that emit nothing
 990 
 991 // ignore do_blob(blob_name, type) declarations
 992 #define DO_BLOB_EMPTY2(blob_name, type)
 993 
 994 // ignore do_blob(blob_name) and end_blob(blob_name) declarations
 995 #define DO_BLOB_EMPTY1(blob_name)
 996 
 997 // ignore do_stub(name, fancy_jump, pass_tls, return_pc) declarations
 998 #define DO_STUB_EMPTY4(name, fancy_jump, pass_tls, return_pc)
 999 
1000 // ignore do_jvmti_stub(name) declarations
1001 #define DO_JVMTI_STUB_EMPTY1(stub_name)
1002 
1003 // ignore do_stub(blob_name, stub_name) declarations
1004 #define DO_STUB_EMPTY2(blob_name, stub_name)
1005 
1006 // ignore do_entry(blob_name, stub_name, fieldname, getter_name) declarations
1007 #define DO_ENTRY_EMPTY4(blob_name, stub_name, fieldname, getter_name)
1008 
1009 // ignore do_entry(blob_name, stub_name, fieldname, getter_name, init_function) and
1010 // do_entry_array(blob_name, stub_name, fieldname, getter_name, count) declarations
1011 #define DO_ENTRY_EMPTY5(blob_name, stub_name, fieldname, getter_name, init_function)
1012 
1013 // ignore do_arch_blob(blob_name, size) declarations
1014 #define DO_ARCH_BLOB_EMPTY2(arch, size)
1015 
1016 // ignore do_arch_entry(arch, blob_name, stub_name, fieldname, getter_name) declarations
1017 #define DO_ARCH_ENTRY_EMPTY5(arch, blob_name, stub_name, field_name, getter_name)
1018 
1019 // ignore do_arch_entry(arch, blob_name, stub_name, fieldname, getter_name, init_function) declarations
1020 #define DO_ARCH_ENTRY_EMPTY6(arch, blob_name, stub_name, field_name, getter_name, init_function)
1021 
1022 // The whole shebang!
1023 //
1024 // client macro for emitting StubGenerator blobs, stubs and entries
1025 
1026 #define STUBGEN_ALL_DO(do_blob, end_blob,                               \
1027                        do_stub,                                         \
1028                        do_entry, do_entry_init,                         \
1029                        do_entry_array,                                  \
1030                        do_arch_blob,                                    \
1031                        do_arch_entry, do_arch_entry_init)               \
1032   STUBGEN_PREUNIVERSE_BLOBS_DO(do_blob, end_blob,                       \
1033                                do_stub,                                 \
1034                                do_entry, do_entry_init,                 \
1035                                do_entry_array,                          \
1036                                do_arch_blob,                            \
1037                                do_arch_entry, do_arch_entry_init)       \
1038   STUBGEN_INITIAL_BLOBS_DO(do_blob, end_blob,                           \
1039                            do_stub,                                     \
1040                            do_entry, do_entry_init,                     \
1041                            do_entry_array,                              \
1042                            do_arch_blob,                                \
1043                            do_arch_entry, do_arch_entry_init)           \
1044   STUBGEN_CONTINUATION_BLOBS_DO(do_blob, end_blob,                      \
1045                                 do_stub,                                \
1046                                 do_entry, do_entry_init,                \
1047                                 do_entry_array,                         \
1048                                 do_arch_blob,                           \
1049                                 do_arch_entry, do_arch_entry_init)      \
1050   STUBGEN_COMPILER_BLOBS_DO(do_blob, end_blob,                          \
1051                             do_stub,                                    \
1052                             do_entry, do_entry_init,                    \
1053                             do_entry_array,                             \
1054                             do_arch_blob,                               \
1055                             do_arch_entry, do_arch_entry_init)          \
1056   STUBGEN_FINAL_BLOBS_DO(do_blob, end_blob,                             \
1057                          do_stub,                                       \
1058                          do_entry, do_entry_init,                       \
1059                          do_entry_array,                                \
1060                          do_arch_blob,                                  \
1061                          do_arch_entry, do_arch_entry_init)             \
1062 
1063 // client macro to operate only on StubGenerator blobs
1064 
1065 #define STUBGEN_BLOBS_DO(do_blob)                                       \
1066   STUBGEN_ALL_DO(do_blob, DO_BLOB_EMPTY1,                               \
1067                  DO_STUB_EMPTY2,                                        \
1068                  DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
1069                  DO_ENTRY_EMPTY5,                                       \
1070                  DO_ARCH_BLOB_EMPTY2,                                   \
1071                  DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \
1072 
1073 // client macro to operate only on StubGenerator stubs
1074 
1075 #define STUBGEN_STUBS_DO(do_stub)                                       \
1076   STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
1077                  do_stub,                                               \
1078                  DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
1079                  DO_ENTRY_EMPTY5,                                       \
1080                  DO_ARCH_BLOB_EMPTY2,                                   \
1081                  DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \
1082 
1083 // client macro to operate only on StubGenerator blobs and stubs
1084 
1085 #define STUBGEN_BLOBS_STUBS_DO(do_blob, end_blob, do_stub)              \
1086   STUBGEN_ALL_DO(do_blob, end_blob,                                     \
1087                  do_stub,                                               \
1088                  DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
1089                  DO_ENTRY_EMPTY5,                                       \
1090                  DO_ARCH_BLOB_EMPTY2,                                   \
1091                  DO_ARCH_ENTRY_EMPTY5,DO_ARCH_ENTRY_EMPTY6)             \
1092 
1093 // client macro to operate only on StubGenerator entries
1094 
1095 #define STUBGEN_ENTRIES_DO(do_entry, do_entry_init, do_entry_array)     \
1096   STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
1097                  DO_STUB_EMPTY2,                                        \
1098                  do_entry, do_entry_init,                               \
1099                  do_entry_array,                                        \
1100                  DO_ARCH_BLOB_EMPTY2,                                   \
1101                  DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \
1102 
1103 // client macro to operate only on StubGenerator arch blobs
1104 
1105 #define STUBGEN_ARCH_BLOBS_DO(do_arch_blob)                             \
1106   STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
1107                  DO_STUB_EMPTY2,                                        \
1108                  DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
1109                  DO_ENTRY_EMPTY5,                                       \
1110                  do_arch_blob,                                          \
1111                  DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \
1112 
1113 // client macro to operate only on StubGenerator arch entries
1114 
1115 #define STUBGEN_ARCH_ENTRIES_DO(do_arch_entry, do_arch_entry_init)      \
1116   STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
1117                  DO_STUB_EMPTY2,                                        \
1118                  DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
1119                  DO_ENTRY_EMPTY5,                                       \
1120                  DO_ARCH_BLOB_EMPTY2,                                   \
1121                  do_arch_entry, do_arch_entry_init)                     \
1122 
1123 #endif // SHARE_RUNTIME_STUBDECLARATIONS_HPP