/*
 * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2025, Red Hat, Inc. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#ifndef SHARE_RUNTIME_STUBDECLARATIONS_HPP
#define SHARE_RUNTIME_STUBDECLARATIONS_HPP

#include "utilities/macros.hpp"

// macros for generating definitions and declarations for shared, c1
// and opto blob fields and associated stub ids

// Different shared stubs can have different blob types and may
// include some JFR stubs
//
// n.b resolve, handler and throw stubs must remain grouped in the
// same order to allow id values to be range checked

#if INCLUDE_JFR
// do_blob(name, type)
#define SHARED_JFR_STUBS_DO(do_blob)                                   \
  do_blob(jfr_write_checkpoint, RuntimeStub*)                          \
  do_blob(jfr_return_lease, RuntimeStub*)                              \

#else
#define SHARED_JFR_STUBS_DO(do_blob)
#endif

// client macro to operate on shared stubs
//
// do_blob(name, type)
#define SHARED_STUBS_DO(do_blob)                                       \
  do_blob(deopt, DeoptimizationBlob*)                                  \
  /* resolve stubs */                                                  \
  do_blob(wrong_method, RuntimeStub*)                                  \
  do_blob(wrong_method_abstract, RuntimeStub*)                         \
  do_blob(ic_miss, RuntimeStub*)                                       \
  do_blob(resolve_opt_virtual_call, RuntimeStub*)                      \
  do_blob(resolve_virtual_call, RuntimeStub*)                          \
  do_blob(resolve_static_call, RuntimeStub*)                           \
  /* handler stubs */                                                  \
  do_blob(polling_page_vectors_safepoint_handler, SafepointBlob*)      \
  do_blob(polling_page_safepoint_handler, SafepointBlob*)              \
  do_blob(polling_page_return_handler, SafepointBlob*)                 \
  /* throw stubs */                                                    \
  do_blob(throw_AbstractMethodError, RuntimeStub*)                     \
  do_blob(throw_IncompatibleClassChangeError, RuntimeStub*)            \
  do_blob(throw_NullPointerException_at_call, RuntimeStub*)            \
  do_blob(throw_StackOverflowError, RuntimeStub*)                      \
  do_blob(throw_delayed_StackOverflowError, RuntimeStub*)              \
  /* other stubs */                                                    \
  SHARED_JFR_STUBS_DO(do_blob)                                         \

// C1 stubs are always generated in a generic CodeBlob

#ifdef COMPILER1
// client macro to operate on c1 stubs
//
// do_blob(name)
#define C1_STUBS_DO(do_blob)                                           \
  do_blob(dtrace_object_alloc)                                         \
  do_blob(unwind_exception)                                            \
  do_blob(forward_exception)                                           \
  do_blob(throw_range_check_failed)       /* throws ArrayIndexOutOfBoundsException */ \
  do_blob(throw_index_exception)          /* throws IndexOutOfBoundsException */ \
  do_blob(throw_div0_exception)                                        \
  do_blob(throw_null_pointer_exception)                                \
  do_blob(register_finalizer)                                          \
  do_blob(new_instance)                                                \
  do_blob(fast_new_instance)                                           \
  do_blob(fast_new_instance_init_check)                                \
  do_blob(new_type_array)                                              \
  do_blob(new_object_array)                                            \
  do_blob(new_multi_array)                                             \
  do_blob(handle_exception_nofpu)         /* optimized version that does not preserve fpu registers */ \
  do_blob(handle_exception)                                            \
  do_blob(handle_exception_from_callee)                                \
  do_blob(throw_array_store_exception)                                 \
  do_blob(throw_class_cast_exception)                                  \
  do_blob(throw_incompatible_class_change_error)                       \
  do_blob(slow_subtype_check)                                          \
  do_blob(is_instance_of)                                              \
  do_blob(monitorenter)                                                \
  do_blob(monitorenter_nofpu)             /* optimized version that does not preserve fpu registers */ \
  do_blob(monitorexit)                                                 \
  do_blob(monitorexit_nofpu)              /* optimized version that does not preserve fpu registers */ \
  do_blob(deoptimize)                                                  \
  do_blob(access_field_patching)                                       \
  do_blob(load_klass_patching)                                         \
  do_blob(load_mirror_patching)                                        \
  do_blob(load_appendix_patching)                                      \
  do_blob(fpu2long_stub)                                               \
  do_blob(counter_overflow)                                            \
  do_blob(predicate_failed_trap)                                       \

#else
#define C1_STUBS_DO(do_blob)
#endif

// Opto stubs can be stored as entries with just an address or as
// blobs of different types. The former may include some JVMTI stubs.
//
// n.b. blobs and stub defines are generated in the order defined by
// C2_STUBS_DO, allowing dependencies from any givem stub on its
// predecessors to be guaranteed. That explains the initial placement
// of the blob declarations and intermediate placement of the jvmti
// stubs.

#ifdef COMPILER2
// do_jvmti_stub(name)
#if INCLUDE_JVMTI
#define C2_JVMTI_STUBS_DO(do_jvmti_stub)                               \
  do_jvmti_stub(notify_jvmti_vthread_start)                            \
  do_jvmti_stub(notify_jvmti_vthread_end)                              \
  do_jvmti_stub(notify_jvmti_vthread_mount)                            \
  do_jvmti_stub(notify_jvmti_vthread_unmount)                          \

#else
#define C2_JVMTI_STUBS_DO(do_jvmti_stub)
#endif // INCLUDE_JVMTI

// client macro to operate on c2 stubs
//
// do_blob(name, type)
// do_stub(name, fancy_jump, pass_tls, return_pc)
// do_jvmti_stub(name)
//
// n.b. non-jvmti stubs may employ a special type of jump (0, 1 or 2)
// and require access to TLS and the return pc. jvmti stubs always
// employ jump 0, and require no special access
#define C2_STUBS_DO(do_blob, do_stub, do_jvmti_stub)                   \
  do_blob(uncommon_trap, UncommonTrapBlob*)                            \
  do_blob(exception, ExceptionBlob*)                                   \
  do_stub(new_instance, 0, true, false)                                \
  do_stub(new_array, 0, true, false)                                   \
  do_stub(new_array_nozero, 0, true, false)                            \
  do_stub(multianewarray2, 0, true, false)                             \
  do_stub(multianewarray3, 0, true, false)                             \
  do_stub(multianewarray4, 0, true, false)                             \
  do_stub(multianewarray5, 0, true, false)                             \
  do_stub(multianewarrayN, 0, true, false)                             \
  C2_JVMTI_STUBS_DO(do_jvmti_stub)                                     \
  do_stub(complete_monitor_locking, 0, false, false)                   \
  do_stub(monitor_notify, 0, false, false)                             \
  do_stub(monitor_notifyAll, 0, false, false)                          \
  do_stub(rethrow, 2, true, true)                                      \
  do_stub(slow_arraycopy, 0, false, false)                             \
  do_stub(register_finalizer, 0, false, false)                         \

#else
#define C2_STUBS_DO(do_blob, do_stub, do_jvmti_stub)
#endif

// Stub Generator Blobs and Stubs Overview
//
// StubGenerator stubs do not require their own individual blob. They
// are generated in batches into one of four distinct BufferBlobs:
//
// 1) Initial stubs
// 2) Continuation stubs
// 3) Compiler stubs
// 4) Final stubs
//
// Creation of each successive BufferBlobs is staged to ensure that
// specific VM subsystems required by those stubs are suitably
// initialized before generated code attempt to reference data or
// addresses exported by those subsystems. The sequencing of
// initialization must be taken into account when adding a new stub
// declaration.
//
// StubGenerator stubs are declared using template macros, one set of
// declarations per blob (see below), with arch-specific stubs for any
// gven blob declared after generic stubs for that blob. Blobs are
// created in a fixed order during startup, which is reflected in the
// order of the declaration set. Stubs within a blob are currently
// created in an order determined by the arch-specific generator code
// which may not reflect the order of stub declarations. It is not
// straightforward to enforce a strict ordering. not least because
// arch-specific stub creation may need to be interleaved with generic
// stub creation.
//
// Blob and stub declaration templates are used to generate a variety
// of C++ code elements needed to manage stubs.
//
// Blob identifiers:
//
// public enum StubGenBlobId is generated to identify each of the
// StubGenerator blobs in blob declaration order. This enum is
// provided for use by client code to identify a specific blob. For a
// blob declared with name <blob_name> the associated enum value is
// StubGenBlobId::<blob_name>_id.
//
// Global stub identifiers:
//
// public enum StubGenStubId is generated to identify all declared
// stubs across all blobs, sorted first by blob declaration order and
// then within a blob by stub declaration order, generic stubs before
// arch-specific stubs. This enum is provided for use by client code
// to identify a specific stub, independent of the blob it belongs to.
// For a stub declared with name <stub_name> the associated enum value
// is StubGenStubId::<stub_name>_id.
//
// Blob-local stub identifiers:
//
// For each blob <blob_name>, public enum StubGenStubId_<blob_name> is
// generated to enumerate all stubs within the blob in stub
// declaration order, generic stubs before arch-specific stubs. This
// enum is provided only in a non-product build and is intended for
// internal use by class StubRoutines to validate stub declarations.
// For a stub declared with name <stub_name> belonging to blob
// <blob_name> the associated enum value is
// StubGenStubId::<blob_name>_<stub_name>_id.
//
// Stub names and associated getters:
//
// Two private static fields are generated to hold the names of the
// four generated blobs and all the generated stubs.
//
//  const char* StubRoutines::_blob_names[];
//  const char* StubRoutines::_stub_names[];
//
// The entry in _blob_names for a blob declared with name <blob_name>
// will be "<blob_name>".
//
// The entry in _stub_names for a stub declared with name <stub_name>
// will be "<stub_name>".
//
// Corresponding public static lookup methods are generated to allow
// names to be looked up by blob or global stub id.
//
//  const char* StubRoutines::get_blob_name(StubGenBlobId id)
//  const char* StubRoutines::get_stub_name(StubGenStubId id)
//
// These name lookup methods should be used by generic and
// cpu-specific client code to ensure that blobs and stubs are
// identified consistently.
//
// Blob code buffer sizes:
//
// An enumeration enum platform_dependent_constants is generated in
// the architecture specific StubRoutines header. For each blob named
// <nnn> an associated enum tag is generated which defines the
// relevant size
//
//  _<nnn>_stubs_code_size      = <size>,
//
// For example,
//
// enum platform_dependent_constants {
//   _initial_stubs_code_size      = 10000,
//   _continuation_stubs_code_size =  2000,
//   . . .
//
// Blob fields and associated getters:
//
// For each blob named <nnn> a private field declaration will be
// generated: static field address StubRoutines::_<nnn>_stubs_code and
// a declaration provided to initialise it to nullptr. A corresponding
// public getter method address StubRoutines::_<nnn>_stubs_code() will
// be generated.
//
// Blob initialization routines:
//
// For each blob named <nnn> an initalization function is defined
// which allows clients to schedule blob and stub generation during
// JVM bootstrap:
//
// void <nnn>_stubs_init() { StubRoutines::initialize_<nnn>_stubs(); }
//
// A declaration and definition of each underlying implementation
// method StubRoutines::initialize_<nnn>_stubs() is also generated.
//
// Stub entry points and associated getters:
//
// Some generated stubs require their main entry point and, possibly,
// auxiliary entry points to be stored in fields declared either as
// members of class SharedRuntime. For stubs that are specific to a
// given cpu, the field needs to be declared in an arch-specific inner
// class of SharedRuntime.
//
// For a generic stub named <nnn> the corresponding main entry usually
// has the same name: static field address StubRoutines::_<nnn> modulo
// an _ prefix.  An associated getter method is also generated, again
// normally using the same name: address StubRoutines::<nnn>() e.g.
//
//  class StubRoutines {
//    . . .
//    static address _aescrypt_encryptBlock;
//    . . .
//    address aescrypt_encryptBlock() { return _aescrypt_encryptBlock; }
//
// Multiple fields and getters may be generated where a stub has more
// than one entry point, each provided with their own unique field and
// getter name e.g.
//
//    . . .
//    static address _call_stub;
//    static address _call_stub_return_address;
//    . . .
//    static address call_stub_entry() { return _call_stub; }
//    static address call_stub_return_address() { return _call_stub_return_address; }
//
// In special cases a stub may declare a (compile-time) fixed size
// array of entries, in which case an address array field is
// generated,along with a getter that accepts an index as argument:
//
//    . . .
//   static address _lookup_secondary_supers_table[Klass::SECONDARY_SUPERS_TABLE_SIZE];
//   . . .
//   static address lookup_secondary_supers_table(int i);
//
// CPU-specific stub entry points and associated getters:
//
// For an arch-specific stub with name <nnn> belonging to architecture
// <arch> private field address StubRoutines::<arch>::_<nnn> is
// generated to hold the entry address. An associated public getter
// method address StubRoutines::<arch>::<nnn>() is also generated e.g.
//
//  class StubRoutines {
//    . . .
//    class x86 {
//      . . .
//      static address _f2i_fixup;
//      . . .
//      static address f2i_fixup() { return _f2i_fixup; }
//      static void set_f2i_fixup(address a) { _f2i_fixup = a; }
//


//--------------------------------------------------
// Stub Generator Blob, Stub and Entry Declarations
// -------------------------------------------------
//
// The formal declarations of blobs, stubs and entries provided below
// are used to schedule application of template macros that either
// declare or define the C++ code we need to manage those blobs, stubs
// and entries.
//
// All ports employ the same blobs. However, the organization of the
// stubs and entry points in a blob can vary from one port to the
// next. A template macro is provided to specify the details of each
// blob, including generic and arch-specific variations.
//
// If you want to define a new stub or entry then you can do so by
// adding suitable declarations within the scope of the relevant blob.
// For the blob with name BLOB_NAME add your declarations to macro
// STUBGEN_<BLOB_NAME>_STUBS_DO. Generic stubs and entries are
// declared using the do_stub, do_entry and do_entry_init and
// array_entry templates (see below for full details). The do_blob
// and end_blob templates should never need to be modified.
//
// Some stubs and their associated entries are architecture-specific.
// They need to be declared in the architecture-specific header file
// src/cpu/<arch>stubDecolaration_<arch>.cpp. For the blob with name
// BLOB_NAME the correspnding declarations macro are provided by macro
// STUBGEN_<BLOB_NAME>_STUBS_ARCH_DO. Arch-specific stubs and entries
// are declared using the do_stub, do_arch_entry and
// do_arch_entry_init templates (see below for details). An
// architecure also needs to specify architecture parameters used when
// creating each blob. These are defined using the do_arch_blob
// template (see below).
//
// Note, the client macro STUBGEN_ALL_DO is provided to allow client
// code to iterate over all blob, stub or entry declarations. It has
// only been split into separate per-blob generic submacros,
// STUBGEN_<BLOB_NAME>_BLOBS_DO and arch-specific per-blob submacros
// STUBGEN_<BLOB_NAME>_BLOBS_ARCH_DO for convenience, to make it
// easier to manage definitions. The blob_specific sub-macros should
// not be called directly by client code (in class StubRoutines and
// StubGenerator),
//
// A client wishing to generate blob, stub or entry code elements is
// expected to pass template macros as arguments to STUBGEN_ALL_DO.
// This will schedule code generation code for whatever C++ code
// elements are required to implement a declaration or definition
// relevant to each blob, stub or entry. Alternatively, a client can
// operate on a subset of the declarations by calling macros
// STUBGEN_BLOBS_DO, STUBGEN_STUBS_DO, STUBGEN_BLOBS_STUBS_DO,
// STUBGEN_ENTRIES_DO and STUBGEN_ARCH_ENTRIES_DO.
//
// The do_blob and end_blob templates receive a blob name as argument.
//
// do_blob(blob_name)
// end_blob(blob_name)
//
// do_blob is primarily used to define a global enum tag for a blob
// and an associated constant string name, both for use by client
// code.
//
// end_blob is provided for use in combination with do_blob to to open
// and close a blob-local enum type identifying all stubs within a
// given blob. This enum is private to the stub management code and
// used to validate correct use of stubs within a given blob.
//
// The do_stub template receives a blob name and stub name as argument.
//
// do_stub(blob_name, stub_name)
//
// do_stub is primarily used to define a global enum tag for a stub
// and a constant string name, both for use by client code. It is also
// used to declare a tag within the blob-local enum type used to
// validate correct use of stubs within their declared blob. Finally,
// it is also used to declare a name for each stub.
//
// The do_entry and do_entry_array templates receive 4 or 5 arguments
//
// do_entry(blob_name, stub_name, field_name, getter_name)
//
// do_entry_init(blob_name, stub_name, field_name, getter_name, init_function)
//
// do_entry_array(blob_name, stub_name, field_name, getter_name, count)
//
// do_entry is used to declare or define a static field of class
// StubRoutines with type address that stores a specific entry point
// for a given stub. n.b. the number of entries associated with a stub
// is often one but it can be more than one and, in a few special
// cases, it is zero. do_entry is also used to declare and define an
// associated getter method for the field. do_entry is used to declare
// fields that should be initialized to nullptr.
//
// do_entry_init is used when the field needs to be initialized a
// specific function or method .
//
// do_entry_array is used for the special case where a stub employs an
// array to store multiple entries which are stored at generate time
// and subsequently accessed using an associated index (e.g. the
// secondary supers table stub which has 63 qassociated entries).
// Note that this distinct from the case where a stub generates
// multiple entries each of them stored in its own named field with
// its own named getter. In the latter case multiple do_entry or
// do_entry_init declarations are associated with the stub.
//
// blob_name and stub_name are the names of the blob and stub to which
// the entry belongs.
//
// field_name is prefixed with a leading '_' to produce the name of
// the field used to store an entry address for the stub. For stubs
// with one entry field_name is normally, but not always, the same as
// stub_name.  Obviously when a stub has multiple entries secondary
// names must be different to stub_name. For normal entry declarations
// the field type is address. For do_entry_array declarations the field
// type is an address[] whose size is defined by then parameter.
//
// getter_name is the name of a getter that is generated to allow
// access to the field. It is normally, but not always, the same as
// stub_name. For normal entry declarations the getter signature is
// (void).  For do_entry_array declarations the getter signature is
// (int).
//
// init_function is the name of an function or method which should be
// assigned to the field as a default value (n.b. fields declared
// using do_entry are intialised to nullptr, array fields declared
// using do_entry_array have their elements initalized to nullptr).
//
// Architecture-specific blob details need to be specified using the
// do_arch_blob template
//
// do_arch_blob(blob_name, size)
//
// Currently, the do_arch_blob macro is only used to define the size
// of the code buffer into which blob-specific stub code is to be
// generated.
//
// Architecture-specific entries need to be declared using the
// do_arch_entry template
//
// do_arch_entry(arch, blob_name, stub_name, field_name, getter_name)
//
// do_arch_entry_init(arch, blob_name, stub_name, field_name,
//                    getter_name, init_function)
//
// The only difference between these templates and the generic ones is
// that they receive an extra argument which identifies the current
// architecture e.g. x86, aarch64 etc.
//
// Currently there is no support for a do_arch_array_entry template.

// Include arch-specific stub and entry declarations and make sure the
// relevant template macros have been defined

#include CPU_HEADER(stubDeclarations)

#ifndef STUBGEN_INITIAL_BLOBS_ARCH_DO
#error "Arch-specific directory failed to declare required initial stubs and entries"
#endif

#ifndef STUBGEN_CONTINUATION_BLOBS_ARCH_DO
#error "Arch-specific directory failed to declare required continuation stubs and entries"
#endif

#ifndef STUBGEN_COMPILER_BLOBS_ARCH_DO
#error "Arch-specific directory failed to declare required compiler stubs and entries"
#endif

#ifndef STUBGEN_FINAL_BLOBS_ARCH_DO
#error "Arch-specific directory failed to declare required final stubs and entries"
#endif

// Iterator macros to apply templates to all relevant blobs, stubs and
// entries. Clients should use STUBGEN_ALL_DO, STUBGEN_BLOBS_DO,
// STUBGEN_STUBS_DO, STUBGEN_BLOBS_STUBS_DO, STUBGEN_ENTRIES_DO,
// STUBGEN_ARCH_BLOBS_DO and STUBGEN_ARCH_ENTRIES_DO.
//
// n.b. Client macros appear after the STUBGEN_<BLOB_NAME>_BLOBS_DO
// submacros which follow next. These submacros are not intended to be
// called directly. They serve to define the main client macro
// STUBGEN_ALL_DO and, from there, the other more specific client
// macros. n.b. multiple, 'per-blob' submacros are used to declare
// each group of stubs and entries, because that makes it simpler to
// lookup and update related elements. If you need to update these
// submacros to change the list of stubs or entries be sure to locate
// stubs within the correct blob and locate entry declarations
// immediately after their associated stub declaration.

#define STUBGEN_INITIAL_BLOBS_DO(do_blob, end_blob,                     \
                                 do_stub,                               \
                                 do_entry, do_entry_init,               \
                                 do_entry_array,                        \
                                 do_arch_blob,                          \
                                 do_arch_entry, do_arch_entry_init)     \
  do_blob(initial)                                                      \
  do_stub(initial, call_stub)                                           \
  do_entry(initial, call_stub, call_stub_entry, call_stub_entry)        \
  do_entry(initial, call_stub, call_stub_return_address,                \
           call_stub_return_address)                                    \
  do_stub(initial, forward_exception)                                   \
  do_entry(initial, forward_exception, forward_exception_entry,         \
           forward_exception_entry)                                     \
  do_stub(initial, catch_exception)                                     \
  do_entry(initial, catch_exception, catch_exception_entry,             \
           catch_exception_entry)                                       \
  do_stub(initial, fence)                                               \
  do_entry(initial, fence, fence_entry, fence_entry)                    \
  do_stub(initial, atomic_add)                                          \
  do_entry(initial, atomic_add, atomic_add_entry, atomic_add_entry)     \
  do_stub(initial, atomic_xchg)                                         \
  do_entry(initial, atomic_xchg, atomic_xchg_entry, atomic_xchg_entry)  \
  do_stub(initial, atomic_cmpxchg)                                      \
  do_entry(initial, atomic_cmpxchg, atomic_cmpxchg_entry,               \
           atomic_cmpxchg_entry)                                        \
  do_stub(initial, atomic_cmpxchg_long)                                 \
  do_entry(initial, atomic_cmpxchg_long, atomic_cmpxchg_long_entry,     \
           atomic_cmpxchg_long_entry)                                   \
  do_stub(initial, updateBytesCRC32)                                    \
  do_entry(initial, updateBytesCRC32, updateBytesCRC32,                 \
           updateBytesCRC32)                                            \
  do_entry(initial, updateBytesCRC32, crc_table_adr, crc_table_addr)    \
  do_stub(initial, updateBytesCRC32C)                                   \
  do_entry(initial, updateBytesCRC32C, updateBytesCRC32C,               \
           updateBytesCRC32C)                                           \
  do_entry(initial, updateBytesCRC32C, crc32c_table_addr,               \
           crc32c_table_addr)                                           \
  do_stub(initial, f2hf)                                                \
  do_entry(initial, f2hf, f2hf, f2hf_adr)                               \
  do_stub(initial, hf2f)                                                \
  do_entry(initial, hf2f, hf2f, hf2f_adr)                               \
  do_stub(initial, dexp)                                                \
  do_entry(initial, dexp, dexp, dexp)                                   \
  do_stub(initial, dlog)                                                \
  do_entry(initial, dlog, dlog, dlog)                                   \
  do_stub(initial, dlog10)                                              \
  do_entry(initial, dlog10, dlog10, dlog10)                             \
  do_stub(initial, dpow)                                                \
  do_entry(initial, dpow, dpow, dpow)                                   \
  do_stub(initial, dsin)                                                \
  do_entry(initial, dsin, dsin, dsin)                                   \
  do_stub(initial, dcos)                                                \
  do_entry(initial, dcos, dcos, dcos)                                   \
  do_stub(initial, dtan)                                                \
  do_entry(initial, dtan, dtan, dtan)                                   \
  do_stub(initial, dtanh)                                               \
  do_entry(initial, dtanh, dtanh, dtanh)                                \
  do_stub(initial, dcbrt)                                               \
  do_entry(initial, dcbrt, dcbrt, dcbrt)                                \
  do_stub(initial, fmod)                                                \
  do_entry(initial, fmod, fmod, fmod)                                   \
  /* following generic entries should really be x86_32 only */          \
  do_stub(initial, dlibm_sin_cos_huge)                                  \
  do_entry(initial, dlibm_sin_cos_huge, dlibm_sin_cos_huge,             \
           dlibm_sin_cos_huge)                                          \
  do_stub(initial, dlibm_reduce_pi04l)                                  \
  do_entry(initial, dlibm_reduce_pi04l, dlibm_reduce_pi04l,             \
           dlibm_reduce_pi04l)                                          \
  do_stub(initial, dlibm_tan_cot_huge)                                  \
  do_entry(initial, dlibm_tan_cot_huge, dlibm_tan_cot_huge,             \
           dlibm_tan_cot_huge)                                          \
  /* merge in stubs and entries declared in arch header */              \
  STUBGEN_INITIAL_BLOBS_ARCH_DO(do_stub, do_arch_blob,                  \
                                do_arch_entry, do_arch_entry_init)      \
  end_blob(initial)                                                     \


#define STUBGEN_CONTINUATION_BLOBS_DO(do_blob, end_blob,                \
                                      do_stub,                          \
                                      do_entry, do_entry_init,          \
                                      do_entry_array,                   \
                                      do_arch_blob,                     \
                                      do_arch_entry, do_arch_entry_init) \
  do_blob(continuation)                                                 \
  do_stub(continuation, cont_thaw)                                      \
  do_entry(continuation, cont_thaw, cont_thaw, cont_thaw)               \
  do_stub(continuation, cont_preempt)                                   \
  do_entry(continuation, cont_prempt, cont_preempt_stub,                \
           cont_preempt_stub)                                           \
  do_stub(continuation, cont_returnBarrier)                             \
  do_entry(continuation, cont_returnBarrier, cont_returnBarrier,        \
           cont_returnBarrier)                                          \
  do_stub(continuation, cont_returnBarrierExc)                          \
  do_entry(continuation, cont_returnBarrierExc, cont_returnBarrierExc,  \
           cont_returnBarrierExc)                                       \
  /* merge in stubs and entries declared in arch header */              \
  STUBGEN_CONTINUATION_BLOBS_ARCH_DO(do_stub,  do_arch_blob,            \
                                     do_arch_entry, do_arch_entry_init) \
  end_blob(continuation)                                                \


#define STUBGEN_COMPILER_BLOBS_DO(do_blob, end_blob,                    \
                                  do_stub,                              \
                                  do_entry, do_entry_init,              \
                                  do_entry_array,                       \
                                  do_arch_blob,                         \
                                  do_arch_entry, do_arch_entry_init)    \
  do_blob(compiler)                                                     \
  do_stub(compiler, array_sort)                                         \
  do_entry(compiler, array_sort, array_sort, select_arraysort_function) \
  do_stub(compiler, array_partition)                                    \
  do_entry(compiler, array_partition, array_partition,                  \
           select_array_partition_function)                             \
  do_stub(compiler, aescrypt_encryptBlock)                              \
  do_entry(compiler, aescrypt_encryptBlock, aescrypt_encryptBlock,      \
           aescrypt_encryptBlock)                                       \
  do_stub(compiler, aescrypt_decryptBlock)                              \
  do_entry(compiler, aescrypt_decryptBlock, aescrypt_decryptBlock,      \
           aescrypt_decryptBlock)                                       \
  do_stub(compiler, cipherBlockChaining_encryptAESCrypt)                \
  do_entry(compiler, cipherBlockChaining_encryptAESCrypt,               \
           cipherBlockChaining_encryptAESCrypt,                         \
           cipherBlockChaining_encryptAESCrypt)                         \
  do_stub(compiler, cipherBlockChaining_decryptAESCrypt)                \
  do_entry(compiler, cipherBlockChaining_decryptAESCrypt,               \
           cipherBlockChaining_decryptAESCrypt,                         \
           cipherBlockChaining_decryptAESCrypt)                         \
  do_stub(compiler, electronicCodeBook_encryptAESCrypt)                 \
  do_entry(compiler, electronicCodeBook_encryptAESCrypt,                \
           electronicCodeBook_encryptAESCrypt,                          \
           electronicCodeBook_encryptAESCrypt)                          \
  do_stub(compiler, electronicCodeBook_decryptAESCrypt)                 \
  do_entry(compiler, electronicCodeBook_decryptAESCrypt,                \
           electronicCodeBook_decryptAESCrypt,                          \
           electronicCodeBook_decryptAESCrypt)                          \
  do_stub(compiler, counterMode_AESCrypt)                               \
  do_entry(compiler, counterMode_AESCrypt, counterMode_AESCrypt,        \
           counterMode_AESCrypt)                                        \
  do_stub(compiler, galoisCounterMode_AESCrypt)                         \
  do_entry(compiler, galoisCounterMode_AESCrypt,                        \
           galoisCounterMode_AESCrypt, galoisCounterMode_AESCrypt)      \
  do_stub(compiler, ghash_processBlocks)                                \
  do_entry(compiler, ghash_processBlocks, ghash_processBlocks,          \
           ghash_processBlocks)                                         \
  do_stub(compiler, chacha20Block)                                      \
  do_entry(compiler, chacha20Block, chacha20Block, chacha20Block)       \
  do_stub(compiler, kyberNtt)                                           \
  do_entry(compiler, kyberNtt, kyberNtt, kyberNtt)                      \
  do_stub(compiler, kyberInverseNtt)                                    \
  do_entry(compiler, kyberInverseNtt, kyberInverseNtt, kyberInverseNtt) \
  do_stub(compiler, kyberNttMult)                                       \
  do_entry(compiler, kyberNttMult, kyberNttMult, kyberNttMult)          \
  do_stub(compiler, kyberAddPoly_2)                                     \
  do_entry(compiler, kyberAddPoly_2, kyberAddPoly_2, kyberAddPoly_2)    \
  do_stub(compiler, kyberAddPoly_3)                                     \
  do_entry(compiler, kyberAddPoly_3, kyberAddPoly_3, kyberAddPoly_3)    \
  do_stub(compiler, kyber12To16)                                        \
  do_entry(compiler, kyber12To16, kyber12To16, kyber12To16)             \
  do_stub(compiler, kyberBarrettReduce)                                 \
  do_entry(compiler, kyberBarrettReduce, kyberBarrettReduce,            \
           kyberBarrettReduce)                                          \
  do_stub(compiler, dilithiumAlmostNtt)                                 \
  do_entry(compiler, dilithiumAlmostNtt,                                \
           dilithiumAlmostNtt, dilithiumAlmostNtt)                      \
  do_stub(compiler, dilithiumAlmostInverseNtt)                          \
  do_entry(compiler, dilithiumAlmostInverseNtt,                         \
           dilithiumAlmostInverseNtt, dilithiumAlmostInverseNtt)        \
  do_stub(compiler, dilithiumNttMult)                                   \
  do_entry(compiler, dilithiumNttMult,                                  \
           dilithiumNttMult, dilithiumNttMult)                          \
  do_stub(compiler, dilithiumMontMulByConstant)                         \
  do_entry(compiler, dilithiumMontMulByConstant,                        \
           dilithiumMontMulByConstant, dilithiumMontMulByConstant)      \
  do_stub(compiler, dilithiumDecomposePoly)                             \
  do_entry(compiler, dilithiumDecomposePoly,                            \
           dilithiumDecomposePoly, dilithiumDecomposePoly)              \
  do_stub(compiler, data_cache_writeback)                               \
  do_entry(compiler, data_cache_writeback, data_cache_writeback,        \
           data_cache_writeback)                                        \
  do_stub(compiler, data_cache_writeback_sync)                          \
  do_entry(compiler, data_cache_writeback_sync,                         \
           data_cache_writeback_sync, data_cache_writeback_sync)        \
  do_stub(compiler, base64_encodeBlock)                                 \
  do_entry(compiler, base64_encodeBlock, base64_encodeBlock,            \
           base64_encodeBlock)                                          \
  do_stub(compiler, base64_decodeBlock)                                 \
  do_entry(compiler, base64_decodeBlock, base64_decodeBlock,            \
           base64_decodeBlock)                                          \
  do_stub(compiler, poly1305_processBlocks)                             \
  do_entry(compiler, poly1305_processBlocks, poly1305_processBlocks,    \
           poly1305_processBlocks)                                      \
  do_stub(compiler, intpoly_montgomeryMult_P256)                        \
  do_entry(compiler, intpoly_montgomeryMult_P256,                       \
           intpoly_montgomeryMult_P256, intpoly_montgomeryMult_P256)    \
  do_stub(compiler, intpoly_assign)                                     \
  do_entry(compiler, intpoly_assign, intpoly_assign, intpoly_assign)    \
  do_stub(compiler, md5_implCompress)                                   \
  do_entry(compiler, md5_implCompress, md5_implCompress,                \
           md5_implCompress)                                            \
  do_stub(compiler, md5_implCompressMB)                                 \
  do_entry(compiler, md5_implCompressMB, md5_implCompressMB,            \
           md5_implCompressMB)                                          \
  do_stub(compiler, sha1_implCompress)                                  \
  do_entry(compiler, sha1_implCompress, sha1_implCompress,              \
           sha1_implCompress)                                           \
  do_stub(compiler, sha1_implCompressMB)                                \
  do_entry(compiler, sha1_implCompressMB, sha1_implCompressMB,          \
           sha1_implCompressMB)                                         \
  do_stub(compiler, sha256_implCompress)                                \
  do_entry(compiler, sha256_implCompress, sha256_implCompress,          \
           sha256_implCompress)                                         \
  do_stub(compiler, sha256_implCompressMB)                              \
  do_entry(compiler, sha256_implCompressMB, sha256_implCompressMB,      \
           sha256_implCompressMB)                                       \
  do_stub(compiler, sha512_implCompress)                                \
  do_entry(compiler, sha512_implCompress, sha512_implCompress,          \
           sha512_implCompress)                                         \
  do_stub(compiler, sha512_implCompressMB)                              \
  do_entry(compiler, sha512_implCompressMB, sha512_implCompressMB,      \
           sha512_implCompressMB)                                       \
  do_stub(compiler, sha3_implCompress)                                  \
  do_entry(compiler, sha3_implCompress, sha3_implCompress,              \
           sha3_implCompress)                                           \
  do_stub(compiler, double_keccak)                                      \
  do_entry(compiler, double_keccak, double_keccak, double_keccak)       \
  do_stub(compiler, sha3_implCompressMB)                                \
  do_entry(compiler, sha3_implCompressMB, sha3_implCompressMB,          \
           sha3_implCompressMB)                                         \
  do_stub(compiler, updateBytesAdler32)                                 \
  do_entry(compiler, updateBytesAdler32, updateBytesAdler32,            \
           updateBytesAdler32)                                          \
  do_stub(compiler, multiplyToLen)                                      \
  do_entry(compiler, multiplyToLen, multiplyToLen, multiplyToLen)       \
  do_stub(compiler, squareToLen)                                        \
  do_entry(compiler, squareToLen, squareToLen, squareToLen)             \
  do_stub(compiler, mulAdd)                                             \
  do_entry(compiler, mulAdd, mulAdd, mulAdd)                            \
  do_stub(compiler, montgomeryMultiply)                                 \
  do_entry(compiler, montgomeryMultiply, montgomeryMultiply,            \
           montgomeryMultiply)                                          \
  do_stub(compiler, montgomerySquare)                                   \
  do_entry(compiler, montgomerySquare, montgomerySquare,                \
           montgomerySquare)                                            \
  do_stub(compiler, bigIntegerRightShiftWorker)                         \
  do_entry(compiler, bigIntegerRightShiftWorker,                        \
           bigIntegerRightShiftWorker, bigIntegerRightShift)            \
  do_stub(compiler, bigIntegerLeftShiftWorker)                          \
  do_entry(compiler, bigIntegerLeftShiftWorker,                         \
           bigIntegerLeftShiftWorker, bigIntegerLeftShift)              \
  /* merge in stubs and entries declared in arch header */              \
  STUBGEN_COMPILER_BLOBS_ARCH_DO(do_stub,  do_arch_blob,                \
                                     do_arch_entry, do_arch_entry_init) \
  end_blob(compiler)                                                    \


#define STUBGEN_FINAL_BLOBS_DO(do_blob, end_blob,                       \
                               do_stub,                                 \
                               do_entry, do_entry_init,                 \
                               do_entry_array,                          \
                               do_arch_blob,                            \
                               do_arch_entry, do_arch_entry_init)       \
  do_blob(final)                                                        \
  do_stub(final, verify_oop)                                            \
  do_entry(final, verify_oop, verify_oop_subroutine_entry,              \
           verify_oop_subroutine_entry)                                 \
  do_stub(final, jbyte_arraycopy)                                       \
  do_entry_init(final, jbyte_arraycopy, jbyte_arraycopy,                \
                jbyte_arraycopy, StubRoutines::jbyte_copy)              \
  do_stub(final, jshort_arraycopy)                                      \
  do_entry_init(final, jshort_arraycopy, jshort_arraycopy,              \
                jshort_arraycopy, StubRoutines::jshort_copy)            \
  do_stub(final, jint_arraycopy)                                        \
  do_entry_init(final, jint_arraycopy, jint_arraycopy,                  \
                jint_arraycopy, StubRoutines::jint_copy)                \
  do_stub(final, jlong_arraycopy)                                       \
  do_entry_init(final, jlong_arraycopy, jlong_arraycopy,                \
                jlong_arraycopy, StubRoutines::jlong_copy)              \
  do_stub(final, oop_arraycopy)                                         \
  do_entry_init(final, oop_arraycopy, oop_arraycopy,                    \
                oop_arraycopy_entry, StubRoutines::oop_copy)            \
  do_stub(final, oop_arraycopy_uninit)                                  \
  do_entry_init(final, oop_arraycopy_uninit, oop_arraycopy_uninit,      \
                oop_arraycopy_uninit_entry,                             \
                StubRoutines::oop_copy_uninit)                          \
  do_stub(final, jbyte_disjoint_arraycopy)                              \
  do_entry_init(final, jbyte_disjoint_arraycopy,                        \
                jbyte_disjoint_arraycopy, jbyte_disjoint_arraycopy,     \
                StubRoutines::jbyte_copy)                               \
  do_stub(final, jshort_disjoint_arraycopy)                             \
  do_entry_init(final, jshort_disjoint_arraycopy,                       \
                jshort_disjoint_arraycopy, jshort_disjoint_arraycopy,   \
                StubRoutines::jshort_copy)                              \
  do_stub(final, jint_disjoint_arraycopy)                               \
  do_entry_init(final, jint_disjoint_arraycopy,                         \
                jint_disjoint_arraycopy, jint_disjoint_arraycopy,       \
                StubRoutines::jint_copy)                                \
  do_stub(final, jlong_disjoint_arraycopy)                              \
  do_entry_init(final, jlong_disjoint_arraycopy,                        \
                jlong_disjoint_arraycopy, jlong_disjoint_arraycopy,     \
                StubRoutines::jlong_copy)                               \
  do_stub(final, oop_disjoint_arraycopy)                                \
  do_entry_init(final, oop_disjoint_arraycopy, oop_disjoint_arraycopy,  \
                oop_disjoint_arraycopy_entry, StubRoutines::oop_copy)   \
  do_stub(final, oop_disjoint_arraycopy_uninit)                         \
  do_entry_init(final, oop_disjoint_arraycopy_uninit,                   \
                oop_disjoint_arraycopy_uninit,                          \
                oop_disjoint_arraycopy_uninit_entry,                    \
                StubRoutines::oop_copy_uninit)                          \
  do_stub(final, arrayof_jbyte_arraycopy)                               \
  do_entry_init(final, arrayof_jbyte_arraycopy,                         \
                arrayof_jbyte_arraycopy, arrayof_jbyte_arraycopy,       \
                StubRoutines::arrayof_jbyte_copy)                       \
  do_stub(final, arrayof_jshort_arraycopy)                              \
  do_entry_init(final, arrayof_jshort_arraycopy,                        \
                arrayof_jshort_arraycopy, arrayof_jshort_arraycopy,     \
                StubRoutines::arrayof_jshort_copy)                      \
  do_stub(final, arrayof_jint_arraycopy)                                \
  do_entry_init(final, arrayof_jint_arraycopy, arrayof_jint_arraycopy,  \
                arrayof_jint_arraycopy,                                 \
                StubRoutines::arrayof_jint_copy)                        \
  do_stub(final, arrayof_jlong_arraycopy)                               \
  do_entry_init(final, arrayof_jlong_arraycopy,                         \
                arrayof_jlong_arraycopy, arrayof_jlong_arraycopy,       \
                StubRoutines::arrayof_jlong_copy)                       \
  do_stub(final, arrayof_oop_arraycopy)                                 \
  do_entry_init(final, arrayof_oop_arraycopy, arrayof_oop_arraycopy,    \
                arrayof_oop_arraycopy, StubRoutines::arrayof_oop_copy)  \
  do_stub(final, arrayof_oop_arraycopy_uninit)                          \
  do_entry_init(final, arrayof_oop_arraycopy_uninit,                    \
                arrayof_oop_arraycopy_uninit,                           \
                arrayof_oop_arraycopy_uninit,                           \
                StubRoutines::arrayof_oop_copy_uninit)                  \
  do_stub(final, arrayof_jbyte_disjoint_arraycopy)                      \
  do_entry_init(final, arrayof_jbyte_disjoint_arraycopy,                \
                arrayof_jbyte_disjoint_arraycopy,                       \
                arrayof_jbyte_disjoint_arraycopy,                       \
                StubRoutines::arrayof_jbyte_copy)                       \
  do_stub(final, arrayof_jshort_disjoint_arraycopy)                     \
  do_entry_init(final, arrayof_jshort_disjoint_arraycopy,               \
                arrayof_jshort_disjoint_arraycopy,                      \
                arrayof_jshort_disjoint_arraycopy,                      \
                StubRoutines::arrayof_jshort_copy)                      \
  do_stub(final, arrayof_jint_disjoint_arraycopy)                       \
  do_entry_init(final, arrayof_jint_disjoint_arraycopy,                 \
                arrayof_jint_disjoint_arraycopy,                        \
                arrayof_jint_disjoint_arraycopy,                        \
                StubRoutines::arrayof_jint_copy)                        \
  do_stub(final, arrayof_jlong_disjoint_arraycopy)                      \
  do_entry_init(final, arrayof_jlong_disjoint_arraycopy,                \
                arrayof_jlong_disjoint_arraycopy,                       \
                arrayof_jlong_disjoint_arraycopy,                       \
                StubRoutines::arrayof_jlong_copy)                       \
  do_stub(final, arrayof_oop_disjoint_arraycopy)                        \
  do_entry_init(final, arrayof_oop_disjoint_arraycopy,                  \
                arrayof_oop_disjoint_arraycopy,                         \
                arrayof_oop_disjoint_arraycopy_entry,                   \
                StubRoutines::arrayof_oop_copy)                         \
  do_stub(final, arrayof_oop_disjoint_arraycopy_uninit)                 \
  do_entry_init(final, arrayof_oop_disjoint_arraycopy_uninit,           \
                arrayof_oop_disjoint_arraycopy_uninit,                  \
                arrayof_oop_disjoint_arraycopy_uninit_entry,            \
                StubRoutines::arrayof_oop_copy_uninit)                  \
  do_stub(final, checkcast_arraycopy)                                   \
  do_entry(final, checkcast_arraycopy, checkcast_arraycopy,             \
           checkcast_arraycopy_entry)                                   \
  do_stub(final, checkcast_arraycopy_uninit)                            \
  do_entry(final, checkcast_arraycopy_uninit,                           \
           checkcast_arraycopy_uninit,                                  \
           checkcast_arraycopy_uninit_entry)                            \
  do_stub(final, unsafe_arraycopy)                                      \
  do_entry(final, unsafe_arraycopy, unsafe_arraycopy, unsafe_arraycopy) \
  do_stub(final, generic_arraycopy)                                     \
  do_entry(final, generic_arraycopy, generic_arraycopy,                 \
           generic_arraycopy)                                           \
  do_stub(final, unsafe_setmemory)                                      \
  do_entry(final, unsafe_setmemory, unsafe_setmemory, unsafe_setmemory) \
  do_stub(final, jbyte_fill)                                            \
  do_entry(final, jbyte_fill, jbyte_fill, jbyte_fill)                   \
  do_stub(final, jshort_fill)                                           \
  do_entry(final, jshort_fill, jshort_fill, jshort_fill)                \
  do_stub(final, jint_fill)                                             \
  do_entry(final, jint_fill, jint_fill, jint_fill)                      \
  do_stub(final, arrayof_jbyte_fill)                                    \
  do_entry(final, arrayof_jbyte_fill, arrayof_jbyte_fill,               \
           arrayof_jbyte_fill)                                          \
  do_stub(final, arrayof_jshort_fill)                                   \
  do_entry(final, arrayof_jshort_fill, arrayof_jshort_fill,             \
           arrayof_jshort_fill)                                         \
  do_stub(final, arrayof_jint_fill)                                     \
  do_entry(final, arrayof_jint_fill, arrayof_jint_fill,                 \
           arrayof_jint_fill)                                           \
  do_stub(final, method_entry_barrier)                                  \
  do_entry(final, method_entry_barrier, method_entry_barrier,           \
           method_entry_barrier)                                        \
  do_stub(final, vectorizedMismatch) /* only used by x86! */            \
  do_entry(final, vectorizedMismatch, vectorizedMismatch,               \
           vectorizedMismatch)                                          \
  do_stub(final, upcall_stub_exception_handler)                         \
  do_entry(final, upcall_stub_exception_handler,                        \
           upcall_stub_exception_handler,                               \
           upcall_stub_exception_handler)                               \
  do_stub(final, upcall_stub_load_target)                               \
  do_entry(final, upcall_stub_load_target, upcall_stub_load_target,     \
           upcall_stub_load_target)                                     \
  do_stub(final, lookup_secondary_supers_table)                         \
  do_entry_array(final, lookup_secondary_supers_table,                  \
                 lookup_secondary_supers_table_stubs,                   \
                 lookup_secondary_supers_table_stub,                    \
                 Klass::SECONDARY_SUPERS_TABLE_SIZE)                    \
  do_stub(final, lookup_secondary_supers_table_slow_path)               \
  do_entry(final, lookup_secondary_supers_table_slow_path,              \
           lookup_secondary_supers_table_slow_path_stub,                \
           lookup_secondary_supers_table_slow_path_stub)                \
  /* merge in stubs and entries declared in arch header */              \
  STUBGEN_FINAL_BLOBS_ARCH_DO(do_stub,  do_arch_blob,                   \
                              do_arch_entry, do_arch_entry_init)        \
  end_blob(final)                                                       \


// Convenience macros for use by template implementations

#define STUB_ID_NAME(base) base##_id

// emit a runtime or stubgen stub field name

#define STUB_FIELD_NAME(base) _##base

// emit a runtime blob field name

#define BLOB_FIELD_NAME(base) _##base##_blob

// emit a stubgen blob field name

#define STUBGEN_BLOB_FIELD_NAME(base) _ ## base ## _stubs_code

// Convenience templates that emit nothing

// ignore do_blob(blob_name, type) declarations
#define DO_BLOB_EMPTY2(blob_name, type)

// ignore do_blob(blob_name) and end_blob(blob_name) declarations
#define DO_BLOB_EMPTY1(blob_name)

// ignore do_stub(name, fancy_jump, pass_tls, return_pc) declarations
#define DO_STUB_EMPTY4(name, fancy_jump, pass_tls, return_pc)

// ignore do_jvmti_stub(name) declarations
#define DO_JVMTI_STUB_EMPTY1(stub_name)

// ignore do_stub(blob_name, stub_name) declarations
#define DO_STUB_EMPTY2(blob_name, stub_name)

// ignore do_entry(blob_name, stub_name, fieldname, getter_name) declarations
#define DO_ENTRY_EMPTY4(blob_name, stub_name, fieldname, getter_name)

// ignore do_entry(blob_name, stub_name, fieldname, getter_name, init_function) and
// do_entry_array(blob_name, stub_name, fieldname, getter_name, count) declarations
#define DO_ENTRY_EMPTY5(blob_name, stub_name, fieldname, getter_name, init_function)

// ignore do_arch_blob(blob_name, size) declarations
#define DO_ARCH_BLOB_EMPTY2(arch, size)

// ignore do_arch_entry(arch, blob_name, stub_name, fieldname, getter_name) declarations
#define DO_ARCH_ENTRY_EMPTY5(arch, blob_name, stub_name, field_name, getter_name)

// ignore do_arch_entry(arch, blob_name, stub_name, fieldname, getter_name, init_function) declarations
#define DO_ARCH_ENTRY_EMPTY6(arch, blob_name, stub_name, field_name, getter_name, init_function)

// The whole shebang!
//
// client macro for emitting StubGenerator blobs, stubs and entries

#define STUBGEN_ALL_DO(do_blob, end_blob,                               \
                       do_stub,                                         \
                       do_entry, do_entry_init,                         \
                       do_entry_array,                                  \
                       do_arch_blob,                                    \
                       do_arch_entry, do_arch_entry_init)               \
  STUBGEN_INITIAL_BLOBS_DO(do_blob, end_blob,                           \
                           do_stub,                                     \
                           do_entry, do_entry_init,                     \
                           do_entry_array,                              \
                           do_arch_blob,                                \
                           do_arch_entry, do_arch_entry_init)           \
  STUBGEN_CONTINUATION_BLOBS_DO(do_blob, end_blob,                      \
                                do_stub,                                \
                                do_entry, do_entry_init,                \
                                do_entry_array,                         \
                                do_arch_blob,                           \
                                do_arch_entry, do_arch_entry_init)      \
  STUBGEN_COMPILER_BLOBS_DO(do_blob, end_blob,                          \
                            do_stub,                                    \
                            do_entry, do_entry_init,                    \
                            do_entry_array,                             \
                            do_arch_blob,                               \
                            do_arch_entry, do_arch_entry_init)          \
  STUBGEN_FINAL_BLOBS_DO(do_blob, end_blob,                             \
                         do_stub,                                       \
                         do_entry, do_entry_init,                       \
                         do_entry_array,                                \
                         do_arch_blob,                                  \
                         do_arch_entry, do_arch_entry_init)             \

// client macro to operate only on StubGenerator blobs

#define STUBGEN_BLOBS_DO(do_blob)                                       \
  STUBGEN_ALL_DO(do_blob, DO_BLOB_EMPTY1,                               \
                 DO_STUB_EMPTY2,                                        \
                 DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
                 DO_ENTRY_EMPTY5,                                       \
                 DO_ARCH_BLOB_EMPTY2,                                   \
                 DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \

// client macro to operate only on StubGenerator stubs

#define STUBGEN_STUBS_DO(do_stub)                                       \
  STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
                 do_stub,                                               \
                 DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
                 DO_ENTRY_EMPTY5,                                       \
                 DO_ARCH_BLOB_EMPTY2,                                   \
                 DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \

// client macro to operate only on StubGenerator blobs and stubs

#define STUBGEN_BLOBS_STUBS_DO(do_blob, end_blob, do_stub)              \
  STUBGEN_ALL_DO(do_blob, end_blob,                                     \
                 do_stub,                                               \
                 DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
                 DO_ENTRY_EMPTY5,                                       \
                 DO_ARCH_BLOB_EMPTY2,                                   \
                 DO_ARCH_ENTRY_EMPTY5,DO_ARCH_ENTRY_EMPTY6)             \

// client macro to operate only on StubGenerator entries

#define STUBGEN_ENTRIES_DO(do_entry, do_entry_init, do_entry_array)     \
  STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
                 DO_STUB_EMPTY2,                                        \
                 do_entry, do_entry_init,                               \
                 do_entry_array,                                        \
                 DO_ARCH_BLOB_EMPTY2,                                   \
                 DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \

// client macro to operate only on StubGenerator arch blobs

#define STUBGEN_ARCH_BLOBS_DO(do_arch_blob)                             \
  STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
                 DO_STUB_EMPTY2,                                        \
                 DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
                 DO_ENTRY_EMPTY5,                                       \
                 do_arch_blob,                                          \
                 DO_ARCH_ENTRY_EMPTY5, DO_ARCH_ENTRY_EMPTY6)            \

// client macro to operate only on StubGenerator arch entries

#define STUBGEN_ARCH_ENTRIES_DO(do_arch_entry, do_arch_entry_init)      \
  STUBGEN_ALL_DO(DO_BLOB_EMPTY1, DO_BLOB_EMPTY1,                        \
                 DO_STUB_EMPTY2,                                        \
                 DO_ENTRY_EMPTY4, DO_ENTRY_EMPTY5,                      \
                 DO_ENTRY_EMPTY5,                                       \
                 DO_ARCH_BLOB_EMPTY2,                                   \
                 do_arch_entry, do_arch_entry_init)                     \

#endif // SHARE_RUNTIME_STUBDECLARATIONS_HPP