truffle: src/share/vm/code/nmethod.hpp annotate

annotate src/share/vm/code/nmethod.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	aff6ccb506cb
children	b12a2a9b05ca

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12080 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1538 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1538 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1538 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	25 #ifndef SHARE_VM_CODE_NMETHOD_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	26 #define SHARE_VM_CODE_NMETHOD_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	28 #include "code/codeBlob.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	29 #include "code/pcDesc.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	30 #include "oops/metadata.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	31
0 a61af66fc99e Initial load duke parents: diff changeset	32 // This class is used internally by nmethods, to cache
a61af66fc99e Initial load duke parents: diff changeset	33 // exception/pc/handler information.
a61af66fc99e Initial load duke parents: diff changeset	34
6197 d2a62e0f25eb 6995781: Native Memory Tracking (Phase 1) zgu parents: 5986 diff changeset	35 class ExceptionCache : public CHeapObj<mtCode> {
0 a61af66fc99e Initial load duke parents: diff changeset	36 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	37 private:
a61af66fc99e Initial load duke parents: diff changeset	38 enum { cache_size = 16 };
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	39 Klass* _exception_type;
0 a61af66fc99e Initial load duke parents: diff changeset	40 address _pc[cache_size];
a61af66fc99e Initial load duke parents: diff changeset	41 address _handler[cache_size];
a61af66fc99e Initial load duke parents: diff changeset	42 int _count;
a61af66fc99e Initial load duke parents: diff changeset	43 ExceptionCache* _next;
a61af66fc99e Initial load duke parents: diff changeset	44
a61af66fc99e Initial load duke parents: diff changeset	45 address pc_at(int index) { assert(index >= 0 && index < count(),""); return _pc[index]; }
a61af66fc99e Initial load duke parents: diff changeset	46 void set_pc_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _pc[index] = a; }
a61af66fc99e Initial load duke parents: diff changeset	47 address handler_at(int index) { assert(index >= 0 && index < count(),""); return _handler[index]; }
a61af66fc99e Initial load duke parents: diff changeset	48 void set_handler_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _handler[index] = a; }
a61af66fc99e Initial load duke parents: diff changeset	49 int count() { return _count; }
a61af66fc99e Initial load duke parents: diff changeset	50 void increment_count() { _count++; }
a61af66fc99e Initial load duke parents: diff changeset	51
a61af66fc99e Initial load duke parents: diff changeset	52 public:
a61af66fc99e Initial load duke parents: diff changeset	53
a61af66fc99e Initial load duke parents: diff changeset	54 ExceptionCache(Handle exception, address pc, address handler);
a61af66fc99e Initial load duke parents: diff changeset	55
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	56 Klass* exception_type() { return _exception_type; }
0 a61af66fc99e Initial load duke parents: diff changeset	57 ExceptionCache* next() { return _next; }
a61af66fc99e Initial load duke parents: diff changeset	58 void set_next(ExceptionCache *ec) { _next = ec; }
a61af66fc99e Initial load duke parents: diff changeset	59
a61af66fc99e Initial load duke parents: diff changeset	60 address match(Handle exception, address pc);
a61af66fc99e Initial load duke parents: diff changeset	61 bool match_exception_with_space(Handle exception) ;
a61af66fc99e Initial load duke parents: diff changeset	62 address test_address(address addr);
a61af66fc99e Initial load duke parents: diff changeset	63 bool add_address_and_handler(address addr, address handler) ;
a61af66fc99e Initial load duke parents: diff changeset	64 };
a61af66fc99e Initial load duke parents: diff changeset	65
a61af66fc99e Initial load duke parents: diff changeset	66
a61af66fc99e Initial load duke parents: diff changeset	67 // cache pc descs found in earlier inquiries
a61af66fc99e Initial load duke parents: diff changeset	68 class PcDescCache VALUE_OBJ_CLASS_SPEC {
a61af66fc99e Initial load duke parents: diff changeset	69 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	70 private:
a61af66fc99e Initial load duke parents: diff changeset	71 enum { cache_size = 4 };
20227 63e0c47ca943 8050972: Concurrency problem in PcDesc cache mdoerr parents: 17780 diff changeset	72 // The array elements MUST be volatile! Several threads may modify
63e0c47ca943 8050972: Concurrency problem in PcDesc cache mdoerr parents: 17780 diff changeset	73 // and read from the cache concurrently. find_pc_desc_internal has
63e0c47ca943 8050972: Concurrency problem in PcDesc cache mdoerr parents: 17780 diff changeset	74 // returned wrong results. C++ compiler (namely xlC12) may duplicate
63e0c47ca943 8050972: Concurrency problem in PcDesc cache mdoerr parents: 17780 diff changeset	75 // C++ field accesses if the elements are not volatile.
63e0c47ca943 8050972: Concurrency problem in PcDesc cache mdoerr parents: 17780 diff changeset	76 typedef PcDesc* PcDescPtr;
63e0c47ca943 8050972: Concurrency problem in PcDesc cache mdoerr parents: 17780 diff changeset	77 volatile PcDescPtr _pc_descs[cache_size]; // last cache_size pc_descs found
0 a61af66fc99e Initial load duke parents: diff changeset	78 public:
2339 3d5a546351ef 7023931: PcDescCache::find_pc_desc should not write _last_pc_desc phh parents: 2321 diff changeset	79 PcDescCache() { debug_only(_pc_descs[0] = NULL); }
0 a61af66fc99e Initial load duke parents: diff changeset	80 void reset_to(PcDesc* initial_pc_desc);
a61af66fc99e Initial load duke parents: diff changeset	81 PcDesc* find_pc_desc(int pc_offset, bool approximate);
a61af66fc99e Initial load duke parents: diff changeset	82 void add_pc_desc(PcDesc* pc_desc);
2339 3d5a546351ef 7023931: PcDescCache::find_pc_desc should not write _last_pc_desc phh parents: 2321 diff changeset	83 PcDesc* last_pc_desc() { return _pc_descs[0]; }
0 a61af66fc99e Initial load duke parents: diff changeset	84 };
a61af66fc99e Initial load duke parents: diff changeset	85
a61af66fc99e Initial load duke parents: diff changeset	86
a61af66fc99e Initial load duke parents: diff changeset	87 // nmethods (native methods) are the compiled code versions of Java methods.
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	88 //
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	89 // An nmethod contains:
0 a61af66fc99e Initial load duke parents: diff changeset	90 // - header (the nmethod structure)
a61af66fc99e Initial load duke parents: diff changeset	91 // [Relocation]
a61af66fc99e Initial load duke parents: diff changeset	92 // - relocation information
a61af66fc99e Initial load duke parents: diff changeset	93 // - constant part (doubles, longs and floats used in nmethod)
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	94 // - oop table
0 a61af66fc99e Initial load duke parents: diff changeset	95 // [Code]
a61af66fc99e Initial load duke parents: diff changeset	96 // - code body
a61af66fc99e Initial load duke parents: diff changeset	97 // - exception handler
a61af66fc99e Initial load duke parents: diff changeset	98 // - stub code
a61af66fc99e Initial load duke parents: diff changeset	99 // [Debugging information]
a61af66fc99e Initial load duke parents: diff changeset	100 // - oop array
a61af66fc99e Initial load duke parents: diff changeset	101 // - data array
a61af66fc99e Initial load duke parents: diff changeset	102 // - pcs
a61af66fc99e Initial load duke parents: diff changeset	103 // [Exception handler table]
a61af66fc99e Initial load duke parents: diff changeset	104 // - handler entry point array
a61af66fc99e Initial load duke parents: diff changeset	105 // [Implicit Null Pointer exception table]
a61af66fc99e Initial load duke parents: diff changeset	106 // - implicit null table array
a61af66fc99e Initial load duke parents: diff changeset	107
a61af66fc99e Initial load duke parents: diff changeset	108 class Dependencies;
a61af66fc99e Initial load duke parents: diff changeset	109 class ExceptionHandlerTable;
a61af66fc99e Initial load duke parents: diff changeset	110 class ImplicitExceptionTable;
a61af66fc99e Initial load duke parents: diff changeset	111 class AbstractCompiler;
a61af66fc99e Initial load duke parents: diff changeset	112 class xmlStream;
a61af66fc99e Initial load duke parents: diff changeset	113
a61af66fc99e Initial load duke parents: diff changeset	114 class nmethod : public CodeBlob {
a61af66fc99e Initial load duke parents: diff changeset	115 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	116 friend class NMethodSweeper;
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	117 friend class CodeCache; // scavengable oops
0 a61af66fc99e Initial load duke parents: diff changeset	118 private:
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	119
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	120 // GC support to help figure out if an nmethod has been
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	121 // cleaned/unloaded by the current GC.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	122 static unsigned char _global_unloading_clock;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	123
0 a61af66fc99e Initial load duke parents: diff changeset	124 // Shared fields for all nmethod's
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	125 Method* _method;
0 a61af66fc99e Initial load duke parents: diff changeset	126 int _entry_bci; // != InvocationEntryBci if this nmethod is an on-stack replacement method
1616 38e8278318ca 6656830: assert((p)->is_oop(),"expected an oop while scanning weak refs") never* parents: 1579 diff changeset	127 jmethodID _jmethod_id; // Cache of method()->jmethod_id()
0 a61af66fc99e Initial load duke parents: diff changeset	128
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	129 // To support simple linked-list chaining of nmethods:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	130 nmethod* _osr_link; // from InstanceKlass::osr_nmethods_head
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	131
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	132 union {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	133 // Used by G1 to chain nmethods.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	134 nmethod* _unloading_next;
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	135 // Used by non-G1 GCs to chain nmethods.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	136 nmethod* _scavenge_root_link; // from CodeCache::scavenge_root_nmethods
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	137 };
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	138
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	139 static nmethod* volatile _oops_do_mark_nmethods;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	140 nmethod* volatile _oops_do_mark_link;
0 a61af66fc99e Initial load duke parents: diff changeset	141
a61af66fc99e Initial load duke parents: diff changeset	142 AbstractCompiler* _compiler; // The compiler which compiled this nmethod
a61af66fc99e Initial load duke parents: diff changeset	143
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	144 // offsets for entry points
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	145 address _entry_point; // entry point with class check
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	146 address _verified_entry_point; // entry point without class check
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	147 address _osr_entry_point; // entry point for on stack replacement
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	148
0 a61af66fc99e Initial load duke parents: diff changeset	149 // Offsets for different nmethod parts
a61af66fc99e Initial load duke parents: diff changeset	150 int _exception_offset;
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	151 // All deoptee's will resume execution at this location described by
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	152 // this offset.
0 a61af66fc99e Initial load duke parents: diff changeset	153 int _deoptimize_offset;
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	154 // All deoptee's at a MethodHandle call site will resume execution
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	155 // at this location described by this offset.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	156 int _deoptimize_mh_offset;
1378 9f5b60a14736 6939930: exception unwind changes in 6919934 hurts compilation speed never parents: 1204 diff changeset	157 // Offset of the unwind handler if it exists
9f5b60a14736 6939930: exception unwind changes in 6919934 hurts compilation speed never parents: 1204 diff changeset	158 int _unwind_handler_offset;
9f5b60a14736 6939930: exception unwind changes in 6919934 hurts compilation speed never parents: 1204 diff changeset	159
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	160 #ifdef HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	161 int _trap_offset;
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	162 #endif // def HAVE_DTRACE_H
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	163 int _consts_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	164 int _stub_offset;
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	165 int _oops_offset; // offset to where embedded oop table begins (inside data)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	166 int _metadata_offset; // embedded meta data table
0 a61af66fc99e Initial load duke parents: diff changeset	167 int _scopes_data_offset;
a61af66fc99e Initial load duke parents: diff changeset	168 int _scopes_pcs_offset;
a61af66fc99e Initial load duke parents: diff changeset	169 int _dependencies_offset;
a61af66fc99e Initial load duke parents: diff changeset	170 int _handler_table_offset;
a61af66fc99e Initial load duke parents: diff changeset	171 int _nul_chk_table_offset;
a61af66fc99e Initial load duke parents: diff changeset	172 int _nmethod_end_offset;
a61af66fc99e Initial load duke parents: diff changeset	173
a61af66fc99e Initial load duke parents: diff changeset	174 // location in frame (offset for sp) that deopt can store the original
a61af66fc99e Initial load duke parents: diff changeset	175 // pc during a deopt.
a61af66fc99e Initial load duke parents: diff changeset	176 int _orig_pc_offset;
a61af66fc99e Initial load duke parents: diff changeset	177
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	178 int _compile_id; // which compilation made this nmethod
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	179 int _comp_level; // compilation level
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	180
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	181 // protected by CodeCache_lock
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	182 bool _has_flushed_dependencies; // Used for maintenance of dependencies (CodeCache_lock)
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	183
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	184 bool _marked_for_reclamation; // Used by NMethodSweeper (set only by sweeper)
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	185 bool _marked_for_deoptimization; // Used for stack deoptimization
0 a61af66fc99e Initial load duke parents: diff changeset	186
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	187 // used by jvmti to track if an unload event has been posted for this nmethod.
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	188 bool _unload_reported;
0 a61af66fc99e Initial load duke parents: diff changeset	189
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	190 // set during construction
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	191 unsigned int _has_unsafe_access:1; // May fault due to unsafe access.
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	192 unsigned int _has_method_handle_invokes:1; // Has this method MethodHandle invokes?
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3899 diff changeset	193 unsigned int _lazy_critical_native:1; // Lazy JNI critical native
6792 137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	194 unsigned int _has_wide_vectors:1; // Preserve wide vectors at safepoints
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	195
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	196 // Protected by Patching_lock
12324 510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	197 volatile unsigned char _state; // {alive, not_entrant, zombie, unloaded}
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	198
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	199 volatile unsigned char _unloading_clock; // Incremented after GC unloaded/cleaned the nmethod
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	200
1726 71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	201 #ifdef ASSERT
71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	202 bool _oops_are_stale; // indicates that it's no longer safe to access oops section
71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	203 #endif
71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	204
13441 df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	205 enum { in_use = 0, // executable nmethod
df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	206 not_entrant = 1, // marked for deoptimization but activations may still exist,
df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	207 // will be transformed to zombie when all activations are gone
df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	208 zombie = 2, // no activations exist, nmethod is ready for purge
df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	209 unloaded = 3 }; // there should be no activations, should not be called,
df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	210 // will be transformed to zombie immediately
0 a61af66fc99e Initial load duke parents: diff changeset	211
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	212 jbyte _scavenge_root_state;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	213
17780 606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	214 #if INCLUDE_RTM_OPT
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	215 // RTM state at compile time. Used during deoptimization to decide
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	216 // whether to restart collecting RTM locking abort statistic again.
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	217 RTMState _rtm_state;
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	218 #endif
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	219
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	220 // Nmethod Flushing lock. If non-zero, then the nmethod is not removed
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	221 // and is not made into a zombie. However, once the nmethod is made into
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	222 // a zombie, it will be locked one final time if CompiledMethodUnload
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	223 // event processing needs to be done.
0 a61af66fc99e Initial load duke parents: diff changeset	224 jint _lock_count;
a61af66fc99e Initial load duke parents: diff changeset	225
a61af66fc99e Initial load duke parents: diff changeset	226 // not_entrant method removal. Each mark_sweep pass will update
a61af66fc99e Initial load duke parents: diff changeset	227 // this mark to current sweep invocation count if it is seen on the
12324 510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	228 // stack. An not_entrant method can be removed when there are no
0 a61af66fc99e Initial load duke parents: diff changeset	229 // more activations, i.e., when the _stack_traversal_mark is less than
a61af66fc99e Initial load duke parents: diff changeset	230 // current sweep traversal index.
a61af66fc99e Initial load duke parents: diff changeset	231 long _stack_traversal_mark;
a61af66fc99e Initial load duke parents: diff changeset	232
12324 510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	233 // The _hotness_counter indicates the hotness of a method. The higher
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	234 // the value the hotter the method. The hotness counter of a nmethod is
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	235 // set to [(ReservedCodeCacheSize / (1024 * 1024)) * 2] each time the method
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	236 // is active while stack scanning (mark_active_nmethods()). The hotness
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	237 // counter is decreased (by 1) while sweeping.
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	238 int _hotness_counter;
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	239
0 a61af66fc99e Initial load duke parents: diff changeset	240 ExceptionCache *_exception_cache;
a61af66fc99e Initial load duke parents: diff changeset	241 PcDescCache _pc_desc_cache;
a61af66fc99e Initial load duke parents: diff changeset	242
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	243 // These are used for compiled synchronized native methods to
0 a61af66fc99e Initial load duke parents: diff changeset	244 // locate the owner and stack slot for the BasicLock so that we can
a61af66fc99e Initial load duke parents: diff changeset	245 // properly revoke the bias of the owner if necessary. They are
a61af66fc99e Initial load duke parents: diff changeset	246 // needed because there is no debug information for compiled native
a61af66fc99e Initial load duke parents: diff changeset	247 // wrappers and the oop maps are insufficient to allow
a61af66fc99e Initial load duke parents: diff changeset	248 // frame::retrieve_receiver() to work. Currently they are expected
a61af66fc99e Initial load duke parents: diff changeset	249 // to be byte offsets from the Java stack pointer for maximum code
a61af66fc99e Initial load duke parents: diff changeset	250 // sharing between platforms. Note that currently biased locking
a61af66fc99e Initial load duke parents: diff changeset	251 // will never cause Class instances to be biased but this code
a61af66fc99e Initial load duke parents: diff changeset	252 // handles the static synchronized case as well.
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	253 // JVMTI's GetLocalInstance() also uses these offsets to find the receiver
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	254 // for non-static native wrapper frames.
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	255 ByteSize _native_receiver_sp_offset;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	256 ByteSize _native_basic_lock_sp_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	257
a61af66fc99e Initial load duke parents: diff changeset	258 friend class nmethodLocker;
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 // For native wrappers
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	261 nmethod(Method* method,
0 a61af66fc99e Initial load duke parents: diff changeset	262 int nmethod_size,
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	263 int compile_id,
0 a61af66fc99e Initial load duke parents: diff changeset	264 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	265 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	266 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	267 ByteSize basic_lock_owner_sp_offset, /* synchronized natives only */
a61af66fc99e Initial load duke parents: diff changeset	268 ByteSize basic_lock_sp_offset, /* synchronized natives only */
a61af66fc99e Initial load duke parents: diff changeset	269 OopMapSet* oop_maps);
a61af66fc99e Initial load duke parents: diff changeset	270
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	271 #ifdef HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	272 // For native wrappers
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	273 nmethod(Method* method,
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	274 int nmethod_size,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	275 CodeOffsets* offsets,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	276 CodeBuffer *code_buffer,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	277 int frame_size);
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	278 #endif // def HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	279
0 a61af66fc99e Initial load duke parents: diff changeset	280 // Creation support
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	281 nmethod(Method* method,
0 a61af66fc99e Initial load duke parents: diff changeset	282 int nmethod_size,
a61af66fc99e Initial load duke parents: diff changeset	283 int compile_id,
a61af66fc99e Initial load duke parents: diff changeset	284 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	285 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	286 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	287 DebugInformationRecorder *recorder,
a61af66fc99e Initial load duke parents: diff changeset	288 Dependencies* dependencies,
a61af66fc99e Initial load duke parents: diff changeset	289 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	290 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	291 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	292 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	293 ImplicitExceptionTable* nul_chk_table,
a61af66fc99e Initial load duke parents: diff changeset	294 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	295 int comp_level);
a61af66fc99e Initial load duke parents: diff changeset	296
a61af66fc99e Initial load duke parents: diff changeset	297 // helper methods
12146 9758d9f36299 8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced coleenp parents: 12080 diff changeset	298 void* operator new(size_t size, int nmethod_size) throw();
0 a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300 const char* reloc_string_for(u_char* begin, u_char* end);
1109 032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	301 // Returns true if this thread changed the state of the nmethod or
032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	302 // false if another thread performed the transition.
1141 b1f619d38249 6914002: unsigned compare problem after 5057818 never parents: 1135 diff changeset	303 bool make_not_entrant_or_zombie(unsigned int state);
0 a61af66fc99e Initial load duke parents: diff changeset	304 void inc_decompile_count();
a61af66fc99e Initial load duke parents: diff changeset	305
a61af66fc99e Initial load duke parents: diff changeset	306 // Used to manipulate the exception cache
a61af66fc99e Initial load duke parents: diff changeset	307 void add_exception_cache_entry(ExceptionCache* new_entry);
a61af66fc99e Initial load duke parents: diff changeset	308 ExceptionCache* exception_cache_entry_for_exception(Handle exception);
a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310 // Inform external interfaces that a compiled method has been unloaded
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	311 void post_compiled_method_unload();
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	312
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	313 // Initailize fields to their default values
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	314 void init_defaults();
0 a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 public:
a61af66fc99e Initial load duke parents: diff changeset	317 // create nmethod with entry_bci
a61af66fc99e Initial load duke parents: diff changeset	318 static nmethod* new_nmethod(methodHandle method,
a61af66fc99e Initial load duke parents: diff changeset	319 int compile_id,
a61af66fc99e Initial load duke parents: diff changeset	320 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	321 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	322 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	323 DebugInformationRecorder* recorder,
a61af66fc99e Initial load duke parents: diff changeset	324 Dependencies* dependencies,
a61af66fc99e Initial load duke parents: diff changeset	325 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	326 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	327 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	328 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	329 ImplicitExceptionTable* nul_chk_table,
a61af66fc99e Initial load duke parents: diff changeset	330 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	331 int comp_level);
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333 static nmethod* new_native_nmethod(methodHandle method,
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	334 int compile_id,
0 a61af66fc99e Initial load duke parents: diff changeset	335 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	336 int vep_offset,
a61af66fc99e Initial load duke parents: diff changeset	337 int frame_complete,
a61af66fc99e Initial load duke parents: diff changeset	338 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	339 ByteSize receiver_sp_offset,
a61af66fc99e Initial load duke parents: diff changeset	340 ByteSize basic_lock_sp_offset,
a61af66fc99e Initial load duke parents: diff changeset	341 OopMapSet* oop_maps);
a61af66fc99e Initial load duke parents: diff changeset	342
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	343 #ifdef HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	344 // The method we generate for a dtrace probe has to look
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	345 // like an nmethod as far as the rest of the system is concerned
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	346 // which is somewhat unfortunate.
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	347 static nmethod* new_dtrace_nmethod(methodHandle method,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	348 CodeBuffer *code_buffer,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	349 int vep_offset,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	350 int trap_offset,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	351 int frame_complete,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	352 int frame_size);
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	353
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	354 int trap_offset() const { return _trap_offset; }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	355 address trap_address() const { return insts_begin() + _trap_offset; }
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	356
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	357 #endif // def HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	358
0 a61af66fc99e Initial load duke parents: diff changeset	359 // accessors
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	360 Method* method() const { return _method; }
0 a61af66fc99e Initial load duke parents: diff changeset	361 AbstractCompiler* compiler() const { return _compiler; }
a61af66fc99e Initial load duke parents: diff changeset	362
a61af66fc99e Initial load duke parents: diff changeset	363 // type info
a61af66fc99e Initial load duke parents: diff changeset	364 bool is_nmethod() const { return true; }
a61af66fc99e Initial load duke parents: diff changeset	365 bool is_java_method() const { return !method()->is_native(); }
a61af66fc99e Initial load duke parents: diff changeset	366 bool is_native_method() const { return method()->is_native(); }
a61af66fc99e Initial load duke parents: diff changeset	367 bool is_osr_method() const { return _entry_bci != InvocationEntryBci; }
a61af66fc99e Initial load duke parents: diff changeset	368
a61af66fc99e Initial load duke parents: diff changeset	369 bool is_compiled_by_c1() const;
a61af66fc99e Initial load duke parents: diff changeset	370 bool is_compiled_by_c2() const;
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1681 diff changeset	371 bool is_compiled_by_shark() const;
0 a61af66fc99e Initial load duke parents: diff changeset	372
a61af66fc99e Initial load duke parents: diff changeset	373 // boundaries for different parts
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	374 address consts_begin () const { return header_begin() + _consts_offset ; }
0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	375 address consts_end () const { return header_begin() + code_offset() ; }
0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	376 address insts_begin () const { return header_begin() + code_offset() ; }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	377 address insts_end () const { return header_begin() + _stub_offset ; }
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	378 address stub_begin () const { return header_begin() + _stub_offset ; }
0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	379 address stub_end () const { return header_begin() + _oops_offset ; }
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	380 address exception_begin () const { return header_begin() + _exception_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	381 address deopt_handler_begin () const { return header_begin() + _deoptimize_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	382 address deopt_mh_handler_begin() const { return header_begin() + _deoptimize_mh_offset ; }
1378 9f5b60a14736 6939930: exception unwind changes in 6919934 hurts compilation speed never parents: 1204 diff changeset	383 address unwind_handler_begin () const { return _unwind_handler_offset != -1 ? (header_begin() + _unwind_handler_offset) : NULL; }
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	384 oop* oops_begin () const { return (oop*) (header_begin() + _oops_offset) ; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	385 oop* oops_end () const { return (oop*) (header_begin() + _metadata_offset) ; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	386
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	387 Metadata metadata_begin () const { return (Metadata) (header_begin() + _metadata_offset) ; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	388 Metadata metadata_end () const { return (Metadata) (header_begin() + _scopes_data_offset) ; }
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	389
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	390 address scopes_data_begin () const { return header_begin() + _scopes_data_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	391 address scopes_data_end () const { return header_begin() + _scopes_pcs_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	392 PcDesc* scopes_pcs_begin () const { return (PcDesc*)(header_begin() + _scopes_pcs_offset ); }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	393 PcDesc* scopes_pcs_end () const { return (PcDesc*)(header_begin() + _dependencies_offset) ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	394 address dependencies_begin () const { return header_begin() + _dependencies_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	395 address dependencies_end () const { return header_begin() + _handler_table_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	396 address handler_table_begin () const { return header_begin() + _handler_table_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	397 address handler_table_end () const { return header_begin() + _nul_chk_table_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	398 address nul_chk_table_begin () const { return header_begin() + _nul_chk_table_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	399 address nul_chk_table_end () const { return header_begin() + _nmethod_end_offset ; }
0 a61af66fc99e Initial load duke parents: diff changeset	400
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	401 // Sizes
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	402 int consts_size () const { return consts_end () - consts_begin (); }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	403 int insts_size () const { return insts_end () - insts_begin (); }
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	404 int stub_size () const { return stub_end () - stub_begin (); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	405 int oops_size () const { return (address) oops_end () - (address) oops_begin (); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	406 int metadata_size () const { return (address) metadata_end () - (address) metadata_begin (); }
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	407 int scopes_data_size () const { return scopes_data_end () - scopes_data_begin (); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	408 int scopes_pcs_size () const { return (intptr_t) scopes_pcs_end () - (intptr_t) scopes_pcs_begin (); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	409 int dependencies_size () const { return dependencies_end () - dependencies_begin (); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	410 int handler_table_size() const { return handler_table_end() - handler_table_begin(); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	411 int nul_chk_table_size() const { return nul_chk_table_end() - nul_chk_table_begin(); }
0 a61af66fc99e Initial load duke parents: diff changeset	412
a61af66fc99e Initial load duke parents: diff changeset	413 int total_size () const;
a61af66fc99e Initial load duke parents: diff changeset	414
12324 510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	415 void dec_hotness_counter() { _hotness_counter--; }
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	416 void set_hotness_counter(int val) { _hotness_counter = val; }
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	417 int hotness_counter() const { return _hotness_counter; }
510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	418
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	419 // Containment
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	420 bool consts_contains (address addr) const { return consts_begin () <= addr && addr < consts_end (); }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	421 bool insts_contains (address addr) const { return insts_begin () <= addr && addr < insts_end (); }
0 a61af66fc99e Initial load duke parents: diff changeset	422 bool stub_contains (address addr) const { return stub_begin () <= addr && addr < stub_end (); }
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	423 bool oops_contains (oop* addr) const { return oops_begin () <= addr && addr < oops_end (); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	424 bool metadata_contains (Metadata** addr) const { return metadata_begin () <= addr && addr < metadata_end (); }
0 a61af66fc99e Initial load duke parents: diff changeset	425 bool scopes_data_contains (address addr) const { return scopes_data_begin () <= addr && addr < scopes_data_end (); }
a61af66fc99e Initial load duke parents: diff changeset	426 bool scopes_pcs_contains (PcDesc* addr) const { return scopes_pcs_begin () <= addr && addr < scopes_pcs_end (); }
a61af66fc99e Initial load duke parents: diff changeset	427 bool handler_table_contains(address addr) const { return handler_table_begin() <= addr && addr < handler_table_end(); }
a61af66fc99e Initial load duke parents: diff changeset	428 bool nul_chk_table_contains(address addr) const { return nul_chk_table_begin() <= addr && addr < nul_chk_table_end(); }
a61af66fc99e Initial load duke parents: diff changeset	429
a61af66fc99e Initial load duke parents: diff changeset	430 // entry points
a61af66fc99e Initial load duke parents: diff changeset	431 address entry_point() const { return _entry_point; } // normal entry point
a61af66fc99e Initial load duke parents: diff changeset	432 address verified_entry_point() const { return _verified_entry_point; } // if klass is correct
a61af66fc99e Initial load duke parents: diff changeset	433
a61af66fc99e Initial load duke parents: diff changeset	434 // flag accessing and manipulation
13441 df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	435 bool is_in_use() const { return _state == in_use; }
df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12324 diff changeset	436 bool is_alive() const { return _state == in_use \|\| _state == not_entrant; }
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	437 bool is_not_entrant() const { return _state == not_entrant; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	438 bool is_zombie() const { return _state == zombie; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	439 bool is_unloaded() const { return _state == unloaded; }
0 a61af66fc99e Initial load duke parents: diff changeset	440
17780 606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	441 #if INCLUDE_RTM_OPT
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	442 // rtm state accessing and manipulating
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	443 RTMState rtm_state() const { return _rtm_state; }
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	444 void set_rtm_state(RTMState state) { _rtm_state = state; }
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	445 #endif
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 13441 diff changeset	446
1109 032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	447 // Make the nmethod non entrant. The nmethod will continue to be
032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	448 // alive. It is used when an uncommon trap happens. Returns true
032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	449 // if this thread changed the state of the nmethod or false if
032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	450 // another thread performed the transition.
20432 aff6ccb506cb 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running iveresov parents: 20278 diff changeset	451 bool make_not_entrant() {
aff6ccb506cb 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running iveresov parents: 20278 diff changeset	452 assert(!method()->is_method_handle_intrinsic(), "Cannot make MH intrinsic not entrant");
aff6ccb506cb 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running iveresov parents: 20278 diff changeset	453 return make_not_entrant_or_zombie(not_entrant);
aff6ccb506cb 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running iveresov parents: 20278 diff changeset	454 }
12324 510fbd28919c 8020151: PSR:PERF Large performance regressions when code cache is filled anoll parents: 12146 diff changeset	455 bool make_zombie() { return make_not_entrant_or_zombie(zombie); }
0 a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 // used by jvmti to track if the unload event has been reported
a61af66fc99e Initial load duke parents: diff changeset	458 bool unload_reported() { return _unload_reported; }
a61af66fc99e Initial load duke parents: diff changeset	459 void set_unload_reported() { _unload_reported = true; }
a61af66fc99e Initial load duke parents: diff changeset	460
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	461 void set_unloading_next(nmethod* next) { _unloading_next = next; }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	462 nmethod* unloading_next() { return _unloading_next; }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	463
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	464 static unsigned char global_unloading_clock() { return _global_unloading_clock; }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	465 static void increase_unloading_clock();
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	466
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	467 void set_unloading_clock(unsigned char unloading_clock);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	468 unsigned char unloading_clock();
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	469
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	470 bool is_marked_for_deoptimization() const { return _marked_for_deoptimization; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	471 void mark_for_deoptimization() { _marked_for_deoptimization = true; }
0 a61af66fc99e Initial load duke parents: diff changeset	472
a61af66fc99e Initial load duke parents: diff changeset	473 void make_unloaded(BoolObjectClosure* is_alive, oop cause);
a61af66fc99e Initial load duke parents: diff changeset	474
a61af66fc99e Initial load duke parents: diff changeset	475 bool has_dependencies() { return dependencies_size() != 0; }
a61af66fc99e Initial load duke parents: diff changeset	476 void flush_dependencies(BoolObjectClosure* is_alive);
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	477 bool has_flushed_dependencies() { return _has_flushed_dependencies; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	478 void set_has_flushed_dependencies() {
0 a61af66fc99e Initial load duke parents: diff changeset	479 assert(!has_flushed_dependencies(), "should only happen once");
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	480 _has_flushed_dependencies = 1;
0 a61af66fc99e Initial load duke parents: diff changeset	481 }
a61af66fc99e Initial load duke parents: diff changeset	482
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	483 bool is_marked_for_reclamation() const { return _marked_for_reclamation; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	484 void mark_for_reclamation() { _marked_for_reclamation = 1; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	485
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	486 bool has_unsafe_access() const { return _has_unsafe_access; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	487 void set_has_unsafe_access(bool z) { _has_unsafe_access = z; }
0 a61af66fc99e Initial load duke parents: diff changeset	488
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	489 bool has_method_handle_invokes() const { return _has_method_handle_invokes; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	490 void set_has_method_handle_invokes(bool z) { _has_method_handle_invokes = z; }
0 a61af66fc99e Initial load duke parents: diff changeset	491
4873 0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3899 diff changeset	492 bool is_lazy_critical_native() const { return _lazy_critical_native; }
0382d2b469b2 7013347: allow crypto functions to be called inline to enhance performance never parents: 3899 diff changeset	493 void set_lazy_critical_native(bool z) { _lazy_critical_native = z; }
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1201 diff changeset	494
6792 137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	495 bool has_wide_vectors() const { return _has_wide_vectors; }
137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	496 void set_has_wide_vectors(bool z) { _has_wide_vectors = z; }
137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	497
0 a61af66fc99e Initial load duke parents: diff changeset	498 int comp_level() const { return _comp_level; }
a61af66fc99e Initial load duke parents: diff changeset	499
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	500 // Support for oops in scopes and relocs:
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	501 // Note: index 0 is reserved for null.
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	502 oop oop_at(int index) const { return index == 0 ? (oop) NULL: *oop_addr_at(index); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	503 oop* oop_addr_at(int index) const { // for GC
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	504 // relocation indexes are biased by 1 (because 0 is reserved)
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	505 assert(index > 0 && index <= oops_size(), "must be a valid non-zero index");
1726 71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	506 assert(!_oops_are_stale, "oops are stale");
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	507 return &oops_begin()[index - 1];
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	508 }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	509
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	510 // Support for meta data in scopes and relocs:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	511 // Note: index 0 is reserved for null.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	512 Metadata* metadata_at(int index) const { return index == 0 ? NULL: *metadata_addr_at(index); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	513 Metadata** metadata_addr_at(int index) const { // for GC
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	514 // relocation indexes are biased by 1 (because 0 is reserved)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	515 assert(index > 0 && index <= metadata_size(), "must be a valid non-zero index");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	516 return &metadata_begin()[index - 1];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	517 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	518
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	519 void copy_values(GrowableArray<jobject>* oops);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	520 void copy_values(GrowableArray<Metadata> metadata);
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	521
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	522 // Relocation support
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	523 private:
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	524 void fix_oop_relocations(address begin, address end, bool initialize_immediates);
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	525 inline void initialize_immediate_oop(oop* dest, jobject handle);
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	526
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	527 public:
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	528 void fix_oop_relocations(address begin, address end) { fix_oop_relocations(begin, end, false); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	529 void fix_oop_relocations() { fix_oop_relocations(NULL, NULL, false); }
2375 d673ef06fe96 7028374: race in fix_oop_relocations for scavengeable nmethods never parents: 2343 diff changeset	530 void verify_oop_relocations();
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	531
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	532 bool is_at_poll_return(address pc);
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	533 bool is_at_poll_or_poll_return(address pc);
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	534
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	535 // Scavengable oop support
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	536 bool on_scavenge_root_list() const { return (_scavenge_root_state & 1) != 0; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	537 protected:
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	538 enum { sl_on_list = 0x01, sl_marked = 0x10 };
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	539 void set_on_scavenge_root_list() { _scavenge_root_state = sl_on_list; }
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	540 void clear_on_scavenge_root_list() { _scavenge_root_state = 0; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	541 // assertion-checking and pruning logic uses the bits of _scavenge_root_state
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	542 #ifndef PRODUCT
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	543 void set_scavenge_root_marked() { _scavenge_root_state \|= sl_marked; }
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	544 void clear_scavenge_root_marked() { _scavenge_root_state &= ~sl_marked; }
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	545 bool scavenge_root_not_marked() { return (_scavenge_root_state &~ sl_on_list) == 0; }
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	546 // N.B. there is no positive marked query, and we only use the not_marked query for asserts.
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	547 #endif //PRODUCT
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	548 nmethod* scavenge_root_link() const { return _scavenge_root_link; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	549 void set_scavenge_root_link(nmethod *n) { _scavenge_root_link = n; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	550
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	551 public:
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	552
0 a61af66fc99e Initial load duke parents: diff changeset	553 // Sweeper support
a61af66fc99e Initial load duke parents: diff changeset	554 long stack_traversal_mark() { return _stack_traversal_mark; }
a61af66fc99e Initial load duke parents: diff changeset	555 void set_stack_traversal_mark(long l) { _stack_traversal_mark = l; }
a61af66fc99e Initial load duke parents: diff changeset	556
a61af66fc99e Initial load duke parents: diff changeset	557 // Exception cache support
a61af66fc99e Initial load duke parents: diff changeset	558 ExceptionCache* exception_cache() const { return _exception_cache; }
a61af66fc99e Initial load duke parents: diff changeset	559 void set_exception_cache(ExceptionCache *ec) { _exception_cache = ec; }
a61af66fc99e Initial load duke parents: diff changeset	560 address handler_for_exception_and_pc(Handle exception, address pc);
a61af66fc99e Initial load duke parents: diff changeset	561 void add_handler_for_exception_and_pc(Handle exception, address pc, address handler);
20269 9717199cb8de 8047373: Clean the ExceptionCache in one pass stefank parents: 20227 diff changeset	562 void clean_exception_cache(BoolObjectClosure* is_alive);
0 a61af66fc99e Initial load duke parents: diff changeset	563
a61af66fc99e Initial load duke parents: diff changeset	564 // implicit exceptions support
a61af66fc99e Initial load duke parents: diff changeset	565 address continuation_for_implicit_exception(address pc);
a61af66fc99e Initial load duke parents: diff changeset	566
a61af66fc99e Initial load duke parents: diff changeset	567 // On-stack replacement support
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	568 int osr_entry_bci() const { assert(is_osr_method(), "wrong kind of nmethod"); return _entry_bci; }
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	569 address osr_entry() const { assert(is_osr_method(), "wrong kind of nmethod"); return _osr_entry_point; }
0 a61af66fc99e Initial load duke parents: diff changeset	570 void invalidate_osr_method();
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	571 nmethod* osr_link() const { return _osr_link; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	572 void set_osr_link(nmethod *n) { _osr_link = n; }
0 a61af66fc99e Initial load duke parents: diff changeset	573
a61af66fc99e Initial load duke parents: diff changeset	574 // tells whether frames described by this nmethod can be deoptimized
a61af66fc99e Initial load duke parents: diff changeset	575 // note: native wrappers cannot be deoptimized.
a61af66fc99e Initial load duke parents: diff changeset	576 bool can_be_deoptimized() const { return is_java_method(); }
a61af66fc99e Initial load duke parents: diff changeset	577
a61af66fc99e Initial load duke parents: diff changeset	578 // Inline cache support
a61af66fc99e Initial load duke parents: diff changeset	579 void clear_inline_caches();
a61af66fc99e Initial load duke parents: diff changeset	580 void cleanup_inline_caches();
a61af66fc99e Initial load duke parents: diff changeset	581 bool inlinecache_check_contains(address addr) const {
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	582 return (addr >= code_begin() && addr < verified_entry_point());
0 a61af66fc99e Initial load duke parents: diff changeset	583 }
a61af66fc99e Initial load duke parents: diff changeset	584
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	585 // Verify calls to dead methods have been cleaned.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	586 void verify_clean_inline_caches();
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	587 // Verify and count cached icholder relocations.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	588 int verify_icholder_relocations();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	589 // Check that all metadata is still alive
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	590 void verify_metadata_loaders(address low_boundary, BoolObjectClosure* is_alive);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	591
0 a61af66fc99e Initial load duke parents: diff changeset	592 // unlink and deallocate this nmethod
a61af66fc99e Initial load duke parents: diff changeset	593 // Only NMethodSweeper class is expected to use this. NMethodSweeper is not
a61af66fc99e Initial load duke parents: diff changeset	594 // expected to use any other private methods/data in this class.
a61af66fc99e Initial load duke parents: diff changeset	595
a61af66fc99e Initial load duke parents: diff changeset	596 protected:
a61af66fc99e Initial load duke parents: diff changeset	597 void flush();
a61af66fc99e Initial load duke parents: diff changeset	598
a61af66fc99e Initial load duke parents: diff changeset	599 public:
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	600 // When true is returned, it is unsafe to remove this nmethod even if
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	601 // it is a zombie, since the VM or the ServiceThread might still be
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	602 // using it.
0 a61af66fc99e Initial load duke parents: diff changeset	603 bool is_locked_by_vm() const { return _lock_count >0; }
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 // See comment at definition of _last_seen_on_stack
a61af66fc99e Initial load duke parents: diff changeset	606 void mark_as_seen_on_stack();
a61af66fc99e Initial load duke parents: diff changeset	607 bool can_not_entrant_be_converted();
a61af66fc99e Initial load duke parents: diff changeset	608
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	609 // Evolution support. We make old (discarded) compiled methods point to new Method*s.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	610 void set_method(Method* method) { _method = method; }
0 a61af66fc99e Initial load duke parents: diff changeset	611
a61af66fc99e Initial load duke parents: diff changeset	612 // GC support
6787 8966c2d65d96 7200470: KeepAliveClosure not needed in CodeCache::do_unloading brutisso parents: 6725 diff changeset	613 void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred);
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	614 // The parallel versions are used by G1.
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	615 bool do_unloading_parallel(BoolObjectClosure* is_alive, bool unloading_occurred);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	616 void do_unloading_parallel_postponed(BoolObjectClosure* is_alive, bool unloading_occurred);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20269 diff changeset	617 // Unload a nmethod if the *root object is dead.
6787 8966c2d65d96 7200470: KeepAliveClosure not needed in CodeCache::do_unloading brutisso parents: 6725 diff changeset	618 bool can_unload(BoolObjectClosure* is_alive, oop* root, bool unloading_occurred);
0 a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map,
a61af66fc99e Initial load duke parents: diff changeset	621 OopClosure* f);
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	622 void oops_do(OopClosure* f) { oops_do(f, false); }
12080 5888334c9c24 7145569: G1: optimize nmethods scanning johnc parents: 6806 diff changeset	623 void oops_do(OopClosure* f, bool allow_zombie);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	624 bool detect_scavenge_root_oops();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	625 void verify_scavenge_root_oops() PRODUCT_RETURN;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	626
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	627 bool test_set_oops_do_mark();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	628 static void oops_do_marking_prologue();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	629 static void oops_do_marking_epilogue();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	630 static bool oops_do_marking_is_active() { return _oops_do_mark_nmethods != NULL; }
5986 500023bd0818 7143511: G1: Another instance of high GC Worker Other time (50ms) johnc parents: 4873 diff changeset	631 bool test_oops_do_mark() { return _oops_do_mark_link != NULL; }
0 a61af66fc99e Initial load duke parents: diff changeset	632
a61af66fc99e Initial load duke parents: diff changeset	633 // ScopeDesc for an instruction
a61af66fc99e Initial load duke parents: diff changeset	634 ScopeDesc* scope_desc_at(address pc);
a61af66fc99e Initial load duke parents: diff changeset	635
a61af66fc99e Initial load duke parents: diff changeset	636 private:
a61af66fc99e Initial load duke parents: diff changeset	637 ScopeDesc* scope_desc_in(address begin, address end);
a61af66fc99e Initial load duke parents: diff changeset	638
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	639 address* orig_pc_addr(const frame* fr) { return (address*) ((address)fr->unextended_sp() + _orig_pc_offset); }
0 a61af66fc99e Initial load duke parents: diff changeset	640
a61af66fc99e Initial load duke parents: diff changeset	641 PcDesc* find_pc_desc_internal(address pc, bool approximate);
a61af66fc99e Initial load duke parents: diff changeset	642
a61af66fc99e Initial load duke parents: diff changeset	643 PcDesc* find_pc_desc(address pc, bool approximate) {
a61af66fc99e Initial load duke parents: diff changeset	644 PcDesc* desc = _pc_desc_cache.last_pc_desc();
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	645 if (desc != NULL && desc->pc_offset() == pc - code_begin()) {
0 a61af66fc99e Initial load duke parents: diff changeset	646 return desc;
a61af66fc99e Initial load duke parents: diff changeset	647 }
a61af66fc99e Initial load duke parents: diff changeset	648 return find_pc_desc_internal(pc, approximate);
a61af66fc99e Initial load duke parents: diff changeset	649 }
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 public:
a61af66fc99e Initial load duke parents: diff changeset	652 // ScopeDesc retrieval operation
a61af66fc99e Initial load duke parents: diff changeset	653 PcDesc* pc_desc_at(address pc) { return find_pc_desc(pc, false); }
a61af66fc99e Initial load duke parents: diff changeset	654 // pc_desc_near returns the first PcDesc at or after the givne pc.
a61af66fc99e Initial load duke parents: diff changeset	655 PcDesc* pc_desc_near(address pc) { return find_pc_desc(pc, true); }
a61af66fc99e Initial load duke parents: diff changeset	656
a61af66fc99e Initial load duke parents: diff changeset	657 public:
a61af66fc99e Initial load duke parents: diff changeset	658 // copying of debugging information
a61af66fc99e Initial load duke parents: diff changeset	659 void copy_scopes_pcs(PcDesc* pcs, int count);
a61af66fc99e Initial load duke parents: diff changeset	660 void copy_scopes_data(address buffer, int size);
a61af66fc99e Initial load duke parents: diff changeset	661
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	662 // Deopt
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	663 // Return true is the PC is one would expect if the frame is being deopted.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	664 bool is_deopt_pc (address pc) { return is_deopt_entry(pc) \|\| is_deopt_mh_entry(pc); }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	665 bool is_deopt_entry (address pc) { return pc == deopt_handler_begin(); }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	666 bool is_deopt_mh_entry(address pc) { return pc == deopt_mh_handler_begin(); }
0 a61af66fc99e Initial load duke parents: diff changeset	667 // Accessor/mutator for the original pc of a frame before a frame was deopted.
a61af66fc99e Initial load duke parents: diff changeset	668 address get_original_pc(const frame* fr) { return *orig_pc_addr(fr); }
a61af66fc99e Initial load duke parents: diff changeset	669 void set_original_pc(const frame* fr, address pc) { *orig_pc_addr(fr) = pc; }
a61af66fc99e Initial load duke parents: diff changeset	670
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	671 static address get_deopt_original_pc(const frame* fr);
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	672
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 1109 diff changeset	673 // MethodHandle
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 1109 diff changeset	674 bool is_method_handle_return(address return_pc);
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 1109 diff changeset	675
0 a61af66fc99e Initial load duke parents: diff changeset	676 // jvmti support:
a61af66fc99e Initial load duke parents: diff changeset	677 void post_compiled_method_load_event();
1616 38e8278318ca 6656830: assert((p)->is_oop(),"expected an oop while scanning weak refs") never* parents: 1579 diff changeset	678 jmethodID get_and_cache_jmethod_id();
0 a61af66fc99e Initial load duke parents: diff changeset	679
a61af66fc99e Initial load duke parents: diff changeset	680 // verify operations
a61af66fc99e Initial load duke parents: diff changeset	681 void verify();
a61af66fc99e Initial load duke parents: diff changeset	682 void verify_scopes();
a61af66fc99e Initial load duke parents: diff changeset	683 void verify_interrupt_point(address interrupt_point);
a61af66fc99e Initial load duke parents: diff changeset	684
a61af66fc99e Initial load duke parents: diff changeset	685 // printing support
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 0 diff changeset	686 void print() const;
c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 0 diff changeset	687 void print_code();
0 a61af66fc99e Initial load duke parents: diff changeset	688 void print_relocations() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	689 void print_pcs() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	690 void print_scopes() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	691 void print_dependencies() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	692 void print_value_on(outputStream* st) const PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	693 void print_calls(outputStream* st) PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	694 void print_handler_table() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	695 void print_nul_chk_table() PRODUCT_RETURN;
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 0 diff changeset	696 void print_nmethod(bool print_code);
0 a61af66fc99e Initial load duke parents: diff changeset	697
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1644 diff changeset	698 // need to re-define this from CodeBlob else the overload hides it
126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1644 diff changeset	699 virtual void print_on(outputStream* st) const { CodeBlob::print_on(st); }
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	700 void print_on(outputStream* st, const char* msg) const;
0 a61af66fc99e Initial load duke parents: diff changeset	701
a61af66fc99e Initial load duke parents: diff changeset	702 // Logging
a61af66fc99e Initial load duke parents: diff changeset	703 void log_identity(xmlStream* log) const;
a61af66fc99e Initial load duke parents: diff changeset	704 void log_new_nmethod() const;
1109 032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	705 void log_state_change() const;
0 a61af66fc99e Initial load duke parents: diff changeset	706
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	707 // Prints block-level comments, including nmethod specific block labels:
6796 b31471cdc53e 7200163: add CodeComments functionality to assember stubs kvn parents: 6792 diff changeset	708 virtual void print_block_comment(outputStream* stream, address block_begin) const {
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	709 print_nmethod_labels(stream, block_begin);
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	710 CodeBlob::print_block_comment(stream, block_begin);
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	711 }
6796 b31471cdc53e 7200163: add CodeComments functionality to assember stubs kvn parents: 6792 diff changeset	712 void print_nmethod_labels(outputStream* stream, address block_begin) const;
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	713
0 a61af66fc99e Initial load duke parents: diff changeset	714 // Prints a comment for one native instruction (reloc info, pc desc)
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 0 diff changeset	715 void print_code_comment_on(outputStream* st, int column, address begin, address end);
0 a61af66fc99e Initial load duke parents: diff changeset	716 static void print_statistics() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	717
a61af66fc99e Initial load duke parents: diff changeset	718 // Compiler task identification. Note that all OSR methods
a61af66fc99e Initial load duke parents: diff changeset	719 // are numbered in an independent sequence if CICountOSR is true,
a61af66fc99e Initial load duke parents: diff changeset	720 // and native method wrappers are also numbered independently if
a61af66fc99e Initial load duke parents: diff changeset	721 // CICountNative is true.
a61af66fc99e Initial load duke parents: diff changeset	722 int compile_id() const { return _compile_id; }
a61af66fc99e Initial load duke parents: diff changeset	723 const char* compile_kind() const;
a61af66fc99e Initial load duke parents: diff changeset	724
a61af66fc99e Initial load duke parents: diff changeset	725 // For debugging
a61af66fc99e Initial load duke parents: diff changeset	726 // CompiledIC* IC_at(char* p) const;
a61af66fc99e Initial load duke parents: diff changeset	727 // PrimitiveIC* primitiveIC_at(char* p) const;
a61af66fc99e Initial load duke parents: diff changeset	728 oop embeddedOop_at(address p);
a61af66fc99e Initial load duke parents: diff changeset	729
a61af66fc99e Initial load duke parents: diff changeset	730 // tells if any of this method's dependencies have been invalidated
a61af66fc99e Initial load duke parents: diff changeset	731 // (this is expensive!)
a61af66fc99e Initial load duke parents: diff changeset	732 bool check_all_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	733
a61af66fc99e Initial load duke parents: diff changeset	734 // tells if this compiled method is dependent on the given changes,
a61af66fc99e Initial load duke parents: diff changeset	735 // and the changes have invalidated it
a61af66fc99e Initial load duke parents: diff changeset	736 bool check_dependency_on(DepChange& changes);
a61af66fc99e Initial load duke parents: diff changeset	737
a61af66fc99e Initial load duke parents: diff changeset	738 // Evolution support. Tells if this compiled method is dependent on any of
a61af66fc99e Initial load duke parents: diff changeset	739 // methods m() of class dependee, such that if m() in dependee is replaced,
a61af66fc99e Initial load duke parents: diff changeset	740 // this compiled method will have to be deoptimized.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	741 bool is_evol_dependent_on(Klass* dependee);
0 a61af66fc99e Initial load duke parents: diff changeset	742
a61af66fc99e Initial load duke parents: diff changeset	743 // Fast breakpoint support. Tells if this compiled method is
a61af66fc99e Initial load duke parents: diff changeset	744 // dependent on the given method. Returns true if this nmethod
a61af66fc99e Initial load duke parents: diff changeset	745 // corresponds to the given method as well.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	746 bool is_dependent_on_method(Method* dependee);
0 a61af66fc99e Initial load duke parents: diff changeset	747
a61af66fc99e Initial load duke parents: diff changeset	748 // is it ok to patch at address?
a61af66fc99e Initial load duke parents: diff changeset	749 bool is_patchable_at(address instr_address);
a61af66fc99e Initial load duke parents: diff changeset	750
a61af66fc99e Initial load duke parents: diff changeset	751 // UseBiasedLocking support
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	752 ByteSize native_receiver_sp_offset() {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	753 return _native_receiver_sp_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	754 }
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	755 ByteSize native_basic_lock_sp_offset() {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	756 return _native_basic_lock_sp_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	757 }
a61af66fc99e Initial load duke parents: diff changeset	758
a61af66fc99e Initial load duke parents: diff changeset	759 // support for code generation
a61af66fc99e Initial load duke parents: diff changeset	760 static int verified_entry_point_offset() { return offset_of(nmethod, _verified_entry_point); }
a61af66fc99e Initial load duke parents: diff changeset	761 static int osr_entry_point_offset() { return offset_of(nmethod, _osr_entry_point); }
a61af66fc99e Initial load duke parents: diff changeset	762 static int entry_bci_offset() { return offset_of(nmethod, _entry_bci); }
a61af66fc99e Initial load duke parents: diff changeset	763
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	764 // RedefineClasses support. Mark metadata in nmethods as on_stack so that
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	765 // redefine classes doesn't purge it.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	766 static void mark_on_stack(nmethod* nm) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	767 nm->metadata_do(Metadata::mark_on_stack);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	768 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6197 diff changeset	769 void metadata_do(void f(Metadata*));
0 a61af66fc99e Initial load duke parents: diff changeset	770 };
a61af66fc99e Initial load duke parents: diff changeset	771
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	772 // Locks an nmethod so its code will not get removed and it will not
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	773 // be made into a zombie, even if it is a not_entrant method. After the
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	774 // nmethod becomes a zombie, if CompiledMethodUnload event processing
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	775 // needs to be done, then lock_nmethod() is used directly to keep the
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	776 // generated code from being reused too early.
0 a61af66fc99e Initial load duke parents: diff changeset	777 class nmethodLocker : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	778 nmethod* _nm;
a61af66fc99e Initial load duke parents: diff changeset	779
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2019 diff changeset	780 public:
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2019 diff changeset	781
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	782 // note: nm can be NULL
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	783 // Only JvmtiDeferredEvent::compiled_method_unload_event()
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	784 // should pass zombie_ok == true.
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	785 static void lock_nmethod(nmethod* nm, bool zombie_ok = false);
0 a61af66fc99e Initial load duke parents: diff changeset	786 static void unlock_nmethod(nmethod* nm); // (ditto)
a61af66fc99e Initial load duke parents: diff changeset	787
a61af66fc99e Initial load duke parents: diff changeset	788 nmethodLocker(address pc); // derive nm from pc
a61af66fc99e Initial load duke parents: diff changeset	789 nmethodLocker(nmethod *nm) { _nm = nm; lock_nmethod(_nm); }
a61af66fc99e Initial load duke parents: diff changeset	790 nmethodLocker() { _nm = NULL; }
a61af66fc99e Initial load duke parents: diff changeset	791 ~nmethodLocker() { unlock_nmethod(_nm); }
a61af66fc99e Initial load duke parents: diff changeset	792
a61af66fc99e Initial load duke parents: diff changeset	793 nmethod* code() { return _nm; }
a61af66fc99e Initial load duke parents: diff changeset	794 void set_code(nmethod* new_nm) {
a61af66fc99e Initial load duke parents: diff changeset	795 unlock_nmethod(_nm); // note: This works even if _nm==new_nm.
a61af66fc99e Initial load duke parents: diff changeset	796 _nm = new_nm;
a61af66fc99e Initial load duke parents: diff changeset	797 lock_nmethod(_nm);
a61af66fc99e Initial load duke parents: diff changeset	798 }
a61af66fc99e Initial load duke parents: diff changeset	799 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	800
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	801 #endif // SHARE_VM_CODE_NMETHOD_HPP

Mercurial > hg > truffle

annotate src/share/vm/code/nmethod.hpp @ 20543:e7d0505c8a30