1 /* 2 * Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #ifndef SHARE_CODE_CODEBLOB_HPP 26 #define SHARE_CODE_CODEBLOB_HPP 27 28 #include "asm/codeBuffer.hpp" 29 #include "compiler/compilerDefinitions.hpp" 30 #include "compiler/oopMap.hpp" 31 #include "runtime/javaFrameAnchor.hpp" 32 #include "runtime/frame.hpp" 33 #include "runtime/handles.hpp" 34 #include "utilities/align.hpp" 35 #include "utilities/macros.hpp" 36 37 class ImmutableOopMap; 38 class ImmutableOopMapSet; 39 class JNIHandleBlock; 40 class OopMapSet; 41 42 // CodeBlob Types 43 // Used in the CodeCache to assign CodeBlobs to different CodeHeaps 44 enum class CodeBlobType { 45 MethodNonProfiled = 0, // Execution level 1 and 4 (non-profiled) nmethods (including native nmethods) 46 MethodProfiled = 1, // Execution level 2 and 3 (profiled) nmethods 47 NonNMethod = 2, // Non-nmethods like Buffers, Adapters and Runtime Stubs 48 All = 3, // All types (No code cache segmentation) 49 NumTypes = 4 // Number of CodeBlobTypes 50 }; 51 52 // CodeBlob - superclass for all entries in the CodeCache. 53 // 54 // Subtypes are: 55 // nmethod : JIT Compiled Java methods 56 // RuntimeBlob : Non-compiled method code; generated glue code 57 // BufferBlob : Used for non-relocatable code such as interpreter, stubroutines, etc. 58 // AdapterBlob : Used to hold C2I/I2C adapters 59 // VtableBlob : Used for holding vtable chunks 60 // MethodHandlesAdapterBlob : Used to hold MethodHandles adapters 61 // RuntimeStub : Call to VM runtime methods 62 // SingletonBlob : Super-class for all blobs that exist in only one instance 63 // DeoptimizationBlob : Used for deoptimization 64 // SafepointBlob : Used to handle illegal instruction exceptions 65 // ExceptionBlob : Used for stack unrolling 66 // UncommonTrapBlob : Used to handle uncommon traps 67 // UpcallStub : Used for upcalls from native code 68 // 69 // 70 // Layout in the CodeCache: 71 // - header 72 // - content space 73 // - instruction space 74 // Outside of the CodeCache: 75 // - mutable_data 76 // - relocation info 77 // - additional data for subclasses 78 79 enum class CodeBlobKind : u1 { 80 None, 81 Nmethod, 82 Buffer, 83 Adapter, 84 Vtable, 85 MHAdapter, 86 RuntimeStub, 87 Deoptimization, 88 Safepoint, 89 #ifdef COMPILER2 90 Exception, 91 UncommonTrap, 92 #endif 93 Upcall, 94 Number_Of_Kinds 95 }; 96 97 class UpcallStub; // for as_upcall_stub() 98 class RuntimeStub; // for as_runtime_stub() 99 class JavaFrameAnchor; // for UpcallStub::jfa_for_frame 100 class AdapterBlob; 101 class ExceptionBlob; 102 class DeoptimizationBlob; 103 class SafepointBlob; 104 class UncommonTrapBlob; 105 106 class CodeBlob { 107 friend class VMStructs; 108 friend class JVMCIVMStructs; 109 110 private: 111 void restore_mutable_data(address reloc_data); 112 113 protected: 114 // order fields from large to small to minimize padding between fields 115 ImmutableOopMapSet* _oop_maps; // OopMap for this CodeBlob 116 const char* _name; 117 address _mutable_data; 118 119 int _size; // total size of CodeBlob in bytes 120 int _relocation_size; // size of relocation (could be bigger than 64Kb) 121 int _content_offset; // offset to where content region begins (this includes consts, insts, stubs) 122 int _code_offset; // offset to where instructions region begins (this includes insts, stubs) 123 int _data_offset; // offset to where data region begins 124 int _frame_size; // size of stack frame in words (NOT slots. On x64 these are 64bit words) 125 int _mutable_data_size; 126 127 S390_ONLY(int _ctable_offset;) 128 129 uint16_t _header_size; // size of header (depends on subclass) 130 int16_t _frame_complete_offset; // instruction offsets in [0.._frame_complete_offset) have 131 // not finished setting up their frame. Beware of pc's in 132 // that range. There is a similar range(s) on returns 133 // which we don't detect. 134 135 CodeBlobKind _kind; // Kind of this code blob 136 137 bool _caller_must_gc_arguments; 138 139 #ifndef PRODUCT 140 AsmRemarks _asm_remarks; 141 DbgStrings _dbg_strings; 142 #endif 143 144 void print_on_impl(outputStream* st) const; 145 void print_value_on_impl(outputStream* st) const; 146 147 class Vptr { 148 public: 149 virtual void print_on(const CodeBlob* instance, outputStream* st) const = 0; 150 virtual void print_value_on(const CodeBlob* instance, outputStream* st) const = 0; 151 virtual void prepare_for_archiving(CodeBlob* instance) const { 152 instance->prepare_for_archiving_impl(); 153 }; 154 virtual void post_restore(CodeBlob* instance) const { 155 instance->post_restore_impl(); 156 }; 157 }; 158 159 static const Vptr* vptr(CodeBlobKind kind); 160 const Vptr* vptr() const; 161 162 CodeBlob(const char* name, CodeBlobKind kind, CodeBuffer* cb, int size, uint16_t header_size, 163 int16_t frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments, 164 int mutable_data_size); 165 166 // Simple CodeBlob used for simple BufferBlob. 167 CodeBlob(const char* name, CodeBlobKind kind, int size, uint16_t header_size); 168 169 170 void operator delete(void* p) { } 171 172 void prepare_for_archiving_impl(); 173 void post_restore_impl(); 174 175 public: 176 177 ~CodeBlob() { 178 assert(_oop_maps == nullptr, "Not flushed"); 179 } 180 181 // Returns the space needed for CodeBlob 182 static unsigned int allocation_size(CodeBuffer* cb, int header_size); 183 static unsigned int align_code_offset(int offset); 184 185 // Deletion 186 void purge(); 187 188 // Typing 189 bool is_nmethod() const { return _kind == CodeBlobKind::Nmethod; } 190 bool is_buffer_blob() const { return _kind == CodeBlobKind::Buffer; } 191 bool is_runtime_stub() const { return _kind == CodeBlobKind::RuntimeStub; } 192 bool is_deoptimization_stub() const { return _kind == CodeBlobKind::Deoptimization; } 193 #ifdef COMPILER2 194 bool is_uncommon_trap_stub() const { return _kind == CodeBlobKind::UncommonTrap; } 195 bool is_exception_stub() const { return _kind == CodeBlobKind::Exception; } 196 #else 197 bool is_uncommon_trap_stub() const { return false; } 198 bool is_exception_stub() const { return false; } 199 #endif 200 bool is_safepoint_stub() const { return _kind == CodeBlobKind::Safepoint; } 201 bool is_adapter_blob() const { return _kind == CodeBlobKind::Adapter; } 202 bool is_vtable_blob() const { return _kind == CodeBlobKind::Vtable; } 203 bool is_method_handles_adapter_blob() const { return _kind == CodeBlobKind::MHAdapter; } 204 bool is_upcall_stub() const { return _kind == CodeBlobKind::Upcall; } 205 206 // Casting 207 nmethod* as_nmethod_or_null() const { return is_nmethod() ? (nmethod*) this : nullptr; } 208 nmethod* as_nmethod() const { assert(is_nmethod(), "must be nmethod"); return (nmethod*) this; } 209 CodeBlob* as_codeblob() const { return (CodeBlob*) this; } 210 AdapterBlob* as_adapter_blob() const { assert(is_adapter_blob(), "must be adapter blob"); return (AdapterBlob*) this; } 211 ExceptionBlob* as_exception_blob() const { assert(is_exception_stub(), "must be exception stub"); return (ExceptionBlob*) this; } 212 DeoptimizationBlob* as_deoptimization_blob() const { assert(is_deoptimization_stub(), "must be deopt stub"); return (DeoptimizationBlob*) this; } 213 SafepointBlob* as_safepoint_blob() const { assert(is_safepoint_stub(), "must be safepoint stub"); return (SafepointBlob*) this; } 214 UpcallStub* as_upcall_stub() const { assert(is_upcall_stub(), "must be upcall stub"); return (UpcallStub*) this; } 215 RuntimeStub* as_runtime_stub() const { assert(is_runtime_stub(), "must be runtime blob"); return (RuntimeStub*) this; } 216 UncommonTrapBlob* as_uncommon_trap_blob() const { assert(is_uncommon_trap_stub(), "must be uncommon trap stub"); return (UncommonTrapBlob*) this; } 217 218 // Boundaries 219 address header_begin() const { return (address) this; } 220 address header_end() const { return ((address) this) + _header_size; } 221 address content_begin() const { return (address) header_begin() + _content_offset; } 222 address content_end() const { return (address) header_begin() + _data_offset; } 223 address code_begin() const { return (address) header_begin() + _code_offset; } 224 address code_end() const { return (address) header_begin() + _data_offset; } 225 address data_begin() const { return (address) header_begin() + _data_offset; } 226 address data_end() const { return (address) header_begin() + _size; } 227 address blob_end() const { return (address) header_begin() + _size; } 228 // code_end == content_end is true for all types of blobs for now, it is also checked in the constructor 229 230 int mutable_data_size() const { return _mutable_data_size; } 231 address mutable_data_begin() const { return _mutable_data; } 232 address mutable_data_end() const { return _mutable_data + _mutable_data_size; } 233 234 relocInfo* relocation_begin() const { return (relocInfo*)_mutable_data; } 235 relocInfo* relocation_end() const { return (relocInfo*)((address)relocation_begin() + _relocation_size); } 236 237 // Offsets 238 int content_offset() const { return _content_offset; } 239 int code_offset() const { return _code_offset; } 240 241 // This field holds the beginning of the const section in the old code buffer. 242 // It is needed to fix relocations of pc-relative loads when resizing the 243 // the constant pool or moving it. 244 S390_ONLY(address ctable_begin() const { return header_begin() + _ctable_offset; }) 245 void set_ctable_begin(address ctable) { S390_ONLY(_ctable_offset = ctable - header_begin();) } 246 247 // Sizes 248 int size() const { return _size; } 249 int header_size() const { return _header_size; } 250 int relocation_size() const { return pointer_delta_as_int((address) relocation_end(), (address) relocation_begin()); } 251 int content_size() const { return pointer_delta_as_int(content_end(), content_begin()); } 252 int code_size() const { return pointer_delta_as_int(code_end(), code_begin()); } 253 254 // Only used from CodeCache::free_unused_tail() after the Interpreter blob was trimmed 255 void adjust_size(size_t used) { 256 _size = (int)used; 257 _data_offset = _size; 258 } 259 260 // Containment 261 bool blob_contains(address addr) const { return header_begin() <= addr && addr < blob_end(); } 262 bool code_contains(address addr) const { return code_begin() <= addr && addr < code_end(); } 263 bool contains(address addr) const { return content_begin() <= addr && addr < content_end(); } 264 bool is_frame_complete_at(address addr) const { return _frame_complete_offset != CodeOffsets::frame_never_safe && 265 code_contains(addr) && addr >= code_begin() + _frame_complete_offset; } 266 int frame_complete_offset() const { return _frame_complete_offset; } 267 268 // OopMap for frame 269 ImmutableOopMapSet* oop_maps() const { return _oop_maps; } 270 void set_oop_maps(OopMapSet* p); 271 void set_oop_maps(ImmutableOopMapSet* p) { _oop_maps = p; } 272 273 const ImmutableOopMap* oop_map_for_slot(int slot, address return_address) const; 274 const ImmutableOopMap* oop_map_for_return_address(address return_address) const; 275 276 // Frame support. Sizes are in word units. 277 int frame_size() const { return _frame_size; } 278 void set_frame_size(int size) { _frame_size = size; } 279 280 // Returns true, if the next frame is responsible for GC'ing oops passed as arguments 281 bool caller_must_gc_arguments(JavaThread* thread) const { return _caller_must_gc_arguments; } 282 283 // Naming 284 const char* name() const { return _name; } 285 void set_name(const char* name) { _name = name; } 286 287 // Debugging 288 void verify(); 289 void print() const; 290 void print_on(outputStream* st) const; 291 void print_value_on(outputStream* st) const; 292 293 void dump_for_addr(address addr, outputStream* st, bool verbose) const; 294 void print_code_on(outputStream* st); 295 296 // Print to stream, any comments associated with offset. 297 void print_block_comment(outputStream* stream, address block_begin) const; 298 299 #ifndef PRODUCT 300 AsmRemarks &asm_remarks() { return _asm_remarks; } 301 DbgStrings &dbg_strings() { return _dbg_strings; } 302 303 void use_remarks(AsmRemarks &remarks) { _asm_remarks.share(remarks); } 304 void use_strings(DbgStrings &strings) { _dbg_strings.share(strings); } 305 #endif 306 307 void copy_to(address buffer) { 308 memcpy(buffer, this, this->size()); 309 } 310 311 // methods to archive a blob into AOT code cache 312 void prepare_for_archiving(); 313 static void archive_blob(CodeBlob* blob, address archive_buffer); 314 315 // methods to restore a blob from AOT code cache into the CodeCache 316 void post_restore(); 317 CodeBlob* restore(address code_cache_buffer, const char* name, address archived_reloc_data, ImmutableOopMapSet* archived_oop_maps); 318 static CodeBlob* create(CodeBlob* archived_blob, 319 const char* name, 320 address archived_reloc_data, 321 ImmutableOopMapSet* archived_oop_maps 322 #ifndef PRODUCT 323 , AsmRemarks& archived_asm_remarks 324 , DbgStrings& archived_dbg_strings 325 #endif // PRODUCT 326 ); 327 }; 328 329 //---------------------------------------------------------------------------------------------------- 330 // RuntimeBlob: used for non-compiled method code (adapters, stubs, blobs) 331 332 class RuntimeBlob : public CodeBlob { 333 friend class VMStructs; 334 public: 335 336 // Creation 337 // a) simple CodeBlob 338 RuntimeBlob(const char* name, CodeBlobKind kind, int size, uint16_t header_size) 339 : CodeBlob(name, kind, size, header_size) 340 {} 341 342 // b) full CodeBlob 343 // frame_complete is the offset from the beginning of the instructions 344 // to where the frame setup (from stackwalk viewpoint) is complete. 345 RuntimeBlob( 346 const char* name, 347 CodeBlobKind kind, 348 CodeBuffer* cb, 349 int size, 350 uint16_t header_size, 351 int16_t frame_complete, 352 int frame_size, 353 OopMapSet* oop_maps, 354 bool caller_must_gc_arguments = false 355 ); 356 357 static void free(RuntimeBlob* blob); 358 359 // Deal with Disassembler, VTune, Forte, JvmtiExport, MemoryService. 360 static void trace_new_stub(RuntimeBlob* blob, const char* name1, const char* name2 = ""); 361 362 class Vptr : public CodeBlob::Vptr { 363 }; 364 }; 365 366 class WhiteBox; 367 //---------------------------------------------------------------------------------------------------- 368 // BufferBlob: used to hold non-relocatable machine code such as the interpreter, stubroutines, etc. 369 370 class BufferBlob: public RuntimeBlob { 371 friend class VMStructs; 372 friend class AdapterBlob; 373 friend class VtableBlob; 374 friend class MethodHandlesAdapterBlob; 375 friend class UpcallStub; 376 friend class WhiteBox; 377 378 private: 379 // Creation support 380 BufferBlob(const char* name, CodeBlobKind kind, int size); 381 BufferBlob(const char* name, CodeBlobKind kind, CodeBuffer* cb, int size); 382 383 void* operator new(size_t s, unsigned size) throw(); 384 385 public: 386 // Creation 387 static BufferBlob* create(const char* name, uint buffer_size); 388 static BufferBlob* create(const char* name, CodeBuffer* cb); 389 390 static void free(BufferBlob* buf); 391 392 void print_on_impl(outputStream* st) const; 393 void print_value_on_impl(outputStream* st) const; 394 395 class Vptr : public RuntimeBlob::Vptr { 396 void print_on(const CodeBlob* instance, outputStream* st) const override { 397 ((const BufferBlob*)instance)->print_on_impl(st); 398 } 399 void print_value_on(const CodeBlob* instance, outputStream* st) const override { 400 ((const BufferBlob*)instance)->print_value_on_impl(st); 401 } 402 }; 403 404 static const Vptr _vpntr; 405 }; 406 407 408 //---------------------------------------------------------------------------------------------------- 409 // AdapterBlob: used to hold C2I/I2C adapters 410 411 class AdapterBlob: public BufferBlob { 412 private: 413 AdapterBlob(int size, CodeBuffer* cb); 414 415 public: 416 // Creation 417 static AdapterBlob* create(CodeBuffer* cb); 418 }; 419 420 //--------------------------------------------------------------------------------------------------- 421 class VtableBlob: public BufferBlob { 422 private: 423 VtableBlob(const char*, int); 424 425 void* operator new(size_t s, unsigned size) throw(); 426 427 public: 428 // Creation 429 static VtableBlob* create(const char* name, int buffer_size); 430 }; 431 432 //---------------------------------------------------------------------------------------------------- 433 // MethodHandlesAdapterBlob: used to hold MethodHandles adapters 434 435 class MethodHandlesAdapterBlob: public BufferBlob { 436 private: 437 MethodHandlesAdapterBlob(int size): BufferBlob("MethodHandles adapters", CodeBlobKind::MHAdapter, size) {} 438 439 public: 440 // Creation 441 static MethodHandlesAdapterBlob* create(int buffer_size); 442 }; 443 444 445 //---------------------------------------------------------------------------------------------------- 446 // RuntimeStub: describes stubs used by compiled code to call a (static) C++ runtime routine 447 448 class RuntimeStub: public RuntimeBlob { 449 friend class VMStructs; 450 private: 451 // Creation support 452 RuntimeStub( 453 const char* name, 454 CodeBuffer* cb, 455 int size, 456 int16_t frame_complete, 457 int frame_size, 458 OopMapSet* oop_maps, 459 bool caller_must_gc_arguments 460 ); 461 462 void* operator new(size_t s, unsigned size) throw(); 463 464 public: 465 // Creation 466 static RuntimeStub* new_runtime_stub( 467 const char* stub_name, 468 CodeBuffer* cb, 469 int16_t frame_complete, 470 int frame_size, 471 OopMapSet* oop_maps, 472 bool caller_must_gc_arguments, 473 bool alloc_fail_is_fatal=true 474 ); 475 476 static void free(RuntimeStub* stub) { RuntimeBlob::free(stub); } 477 478 address entry_point() const { return code_begin(); } 479 480 void print_on_impl(outputStream* st) const; 481 void print_value_on_impl(outputStream* st) const; 482 483 class Vptr : public RuntimeBlob::Vptr { 484 void print_on(const CodeBlob* instance, outputStream* st) const override { 485 instance->as_runtime_stub()->print_on_impl(st); 486 } 487 void print_value_on(const CodeBlob* instance, outputStream* st) const override { 488 instance->as_runtime_stub()->print_value_on_impl(st); 489 } 490 }; 491 492 static const Vptr _vpntr; 493 }; 494 495 496 //---------------------------------------------------------------------------------------------------- 497 // Super-class for all blobs that exist in only one instance. Implements default behaviour. 498 499 class SingletonBlob: public RuntimeBlob { 500 friend class VMStructs; 501 502 protected: 503 void* operator new(size_t s, unsigned size, bool alloc_fail_is_fatal=true) throw(); 504 505 public: 506 SingletonBlob( 507 const char* name, 508 CodeBlobKind kind, 509 CodeBuffer* cb, 510 int size, 511 uint16_t header_size, 512 int frame_size, 513 OopMapSet* oop_maps 514 ) 515 : RuntimeBlob(name, kind, cb, size, header_size, CodeOffsets::frame_never_safe, frame_size, oop_maps) 516 {}; 517 518 address entry_point() { return code_begin(); } 519 520 void print_on_impl(outputStream* st) const; 521 void print_value_on_impl(outputStream* st) const; 522 523 class Vptr : public RuntimeBlob::Vptr { 524 void print_on(const CodeBlob* instance, outputStream* st) const override { 525 ((const SingletonBlob*)instance)->print_on_impl(st); 526 } 527 void print_value_on(const CodeBlob* instance, outputStream* st) const override { 528 ((const SingletonBlob*)instance)->print_value_on_impl(st); 529 } 530 }; 531 532 static const Vptr _vpntr; 533 }; 534 535 536 //---------------------------------------------------------------------------------------------------- 537 // DeoptimizationBlob 538 539 class DeoptimizationBlob: public SingletonBlob { 540 friend class VMStructs; 541 friend class JVMCIVMStructs; 542 private: 543 int _unpack_offset; 544 int _unpack_with_exception; 545 int _unpack_with_reexecution; 546 547 int _unpack_with_exception_in_tls; 548 549 #if INCLUDE_JVMCI 550 // Offsets when JVMCI calls uncommon_trap. 551 int _uncommon_trap_offset; 552 int _implicit_exception_uncommon_trap_offset; 553 #endif 554 555 // Creation support 556 DeoptimizationBlob( 557 CodeBuffer* cb, 558 int size, 559 OopMapSet* oop_maps, 560 int unpack_offset, 561 int unpack_with_exception_offset, 562 int unpack_with_reexecution_offset, 563 int frame_size 564 ); 565 566 public: 567 // Creation 568 static DeoptimizationBlob* create( 569 CodeBuffer* cb, 570 OopMapSet* oop_maps, 571 int unpack_offset, 572 int unpack_with_exception_offset, 573 int unpack_with_reexecution_offset, 574 int frame_size 575 ); 576 577 address unpack() const { return code_begin() + _unpack_offset; } 578 address unpack_with_exception() const { return code_begin() + _unpack_with_exception; } 579 address unpack_with_reexecution() const { return code_begin() + _unpack_with_reexecution; } 580 581 // Alternate entry point for C1 where the exception and issuing pc 582 // are in JavaThread::_exception_oop and JavaThread::_exception_pc 583 // instead of being in registers. This is needed because C1 doesn't 584 // model exception paths in a way that keeps these registers free so 585 // there may be live values in those registers during deopt. 586 void set_unpack_with_exception_in_tls_offset(int offset) { 587 _unpack_with_exception_in_tls = offset; 588 assert(code_contains(code_begin() + _unpack_with_exception_in_tls), "must be PC inside codeblob"); 589 } 590 address unpack_with_exception_in_tls() const { return code_begin() + _unpack_with_exception_in_tls; } 591 592 #if INCLUDE_JVMCI 593 // Offsets when JVMCI calls uncommon_trap. 594 void set_uncommon_trap_offset(int offset) { 595 _uncommon_trap_offset = offset; 596 assert(contains(code_begin() + _uncommon_trap_offset), "must be PC inside codeblob"); 597 } 598 address uncommon_trap() const { return code_begin() + _uncommon_trap_offset; } 599 600 void set_implicit_exception_uncommon_trap_offset(int offset) { 601 _implicit_exception_uncommon_trap_offset = offset; 602 assert(contains(code_begin() + _implicit_exception_uncommon_trap_offset), "must be PC inside codeblob"); 603 } 604 address implicit_exception_uncommon_trap() const { return code_begin() + _implicit_exception_uncommon_trap_offset; } 605 #endif // INCLUDE_JVMCI 606 607 void print_value_on_impl(outputStream* st) const; 608 609 class Vptr : public SingletonBlob::Vptr { 610 void print_value_on(const CodeBlob* instance, outputStream* st) const override { 611 ((const DeoptimizationBlob*)instance)->print_value_on_impl(st); 612 } 613 }; 614 615 static const Vptr _vpntr; 616 }; 617 618 619 //---------------------------------------------------------------------------------------------------- 620 // UncommonTrapBlob (currently only used by Compiler 2) 621 622 #ifdef COMPILER2 623 624 class UncommonTrapBlob: public SingletonBlob { 625 friend class VMStructs; 626 private: 627 // Creation support 628 UncommonTrapBlob( 629 CodeBuffer* cb, 630 int size, 631 OopMapSet* oop_maps, 632 int frame_size 633 ); 634 635 public: 636 // Creation 637 static UncommonTrapBlob* create( 638 CodeBuffer* cb, 639 OopMapSet* oop_maps, 640 int frame_size 641 ); 642 }; 643 644 645 //---------------------------------------------------------------------------------------------------- 646 // ExceptionBlob: used for exception unwinding in compiled code (currently only used by Compiler 2) 647 648 class ExceptionBlob: public SingletonBlob { 649 friend class VMStructs; 650 private: 651 // Creation support 652 ExceptionBlob( 653 CodeBuffer* cb, 654 int size, 655 OopMapSet* oop_maps, 656 int frame_size 657 ); 658 659 public: 660 // Creation 661 static ExceptionBlob* create( 662 CodeBuffer* cb, 663 OopMapSet* oop_maps, 664 int frame_size 665 ); 666 667 void post_restore_impl() { 668 trace_new_stub(this, "ExceptionBlob"); 669 } 670 671 class Vptr : public SingletonBlob::Vptr { 672 void post_restore(CodeBlob* instance) const override { 673 ((ExceptionBlob*)instance)->post_restore_impl(); 674 } 675 }; 676 677 static const Vptr _vpntr; 678 }; 679 #endif // COMPILER2 680 681 682 //---------------------------------------------------------------------------------------------------- 683 // SafepointBlob: handles illegal_instruction exceptions during a safepoint 684 685 class SafepointBlob: public SingletonBlob { 686 friend class VMStructs; 687 private: 688 // Creation support 689 SafepointBlob( 690 CodeBuffer* cb, 691 int size, 692 OopMapSet* oop_maps, 693 int frame_size 694 ); 695 696 public: 697 // Creation 698 static SafepointBlob* create( 699 CodeBuffer* cb, 700 OopMapSet* oop_maps, 701 int frame_size 702 ); 703 }; 704 705 //---------------------------------------------------------------------------------------------------- 706 707 class UpcallLinker; 708 709 // A (Panama) upcall stub. Not used by JNI. 710 class UpcallStub: public RuntimeBlob { 711 friend class VMStructs; 712 friend class UpcallLinker; 713 private: 714 jobject _receiver; 715 ByteSize _frame_data_offset; 716 717 UpcallStub(const char* name, CodeBuffer* cb, int size, jobject receiver, ByteSize frame_data_offset); 718 719 void* operator new(size_t s, unsigned size) throw(); 720 721 struct FrameData { 722 JavaFrameAnchor jfa; 723 JavaThread* thread; 724 JNIHandleBlock* old_handles; 725 JNIHandleBlock* new_handles; 726 }; 727 728 // defined in frame_ARCH.cpp 729 FrameData* frame_data_for_frame(const frame& frame) const; 730 public: 731 // Creation 732 static UpcallStub* create(const char* name, CodeBuffer* cb, jobject receiver, ByteSize frame_data_offset); 733 734 static void free(UpcallStub* blob); 735 736 jobject receiver() { return _receiver; } 737 738 JavaFrameAnchor* jfa_for_frame(const frame& frame) const; 739 740 // GC support 741 void oops_do(OopClosure* f, const frame& frame); 742 743 void print_on_impl(outputStream* st) const; 744 void print_value_on_impl(outputStream* st) const; 745 746 class Vptr : public RuntimeBlob::Vptr { 747 void print_on(const CodeBlob* instance, outputStream* st) const override { 748 instance->as_upcall_stub()->print_on_impl(st); 749 } 750 void print_value_on(const CodeBlob* instance, outputStream* st) const override { 751 instance->as_upcall_stub()->print_value_on_impl(st); 752 } 753 }; 754 755 static const Vptr _vpntr; 756 }; 757 758 #endif // SHARE_CODE_CODEBLOB_HPP