1 /* 2 * Copyright (c) 2015, 2023, 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_COMPILEDMETHOD_HPP 26 #define SHARE_CODE_COMPILEDMETHOD_HPP 27 28 #include "code/codeBlob.hpp" 29 #include "code/pcDesc.hpp" 30 #include "oops/metadata.hpp" 31 #include "oops/method.hpp" 32 33 class Dependencies; 34 class ExceptionHandlerTable; 35 class ImplicitExceptionTable; 36 class AbstractCompiler; 37 class xmlStream; 38 class CompiledStaticCall; 39 class NativeCallWrapper; 40 class ScopeDesc; 41 class CompiledIC; 42 class MetadataClosure; 43 44 // This class is used internally by nmethods, to cache 45 // exception/pc/handler information. 46 47 class ExceptionCache : public CHeapObj<mtCode> { 48 friend class VMStructs; 49 private: 50 enum { cache_size = 16 }; 51 Klass* _exception_type; 52 address _pc[cache_size]; 53 address _handler[cache_size]; 54 volatile int _count; 55 ExceptionCache* volatile _next; 56 ExceptionCache* _purge_list_next; 57 58 inline address pc_at(int index); 59 void set_pc_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _pc[index] = a; } 60 61 inline address handler_at(int index); 62 void set_handler_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _handler[index] = a; } 63 64 inline int count(); 65 // increment_count is only called under lock, but there may be concurrent readers. 66 void increment_count(); 67 68 public: 69 70 ExceptionCache(Handle exception, address pc, address handler); 71 72 Klass* exception_type() { return _exception_type; } 73 ExceptionCache* next(); 74 void set_next(ExceptionCache *ec); 75 ExceptionCache* purge_list_next() { return _purge_list_next; } 76 void set_purge_list_next(ExceptionCache *ec) { _purge_list_next = ec; } 77 78 address match(Handle exception, address pc); 79 bool match_exception_with_space(Handle exception) ; 80 address test_address(address addr); 81 bool add_address_and_handler(address addr, address handler) ; 82 }; 83 84 class nmethod; 85 86 // cache pc descs found in earlier inquiries 87 class PcDescCache { 88 friend class VMStructs; 89 private: 90 enum { cache_size = 4 }; 91 // The array elements MUST be volatile! Several threads may modify 92 // and read from the cache concurrently. find_pc_desc_internal has 93 // returned wrong results. C++ compiler (namely xlC12) may duplicate 94 // C++ field accesses if the elements are not volatile. 95 typedef PcDesc* PcDescPtr; 96 volatile PcDescPtr _pc_descs[cache_size]; // last cache_size pc_descs found 97 public: 98 PcDescCache() { debug_only(_pc_descs[0] = nullptr); } 99 void reset_to(PcDesc* initial_pc_desc); 100 PcDesc* find_pc_desc(int pc_offset, bool approximate); 101 void add_pc_desc(PcDesc* pc_desc); 102 PcDesc* last_pc_desc() { return _pc_descs[0]; } 103 }; 104 105 class PcDescSearch { 106 private: 107 address _code_begin; 108 PcDesc* _lower; 109 PcDesc* _upper; 110 public: 111 PcDescSearch(address code, PcDesc* lower, PcDesc* upper) : 112 _code_begin(code), _lower(lower), _upper(upper) 113 { 114 } 115 116 address code_begin() const { return _code_begin; } 117 PcDesc* scopes_pcs_begin() const { return _lower; } 118 PcDesc* scopes_pcs_end() const { return _upper; } 119 }; 120 121 class PcDescContainer { 122 private: 123 PcDescCache _pc_desc_cache; 124 public: 125 PcDescContainer() {} 126 127 PcDesc* find_pc_desc_internal(address pc, bool approximate, const PcDescSearch& search); 128 void reset_to(PcDesc* initial_pc_desc) { _pc_desc_cache.reset_to(initial_pc_desc); } 129 130 PcDesc* find_pc_desc(address pc, bool approximate, const PcDescSearch& search) { 131 address base_address = search.code_begin(); 132 PcDesc* desc = _pc_desc_cache.last_pc_desc(); 133 if (desc != nullptr && desc->pc_offset() == pc - base_address) { 134 return desc; 135 } 136 return find_pc_desc_internal(pc, approximate, search); 137 } 138 }; 139 140 141 class CompiledMethod : public CodeBlob { 142 friend class VMStructs; 143 friend class DeoptimizationScope; 144 void init_defaults(); 145 protected: 146 enum DeoptimizationStatus : u1 { 147 not_marked, 148 deoptimize, 149 deoptimize_noupdate, 150 deoptimize_done 151 }; 152 153 volatile DeoptimizationStatus _deoptimization_status; // Used for stack deoptimization 154 // Used to track in which deoptimize handshake this method will be deoptimized. 155 uint64_t _deoptimization_generation; 156 157 // set during construction 158 unsigned int _has_unsafe_access:1; // May fault due to unsafe access. 159 unsigned int _has_method_handle_invokes:1; // Has this method MethodHandle invokes? 160 unsigned int _has_wide_vectors:1; // Preserve wide vectors at safepoints 161 unsigned int _has_monitors:1; // Fastpath monitor detection for continuations 162 163 Method* _method; 164 address _scopes_data_begin; 165 // All deoptee's will resume execution at this location described by 166 // this address. 167 address _deopt_handler_begin; 168 // All deoptee's at a MethodHandle call site will resume execution 169 // at this location described by this offset. 170 address _deopt_mh_handler_begin; 171 172 PcDescContainer _pc_desc_container; 173 ExceptionCache * volatile _exception_cache; 174 175 void* _gc_data; 176 177 virtual void purge(bool free_code_cache_data = true) = 0; 178 179 private: 180 DeoptimizationStatus deoptimization_status() const { 181 return Atomic::load(&_deoptimization_status); 182 } 183 184 protected: 185 CompiledMethod(Method* method, const char* name, CompilerType type, const CodeBlobLayout& layout, int frame_complete_offset, int frame_size, ImmutableOopMapSet* oop_maps, bool caller_must_gc_arguments, bool compiled); 186 CompiledMethod(Method* method, const char* name, CompilerType type, int size, int header_size, CodeBuffer* cb, int frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments, bool compiled); 187 188 public: 189 // Only used by unit test. 190 CompiledMethod() {} 191 192 template<typename T> 193 T* gc_data() const { return reinterpret_cast<T*>(_gc_data); } 194 template<typename T> 195 void set_gc_data(T* gc_data) { _gc_data = reinterpret_cast<void*>(gc_data); } 196 197 bool has_unsafe_access() const { return _has_unsafe_access; } 198 void set_has_unsafe_access(bool z) { _has_unsafe_access = z; } 199 200 bool has_monitors() const { return _has_monitors; } 201 void set_has_monitors(bool z) { _has_monitors = z; } 202 203 bool has_method_handle_invokes() const { return _has_method_handle_invokes; } 204 void set_has_method_handle_invokes(bool z) { _has_method_handle_invokes = z; } 205 206 bool has_wide_vectors() const { return _has_wide_vectors; } 207 void set_has_wide_vectors(bool z) { _has_wide_vectors = z; } 208 209 enum : signed char { not_installed = -1, // in construction, only the owner doing the construction is 210 // allowed to advance state 211 in_use = 0, // executable nmethod 212 not_used = 1, // not entrant, but revivable 213 not_entrant = 2, // marked for deoptimization but activations may still exist 214 }; 215 216 virtual bool is_in_use() const = 0; 217 virtual int comp_level() const = 0; 218 virtual int compile_id() const = 0; 219 220 virtual address verified_entry_point() const = 0; 221 virtual void log_identity(xmlStream* log) const = 0; 222 virtual void log_state_change() const = 0; 223 virtual bool make_not_used() = 0; 224 virtual bool make_not_entrant() = 0; 225 virtual bool make_entrant() = 0; 226 virtual address entry_point() const = 0; 227 virtual bool is_osr_method() const = 0; 228 virtual int osr_entry_bci() const = 0; 229 Method* method() const { return _method; } 230 virtual void print_pcs() = 0; 231 bool is_native_method() const { return _method != nullptr && _method->is_native(); } 232 bool is_java_method() const { return _method != nullptr && !_method->is_native(); } 233 234 // ScopeDesc retrieval operation 235 PcDesc* pc_desc_at(address pc) { return find_pc_desc(pc, false); } 236 // pc_desc_near returns the first PcDesc at or after the given pc. 237 PcDesc* pc_desc_near(address pc) { return find_pc_desc(pc, true); } 238 239 // ScopeDesc for an instruction 240 ScopeDesc* scope_desc_at(address pc); 241 ScopeDesc* scope_desc_near(address pc); 242 243 bool is_at_poll_return(address pc); 244 bool is_at_poll_or_poll_return(address pc); 245 246 bool is_marked_for_deoptimization() const { return deoptimization_status() != not_marked; } 247 bool has_been_deoptimized() const { return deoptimization_status() == deoptimize_done; } 248 void set_deoptimized_done(); 249 250 virtual void make_deoptimized() { assert(false, "not supported"); }; 251 252 bool update_recompile_counts() const { 253 // Update recompile counts when either the update is explicitly requested (deoptimize) 254 // or the nmethod is not marked for deoptimization at all (not_marked). 255 // The latter happens during uncommon traps when deoptimized nmethod is made not entrant. 256 DeoptimizationStatus status = deoptimization_status(); 257 return status != deoptimize_noupdate && status != deoptimize_done; 258 } 259 260 // tells whether frames described by this nmethod can be deoptimized 261 // note: native wrappers cannot be deoptimized. 262 bool can_be_deoptimized() const { return is_java_method(); } 263 264 virtual oop oop_at(int index) const = 0; 265 virtual Metadata* metadata_at(int index) const = 0; 266 267 address scopes_data_begin() const { return _scopes_data_begin; } 268 virtual address scopes_data_end() const = 0; 269 int scopes_data_size() const { return int(scopes_data_end() - scopes_data_begin()); } 270 271 virtual PcDesc* scopes_pcs_begin() const = 0; 272 virtual PcDesc* scopes_pcs_end() const = 0; 273 int scopes_pcs_size() const { return int((intptr_t) scopes_pcs_end() - (intptr_t) scopes_pcs_begin()); } 274 275 address insts_begin() const { return code_begin(); } 276 address insts_end() const { return stub_begin(); } 277 // Returns true if a given address is in the 'insts' section. The method 278 // insts_contains_inclusive() is end-inclusive. 279 bool insts_contains(address addr) const { return insts_begin() <= addr && addr < insts_end(); } 280 bool insts_contains_inclusive(address addr) const { return insts_begin() <= addr && addr <= insts_end(); } 281 282 int insts_size() const { return int(insts_end() - insts_begin()); } 283 284 virtual address consts_begin() const = 0; 285 virtual address consts_end() const = 0; 286 bool consts_contains(address addr) const { return consts_begin() <= addr && addr < consts_end(); } 287 int consts_size() const { return int(consts_end() - consts_begin()); } 288 289 virtual int skipped_instructions_size() const = 0; 290 291 virtual address stub_begin() const = 0; 292 virtual address stub_end() const = 0; 293 bool stub_contains(address addr) const { return stub_begin() <= addr && addr < stub_end(); } 294 int stub_size() const { return int(stub_end() - stub_begin()); } 295 296 virtual address handler_table_begin() const = 0; 297 virtual address handler_table_end() const = 0; 298 bool handler_table_contains(address addr) const { return handler_table_begin() <= addr && addr < handler_table_end(); } 299 int handler_table_size() const { return int(handler_table_end() - handler_table_begin()); } 300 301 virtual address exception_begin() const = 0; 302 303 virtual address nul_chk_table_begin() const = 0; 304 virtual address nul_chk_table_end() const = 0; 305 bool nul_chk_table_contains(address addr) const { return nul_chk_table_begin() <= addr && addr < nul_chk_table_end(); } 306 int nul_chk_table_size() const { return int(nul_chk_table_end() - nul_chk_table_begin()); } 307 308 virtual oop* oop_addr_at(int index) const = 0; 309 virtual Metadata** metadata_addr_at(int index) const = 0; 310 311 protected: 312 // Exception cache support 313 // Note: _exception_cache may be read and cleaned concurrently. 314 ExceptionCache* exception_cache() const { return _exception_cache; } 315 ExceptionCache* exception_cache_acquire() const; 316 void set_exception_cache(ExceptionCache *ec) { _exception_cache = ec; } 317 318 public: 319 address handler_for_exception_and_pc(Handle exception, address pc); 320 void add_handler_for_exception_and_pc(Handle exception, address pc, address handler); 321 void clean_exception_cache(); 322 323 void add_exception_cache_entry(ExceptionCache* new_entry); 324 ExceptionCache* exception_cache_entry_for_exception(Handle exception); 325 326 // MethodHandle 327 bool is_method_handle_return(address return_pc); 328 address deopt_mh_handler_begin() const { return _deopt_mh_handler_begin; } 329 330 address deopt_handler_begin() const { return _deopt_handler_begin; } 331 address* deopt_handler_begin_addr() { return &_deopt_handler_begin; } 332 // Deopt 333 // Return true is the PC is one would expect if the frame is being deopted. 334 inline bool is_deopt_pc(address pc); 335 inline bool is_deopt_mh_entry(address pc); 336 inline bool is_deopt_entry(address pc); 337 338 // Accessor/mutator for the original pc of a frame before a frame was deopted. 339 address get_original_pc(const frame* fr) { return *orig_pc_addr(fr); } 340 void set_original_pc(const frame* fr, address pc) { *orig_pc_addr(fr) = pc; } 341 342 virtual int orig_pc_offset() = 0; 343 344 private: 345 address* orig_pc_addr(const frame* fr); 346 347 public: 348 virtual const char* compile_kind() const = 0; 349 virtual int get_state() const = 0; 350 351 const char* state() const; 352 353 bool inlinecache_check_contains(address addr) const { 354 return (addr >= code_begin() && addr < verified_entry_point()); 355 } 356 357 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f); 358 359 // implicit exceptions support 360 address continuation_for_implicit_div0_exception(address pc) { return continuation_for_implicit_exception(pc, true); } 361 address continuation_for_implicit_null_exception(address pc) { return continuation_for_implicit_exception(pc, false); } 362 363 static address get_deopt_original_pc(const frame* fr); 364 365 // Inline cache support for class unloading and nmethod unloading 366 private: 367 bool cleanup_inline_caches_impl(bool unloading_occurred, bool clean_all); 368 369 address continuation_for_implicit_exception(address pc, bool for_div0_check); 370 371 public: 372 // Serial version used by whitebox test 373 void cleanup_inline_caches_whitebox(); 374 375 virtual void clear_inline_caches(); 376 void clear_ic_callsites(); 377 378 // Execute nmethod barrier code, as if entering through nmethod call. 379 void run_nmethod_entry_barrier(); 380 381 // Verify and count cached icholder relocations. 382 int verify_icholder_relocations(); 383 void verify_oop_relocations(); 384 385 bool has_evol_metadata(); 386 387 // Fast breakpoint support. Tells if this compiled method is 388 // dependent on the given method. Returns true if this nmethod 389 // corresponds to the given method as well. 390 virtual bool is_dependent_on_method(Method* dependee) = 0; 391 392 virtual NativeCallWrapper* call_wrapper_at(address call) const = 0; 393 virtual NativeCallWrapper* call_wrapper_before(address return_pc) const = 0; 394 virtual address call_instruction_address(address pc) const = 0; 395 396 virtual CompiledStaticCall* compiledStaticCall_at(Relocation* call_site) const = 0; 397 virtual CompiledStaticCall* compiledStaticCall_at(address addr) const = 0; 398 virtual CompiledStaticCall* compiledStaticCall_before(address addr) const = 0; 399 400 Method* attached_method(address call_pc); 401 Method* attached_method_before_pc(address pc); 402 403 virtual void metadata_do(MetadataClosure* f) = 0; 404 405 // GC support 406 protected: 407 address oops_reloc_begin() const; 408 409 private: 410 bool static clean_ic_if_metadata_is_dead(CompiledIC *ic); 411 412 public: 413 // GC unloading support 414 // Cleans unloaded klasses and unloaded nmethods in inline caches 415 416 virtual bool is_unloading() = 0; 417 418 bool unload_nmethod_caches(bool class_unloading_occurred); 419 virtual void do_unloading(bool unloading_occurred) = 0; 420 421 private: 422 PcDesc* find_pc_desc(address pc, bool approximate) { 423 return _pc_desc_container.find_pc_desc(pc, approximate, PcDescSearch(code_begin(), scopes_pcs_begin(), scopes_pcs_end())); 424 } 425 }; 426 427 #endif // SHARE_CODE_COMPILEDMETHOD_HPP