codeBlob.hpp revision 9111:a41fe5ffa839
1/* 2 * Copyright (c) 1998, 2015, 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_VM_CODE_CODEBLOB_HPP 26#define SHARE_VM_CODE_CODEBLOB_HPP 27 28#include "asm/codeBuffer.hpp" 29#include "compiler/oopMap.hpp" 30#include "runtime/frame.hpp" 31#include "runtime/handles.hpp" 32 33// CodeBlob Types 34// Used in the CodeCache to assign CodeBlobs to different CodeHeaps 35struct CodeBlobType { 36 enum { 37 MethodNonProfiled = 0, // Execution level 1 and 4 (non-profiled) nmethods (including native nmethods) 38 MethodProfiled = 1, // Execution level 2 and 3 (profiled) nmethods 39 NonNMethod = 2, // Non-nmethods like Buffers, Adapters and Runtime Stubs 40 All = 3, // All types (No code cache segmentation) 41 Pregenerated = 4, // Special blobs, managed by CodeCacheExtensions 42 NumTypes = 5 // Number of CodeBlobTypes 43 }; 44}; 45 46// CodeBlob - superclass for all entries in the CodeCache. 47// 48// Suptypes are: 49// nmethod : Compiled Java methods (include method that calls to native code) 50// RuntimeStub : Call to VM runtime methods 51// DeoptimizationBlob : Used for deoptimizatation 52// ExceptionBlob : Used for stack unrolling 53// SafepointBlob : Used to handle illegal instruction exceptions 54// 55// 56// Layout: 57// - header 58// - relocation 59// - content space 60// - instruction space 61// - data space 62class DeoptimizationBlob; 63 64class CodeBlob VALUE_OBJ_CLASS_SPEC { 65 66 friend class VMStructs; 67 friend class CodeCacheDumper; 68 69 private: 70 const char* _name; 71 int _size; // total size of CodeBlob in bytes 72 int _header_size; // size of header (depends on subclass) 73 int _relocation_size; // size of relocation 74 int _content_offset; // offset to where content region begins (this includes consts, insts, stubs) 75 int _code_offset; // offset to where instructions region begins (this includes insts, stubs) 76 int _frame_complete_offset; // instruction offsets in [0.._frame_complete_offset) have 77 // not finished setting up their frame. Beware of pc's in 78 // that range. There is a similar range(s) on returns 79 // which we don't detect. 80 int _data_offset; // offset to where data region begins 81 int _frame_size; // size of stack frame 82 ImmutableOopMapSet* _oop_maps; // OopMap for this CodeBlob 83 CodeStrings _strings; 84 85 public: 86 // Returns the space needed for CodeBlob 87 static unsigned int allocation_size(CodeBuffer* cb, int header_size); 88 static unsigned int align_code_offset(int offset); 89 90 // Creation 91 // a) simple CodeBlob 92 // frame_complete is the offset from the beginning of the instructions 93 // to where the frame setup (from stackwalk viewpoint) is complete. 94 CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size); 95 96 // b) full CodeBlob 97 CodeBlob( 98 const char* name, 99 CodeBuffer* cb, 100 int header_size, 101 int size, 102 int frame_complete, 103 int frame_size, 104 OopMapSet* oop_maps 105 ); 106 107 // Deletion 108 void flush(); 109 110 // Typing 111 virtual bool is_buffer_blob() const { return false; } 112 virtual bool is_nmethod() const { return false; } 113 virtual bool is_runtime_stub() const { return false; } 114 virtual bool is_deoptimization_stub() const { return false; } 115 virtual bool is_uncommon_trap_stub() const { return false; } 116 virtual bool is_exception_stub() const { return false; } 117 virtual bool is_safepoint_stub() const { return false; } 118 virtual bool is_adapter_blob() const { return false; } 119 virtual bool is_method_handles_adapter_blob() const { return false; } 120 121 virtual bool is_compiled_by_c2() const { return false; } 122 virtual bool is_compiled_by_c1() const { return false; } 123 virtual bool is_compiled_by_jvmci() const { return false; } 124 125 // Casting 126 nmethod* as_nmethod_or_null() { return is_nmethod() ? (nmethod*) this : NULL; } 127 128 // Boundaries 129 address header_begin() const { return (address) this; } 130 address header_end() const { return ((address) this) + _header_size; }; 131 relocInfo* relocation_begin() const { return (relocInfo*) header_end(); }; 132 relocInfo* relocation_end() const { return (relocInfo*)(header_end() + _relocation_size); } 133 address content_begin() const { return (address) header_begin() + _content_offset; } 134 address content_end() const { return (address) header_begin() + _data_offset; } 135 address code_begin() const { return (address) header_begin() + _code_offset; } 136 address code_end() const { return (address) header_begin() + _data_offset; } 137 address data_begin() const { return (address) header_begin() + _data_offset; } 138 address data_end() const { return (address) header_begin() + _size; } 139 140 // Offsets 141 int relocation_offset() const { return _header_size; } 142 int content_offset() const { return _content_offset; } 143 int code_offset() const { return _code_offset; } 144 int data_offset() const { return _data_offset; } 145 146 // Sizes 147 int size() const { return _size; } 148 int header_size() const { return _header_size; } 149 int relocation_size() const { return (address) relocation_end() - (address) relocation_begin(); } 150 int content_size() const { return content_end() - content_begin(); } 151 int code_size() const { return code_end() - code_begin(); } 152 int data_size() const { return data_end() - data_begin(); } 153 154 // Containment 155 bool blob_contains(address addr) const { return header_begin() <= addr && addr < data_end(); } 156 bool relocation_contains(relocInfo* addr) const{ return relocation_begin() <= addr && addr < relocation_end(); } 157 bool content_contains(address addr) const { return content_begin() <= addr && addr < content_end(); } 158 bool code_contains(address addr) const { return code_begin() <= addr && addr < code_end(); } 159 bool data_contains(address addr) const { return data_begin() <= addr && addr < data_end(); } 160 bool contains(address addr) const { return content_contains(addr); } 161 bool is_frame_complete_at(address addr) const { return code_contains(addr) && 162 addr >= code_begin() + _frame_complete_offset; } 163 164 // CodeCache support: really only used by the nmethods, but in order to get 165 // asserts and certain bookkeeping to work in the CodeCache they are defined 166 // virtual here. 167 virtual bool is_zombie() const { return false; } 168 virtual bool is_locked_by_vm() const { return false; } 169 170 virtual bool is_unloaded() const { return false; } 171 virtual bool is_not_entrant() const { return false; } 172 173 // GC support 174 virtual bool is_alive() const = 0; 175 176 // OopMap for frame 177 ImmutableOopMapSet* oop_maps() const { return _oop_maps; } 178 void set_oop_maps(OopMapSet* p); 179 const ImmutableOopMap* oop_map_for_return_address(address return_address); 180 virtual void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { ShouldNotReachHere(); } 181 182 // Frame support 183 int frame_size() const { return _frame_size; } 184 void set_frame_size(int size) { _frame_size = size; } 185 186 // Returns true, if the next frame is responsible for GC'ing oops passed as arguments 187 virtual bool caller_must_gc_arguments(JavaThread* thread) const { return false; } 188 189 // Naming 190 const char* name() const { return _name; } 191 void set_name(const char* name) { _name = name; } 192 193 // Debugging 194 virtual void verify(); 195 void print() const { print_on(tty); } 196 virtual void print_on(outputStream* st) const; 197 virtual void print_value_on(outputStream* st) const; 198 199 // Deal with Disassembler, VTune, Forte, JvmtiExport, MemoryService. 200 static void trace_new_stub(CodeBlob* blob, const char* name1, const char* name2 = ""); 201 202 // Print the comment associated with offset on stream, if there is one 203 virtual void print_block_comment(outputStream* stream, address block_begin) const { 204 intptr_t offset = (intptr_t)(block_begin - code_begin()); 205 _strings.print_block_comment(stream, offset); 206 } 207 208 // Transfer ownership of comments to this CodeBlob 209 void set_strings(CodeStrings& strings) { 210 _strings.assign(strings); 211 } 212 213 static ByteSize name_field_offset() { 214 return byte_offset_of(CodeBlob, _name); 215 } 216 217 static ByteSize oop_maps_field_offset() { 218 return byte_offset_of(CodeBlob, _oop_maps); 219 } 220}; 221 222class WhiteBox; 223//---------------------------------------------------------------------------------------------------- 224// BufferBlob: used to hold non-relocatable machine code such as the interpreter, stubroutines, etc. 225 226class BufferBlob: public CodeBlob { 227 friend class VMStructs; 228 friend class AdapterBlob; 229 friend class MethodHandlesAdapterBlob; 230 friend class WhiteBox; 231 232 private: 233 // Creation support 234 BufferBlob(const char* name, int size); 235 BufferBlob(const char* name, int size, CodeBuffer* cb); 236 237 void* operator new(size_t s, unsigned size) throw(); 238 239 public: 240 // Creation 241 static BufferBlob* create(const char* name, int buffer_size); 242 static BufferBlob* create(const char* name, CodeBuffer* cb); 243 244 static void free(BufferBlob* buf); 245 246 // Typing 247 virtual bool is_buffer_blob() const { return true; } 248 249 // GC/Verification support 250 void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { /* nothing to do */ } 251 bool is_alive() const { return true; } 252 253 void verify(); 254 void print_on(outputStream* st) const; 255 void print_value_on(outputStream* st) const; 256}; 257 258 259//---------------------------------------------------------------------------------------------------- 260// AdapterBlob: used to hold C2I/I2C adapters 261 262class AdapterBlob: public BufferBlob { 263private: 264 AdapterBlob(int size, CodeBuffer* cb); 265 266public: 267 // Creation 268 static AdapterBlob* create(CodeBuffer* cb); 269 270 // Typing 271 virtual bool is_adapter_blob() const { return true; } 272}; 273 274 275//---------------------------------------------------------------------------------------------------- 276// MethodHandlesAdapterBlob: used to hold MethodHandles adapters 277 278class MethodHandlesAdapterBlob: public BufferBlob { 279private: 280 MethodHandlesAdapterBlob(int size) : BufferBlob("MethodHandles adapters", size) {} 281 282public: 283 // Creation 284 static MethodHandlesAdapterBlob* create(int buffer_size); 285 286 // Typing 287 virtual bool is_method_handles_adapter_blob() const { return true; } 288}; 289 290 291//---------------------------------------------------------------------------------------------------- 292// RuntimeStub: describes stubs used by compiled code to call a (static) C++ runtime routine 293 294class RuntimeStub: public CodeBlob { 295 friend class VMStructs; 296 private: 297 bool _caller_must_gc_arguments; 298 299 // Creation support 300 RuntimeStub( 301 const char* name, 302 CodeBuffer* cb, 303 int size, 304 int frame_complete, 305 int frame_size, 306 OopMapSet* oop_maps, 307 bool caller_must_gc_arguments 308 ); 309 310 void* operator new(size_t s, unsigned size) throw(); 311 312 public: 313 // Creation 314 static RuntimeStub* new_runtime_stub( 315 const char* stub_name, 316 CodeBuffer* cb, 317 int frame_complete, 318 int frame_size, 319 OopMapSet* oop_maps, 320 bool caller_must_gc_arguments 321 ); 322 323 // Typing 324 bool is_runtime_stub() const { return true; } 325 326 // GC support 327 bool caller_must_gc_arguments(JavaThread* thread) const { return _caller_must_gc_arguments; } 328 329 address entry_point() { return code_begin(); } 330 331 // GC/Verification support 332 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { /* nothing to do */ } 333 bool is_alive() const { return true; } 334 335 void verify(); 336 void print_on(outputStream* st) const; 337 void print_value_on(outputStream* st) const; 338}; 339 340 341//---------------------------------------------------------------------------------------------------- 342// Super-class for all blobs that exist in only one instance. Implements default behaviour. 343 344class SingletonBlob: public CodeBlob { 345 friend class VMStructs; 346 347 protected: 348 void* operator new(size_t s, unsigned size) throw(); 349 350 public: 351 SingletonBlob( 352 const char* name, 353 CodeBuffer* cb, 354 int header_size, 355 int size, 356 int frame_size, 357 OopMapSet* oop_maps 358 ) 359 : CodeBlob(name, cb, header_size, size, CodeOffsets::frame_never_safe, frame_size, oop_maps) 360 {}; 361 362 address entry_point() { return code_begin(); } 363 364 bool is_alive() const { return true; } 365 366 void verify(); // does nothing 367 void print_on(outputStream* st) const; 368 void print_value_on(outputStream* st) const; 369}; 370 371 372//---------------------------------------------------------------------------------------------------- 373// DeoptimizationBlob 374 375class DeoptimizationBlob: public SingletonBlob { 376 friend class VMStructs; 377 private: 378 int _unpack_offset; 379 int _unpack_with_exception; 380 int _unpack_with_reexecution; 381 382 int _unpack_with_exception_in_tls; 383 384#if INCLUDE_JVMCI 385 // Offsets when JVMCI calls uncommon_trap. 386 int _uncommon_trap_offset; 387 int _implicit_exception_uncommon_trap_offset; 388#endif 389 390 // Creation support 391 DeoptimizationBlob( 392 CodeBuffer* cb, 393 int size, 394 OopMapSet* oop_maps, 395 int unpack_offset, 396 int unpack_with_exception_offset, 397 int unpack_with_reexecution_offset, 398 int frame_size 399 ); 400 401 public: 402 // Creation 403 static DeoptimizationBlob* create( 404 CodeBuffer* cb, 405 OopMapSet* oop_maps, 406 int unpack_offset, 407 int unpack_with_exception_offset, 408 int unpack_with_reexecution_offset, 409 int frame_size 410 ); 411 412 // Typing 413 bool is_deoptimization_stub() const { return true; } 414 bool exception_address_is_unpack_entry(address pc) const { 415 address unpack_pc = unpack(); 416 return (pc == unpack_pc || (pc + frame::pc_return_offset) == unpack_pc); 417 } 418 419 // GC for args 420 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { /* Nothing to do */ } 421 422 // Printing 423 void print_value_on(outputStream* st) const; 424 425 address unpack() const { return code_begin() + _unpack_offset; } 426 address unpack_with_exception() const { return code_begin() + _unpack_with_exception; } 427 address unpack_with_reexecution() const { return code_begin() + _unpack_with_reexecution; } 428 429 // Alternate entry point for C1 where the exception and issuing pc 430 // are in JavaThread::_exception_oop and JavaThread::_exception_pc 431 // instead of being in registers. This is needed because C1 doesn't 432 // model exception paths in a way that keeps these registers free so 433 // there may be live values in those registers during deopt. 434 void set_unpack_with_exception_in_tls_offset(int offset) { 435 _unpack_with_exception_in_tls = offset; 436 assert(code_contains(code_begin() + _unpack_with_exception_in_tls), "must be PC inside codeblob"); 437 } 438 address unpack_with_exception_in_tls() const { return code_begin() + _unpack_with_exception_in_tls; } 439 440#if INCLUDE_JVMCI 441 // Offsets when JVMCI calls uncommon_trap. 442 void set_uncommon_trap_offset(int offset) { 443 _uncommon_trap_offset = offset; 444 assert(contains(code_begin() + _uncommon_trap_offset), "must be PC inside codeblob"); 445 } 446 address uncommon_trap() const { return code_begin() + _uncommon_trap_offset; } 447 448 void set_implicit_exception_uncommon_trap_offset(int offset) { 449 _implicit_exception_uncommon_trap_offset = offset; 450 assert(contains(code_begin() + _implicit_exception_uncommon_trap_offset), "must be PC inside codeblob"); 451 } 452 address implicit_exception_uncommon_trap() const { return code_begin() + _implicit_exception_uncommon_trap_offset; } 453#endif // INCLUDE_JVMCI 454}; 455 456 457//---------------------------------------------------------------------------------------------------- 458// UncommonTrapBlob (currently only used by Compiler 2) 459 460#ifdef COMPILER2 461 462class UncommonTrapBlob: public SingletonBlob { 463 friend class VMStructs; 464 private: 465 // Creation support 466 UncommonTrapBlob( 467 CodeBuffer* cb, 468 int size, 469 OopMapSet* oop_maps, 470 int frame_size 471 ); 472 473 public: 474 // Creation 475 static UncommonTrapBlob* create( 476 CodeBuffer* cb, 477 OopMapSet* oop_maps, 478 int frame_size 479 ); 480 481 // GC for args 482 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { /* nothing to do */ } 483 484 // Typing 485 bool is_uncommon_trap_stub() const { return true; } 486}; 487 488 489//---------------------------------------------------------------------------------------------------- 490// ExceptionBlob: used for exception unwinding in compiled code (currently only used by Compiler 2) 491 492class ExceptionBlob: public SingletonBlob { 493 friend class VMStructs; 494 private: 495 // Creation support 496 ExceptionBlob( 497 CodeBuffer* cb, 498 int size, 499 OopMapSet* oop_maps, 500 int frame_size 501 ); 502 503 public: 504 // Creation 505 static ExceptionBlob* create( 506 CodeBuffer* cb, 507 OopMapSet* oop_maps, 508 int frame_size 509 ); 510 511 // GC for args 512 void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { /* nothing to do */ } 513 514 // Typing 515 bool is_exception_stub() const { return true; } 516}; 517#endif // COMPILER2 518 519 520//---------------------------------------------------------------------------------------------------- 521// SafepointBlob: handles illegal_instruction exceptions during a safepoint 522 523class SafepointBlob: public SingletonBlob { 524 friend class VMStructs; 525 private: 526 // Creation support 527 SafepointBlob( 528 CodeBuffer* cb, 529 int size, 530 OopMapSet* oop_maps, 531 int frame_size 532 ); 533 534 public: 535 // Creation 536 static SafepointBlob* create( 537 CodeBuffer* cb, 538 OopMapSet* oop_maps, 539 int frame_size 540 ); 541 542 // GC for args 543 void preserve_callee_argument_oops(frame fr, const RegisterMap* reg_map, OopClosure* f) { /* nothing to do */ } 544 545 // Typing 546 bool is_safepoint_stub() const { return true; } 547}; 548 549#endif // SHARE_VM_CODE_CODEBLOB_HPP 550