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