graal-compiler: src/share/vm/code/nmethod.hpp annotate

annotate src/share/vm/code/nmethod.hpp @ 3992:d1bdeef3e3e2

7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing. Reviewed-by: tonyp, brutisso, ysr

author	johnc
date	Wed, 12 Oct 2011 10:25:51 -0700
parents	c124e2e7463e
children	04b9a2566eec 0382d2b469b2

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2019 diff changeset	2 * Copyright (c) 1997, 2011, 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"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	30
0 a61af66fc99e Initial load duke parents: diff changeset	31 // This class is used internally by nmethods, to cache
a61af66fc99e Initial load duke parents: diff changeset	32 // exception/pc/handler information.
a61af66fc99e Initial load duke parents: diff changeset	33
a61af66fc99e Initial load duke parents: diff changeset	34 class ExceptionCache : public CHeapObj {
a61af66fc99e Initial load duke parents: diff changeset	35 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	36 private:
a61af66fc99e Initial load duke parents: diff changeset	37 enum { cache_size = 16 };
a61af66fc99e Initial load duke parents: diff changeset	38 klassOop _exception_type;
a61af66fc99e Initial load duke parents: diff changeset	39 address _pc[cache_size];
a61af66fc99e Initial load duke parents: diff changeset	40 address _handler[cache_size];
a61af66fc99e Initial load duke parents: diff changeset	41 int _count;
a61af66fc99e Initial load duke parents: diff changeset	42 ExceptionCache* _next;
a61af66fc99e Initial load duke parents: diff changeset	43
a61af66fc99e Initial load duke parents: diff changeset	44 address pc_at(int index) { assert(index >= 0 && index < count(),""); return _pc[index]; }
a61af66fc99e Initial load duke parents: diff changeset	45 void set_pc_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _pc[index] = a; }
a61af66fc99e Initial load duke parents: diff changeset	46 address handler_at(int index) { assert(index >= 0 && index < count(),""); return _handler[index]; }
a61af66fc99e Initial load duke parents: diff changeset	47 void set_handler_at(int index, address a) { assert(index >= 0 && index < cache_size,""); _handler[index] = a; }
a61af66fc99e Initial load duke parents: diff changeset	48 int count() { return _count; }
a61af66fc99e Initial load duke parents: diff changeset	49 void increment_count() { _count++; }
a61af66fc99e Initial load duke parents: diff changeset	50
a61af66fc99e Initial load duke parents: diff changeset	51 public:
a61af66fc99e Initial load duke parents: diff changeset	52
a61af66fc99e Initial load duke parents: diff changeset	53 ExceptionCache(Handle exception, address pc, address handler);
a61af66fc99e Initial load duke parents: diff changeset	54
a61af66fc99e Initial load duke parents: diff changeset	55 klassOop exception_type() { return _exception_type; }
a61af66fc99e Initial load duke parents: diff changeset	56 klassOop* exception_type_addr() { return &_exception_type; }
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 };
a61af66fc99e Initial load duke parents: diff changeset	72 PcDesc* _pc_descs[cache_size]; // last cache_size pc_descs found
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	75 void reset_to(PcDesc* initial_pc_desc);
a61af66fc99e Initial load duke parents: diff changeset	76 PcDesc* find_pc_desc(int pc_offset, bool approximate);
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	79 };
a61af66fc99e Initial load duke parents: diff changeset	80
a61af66fc99e Initial load duke parents: diff changeset	81
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	85 // - header (the nmethod structure)
a61af66fc99e Initial load duke parents: diff changeset	86 // [Relocation]
a61af66fc99e Initial load duke parents: diff changeset	87 // - relocation information
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	90 // [Code]
a61af66fc99e Initial load duke parents: diff changeset	91 // - code body
a61af66fc99e Initial load duke parents: diff changeset	92 // - exception handler
a61af66fc99e Initial load duke parents: diff changeset	93 // - stub code
a61af66fc99e Initial load duke parents: diff changeset	94 // [Debugging information]
a61af66fc99e Initial load duke parents: diff changeset	95 // - oop array
a61af66fc99e Initial load duke parents: diff changeset	96 // - data array
a61af66fc99e Initial load duke parents: diff changeset	97 // - pcs
a61af66fc99e Initial load duke parents: diff changeset	98 // [Exception handler table]
a61af66fc99e Initial load duke parents: diff changeset	99 // - handler entry point array
a61af66fc99e Initial load duke parents: diff changeset	100 // [Implicit Null Pointer exception table]
a61af66fc99e Initial load duke parents: diff changeset	101 // - implicit null table array
a61af66fc99e Initial load duke parents: diff changeset	102
a61af66fc99e Initial load duke parents: diff changeset	103 class Dependencies;
a61af66fc99e Initial load duke parents: diff changeset	104 class ExceptionHandlerTable;
a61af66fc99e Initial load duke parents: diff changeset	105 class ImplicitExceptionTable;
a61af66fc99e Initial load duke parents: diff changeset	106 class AbstractCompiler;
a61af66fc99e Initial load duke parents: diff changeset	107 class xmlStream;
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 class nmethod : public CodeBlob {
a61af66fc99e Initial load duke parents: diff changeset	110 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	113 private:
a61af66fc99e Initial load duke parents: diff changeset	114 // Shared fields for all nmethod's
a61af66fc99e Initial load duke parents: diff changeset	115 methodOop _method;
a61af66fc99e Initial load duke parents: diff changeset	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 a61af66fc99e Initial load duke parents: diff changeset	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:
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	120 nmethod* _osr_link; // from instanceKlass::osr_nmethods_head
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
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1201 diff changeset	122 nmethod* _saved_nmethod_link; // from CodeCache::speculatively_disconnect
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	123
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	124 static nmethod* volatile _oops_do_mark_nmethods;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	125 nmethod* volatile _oops_do_mark_link;
0 a61af66fc99e Initial load duke parents: diff changeset	126
a61af66fc99e Initial load duke parents: diff changeset	127 AbstractCompiler* _compiler; // The compiler which compiled this nmethod
a61af66fc99e Initial load duke parents: diff changeset	128
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	129 // offsets for entry points
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	130 address _entry_point; // entry point with class check
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	131 address _verified_entry_point; // entry point without class check
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	132 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	133
0 a61af66fc99e Initial load duke parents: diff changeset	134 // Offsets for different nmethod parts
a61af66fc99e Initial load duke parents: diff changeset	135 int _exception_offset;
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	136 // 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	137 // this offset.
0 a61af66fc99e Initial load duke parents: diff changeset	138 int _deoptimize_offset;
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	139 // 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	140 // at this location described by this offset.
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	141 int _deoptimize_mh_offset;
1378 9f5b60a14736 6939930: exception unwind changes in 6919934 hurts compilation speed never parents: 1204 diff changeset	142 // Offset of the unwind handler if it exists
9f5b60a14736 6939930: exception unwind changes in 6919934 hurts compilation speed never parents: 1204 diff changeset	143 int _unwind_handler_offset;
9f5b60a14736 6939930: exception unwind changes in 6919934 hurts compilation speed never parents: 1204 diff changeset	144
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	145 #ifdef HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	146 int _trap_offset;
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	147 #endif // def HAVE_DTRACE_H
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	148 int _consts_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	149 int _stub_offset;
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	150 int _oops_offset; // offset to where embedded oop table begins (inside data)
0 a61af66fc99e Initial load duke parents: diff changeset	151 int _scopes_data_offset;
a61af66fc99e Initial load duke parents: diff changeset	152 int _scopes_pcs_offset;
a61af66fc99e Initial load duke parents: diff changeset	153 int _dependencies_offset;
a61af66fc99e Initial load duke parents: diff changeset	154 int _handler_table_offset;
a61af66fc99e Initial load duke parents: diff changeset	155 int _nul_chk_table_offset;
a61af66fc99e Initial load duke parents: diff changeset	156 int _nmethod_end_offset;
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158 // location in frame (offset for sp) that deopt can store the original
a61af66fc99e Initial load duke parents: diff changeset	159 // pc during a deopt.
a61af66fc99e Initial load duke parents: diff changeset	160 int _orig_pc_offset;
a61af66fc99e Initial load duke parents: diff changeset	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 bool _speculatively_disconnected; // Marked for potential unload
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	168
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	169 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	170 bool _marked_for_deoptimization; // Used for stack deoptimization
0 a61af66fc99e Initial load duke parents: diff changeset	171
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	172 // 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	173 bool _unload_reported;
0 a61af66fc99e Initial load duke parents: diff changeset	174
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	175 // set during construction
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	176 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	177 unsigned int _has_method_handle_invokes:1; // Has this method MethodHandle invokes?
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	178
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	179 // Protected by Patching_lock
2339 3d5a546351ef 7023931: PcDescCache::find_pc_desc should not write _last_pc_desc phh parents: 2321 diff changeset	180 unsigned char _state; // {alive, not_entrant, zombie, unloaded}
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	181
1726 71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	182 #ifdef ASSERT
71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	183 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	184 #endif
71faaa8e3ccc 6974176: ShouldNotReachHere, instanceKlass.cpp:1426 never parents: 1692 diff changeset	185
0 a61af66fc99e Initial load duke parents: diff changeset	186 enum { alive = 0,
605 98cb887364d3 6810672: Comment typos twisti parents: 196 diff changeset	187 not_entrant = 1, // uncommon trap has happened but activations may still exist
0 a61af66fc99e Initial load duke parents: diff changeset	188 zombie = 2,
a61af66fc99e Initial load duke parents: diff changeset	189 unloaded = 3 };
a61af66fc99e Initial load duke parents: diff changeset	190
a61af66fc99e Initial load duke parents: diff changeset	191
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	192 jbyte _scavenge_root_state;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	193
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	194 // 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	195 // 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	196 // 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	197 // event processing needs to be done.
0 a61af66fc99e Initial load duke parents: diff changeset	198 jint _lock_count;
a61af66fc99e Initial load duke parents: diff changeset	199
a61af66fc99e Initial load duke parents: diff changeset	200 // not_entrant method removal. Each mark_sweep pass will update
a61af66fc99e Initial load duke parents: diff changeset	201 // this mark to current sweep invocation count if it is seen on the
a61af66fc99e Initial load duke parents: diff changeset	202 // stack. An not_entrant method can be removed when there is no
a61af66fc99e Initial load duke parents: diff changeset	203 // more activations, i.e., when the _stack_traversal_mark is less than
a61af66fc99e Initial load duke parents: diff changeset	204 // current sweep traversal index.
a61af66fc99e Initial load duke parents: diff changeset	205 long _stack_traversal_mark;
a61af66fc99e Initial load duke parents: diff changeset	206
a61af66fc99e Initial load duke parents: diff changeset	207 ExceptionCache *_exception_cache;
a61af66fc99e Initial load duke parents: diff changeset	208 PcDescCache _pc_desc_cache;
a61af66fc99e Initial load duke parents: diff changeset	209
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	210 // These are used for compiled synchronized native methods to
0 a61af66fc99e Initial load duke parents: diff changeset	211 // locate the owner and stack slot for the BasicLock so that we can
a61af66fc99e Initial load duke parents: diff changeset	212 // properly revoke the bias of the owner if necessary. They are
a61af66fc99e Initial load duke parents: diff changeset	213 // needed because there is no debug information for compiled native
a61af66fc99e Initial load duke parents: diff changeset	214 // wrappers and the oop maps are insufficient to allow
a61af66fc99e Initial load duke parents: diff changeset	215 // frame::retrieve_receiver() to work. Currently they are expected
a61af66fc99e Initial load duke parents: diff changeset	216 // to be byte offsets from the Java stack pointer for maximum code
a61af66fc99e Initial load duke parents: diff changeset	217 // sharing between platforms. Note that currently biased locking
a61af66fc99e Initial load duke parents: diff changeset	218 // will never cause Class instances to be biased but this code
a61af66fc99e Initial load duke parents: diff changeset	219 // handles the static synchronized case as well.
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	220 // 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	221 // for non-static native wrapper frames.
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	222 ByteSize _native_receiver_sp_offset;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	223 ByteSize _native_basic_lock_sp_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 friend class nmethodLocker;
a61af66fc99e Initial load duke parents: diff changeset	226
a61af66fc99e Initial load duke parents: diff changeset	227 // For native wrappers
a61af66fc99e Initial load duke parents: diff changeset	228 nmethod(methodOop method,
a61af66fc99e Initial load duke parents: diff changeset	229 int nmethod_size,
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	230 int compile_id,
0 a61af66fc99e Initial load duke parents: diff changeset	231 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	232 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	233 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	234 ByteSize basic_lock_owner_sp_offset, /* synchronized natives only */
a61af66fc99e Initial load duke parents: diff changeset	235 ByteSize basic_lock_sp_offset, /* synchronized natives only */
a61af66fc99e Initial load duke parents: diff changeset	236 OopMapSet* oop_maps);
a61af66fc99e Initial load duke parents: diff changeset	237
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	238 #ifdef HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	239 // For native wrappers
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	240 nmethod(methodOop method,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	241 int nmethod_size,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	242 CodeOffsets* offsets,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	243 CodeBuffer *code_buffer,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	244 int frame_size);
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	245 #endif // def HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	246
0 a61af66fc99e Initial load duke parents: diff changeset	247 // Creation support
a61af66fc99e Initial load duke parents: diff changeset	248 nmethod(methodOop method,
a61af66fc99e Initial load duke parents: diff changeset	249 int nmethod_size,
a61af66fc99e Initial load duke parents: diff changeset	250 int compile_id,
a61af66fc99e Initial load duke parents: diff changeset	251 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	252 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	253 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	254 DebugInformationRecorder *recorder,
a61af66fc99e Initial load duke parents: diff changeset	255 Dependencies* dependencies,
a61af66fc99e Initial load duke parents: diff changeset	256 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	257 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	258 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	259 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	260 ImplicitExceptionTable* nul_chk_table,
a61af66fc99e Initial load duke parents: diff changeset	261 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	262 int comp_level);
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 // helper methods
a61af66fc99e Initial load duke parents: diff changeset	265 void* operator new(size_t size, int nmethod_size);
a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 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	268 // 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	269 // false if another thread performed the transition.
1141 b1f619d38249 6914002: unsigned compare problem after 5057818 never parents: 1135 diff changeset	270 bool make_not_entrant_or_zombie(unsigned int state);
0 a61af66fc99e Initial load duke parents: diff changeset	271 void inc_decompile_count();
a61af66fc99e Initial load duke parents: diff changeset	272
a61af66fc99e Initial load duke parents: diff changeset	273 // Used to manipulate the exception cache
a61af66fc99e Initial load duke parents: diff changeset	274 void add_exception_cache_entry(ExceptionCache* new_entry);
a61af66fc99e Initial load duke parents: diff changeset	275 ExceptionCache* exception_cache_entry_for_exception(Handle exception);
a61af66fc99e Initial load duke parents: diff changeset	276
a61af66fc99e Initial load duke parents: diff changeset	277 // 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	278 void post_compiled_method_unload();
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	279
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	280 // Initailize fields to their default values
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	281 void init_defaults();
0 a61af66fc99e Initial load duke parents: diff changeset	282
a61af66fc99e Initial load duke parents: diff changeset	283 public:
a61af66fc99e Initial load duke parents: diff changeset	284 // create nmethod with entry_bci
a61af66fc99e Initial load duke parents: diff changeset	285 static nmethod* new_nmethod(methodHandle method,
a61af66fc99e Initial load duke parents: diff changeset	286 int compile_id,
a61af66fc99e Initial load duke parents: diff changeset	287 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	288 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	289 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	290 DebugInformationRecorder* recorder,
a61af66fc99e Initial load duke parents: diff changeset	291 Dependencies* dependencies,
a61af66fc99e Initial load duke parents: diff changeset	292 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	293 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	294 OopMapSet* oop_maps,
a61af66fc99e Initial load duke parents: diff changeset	295 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	296 ImplicitExceptionTable* nul_chk_table,
a61af66fc99e Initial load duke parents: diff changeset	297 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	298 int comp_level);
a61af66fc99e Initial load duke parents: diff changeset	299
a61af66fc99e Initial load duke parents: diff changeset	300 static nmethod* new_native_nmethod(methodHandle method,
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	301 int compile_id,
0 a61af66fc99e Initial load duke parents: diff changeset	302 CodeBuffer *code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	303 int vep_offset,
a61af66fc99e Initial load duke parents: diff changeset	304 int frame_complete,
a61af66fc99e Initial load duke parents: diff changeset	305 int frame_size,
a61af66fc99e Initial load duke parents: diff changeset	306 ByteSize receiver_sp_offset,
a61af66fc99e Initial load duke parents: diff changeset	307 ByteSize basic_lock_sp_offset,
a61af66fc99e Initial load duke parents: diff changeset	308 OopMapSet* oop_maps);
a61af66fc99e Initial load duke parents: diff changeset	309
116 018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	310 #ifdef HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	311 // 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	312 // 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	313 // which is somewhat unfortunate.
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	314 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	315 CodeBuffer *code_buffer,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	316 int vep_offset,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	317 int trap_offset,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	318 int frame_complete,
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	319 int frame_size);
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	320
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	321 int trap_offset() const { return _trap_offset; }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	322 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	323
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	324 #endif // def HAVE_DTRACE_H
018d5b58dd4f 6537506: Provide a mechanism for specifying Java-level USDT-like dtrace probes kamg parents: 100 diff changeset	325
0 a61af66fc99e Initial load duke parents: diff changeset	326 // accessors
a61af66fc99e Initial load duke parents: diff changeset	327 methodOop method() const { return _method; }
a61af66fc99e Initial load duke parents: diff changeset	328 AbstractCompiler* compiler() const { return _compiler; }
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 // type info
a61af66fc99e Initial load duke parents: diff changeset	331 bool is_nmethod() const { return true; }
a61af66fc99e Initial load duke parents: diff changeset	332 bool is_java_method() const { return !method()->is_native(); }
a61af66fc99e Initial load duke parents: diff changeset	333 bool is_native_method() const { return method()->is_native(); }
a61af66fc99e Initial load duke parents: diff changeset	334 bool is_osr_method() const { return _entry_bci != InvocationEntryBci; }
a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336 bool is_compiled_by_c1() const;
a61af66fc99e Initial load duke parents: diff changeset	337 bool is_compiled_by_c2() const;
1692 d2ede61b7a12 6976186: integrate Shark HotSpot changes twisti parents: 1681 diff changeset	338 bool is_compiled_by_shark() const;
0 a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 // boundaries for different parts
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	341 address consts_begin () const { return header_begin() + _consts_offset ; }
0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	342 address consts_end () const { return header_begin() + code_offset() ; }
0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	343 address insts_begin () const { return header_begin() + code_offset() ; }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	344 address insts_end () const { return header_begin() + _stub_offset ; }
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	345 address stub_begin () const { return header_begin() + _stub_offset ; }
0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	346 address stub_end () const { return header_begin() + _oops_offset ; }
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	347 address exception_begin () const { return header_begin() + _exception_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	348 address deopt_handler_begin () const { return header_begin() + _deoptimize_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	349 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	350 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	351 oop* oops_begin () const { return (oop*) (header_begin() + _oops_offset) ; }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	352 oop* oops_end () const { return (oop*) (header_begin() + _scopes_data_offset) ; }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	353
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	354 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	355 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	356 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	357 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	358 address dependencies_begin () const { return header_begin() + _dependencies_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	359 address dependencies_end () const { return header_begin() + _handler_table_offset ; }
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	360 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	361 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	362 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	363 address nul_chk_table_end () const { return header_begin() + _nmethod_end_offset ; }
0 a61af66fc99e Initial load duke parents: diff changeset	364
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	365 // Sizes
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	366 int consts_size () const { return consts_end () - consts_begin (); }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	367 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	368 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	369 int oops_size () const { return (address) oops_end () - (address) oops_begin (); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	370 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	371 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	372 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	373 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	374 int nul_chk_table_size() const { return nul_chk_table_end() - nul_chk_table_begin(); }
0 a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 int total_size () const;
a61af66fc99e Initial load duke parents: diff changeset	377
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	378 // Containment
1762 0878d7bae69f 6961697: move nmethod constants section before instruction section twisti parents: 1748 diff changeset	379 bool consts_contains (address addr) const { return consts_begin () <= addr && addr < consts_end (); }
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	380 bool insts_contains (address addr) const { return insts_begin () <= addr && addr < insts_end (); }
0 a61af66fc99e Initial load duke parents: diff changeset	381 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	382 bool oops_contains (oop* addr) const { return oops_begin () <= addr && addr < oops_end (); }
0 a61af66fc99e Initial load duke parents: diff changeset	383 bool scopes_data_contains (address addr) const { return scopes_data_begin () <= addr && addr < scopes_data_end (); }
a61af66fc99e Initial load duke parents: diff changeset	384 bool scopes_pcs_contains (PcDesc* addr) const { return scopes_pcs_begin () <= addr && addr < scopes_pcs_end (); }
a61af66fc99e Initial load duke parents: diff changeset	385 bool handler_table_contains(address addr) const { return handler_table_begin() <= addr && addr < handler_table_end(); }
a61af66fc99e Initial load duke parents: diff changeset	386 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	387
a61af66fc99e Initial load duke parents: diff changeset	388 // entry points
a61af66fc99e Initial load duke parents: diff changeset	389 address entry_point() const { return _entry_point; } // normal entry point
a61af66fc99e Initial load duke parents: diff changeset	390 address verified_entry_point() const { return _verified_entry_point; } // if klass is correct
a61af66fc99e Initial load duke parents: diff changeset	391
a61af66fc99e Initial load duke parents: diff changeset	392 // flag accessing and manipulation
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	393 bool is_in_use() const { return _state == alive; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	394 bool is_alive() const { return _state == alive \|\| _state == not_entrant; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	395 bool is_not_entrant() const { return _state == not_entrant; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	396 bool is_zombie() const { return _state == zombie; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	397 bool is_unloaded() const { return _state == unloaded; }
0 a61af66fc99e Initial load duke parents: diff changeset	398
1109 032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	399 // 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	400 // 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	401 // 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	402 // another thread performed the transition.
032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	403 bool make_not_entrant() { return make_not_entrant_or_zombie(not_entrant); }
032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	404 bool make_zombie() { return make_not_entrant_or_zombie(zombie); }
0 a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 // used by jvmti to track if the unload event has been reported
a61af66fc99e Initial load duke parents: diff changeset	407 bool unload_reported() { return _unload_reported; }
a61af66fc99e Initial load duke parents: diff changeset	408 void set_unload_reported() { _unload_reported = true; }
a61af66fc99e Initial load duke parents: diff changeset	409
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	410 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	411 void mark_for_deoptimization() { _marked_for_deoptimization = true; }
0 a61af66fc99e Initial load duke parents: diff changeset	412
a61af66fc99e Initial load duke parents: diff changeset	413 void make_unloaded(BoolObjectClosure* is_alive, oop cause);
a61af66fc99e Initial load duke parents: diff changeset	414
a61af66fc99e Initial load duke parents: diff changeset	415 bool has_dependencies() { return dependencies_size() != 0; }
a61af66fc99e Initial load duke parents: diff changeset	416 void flush_dependencies(BoolObjectClosure* is_alive);
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	417 bool has_flushed_dependencies() { return _has_flushed_dependencies; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	418 void set_has_flushed_dependencies() {
0 a61af66fc99e Initial load duke parents: diff changeset	419 assert(!has_flushed_dependencies(), "should only happen once");
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	420 _has_flushed_dependencies = 1;
0 a61af66fc99e Initial load duke parents: diff changeset	421 }
a61af66fc99e Initial load duke parents: diff changeset	422
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	423 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	424 void mark_for_reclamation() { _marked_for_reclamation = 1; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	425
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	426 bool has_unsafe_access() const { return _has_unsafe_access; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	427 void set_has_unsafe_access(bool z) { _has_unsafe_access = z; }
0 a61af66fc99e Initial load duke parents: diff changeset	428
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	429 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	430 void set_has_method_handle_invokes(bool z) { _has_method_handle_invokes = z; }
0 a61af66fc99e Initial load duke parents: diff changeset	431
1644 2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	432 bool is_speculatively_disconnected() const { return _speculatively_disconnected; }
2a47bd84841f 6965184: possible races in make_not_entrant_or_zombie never parents: 1616 diff changeset	433 void set_speculatively_disconnected(bool z) { _speculatively_disconnected = z; }
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1201 diff changeset	434
0 a61af66fc99e Initial load duke parents: diff changeset	435 int comp_level() const { return _comp_level; }
a61af66fc99e Initial load duke parents: diff changeset	436
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	437 // Support for oops in scopes and relocs:
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	438 // Note: index 0 is reserved for null.
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	439 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	440 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	441 // 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	442 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	443 assert(!_oops_are_stale, "oops are stale");
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	444 return &oops_begin()[index - 1];
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	445 }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	446
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	447 void copy_oops(GrowableArray<jobject>* oops);
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	448
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	449 // Relocation support
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	450 private:
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	451 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	452 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	453
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	454 public:
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	455 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	456 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	457 void verify_oop_relocations();
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	458
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	459 bool is_at_poll_return(address pc);
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	460 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	461
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	462 // Scavengable oop support
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	463 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	464 protected:
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	465 enum { sl_on_list = 0x01, sl_marked = 0x10 };
2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	466 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	467 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	468 // 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	469 #ifndef PRODUCT
3377 2aa9ddbb9e60 7041789: 30% perf regression with c2/arm following 7017732 jmasa parents: 2405 diff changeset	470 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	471 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	472 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	473 // 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	474 #endif //PRODUCT
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	475 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	476 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	477
1202 5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1201 diff changeset	478 nmethod* saved_nmethod_link() const { return _saved_nmethod_link; }
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1201 diff changeset	479 void set_saved_nmethod_link(nmethod *n) { _saved_nmethod_link = n; }
5f24d0319e54 4360113: Evict nmethods when code cache gets full kvn parents: 1201 diff changeset	480
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	481 public:
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	482
0 a61af66fc99e Initial load duke parents: diff changeset	483 // Sweeper support
a61af66fc99e Initial load duke parents: diff changeset	484 long stack_traversal_mark() { return _stack_traversal_mark; }
a61af66fc99e Initial load duke parents: diff changeset	485 void set_stack_traversal_mark(long l) { _stack_traversal_mark = l; }
a61af66fc99e Initial load duke parents: diff changeset	486
a61af66fc99e Initial load duke parents: diff changeset	487 // Exception cache support
a61af66fc99e Initial load duke parents: diff changeset	488 ExceptionCache* exception_cache() const { return _exception_cache; }
a61af66fc99e Initial load duke parents: diff changeset	489 void set_exception_cache(ExceptionCache *ec) { _exception_cache = ec; }
a61af66fc99e Initial load duke parents: diff changeset	490 address handler_for_exception_and_pc(Handle exception, address pc);
a61af66fc99e Initial load duke parents: diff changeset	491 void add_handler_for_exception_and_pc(Handle exception, address pc, address handler);
a61af66fc99e Initial load duke parents: diff changeset	492 void remove_from_exception_cache(ExceptionCache* ec);
a61af66fc99e Initial load duke parents: diff changeset	493
a61af66fc99e Initial load duke parents: diff changeset	494 // implicit exceptions support
a61af66fc99e Initial load duke parents: diff changeset	495 address continuation_for_implicit_exception(address pc);
a61af66fc99e Initial load duke parents: diff changeset	496
a61af66fc99e Initial load duke parents: diff changeset	497 // On-stack replacement support
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2375 diff changeset	498 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	499 address osr_entry() const { assert(is_osr_method(), "wrong kind of nmethod"); return _osr_entry_point; }
0 a61af66fc99e Initial load duke parents: diff changeset	500 void invalidate_osr_method();
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	501 nmethod* osr_link() const { return _osr_link; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	502 void set_osr_link(nmethod *n) { _osr_link = n; }
0 a61af66fc99e Initial load duke parents: diff changeset	503
a61af66fc99e Initial load duke parents: diff changeset	504 // tells whether frames described by this nmethod can be deoptimized
a61af66fc99e Initial load duke parents: diff changeset	505 // note: native wrappers cannot be deoptimized.
a61af66fc99e Initial load duke parents: diff changeset	506 bool can_be_deoptimized() const { return is_java_method(); }
a61af66fc99e Initial load duke parents: diff changeset	507
a61af66fc99e Initial load duke parents: diff changeset	508 // Inline cache support
a61af66fc99e Initial load duke parents: diff changeset	509 void clear_inline_caches();
a61af66fc99e Initial load duke parents: diff changeset	510 void cleanup_inline_caches();
a61af66fc99e Initial load duke parents: diff changeset	511 bool inlinecache_check_contains(address addr) const {
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	512 return (addr >= code_begin() && addr < verified_entry_point());
0 a61af66fc99e Initial load duke parents: diff changeset	513 }
a61af66fc99e Initial load duke parents: diff changeset	514
a61af66fc99e Initial load duke parents: diff changeset	515 // unlink and deallocate this nmethod
a61af66fc99e Initial load duke parents: diff changeset	516 // Only NMethodSweeper class is expected to use this. NMethodSweeper is not
a61af66fc99e Initial load duke parents: diff changeset	517 // expected to use any other private methods/data in this class.
a61af66fc99e Initial load duke parents: diff changeset	518
a61af66fc99e Initial load duke parents: diff changeset	519 protected:
a61af66fc99e Initial load duke parents: diff changeset	520 void flush();
a61af66fc99e Initial load duke parents: diff changeset	521
a61af66fc99e Initial load duke parents: diff changeset	522 public:
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	523 // 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	524 // 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	525 // using it.
0 a61af66fc99e Initial load duke parents: diff changeset	526 bool is_locked_by_vm() const { return _lock_count >0; }
a61af66fc99e Initial load duke parents: diff changeset	527
a61af66fc99e Initial load duke parents: diff changeset	528 // See comment at definition of _last_seen_on_stack
a61af66fc99e Initial load duke parents: diff changeset	529 void mark_as_seen_on_stack();
a61af66fc99e Initial load duke parents: diff changeset	530 bool can_not_entrant_be_converted();
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532 // Evolution support. We make old (discarded) compiled methods point to new methodOops.
a61af66fc99e Initial load duke parents: diff changeset	533 void set_method(methodOop method) { _method = method; }
a61af66fc99e Initial load duke parents: diff changeset	534
a61af66fc99e Initial load duke parents: diff changeset	535 // GC support
a61af66fc99e Initial load duke parents: diff changeset	536 void do_unloading(BoolObjectClosure* is_alive, OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	537 bool unloading_occurred);
a61af66fc99e Initial load duke parents: diff changeset	538 bool can_unload(BoolObjectClosure* is_alive, OopClosure* keep_alive,
a61af66fc99e Initial load duke parents: diff changeset	539 oop* root, bool unloading_occurred);
a61af66fc99e Initial load duke parents: diff changeset	540
a61af66fc99e Initial load duke parents: diff changeset	541 void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map,
a61af66fc99e Initial load duke parents: diff changeset	542 OopClosure* f);
1563 1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	543 void oops_do(OopClosure* f) { oops_do(f, false); }
1a5913bf5e19 6951083: oops and relocations should part of nmethod not CodeBlob twisti parents: 1538 diff changeset	544 void oops_do(OopClosure* f, bool do_strong_roots_only);
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	545 bool detect_scavenge_root_oops();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	546 void verify_scavenge_root_oops() PRODUCT_RETURN;
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	547
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	548 bool test_set_oops_do_mark();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	549 static void oops_do_marking_prologue();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	550 static void oops_do_marking_epilogue();
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	551 static bool oops_do_marking_is_active() { return _oops_do_mark_nmethods != NULL; }
148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 605 diff changeset	552 DEBUG_ONLY(bool test_oops_do_mark() { return _oops_do_mark_link != NULL; })
0 a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 // ScopeDesc for an instruction
a61af66fc99e Initial load duke parents: diff changeset	555 ScopeDesc* scope_desc_at(address pc);
a61af66fc99e Initial load duke parents: diff changeset	556
a61af66fc99e Initial load duke parents: diff changeset	557 private:
a61af66fc99e Initial load duke parents: diff changeset	558 ScopeDesc* scope_desc_in(address begin, address end);
a61af66fc99e Initial load duke parents: diff changeset	559
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	560 address* orig_pc_addr(const frame* fr) { return (address*) ((address)fr->unextended_sp() + _orig_pc_offset); }
0 a61af66fc99e Initial load duke parents: diff changeset	561
a61af66fc99e Initial load duke parents: diff changeset	562 PcDesc* find_pc_desc_internal(address pc, bool approximate);
a61af66fc99e Initial load duke parents: diff changeset	563
a61af66fc99e Initial load duke parents: diff changeset	564 PcDesc* find_pc_desc(address pc, bool approximate) {
a61af66fc99e Initial load duke parents: diff changeset	565 PcDesc* desc = _pc_desc_cache.last_pc_desc();
1748 3e8fbc61cee8 6978355: renaming for 6961697 twisti parents: 1726 diff changeset	566 if (desc != NULL && desc->pc_offset() == pc - code_begin()) {
0 a61af66fc99e Initial load duke parents: diff changeset	567 return desc;
a61af66fc99e Initial load duke parents: diff changeset	568 }
a61af66fc99e Initial load duke parents: diff changeset	569 return find_pc_desc_internal(pc, approximate);
a61af66fc99e Initial load duke parents: diff changeset	570 }
a61af66fc99e Initial load duke parents: diff changeset	571
a61af66fc99e Initial load duke parents: diff changeset	572 public:
a61af66fc99e Initial load duke parents: diff changeset	573 // ScopeDesc retrieval operation
a61af66fc99e Initial load duke parents: diff changeset	574 PcDesc* pc_desc_at(address pc) { return find_pc_desc(pc, false); }
a61af66fc99e Initial load duke parents: diff changeset	575 // pc_desc_near returns the first PcDesc at or after the givne pc.
a61af66fc99e Initial load duke parents: diff changeset	576 PcDesc* pc_desc_near(address pc) { return find_pc_desc(pc, true); }
a61af66fc99e Initial load duke parents: diff changeset	577
a61af66fc99e Initial load duke parents: diff changeset	578 public:
a61af66fc99e Initial load duke parents: diff changeset	579 // copying of debugging information
a61af66fc99e Initial load duke parents: diff changeset	580 void copy_scopes_pcs(PcDesc* pcs, int count);
a61af66fc99e Initial load duke parents: diff changeset	581 void copy_scopes_data(address buffer, int size);
a61af66fc99e Initial load duke parents: diff changeset	582
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	583 // Deopt
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	584 // 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	585 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	586 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	587 bool is_deopt_mh_entry(address pc) { return pc == deopt_mh_handler_begin(); }
0 a61af66fc99e Initial load duke parents: diff changeset	588 // Accessor/mutator for the original pc of a frame before a frame was deopted.
a61af66fc99e Initial load duke parents: diff changeset	589 address get_original_pc(const frame* fr) { return *orig_pc_addr(fr); }
a61af66fc99e Initial load duke parents: diff changeset	590 void set_original_pc(const frame* fr, address pc) { *orig_pc_addr(fr) = pc; }
a61af66fc99e Initial load duke parents: diff changeset	591
1204 18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	592 static address get_deopt_original_pc(const frame* fr);
18a389214829 6921352: JSR 292 needs its own deopt handler twisti parents: 1202 diff changeset	593
1135 e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 1109 diff changeset	594 // MethodHandle
e66fd840cb6b 6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164) twisti parents: 1109 diff changeset	595 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	596
0 a61af66fc99e Initial load duke parents: diff changeset	597 // jvmti support:
a61af66fc99e Initial load duke parents: diff changeset	598 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	599 jmethodID get_and_cache_jmethod_id();
0 a61af66fc99e Initial load duke parents: diff changeset	600
a61af66fc99e Initial load duke parents: diff changeset	601 // verify operations
a61af66fc99e Initial load duke parents: diff changeset	602 void verify();
a61af66fc99e Initial load duke parents: diff changeset	603 void verify_scopes();
a61af66fc99e Initial load duke parents: diff changeset	604 void verify_interrupt_point(address interrupt_point);
a61af66fc99e Initial load duke parents: diff changeset	605
a61af66fc99e Initial load duke parents: diff changeset	606 // printing support
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 0 diff changeset	607 void print() const;
c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 0 diff changeset	608 void print_code();
0 a61af66fc99e Initial load duke parents: diff changeset	609 void print_relocations() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	610 void print_pcs() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	611 void print_scopes() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	612 void print_dependencies() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	613 void print_value_on(outputStream* st) const PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	614 void print_calls(outputStream* st) PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	615 void print_handler_table() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	616 void print_nul_chk_table() PRODUCT_RETURN;
100 c7c777385a15 6667042: PrintAssembly option does not work without special plugin jrose parents: 0 diff changeset	617 void print_nmethod(bool print_code);
0 a61af66fc99e Initial load duke parents: diff changeset	618
1681 126ea7725993 6953477: Increase portability and flexibility of building Hotspot bobv parents: 1644 diff changeset	619 // 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	620 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	621 void print_on(outputStream* st, const char* msg) const;
0 a61af66fc99e Initial load duke parents: diff changeset	622
a61af66fc99e Initial load duke parents: diff changeset	623 // Logging
a61af66fc99e Initial load duke parents: diff changeset	624 void log_identity(xmlStream* log) const;
a61af66fc99e Initial load duke parents: diff changeset	625 void log_new_nmethod() const;
1109 032260830071 5057818: codecache full and compiler disabled in bigapps fastdebug run never parents: 1000 diff changeset	626 void log_state_change() const;
0 a61af66fc99e Initial load duke parents: diff changeset	627
1155 4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	628 // Prints block-level comments, including nmethod specific block labels:
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	629 virtual void print_block_comment(outputStream* stream, address block_begin) {
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	630 print_nmethod_labels(stream, block_begin);
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	631 CodeBlob::print_block_comment(stream, block_begin);
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	632 }
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	633 void print_nmethod_labels(outputStream* stream, address block_begin);
4e6abf09f540 6912062: disassembler plugin needs to produce symbolic information in product mode jrose parents: 1141 diff changeset	634
0 a61af66fc99e Initial load duke parents: diff changeset	635 // 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	636 void print_code_comment_on(outputStream* st, int column, address begin, address end);
0 a61af66fc99e Initial load duke parents: diff changeset	637 static void print_statistics() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	638
a61af66fc99e Initial load duke parents: diff changeset	639 // Compiler task identification. Note that all OSR methods
a61af66fc99e Initial load duke parents: diff changeset	640 // are numbered in an independent sequence if CICountOSR is true,
a61af66fc99e Initial load duke parents: diff changeset	641 // and native method wrappers are also numbered independently if
a61af66fc99e Initial load duke parents: diff changeset	642 // CICountNative is true.
a61af66fc99e Initial load duke parents: diff changeset	643 int compile_id() const { return _compile_id; }
a61af66fc99e Initial load duke parents: diff changeset	644 const char* compile_kind() const;
a61af66fc99e Initial load duke parents: diff changeset	645
a61af66fc99e Initial load duke parents: diff changeset	646 // For debugging
a61af66fc99e Initial load duke parents: diff changeset	647 // CompiledIC* IC_at(char* p) const;
a61af66fc99e Initial load duke parents: diff changeset	648 // PrimitiveIC* primitiveIC_at(char* p) const;
a61af66fc99e Initial load duke parents: diff changeset	649 oop embeddedOop_at(address p);
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 // tells if any of this method's dependencies have been invalidated
a61af66fc99e Initial load duke parents: diff changeset	652 // (this is expensive!)
a61af66fc99e Initial load duke parents: diff changeset	653 bool check_all_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	654
a61af66fc99e Initial load duke parents: diff changeset	655 // tells if this compiled method is dependent on the given changes,
a61af66fc99e Initial load duke parents: diff changeset	656 // and the changes have invalidated it
a61af66fc99e Initial load duke parents: diff changeset	657 bool check_dependency_on(DepChange& changes);
a61af66fc99e Initial load duke parents: diff changeset	658
a61af66fc99e Initial load duke parents: diff changeset	659 // Evolution support. Tells if this compiled method is dependent on any of
a61af66fc99e Initial load duke parents: diff changeset	660 // methods m() of class dependee, such that if m() in dependee is replaced,
a61af66fc99e Initial load duke parents: diff changeset	661 // this compiled method will have to be deoptimized.
a61af66fc99e Initial load duke parents: diff changeset	662 bool is_evol_dependent_on(klassOop dependee);
a61af66fc99e Initial load duke parents: diff changeset	663
a61af66fc99e Initial load duke parents: diff changeset	664 // Fast breakpoint support. Tells if this compiled method is
a61af66fc99e Initial load duke parents: diff changeset	665 // dependent on the given method. Returns true if this nmethod
a61af66fc99e Initial load duke parents: diff changeset	666 // corresponds to the given method as well.
a61af66fc99e Initial load duke parents: diff changeset	667 bool is_dependent_on_method(methodOop dependee);
a61af66fc99e Initial load duke parents: diff changeset	668
a61af66fc99e Initial load duke parents: diff changeset	669 // is it ok to patch at address?
a61af66fc99e Initial load duke parents: diff changeset	670 bool is_patchable_at(address instr_address);
a61af66fc99e Initial load duke parents: diff changeset	671
a61af66fc99e Initial load duke parents: diff changeset	672 // UseBiasedLocking support
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	673 ByteSize native_receiver_sp_offset() {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	674 return _native_receiver_sp_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	675 }
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	676 ByteSize native_basic_lock_sp_offset() {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	677 return _native_basic_lock_sp_offset;
0 a61af66fc99e Initial load duke parents: diff changeset	678 }
a61af66fc99e Initial load duke parents: diff changeset	679
a61af66fc99e Initial load duke parents: diff changeset	680 // support for code generation
a61af66fc99e Initial load duke parents: diff changeset	681 static int verified_entry_point_offset() { return offset_of(nmethod, _verified_entry_point); }
a61af66fc99e Initial load duke parents: diff changeset	682 static int osr_entry_point_offset() { return offset_of(nmethod, _osr_entry_point); }
a61af66fc99e Initial load duke parents: diff changeset	683 static int entry_bci_offset() { return offset_of(nmethod, _entry_bci); }
a61af66fc99e Initial load duke parents: diff changeset	684
a61af66fc99e Initial load duke parents: diff changeset	685 };
a61af66fc99e Initial load duke parents: diff changeset	686
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	687 // 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	688 // 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	689 // 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	690 // 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	691 // generated code from being reused too early.
0 a61af66fc99e Initial load duke parents: diff changeset	692 class nmethodLocker : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	693 nmethod* _nm;
a61af66fc99e Initial load duke parents: diff changeset	694
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2019 diff changeset	695 public:
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2019 diff changeset	696
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2321 diff changeset	697 // 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	698 // 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	699 // 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	700 static void lock_nmethod(nmethod* nm, bool zombie_ok = false);
0 a61af66fc99e Initial load duke parents: diff changeset	701 static void unlock_nmethod(nmethod* nm); // (ditto)
a61af66fc99e Initial load duke parents: diff changeset	702
a61af66fc99e Initial load duke parents: diff changeset	703 nmethodLocker(address pc); // derive nm from pc
a61af66fc99e Initial load duke parents: diff changeset	704 nmethodLocker(nmethod *nm) { _nm = nm; lock_nmethod(_nm); }
a61af66fc99e Initial load duke parents: diff changeset	705 nmethodLocker() { _nm = NULL; }
a61af66fc99e Initial load duke parents: diff changeset	706 ~nmethodLocker() { unlock_nmethod(_nm); }
a61af66fc99e Initial load duke parents: diff changeset	707
a61af66fc99e Initial load duke parents: diff changeset	708 nmethod* code() { return _nm; }
a61af66fc99e Initial load duke parents: diff changeset	709 void set_code(nmethod* new_nm) {
a61af66fc99e Initial load duke parents: diff changeset	710 unlock_nmethod(_nm); // note: This works even if _nm==new_nm.
a61af66fc99e Initial load duke parents: diff changeset	711 _nm = new_nm;
a61af66fc99e Initial load duke parents: diff changeset	712 lock_nmethod(_nm);
a61af66fc99e Initial load duke parents: diff changeset	713 }
a61af66fc99e Initial load duke parents: diff changeset	714 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	715
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	716 #endif // SHARE_VM_CODE_NMETHOD_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/code/nmethod.hpp @ 3992:d1bdeef3e3e2