Mercurial > hg > truffle
annotate src/share/vm/code/nmethod.hpp @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | df832bd8edb9 |
| children | 02f27ecb4f3a 3aaa4b9966f6 606acabe7b5c |
| rev | line source |
|---|---|
| 0 | 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 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_CODE_NMETHOD_HPP |
| 26 #define SHARE_VM_CODE_NMETHOD_HPP | |
| 27 | |
| 28 #include "code/codeBlob.hpp" | |
| 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 | 31 |
| 0 | 32 // This class is used internally by nmethods, to cache |
| 33 // exception/pc/handler information. | |
| 34 | |
| 6197 | 35 class ExceptionCache : public CHeapObj<mtCode> { |
| 0 | 36 friend class VMStructs; |
| 37 private: | |
| 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 | 40 address _pc[cache_size]; |
| 41 address _handler[cache_size]; | |
| 42 int _count; | |
| 43 ExceptionCache* _next; | |
| 44 | |
| 45 address pc_at(int index) { assert(index >= 0 && index < count(),""); return _pc[index]; } | |
| 46 void set_pc_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _pc[index] = a; } | |
| 47 address handler_at(int index) { assert(index >= 0 && index < count(),""); return _handler[index]; } | |
| 48 void set_handler_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _handler[index] = a; } | |
| 49 int count() { return _count; } | |
| 50 void increment_count() { _count++; } | |
| 51 | |
| 52 public: | |
| 53 | |
| 54 ExceptionCache(Handle exception, address pc, address handler); | |
| 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 | 57 ExceptionCache* next() { return _next; } |
| 58 void set_next(ExceptionCache *ec) { _next = ec; } | |
| 59 | |
| 60 address match(Handle exception, address pc); | |
| 61 bool match_exception_with_space(Handle exception) ; | |
| 62 address test_address(address addr); | |
| 63 bool add_address_and_handler(address addr, address handler) ; | |
| 64 }; | |
| 65 | |
| 66 | |
| 67 // cache pc descs found in earlier inquiries | |
| 68 class PcDescCache VALUE_OBJ_CLASS_SPEC { | |
| 69 friend class VMStructs; | |
| 70 private: | |
| 71 enum { cache_size = 4 }; | |
| 72 PcDesc* _pc_descs[cache_size]; // last cache_size pc_descs found | |
| 73 public: | |
|
2339
3d5a546351ef
7023931: PcDescCache::find_pc_desc should not write _last_pc_desc
phh
parents:
2321
diff
changeset
|
74 PcDescCache() { debug_only(_pc_descs[0] = NULL); } |
| 0 | 75 void reset_to(PcDesc* initial_pc_desc); |
| 76 PcDesc* find_pc_desc(int pc_offset, bool approximate); | |
| 77 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
|
78 PcDesc* last_pc_desc() { return _pc_descs[0]; } |
| 0 | 79 }; |
| 80 | |
| 81 | |
| 82 // 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
|
83 // |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
84 // An nmethod contains: |
| 0 | 85 // - header (the nmethod structure) |
| 86 // [Relocation] | |
| 87 // - relocation information | |
| 88 // - 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
|
89 // - oop table |
| 0 | 90 // [Code] |
| 91 // - code body | |
| 92 // - exception handler | |
| 93 // - stub code | |
| 94 // [Debugging information] | |
| 95 // - oop array | |
| 96 // - data array | |
| 97 // - pcs | |
| 98 // [Exception handler table] | |
| 99 // - handler entry point array | |
| 100 // [Implicit Null Pointer exception table] | |
| 101 // - implicit null table array | |
| 102 | |
| 103 class Dependencies; | |
| 104 class ExceptionHandlerTable; | |
| 105 class ImplicitExceptionTable; | |
| 106 class AbstractCompiler; | |
| 107 class xmlStream; | |
| 108 | |
| 109 class nmethod : public CodeBlob { | |
| 110 friend class VMStructs; | |
| 111 friend class NMethodSweeper; | |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
2405
diff
changeset
|
112 friend class CodeCache; // scavengable oops |
| 0 | 113 private: |
| 114 // Shared fields for all nmethod's | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
115 Method* _method; |
| 0 | 116 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
|
117 jmethodID _jmethod_id; // Cache of method()->jmethod_id() |
| 0 | 118 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
119 // 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
|
120 nmethod* _osr_link; // from InstanceKlass::osr_nmethods_head |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
121 nmethod* _scavenge_root_link; // from CodeCache::scavenge_root_nmethods |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
122 |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
123 static nmethod* volatile _oops_do_mark_nmethods; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
124 nmethod* volatile _oops_do_mark_link; |
| 0 | 125 |
| 126 AbstractCompiler* _compiler; // The compiler which compiled this nmethod | |
| 127 | |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
128 // offsets for entry points |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
129 address _entry_point; // entry point with class check |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
130 address _verified_entry_point; // entry point without class check |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
131 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
|
132 |
| 0 | 133 // Offsets for different nmethod parts |
| 134 int _exception_offset; | |
| 1204 | 135 // All deoptee's will resume execution at this location described by |
| 136 // this offset. | |
| 0 | 137 int _deoptimize_offset; |
| 1204 | 138 // All deoptee's at a MethodHandle call site will resume execution |
| 139 // at this location described by this offset. | |
| 140 int _deoptimize_mh_offset; | |
|
1378
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1204
diff
changeset
|
141 // Offset of the unwind handler if it exists |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1204
diff
changeset
|
142 int _unwind_handler_offset; |
|
9f5b60a14736
6939930: exception unwind changes in 6919934 hurts compilation speed
never
parents:
1204
diff
changeset
|
143 |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
144 #ifdef HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
145 int _trap_offset; |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
146 #endif // def HAVE_DTRACE_H |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
147 int _consts_offset; |
| 0 | 148 int _stub_offset; |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
149 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
|
150 int _metadata_offset; // embedded meta data table |
| 0 | 151 int _scopes_data_offset; |
| 152 int _scopes_pcs_offset; | |
| 153 int _dependencies_offset; | |
| 154 int _handler_table_offset; | |
| 155 int _nul_chk_table_offset; | |
| 156 int _nmethod_end_offset; | |
| 157 | |
| 158 // location in frame (offset for sp) that deopt can store the original | |
| 159 // pc during a deopt. | |
| 160 int _orig_pc_offset; | |
| 161 | |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
162 int _compile_id; // which compilation made this nmethod |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
163 int _comp_level; // compilation level |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
164 |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
165 // protected by CodeCache_lock |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
166 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
|
167 |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
168 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
|
169 bool _marked_for_deoptimization; // Used for stack deoptimization |
| 0 | 170 |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
171 // 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
|
172 bool _unload_reported; |
| 0 | 173 |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
174 // set during construction |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
175 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
|
176 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
|
177 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
|
178 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
|
179 |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
180 // Protected by Patching_lock |
|
12324
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
181 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
|
182 |
| 1726 | 183 #ifdef ASSERT |
| 184 bool _oops_are_stale; // indicates that it's no longer safe to access oops section | |
| 185 #endif | |
| 186 | |
| 13441 | 187 enum { in_use = 0, // executable nmethod |
| 188 not_entrant = 1, // marked for deoptimization but activations may still exist, | |
| 189 // will be transformed to zombie when all activations are gone | |
| 190 zombie = 2, // no activations exist, nmethod is ready for purge | |
| 191 unloaded = 3 }; // there should be no activations, should not be called, | |
| 192 // will be transformed to zombie immediately | |
| 0 | 193 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
194 jbyte _scavenge_root_state; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
195 |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2321
diff
changeset
|
196 // 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
|
197 // 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
|
198 // 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
|
199 // event processing needs to be done. |
| 0 | 200 jint _lock_count; |
| 201 | |
| 202 // not_entrant method removal. Each mark_sweep pass will update | |
| 203 // 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
|
204 // stack. An not_entrant method can be removed when there are no |
| 0 | 205 // more activations, i.e., when the _stack_traversal_mark is less than |
| 206 // current sweep traversal index. | |
| 207 long _stack_traversal_mark; | |
| 208 | |
|
12324
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
209 // 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
|
210 // 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
|
211 // 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
|
212 // 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
|
213 // counter is decreased (by 1) while sweeping. |
|
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
214 int _hotness_counter; |
|
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
215 |
| 0 | 216 ExceptionCache *_exception_cache; |
| 217 PcDescCache _pc_desc_cache; | |
| 218 | |
| 2019 | 219 // These are used for compiled synchronized native methods to |
| 0 | 220 // locate the owner and stack slot for the BasicLock so that we can |
| 221 // properly revoke the bias of the owner if necessary. They are | |
| 222 // needed because there is no debug information for compiled native | |
| 223 // wrappers and the oop maps are insufficient to allow | |
| 224 // frame::retrieve_receiver() to work. Currently they are expected | |
| 225 // to be byte offsets from the Java stack pointer for maximum code | |
| 226 // sharing between platforms. Note that currently biased locking | |
| 227 // will never cause Class instances to be biased but this code | |
| 228 // handles the static synchronized case as well. | |
| 2019 | 229 // JVMTI's GetLocalInstance() also uses these offsets to find the receiver |
| 230 // for non-static native wrapper frames. | |
| 231 ByteSize _native_receiver_sp_offset; | |
| 232 ByteSize _native_basic_lock_sp_offset; | |
| 0 | 233 |
| 234 friend class nmethodLocker; | |
| 235 | |
| 236 // For native wrappers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
237 nmethod(Method* method, |
| 0 | 238 int nmethod_size, |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2375
diff
changeset
|
239 int compile_id, |
| 0 | 240 CodeOffsets* offsets, |
| 241 CodeBuffer *code_buffer, | |
| 242 int frame_size, | |
| 243 ByteSize basic_lock_owner_sp_offset, /* synchronized natives only */ | |
| 244 ByteSize basic_lock_sp_offset, /* synchronized natives only */ | |
| 245 OopMapSet* oop_maps); | |
| 246 | |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
247 #ifdef HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
248 // For native wrappers |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
249 nmethod(Method* method, |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
250 int nmethod_size, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
251 CodeOffsets* offsets, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
252 CodeBuffer *code_buffer, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
253 int frame_size); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
254 #endif // def HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
255 |
| 0 | 256 // Creation support |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
257 nmethod(Method* method, |
| 0 | 258 int nmethod_size, |
| 259 int compile_id, | |
| 260 int entry_bci, | |
| 261 CodeOffsets* offsets, | |
| 262 int orig_pc_offset, | |
| 263 DebugInformationRecorder *recorder, | |
| 264 Dependencies* dependencies, | |
| 265 CodeBuffer *code_buffer, | |
| 266 int frame_size, | |
| 267 OopMapSet* oop_maps, | |
| 268 ExceptionHandlerTable* handler_table, | |
| 269 ImplicitExceptionTable* nul_chk_table, | |
| 270 AbstractCompiler* compiler, | |
| 271 int comp_level); | |
| 272 | |
| 273 // helper methods | |
|
12146
9758d9f36299
8021954: VM SIGSEGV during classloading on MacOS; hs_err_pid file produced
coleenp
parents:
12080
diff
changeset
|
274 void* operator new(size_t size, int nmethod_size) throw(); |
| 0 | 275 |
| 276 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
|
277 // 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
|
278 // false if another thread performed the transition. |
| 1141 | 279 bool make_not_entrant_or_zombie(unsigned int state); |
| 0 | 280 void inc_decompile_count(); |
| 281 | |
| 282 // Used to manipulate the exception cache | |
| 283 void add_exception_cache_entry(ExceptionCache* new_entry); | |
| 284 ExceptionCache* exception_cache_entry_for_exception(Handle exception); | |
| 285 | |
| 286 // 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
|
287 void post_compiled_method_unload(); |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
288 |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
289 // Initailize fields to their default values |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
290 void init_defaults(); |
| 0 | 291 |
| 292 public: | |
| 293 // create nmethod with entry_bci | |
| 294 static nmethod* new_nmethod(methodHandle method, | |
| 295 int compile_id, | |
| 296 int entry_bci, | |
| 297 CodeOffsets* offsets, | |
| 298 int orig_pc_offset, | |
| 299 DebugInformationRecorder* recorder, | |
| 300 Dependencies* dependencies, | |
| 301 CodeBuffer *code_buffer, | |
| 302 int frame_size, | |
| 303 OopMapSet* oop_maps, | |
| 304 ExceptionHandlerTable* handler_table, | |
| 305 ImplicitExceptionTable* nul_chk_table, | |
| 306 AbstractCompiler* compiler, | |
| 307 int comp_level); | |
| 308 | |
| 309 static nmethod* new_native_nmethod(methodHandle method, | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2375
diff
changeset
|
310 int compile_id, |
| 0 | 311 CodeBuffer *code_buffer, |
| 312 int vep_offset, | |
| 313 int frame_complete, | |
| 314 int frame_size, | |
| 315 ByteSize receiver_sp_offset, | |
| 316 ByteSize basic_lock_sp_offset, | |
| 317 OopMapSet* oop_maps); | |
| 318 | |
|
116
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
319 #ifdef HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
320 // 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
|
321 // 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
|
322 // which is somewhat unfortunate. |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
323 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
|
324 CodeBuffer *code_buffer, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
325 int vep_offset, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
326 int trap_offset, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
327 int frame_complete, |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
328 int frame_size); |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
329 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
330 int trap_offset() const { return _trap_offset; } |
| 1748 | 331 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
|
332 |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
333 #endif // def HAVE_DTRACE_H |
|
018d5b58dd4f
6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes
kamg
parents:
100
diff
changeset
|
334 |
| 0 | 335 // accessors |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
336 Method* method() const { return _method; } |
| 0 | 337 AbstractCompiler* compiler() const { return _compiler; } |
| 338 | |
| 339 // type info | |
| 340 bool is_nmethod() const { return true; } | |
| 341 bool is_java_method() const { return !method()->is_native(); } | |
| 342 bool is_native_method() const { return method()->is_native(); } | |
| 343 bool is_osr_method() const { return _entry_bci != InvocationEntryBci; } | |
| 344 | |
| 345 bool is_compiled_by_c1() const; | |
| 346 bool is_compiled_by_c2() const; | |
| 1692 | 347 bool is_compiled_by_shark() const; |
| 0 | 348 |
| 349 // boundaries for different parts | |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
350 address consts_begin () const { return header_begin() + _consts_offset ; } |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
351 address consts_end () const { return header_begin() + code_offset() ; } |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
352 address insts_begin () const { return header_begin() + code_offset() ; } |
| 1748 | 353 address insts_end () const { return header_begin() + _stub_offset ; } |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
354 address stub_begin () const { return header_begin() + _stub_offset ; } |
|
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
355 address stub_end () const { return header_begin() + _oops_offset ; } |
| 1204 | 356 address exception_begin () const { return header_begin() + _exception_offset ; } |
| 357 address deopt_handler_begin () const { return header_begin() + _deoptimize_offset ; } | |
| 358 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
|
359 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
|
360 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
|
361 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
|
362 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
363 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
|
364 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
|
365 |
| 1204 | 366 address scopes_data_begin () const { return header_begin() + _scopes_data_offset ; } |
| 367 address scopes_data_end () const { return header_begin() + _scopes_pcs_offset ; } | |
| 368 PcDesc* scopes_pcs_begin () const { return (PcDesc*)(header_begin() + _scopes_pcs_offset ); } | |
| 369 PcDesc* scopes_pcs_end () const { return (PcDesc*)(header_begin() + _dependencies_offset) ; } | |
| 370 address dependencies_begin () const { return header_begin() + _dependencies_offset ; } | |
| 371 address dependencies_end () const { return header_begin() + _handler_table_offset ; } | |
| 372 address handler_table_begin () const { return header_begin() + _handler_table_offset ; } | |
| 373 address handler_table_end () const { return header_begin() + _nul_chk_table_offset ; } | |
| 374 address nul_chk_table_begin () const { return header_begin() + _nul_chk_table_offset ; } | |
| 375 address nul_chk_table_end () const { return header_begin() + _nmethod_end_offset ; } | |
| 0 | 376 |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
377 // Sizes |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
378 int consts_size () const { return consts_end () - consts_begin (); } |
| 1748 | 379 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
|
380 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
|
381 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
|
382 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
|
383 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
|
384 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
|
385 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
|
386 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
|
387 int nul_chk_table_size() const { return nul_chk_table_end() - nul_chk_table_begin(); } |
| 0 | 388 |
| 389 int total_size () const; | |
| 390 | |
|
12324
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
391 void dec_hotness_counter() { _hotness_counter--; } |
|
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
392 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
|
393 int hotness_counter() const { return _hotness_counter; } |
|
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
394 |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
395 // Containment |
|
1762
0878d7bae69f
6961697: move nmethod constants section before instruction section
twisti
parents:
1748
diff
changeset
|
396 bool consts_contains (address addr) const { return consts_begin () <= addr && addr < consts_end (); } |
| 1748 | 397 bool insts_contains (address addr) const { return insts_begin () <= addr && addr < insts_end (); } |
| 0 | 398 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
|
399 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
|
400 bool metadata_contains (Metadata** addr) const { return metadata_begin () <= addr && addr < metadata_end (); } |
| 0 | 401 bool scopes_data_contains (address addr) const { return scopes_data_begin () <= addr && addr < scopes_data_end (); } |
| 402 bool scopes_pcs_contains (PcDesc* addr) const { return scopes_pcs_begin () <= addr && addr < scopes_pcs_end (); } | |
| 403 bool handler_table_contains(address addr) const { return handler_table_begin() <= addr && addr < handler_table_end(); } | |
| 404 bool nul_chk_table_contains(address addr) const { return nul_chk_table_begin() <= addr && addr < nul_chk_table_end(); } | |
| 405 | |
| 406 // entry points | |
| 407 address entry_point() const { return _entry_point; } // normal entry point | |
| 408 address verified_entry_point() const { return _verified_entry_point; } // if klass is correct | |
| 409 | |
| 410 // flag accessing and manipulation | |
| 13441 | 411 bool is_in_use() const { return _state == in_use; } |
| 412 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
|
413 bool is_not_entrant() const { return _state == not_entrant; } |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
414 bool is_zombie() const { return _state == zombie; } |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
415 bool is_unloaded() const { return _state == unloaded; } |
| 0 | 416 |
|
1109
032260830071
5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents:
1000
diff
changeset
|
417 // 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
|
418 // 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
|
419 // 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
|
420 // another thread performed the transition. |
|
12324
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
421 bool make_not_entrant() { return make_not_entrant_or_zombie(not_entrant); } |
|
510fbd28919c
8020151: PSR:PERF Large performance regressions when code cache is filled
anoll
parents:
12146
diff
changeset
|
422 bool make_zombie() { return make_not_entrant_or_zombie(zombie); } |
| 0 | 423 |
| 424 // used by jvmti to track if the unload event has been reported | |
| 425 bool unload_reported() { return _unload_reported; } | |
| 426 void set_unload_reported() { _unload_reported = true; } | |
| 427 | |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
428 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
|
429 void mark_for_deoptimization() { _marked_for_deoptimization = true; } |
| 0 | 430 |
| 431 void make_unloaded(BoolObjectClosure* is_alive, oop cause); | |
| 432 | |
| 433 bool has_dependencies() { return dependencies_size() != 0; } | |
| 434 void flush_dependencies(BoolObjectClosure* is_alive); | |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
435 bool has_flushed_dependencies() { return _has_flushed_dependencies; } |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
436 void set_has_flushed_dependencies() { |
| 0 | 437 assert(!has_flushed_dependencies(), "should only happen once"); |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
438 _has_flushed_dependencies = 1; |
| 0 | 439 } |
| 440 | |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
441 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
|
442 void mark_for_reclamation() { _marked_for_reclamation = 1; } |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
443 |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
444 bool has_unsafe_access() const { return _has_unsafe_access; } |
|
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
445 void set_has_unsafe_access(bool z) { _has_unsafe_access = z; } |
| 0 | 446 |
|
1644
2a47bd84841f
6965184: possible races in make_not_entrant_or_zombie
never
parents:
1616
diff
changeset
|
447 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
|
448 void set_has_method_handle_invokes(bool z) { _has_method_handle_invokes = z; } |
| 0 | 449 |
|
4873
0382d2b469b2
7013347: allow crypto functions to be called inline to enhance performance
never
parents:
3899
diff
changeset
|
450 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
|
451 void set_lazy_critical_native(bool z) { _lazy_critical_native = z; } |
| 1202 | 452 |
|
6792
137868b7aa6f
7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents:
6725
diff
changeset
|
453 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
|
454 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
|
455 |
| 0 | 456 int comp_level() const { return _comp_level; } |
| 457 | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
458 // Support for oops in scopes and relocs: |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
459 // Note: index 0 is reserved for null. |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
460 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
|
461 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
|
462 // 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
|
463 assert(index > 0 && index <= oops_size(), "must be a valid non-zero index"); |
| 1726 | 464 assert(!_oops_are_stale, "oops are stale"); |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
465 return &oops_begin()[index - 1]; |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
466 } |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
467 |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
468 // Support for meta data in scopes and relocs: |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
469 // Note: index 0 is reserved for null. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
470 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
|
471 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
|
472 // 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
|
473 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
|
474 return &metadata_begin()[index - 1]; |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
475 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
476 |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
477 void copy_values(GrowableArray<jobject>* oops); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
478 void copy_values(GrowableArray<Metadata*>* metadata); |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
479 |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
480 // Relocation support |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
481 private: |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
482 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
|
483 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
|
484 |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
485 public: |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
486 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
|
487 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
|
488 void verify_oop_relocations(); |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
489 |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
490 bool is_at_poll_return(address pc); |
|
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
491 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
|
492 |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
2405
diff
changeset
|
493 // Scavengable oop support |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
494 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
|
495 protected: |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
2405
diff
changeset
|
496 enum { sl_on_list = 0x01, sl_marked = 0x10 }; |
|
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
2405
diff
changeset
|
497 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
|
498 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
|
499 // 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
|
500 #ifndef PRODUCT |
|
3377
2aa9ddbb9e60
7041789: 30% perf regression with c2/arm following 7017732
jmasa
parents:
2405
diff
changeset
|
501 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
|
502 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
|
503 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
|
504 // 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
|
505 #endif //PRODUCT |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
506 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
|
507 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
|
508 |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
509 public: |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
510 |
| 0 | 511 // Sweeper support |
| 512 long stack_traversal_mark() { return _stack_traversal_mark; } | |
| 513 void set_stack_traversal_mark(long l) { _stack_traversal_mark = l; } | |
| 514 | |
| 515 // Exception cache support | |
| 516 ExceptionCache* exception_cache() const { return _exception_cache; } | |
| 517 void set_exception_cache(ExceptionCache *ec) { _exception_cache = ec; } | |
| 518 address handler_for_exception_and_pc(Handle exception, address pc); | |
| 519 void add_handler_for_exception_and_pc(Handle exception, address pc, address handler); | |
| 520 void remove_from_exception_cache(ExceptionCache* ec); | |
| 521 | |
| 522 // implicit exceptions support | |
| 523 address continuation_for_implicit_exception(address pc); | |
| 524 | |
| 525 // On-stack replacement support | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2375
diff
changeset
|
526 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
|
527 address osr_entry() const { assert(is_osr_method(), "wrong kind of nmethod"); return _osr_entry_point; } |
| 0 | 528 void invalidate_osr_method(); |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
529 nmethod* osr_link() const { return _osr_link; } |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
530 void set_osr_link(nmethod *n) { _osr_link = n; } |
| 0 | 531 |
| 532 // tells whether frames described by this nmethod can be deoptimized | |
| 533 // note: native wrappers cannot be deoptimized. | |
| 534 bool can_be_deoptimized() const { return is_java_method(); } | |
| 535 | |
| 536 // Inline cache support | |
| 537 void clear_inline_caches(); | |
| 538 void cleanup_inline_caches(); | |
| 539 bool inlinecache_check_contains(address addr) const { | |
| 1748 | 540 return (addr >= code_begin() && addr < verified_entry_point()); |
| 0 | 541 } |
| 542 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
543 // Check that all metadata is still alive |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
544 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
|
545 |
| 0 | 546 // unlink and deallocate this nmethod |
| 547 // Only NMethodSweeper class is expected to use this. NMethodSweeper is not | |
| 548 // expected to use any other private methods/data in this class. | |
| 549 | |
| 550 protected: | |
| 551 void flush(); | |
| 552 | |
| 553 public: | |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2321
diff
changeset
|
554 // 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
|
555 // 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
|
556 // using it. |
| 0 | 557 bool is_locked_by_vm() const { return _lock_count >0; } |
| 558 | |
| 559 // See comment at definition of _last_seen_on_stack | |
| 560 void mark_as_seen_on_stack(); | |
| 561 bool can_not_entrant_be_converted(); | |
| 562 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
563 // 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
|
564 void set_method(Method* method) { _method = method; } |
| 0 | 565 |
| 566 // GC support | |
|
6787
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6725
diff
changeset
|
567 void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred); |
|
8966c2d65d96
7200470: KeepAliveClosure not needed in CodeCache::do_unloading
brutisso
parents:
6725
diff
changeset
|
568 bool can_unload(BoolObjectClosure* is_alive, oop* root, bool unloading_occurred); |
| 0 | 569 |
| 570 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, | |
| 571 OopClosure* f); | |
|
1563
1a5913bf5e19
6951083: oops and relocations should part of nmethod not CodeBlob
twisti
parents:
1538
diff
changeset
|
572 void oops_do(OopClosure* f) { oops_do(f, false); } |
| 12080 | 573 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
|
574 bool detect_scavenge_root_oops(); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
575 void verify_scavenge_root_oops() PRODUCT_RETURN; |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
576 |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
577 bool test_set_oops_do_mark(); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
578 static void oops_do_marking_prologue(); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
579 static void oops_do_marking_epilogue(); |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
605
diff
changeset
|
580 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
|
581 bool test_oops_do_mark() { return _oops_do_mark_link != NULL; } |
| 0 | 582 |
| 583 // ScopeDesc for an instruction | |
| 584 ScopeDesc* scope_desc_at(address pc); | |
| 585 | |
| 586 private: | |
| 587 ScopeDesc* scope_desc_in(address begin, address end); | |
| 588 | |
| 1204 | 589 address* orig_pc_addr(const frame* fr) { return (address*) ((address)fr->unextended_sp() + _orig_pc_offset); } |
| 0 | 590 |
| 591 PcDesc* find_pc_desc_internal(address pc, bool approximate); | |
| 592 | |
| 593 PcDesc* find_pc_desc(address pc, bool approximate) { | |
| 594 PcDesc* desc = _pc_desc_cache.last_pc_desc(); | |
| 1748 | 595 if (desc != NULL && desc->pc_offset() == pc - code_begin()) { |
| 0 | 596 return desc; |
| 597 } | |
| 598 return find_pc_desc_internal(pc, approximate); | |
| 599 } | |
| 600 | |
| 601 public: | |
| 602 // ScopeDesc retrieval operation | |
| 603 PcDesc* pc_desc_at(address pc) { return find_pc_desc(pc, false); } | |
| 604 // pc_desc_near returns the first PcDesc at or after the givne pc. | |
| 605 PcDesc* pc_desc_near(address pc) { return find_pc_desc(pc, true); } | |
| 606 | |
| 607 public: | |
| 608 // copying of debugging information | |
| 609 void copy_scopes_pcs(PcDesc* pcs, int count); | |
| 610 void copy_scopes_data(address buffer, int size); | |
| 611 | |
| 1204 | 612 // Deopt |
| 613 // Return true is the PC is one would expect if the frame is being deopted. | |
| 614 bool is_deopt_pc (address pc) { return is_deopt_entry(pc) || is_deopt_mh_entry(pc); } | |
| 615 bool is_deopt_entry (address pc) { return pc == deopt_handler_begin(); } | |
| 616 bool is_deopt_mh_entry(address pc) { return pc == deopt_mh_handler_begin(); } | |
| 0 | 617 // Accessor/mutator for the original pc of a frame before a frame was deopted. |
| 618 address get_original_pc(const frame* fr) { return *orig_pc_addr(fr); } | |
| 619 void set_original_pc(const frame* fr, address pc) { *orig_pc_addr(fr) = pc; } | |
| 620 | |
| 1204 | 621 static address get_deopt_original_pc(const frame* fr); |
| 622 | |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1109
diff
changeset
|
623 // MethodHandle |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1109
diff
changeset
|
624 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
|
625 |
| 0 | 626 // jvmti support: |
| 627 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
|
628 jmethodID get_and_cache_jmethod_id(); |
| 0 | 629 |
| 630 // verify operations | |
| 631 void verify(); | |
| 632 void verify_scopes(); | |
| 633 void verify_interrupt_point(address interrupt_point); | |
| 634 | |
| 635 // printing support | |
|
100
c7c777385a15
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
0
diff
changeset
|
636 void print() const; |
|
c7c777385a15
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
0
diff
changeset
|
637 void print_code(); |
| 0 | 638 void print_relocations() PRODUCT_RETURN; |
| 639 void print_pcs() PRODUCT_RETURN; | |
| 640 void print_scopes() PRODUCT_RETURN; | |
| 641 void print_dependencies() PRODUCT_RETURN; | |
| 642 void print_value_on(outputStream* st) const PRODUCT_RETURN; | |
| 643 void print_calls(outputStream* st) PRODUCT_RETURN; | |
| 644 void print_handler_table() PRODUCT_RETURN; | |
| 645 void print_nul_chk_table() PRODUCT_RETURN; | |
|
100
c7c777385a15
6667042: PrintAssembly option does not work without special plugin
jrose
parents:
0
diff
changeset
|
646 void print_nmethod(bool print_code); |
| 0 | 647 |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1644
diff
changeset
|
648 // 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
|
649 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
|
650 void print_on(outputStream* st, const char* msg) const; |
| 0 | 651 |
| 652 // Logging | |
| 653 void log_identity(xmlStream* log) const; | |
| 654 void log_new_nmethod() const; | |
|
1109
032260830071
5057818: codecache full and compiler disabled in bigapps fastdebug run
never
parents:
1000
diff
changeset
|
655 void log_state_change() const; |
| 0 | 656 |
|
1155
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1141
diff
changeset
|
657 // Prints block-level comments, including nmethod specific block labels: |
|
6796
b31471cdc53e
7200163: add CodeComments functionality to assember stubs
kvn
parents:
6792
diff
changeset
|
658 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
|
659 print_nmethod_labels(stream, block_begin); |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1141
diff
changeset
|
660 CodeBlob::print_block_comment(stream, block_begin); |
|
4e6abf09f540
6912062: disassembler plugin needs to produce symbolic information in product mode
jrose
parents:
1141
diff
changeset
|
661 } |
|
6796
b31471cdc53e
7200163: add CodeComments functionality to assember stubs
kvn
parents:
6792
diff
changeset
|
662 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
|
663 |
| 0 | 664 // 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
|
665 void print_code_comment_on(outputStream* st, int column, address begin, address end); |
| 0 | 666 static void print_statistics() PRODUCT_RETURN; |
| 667 | |
| 668 // Compiler task identification. Note that all OSR methods | |
| 669 // are numbered in an independent sequence if CICountOSR is true, | |
| 670 // and native method wrappers are also numbered independently if | |
| 671 // CICountNative is true. | |
| 672 int compile_id() const { return _compile_id; } | |
| 673 const char* compile_kind() const; | |
| 674 | |
| 675 // For debugging | |
| 676 // CompiledIC* IC_at(char* p) const; | |
| 677 // PrimitiveIC* primitiveIC_at(char* p) const; | |
| 678 oop embeddedOop_at(address p); | |
| 679 | |
| 680 // tells if any of this method's dependencies have been invalidated | |
| 681 // (this is expensive!) | |
| 682 bool check_all_dependencies(); | |
| 683 | |
| 684 // tells if this compiled method is dependent on the given changes, | |
| 685 // and the changes have invalidated it | |
| 686 bool check_dependency_on(DepChange& changes); | |
| 687 | |
| 688 // Evolution support. Tells if this compiled method is dependent on any of | |
| 689 // methods m() of class dependee, such that if m() in dependee is replaced, | |
| 690 // 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
|
691 bool is_evol_dependent_on(Klass* dependee); |
| 0 | 692 |
| 693 // Fast breakpoint support. Tells if this compiled method is | |
| 694 // dependent on the given method. Returns true if this nmethod | |
| 695 // corresponds to the given method as well. | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
696 bool is_dependent_on_method(Method* dependee); |
| 0 | 697 |
| 698 // is it ok to patch at address? | |
| 699 bool is_patchable_at(address instr_address); | |
| 700 | |
| 701 // UseBiasedLocking support | |
| 2019 | 702 ByteSize native_receiver_sp_offset() { |
| 703 return _native_receiver_sp_offset; | |
| 0 | 704 } |
| 2019 | 705 ByteSize native_basic_lock_sp_offset() { |
| 706 return _native_basic_lock_sp_offset; | |
| 0 | 707 } |
| 708 | |
| 709 // support for code generation | |
| 710 static int verified_entry_point_offset() { return offset_of(nmethod, _verified_entry_point); } | |
| 711 static int osr_entry_point_offset() { return offset_of(nmethod, _osr_entry_point); } | |
| 712 static int entry_bci_offset() { return offset_of(nmethod, _entry_bci); } | |
| 713 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
714 // 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
|
715 // redefine classes doesn't purge it. |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
716 static void mark_on_stack(nmethod* nm) { |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
717 nm->metadata_do(Metadata::mark_on_stack); |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
718 } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
719 void metadata_do(void f(Metadata*)); |
| 0 | 720 }; |
| 721 | |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2321
diff
changeset
|
722 // 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
|
723 // 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
|
724 // 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
|
725 // 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
|
726 // generated code from being reused too early. |
| 0 | 727 class nmethodLocker : public StackObj { |
| 728 nmethod* _nm; | |
| 729 | |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2019
diff
changeset
|
730 public: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2019
diff
changeset
|
731 |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2321
diff
changeset
|
732 // 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
|
733 // 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
|
734 // 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
|
735 static void lock_nmethod(nmethod* nm, bool zombie_ok = false); |
| 0 | 736 static void unlock_nmethod(nmethod* nm); // (ditto) |
| 737 | |
| 738 nmethodLocker(address pc); // derive nm from pc | |
| 739 nmethodLocker(nmethod *nm) { _nm = nm; lock_nmethod(_nm); } | |
| 740 nmethodLocker() { _nm = NULL; } | |
| 741 ~nmethodLocker() { unlock_nmethod(_nm); } | |
| 742 | |
| 743 nmethod* code() { return _nm; } | |
| 744 void set_code(nmethod* new_nm) { | |
| 745 unlock_nmethod(_nm); // note: This works even if _nm==new_nm. | |
| 746 _nm = new_nm; | |
| 747 lock_nmethod(_nm); | |
| 748 } | |
| 749 }; | |
| 1972 | 750 |
| 751 #endif // SHARE_VM_CODE_NMETHOD_HPP |