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