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