graal-compiler: src/share/vm/prims/jvmtiImpl.cpp annotate

annotate src/share/vm/prims/jvmtiImpl.cpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank

author	ysr
date	Wed, 07 Sep 2011 13:55:42 -0700
parents	0cddebc420d8
children	f08d439fab8c

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: 2177 diff changeset	2 * Copyright (c) 2003, 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: 611 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 611 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: 611 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: 1922 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	27 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	28 #include "jvmtifiles/jvmtiEnv.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	29 #include "memory/resourceArea.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	30 #include "oops/instanceKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	31 #include "prims/jvmtiAgentThread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	32 #include "prims/jvmtiEventController.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	33 #include "prims/jvmtiImpl.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	34 #include "prims/jvmtiRedefineClasses.hpp"
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	35 #include "runtime/atomic.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	36 #include "runtime/deoptimization.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	37 #include "runtime/handles.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	38 #include "runtime/handles.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	39 #include "runtime/interfaceSupport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	40 #include "runtime/javaCalls.hpp"
3304 0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	41 #include "runtime/os.hpp"
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	42 #include "runtime/serviceThread.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	43 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	44 #include "runtime/vframe.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	45 #include "runtime/vframe_hp.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	46 #include "runtime/vm_operations.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	47 #include "utilities/exceptions.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	48 #ifdef TARGET_OS_FAMILY_linux
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	49 # include "thread_linux.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	50 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	51 #ifdef TARGET_OS_FAMILY_solaris
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	52 # include "thread_solaris.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	53 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	54 #ifdef TARGET_OS_FAMILY_windows
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	55 # include "thread_windows.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1922 diff changeset	56 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	57
a61af66fc99e Initial load duke parents: diff changeset	58 //
a61af66fc99e Initial load duke parents: diff changeset	59 // class JvmtiAgentThread
a61af66fc99e Initial load duke parents: diff changeset	60 //
a61af66fc99e Initial load duke parents: diff changeset	61 // JavaThread used to wrap a thread started by an agent
a61af66fc99e Initial load duke parents: diff changeset	62 // using the JVMTI method RunAgentThread.
a61af66fc99e Initial load duke parents: diff changeset	63 //
a61af66fc99e Initial load duke parents: diff changeset	64
a61af66fc99e Initial load duke parents: diff changeset	65 JvmtiAgentThread::JvmtiAgentThread(JvmtiEnv* env, jvmtiStartFunction start_fn, const void *start_arg)
a61af66fc99e Initial load duke parents: diff changeset	66 : JavaThread(start_function_wrapper) {
a61af66fc99e Initial load duke parents: diff changeset	67 _env = env;
a61af66fc99e Initial load duke parents: diff changeset	68 _start_fn = start_fn;
a61af66fc99e Initial load duke parents: diff changeset	69 _start_arg = start_arg;
a61af66fc99e Initial load duke parents: diff changeset	70 }
a61af66fc99e Initial load duke parents: diff changeset	71
a61af66fc99e Initial load duke parents: diff changeset	72 void
a61af66fc99e Initial load duke parents: diff changeset	73 JvmtiAgentThread::start_function_wrapper(JavaThread *thread, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	74 // It is expected that any Agent threads will be created as
a61af66fc99e Initial load duke parents: diff changeset	75 // Java Threads. If this is the case, notification of the creation
a61af66fc99e Initial load duke parents: diff changeset	76 // of the thread is given in JavaThread::thread_main().
a61af66fc99e Initial load duke parents: diff changeset	77 assert(thread->is_Java_thread(), "debugger thread should be a Java Thread");
a61af66fc99e Initial load duke parents: diff changeset	78 assert(thread == JavaThread::current(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 JvmtiAgentThread dthread = (JvmtiAgentThread )thread;
a61af66fc99e Initial load duke parents: diff changeset	81 dthread->call_start_function();
a61af66fc99e Initial load duke parents: diff changeset	82 }
a61af66fc99e Initial load duke parents: diff changeset	83
a61af66fc99e Initial load duke parents: diff changeset	84 void
a61af66fc99e Initial load duke parents: diff changeset	85 JvmtiAgentThread::call_start_function() {
a61af66fc99e Initial load duke parents: diff changeset	86 ThreadToNativeFromVM transition(this);
a61af66fc99e Initial load duke parents: diff changeset	87 _start_fn(_env->jvmti_external(), jni_environment(), (void*)_start_arg);
a61af66fc99e Initial load duke parents: diff changeset	88 }
a61af66fc99e Initial load duke parents: diff changeset	89
a61af66fc99e Initial load duke parents: diff changeset	90
a61af66fc99e Initial load duke parents: diff changeset	91 //
a61af66fc99e Initial load duke parents: diff changeset	92 // class GrowableCache - private methods
a61af66fc99e Initial load duke parents: diff changeset	93 //
a61af66fc99e Initial load duke parents: diff changeset	94
a61af66fc99e Initial load duke parents: diff changeset	95 void GrowableCache::recache() {
a61af66fc99e Initial load duke parents: diff changeset	96 int len = _elements->length();
a61af66fc99e Initial load duke parents: diff changeset	97
a61af66fc99e Initial load duke parents: diff changeset	98 FREE_C_HEAP_ARRAY(address, _cache);
a61af66fc99e Initial load duke parents: diff changeset	99 _cache = NEW_C_HEAP_ARRAY(address,len+1);
a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 for (int i=0; i<len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	102 _cache[i] = _elements->at(i)->getCacheValue();
a61af66fc99e Initial load duke parents: diff changeset	103 //
a61af66fc99e Initial load duke parents: diff changeset	104 // The cache entry has gone bad. Without a valid frame pointer
a61af66fc99e Initial load duke parents: diff changeset	105 // value, the entry is useless so we simply delete it in product
a61af66fc99e Initial load duke parents: diff changeset	106 // mode. The call to remove() will rebuild the cache again
a61af66fc99e Initial load duke parents: diff changeset	107 // without the bad entry.
a61af66fc99e Initial load duke parents: diff changeset	108 //
a61af66fc99e Initial load duke parents: diff changeset	109 if (_cache[i] == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	110 assert(false, "cannot recache NULL elements");
a61af66fc99e Initial load duke parents: diff changeset	111 remove(i);
a61af66fc99e Initial load duke parents: diff changeset	112 return;
a61af66fc99e Initial load duke parents: diff changeset	113 }
a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115 _cache[len] = NULL;
a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 _listener_fun(_this_obj,_cache);
a61af66fc99e Initial load duke parents: diff changeset	118 }
a61af66fc99e Initial load duke parents: diff changeset	119
a61af66fc99e Initial load duke parents: diff changeset	120 bool GrowableCache::equals(void* v, GrowableElement *e2) {
a61af66fc99e Initial load duke parents: diff changeset	121 GrowableElement e1 = (GrowableElement ) v;
a61af66fc99e Initial load duke parents: diff changeset	122 assert(e1 != NULL, "e1 != NULL");
a61af66fc99e Initial load duke parents: diff changeset	123 assert(e2 != NULL, "e2 != NULL");
a61af66fc99e Initial load duke parents: diff changeset	124
a61af66fc99e Initial load duke parents: diff changeset	125 return e1->equals(e2);
a61af66fc99e Initial load duke parents: diff changeset	126 }
a61af66fc99e Initial load duke parents: diff changeset	127
a61af66fc99e Initial load duke parents: diff changeset	128 //
a61af66fc99e Initial load duke parents: diff changeset	129 // class GrowableCache - public methods
a61af66fc99e Initial load duke parents: diff changeset	130 //
a61af66fc99e Initial load duke parents: diff changeset	131
a61af66fc99e Initial load duke parents: diff changeset	132 GrowableCache::GrowableCache() {
a61af66fc99e Initial load duke parents: diff changeset	133 _this_obj = NULL;
a61af66fc99e Initial load duke parents: diff changeset	134 _listener_fun = NULL;
a61af66fc99e Initial load duke parents: diff changeset	135 _elements = NULL;
a61af66fc99e Initial load duke parents: diff changeset	136 _cache = NULL;
a61af66fc99e Initial load duke parents: diff changeset	137 }
a61af66fc99e Initial load duke parents: diff changeset	138
a61af66fc99e Initial load duke parents: diff changeset	139 GrowableCache::~GrowableCache() {
a61af66fc99e Initial load duke parents: diff changeset	140 clear();
a61af66fc99e Initial load duke parents: diff changeset	141 delete _elements;
a61af66fc99e Initial load duke parents: diff changeset	142 FREE_C_HEAP_ARRAY(address, _cache);
a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 void GrowableCache::initialize(void this_obj, void listener_fun(void , address*) ) {
a61af66fc99e Initial load duke parents: diff changeset	146 _this_obj = this_obj;
a61af66fc99e Initial load duke parents: diff changeset	147 _listener_fun = listener_fun;
a61af66fc99e Initial load duke parents: diff changeset	148 _elements = new (ResourceObj::C_HEAP) GrowableArray<GrowableElement*>(5,true);
a61af66fc99e Initial load duke parents: diff changeset	149 recache();
a61af66fc99e Initial load duke parents: diff changeset	150 }
a61af66fc99e Initial load duke parents: diff changeset	151
a61af66fc99e Initial load duke parents: diff changeset	152 // number of elements in the collection
a61af66fc99e Initial load duke parents: diff changeset	153 int GrowableCache::length() {
a61af66fc99e Initial load duke parents: diff changeset	154 return _elements->length();
a61af66fc99e Initial load duke parents: diff changeset	155 }
a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157 // get the value of the index element in the collection
a61af66fc99e Initial load duke parents: diff changeset	158 GrowableElement* GrowableCache::at(int index) {
a61af66fc99e Initial load duke parents: diff changeset	159 GrowableElement e = (GrowableElement ) _elements->at(index);
a61af66fc99e Initial load duke parents: diff changeset	160 assert(e != NULL, "e != NULL");
a61af66fc99e Initial load duke parents: diff changeset	161 return e;
a61af66fc99e Initial load duke parents: diff changeset	162 }
a61af66fc99e Initial load duke parents: diff changeset	163
a61af66fc99e Initial load duke parents: diff changeset	164 int GrowableCache::find(GrowableElement* e) {
a61af66fc99e Initial load duke parents: diff changeset	165 return _elements->find(e, GrowableCache::equals);
a61af66fc99e Initial load duke parents: diff changeset	166 }
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 // append a copy of the element to the end of the collection
a61af66fc99e Initial load duke parents: diff changeset	169 void GrowableCache::append(GrowableElement* e) {
a61af66fc99e Initial load duke parents: diff changeset	170 GrowableElement *new_e = e->clone();
a61af66fc99e Initial load duke parents: diff changeset	171 _elements->append(new_e);
a61af66fc99e Initial load duke parents: diff changeset	172 recache();
a61af66fc99e Initial load duke parents: diff changeset	173 }
a61af66fc99e Initial load duke parents: diff changeset	174
a61af66fc99e Initial load duke parents: diff changeset	175 // insert a copy of the element using lessthan()
a61af66fc99e Initial load duke parents: diff changeset	176 void GrowableCache::insert(GrowableElement* e) {
a61af66fc99e Initial load duke parents: diff changeset	177 GrowableElement *new_e = e->clone();
a61af66fc99e Initial load duke parents: diff changeset	178 _elements->append(new_e);
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 int n = length()-2;
a61af66fc99e Initial load duke parents: diff changeset	181 for (int i=n; i>=0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	182 GrowableElement *e1 = _elements->at(i);
a61af66fc99e Initial load duke parents: diff changeset	183 GrowableElement *e2 = _elements->at(i+1);
a61af66fc99e Initial load duke parents: diff changeset	184 if (e2->lessThan(e1)) {
a61af66fc99e Initial load duke parents: diff changeset	185 _elements->at_put(i+1, e1);
a61af66fc99e Initial load duke parents: diff changeset	186 _elements->at_put(i, e2);
a61af66fc99e Initial load duke parents: diff changeset	187 }
a61af66fc99e Initial load duke parents: diff changeset	188 }
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 recache();
a61af66fc99e Initial load duke parents: diff changeset	191 }
a61af66fc99e Initial load duke parents: diff changeset	192
a61af66fc99e Initial load duke parents: diff changeset	193 // remove the element at index
a61af66fc99e Initial load duke parents: diff changeset	194 void GrowableCache::remove (int index) {
a61af66fc99e Initial load duke parents: diff changeset	195 GrowableElement *e = _elements->at(index);
a61af66fc99e Initial load duke parents: diff changeset	196 assert(e != NULL, "e != NULL");
a61af66fc99e Initial load duke parents: diff changeset	197 _elements->remove(e);
a61af66fc99e Initial load duke parents: diff changeset	198 delete e;
a61af66fc99e Initial load duke parents: diff changeset	199 recache();
a61af66fc99e Initial load duke parents: diff changeset	200 }
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 // clear out all elements, release all heap space and
a61af66fc99e Initial load duke parents: diff changeset	203 // let our listener know that things have changed.
a61af66fc99e Initial load duke parents: diff changeset	204 void GrowableCache::clear() {
a61af66fc99e Initial load duke parents: diff changeset	205 int len = _elements->length();
a61af66fc99e Initial load duke parents: diff changeset	206 for (int i=0; i<len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	207 delete _elements->at(i);
a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209 _elements->clear();
a61af66fc99e Initial load duke parents: diff changeset	210 recache();
a61af66fc99e Initial load duke parents: diff changeset	211 }
a61af66fc99e Initial load duke parents: diff changeset	212
a61af66fc99e Initial load duke parents: diff changeset	213 void GrowableCache::oops_do(OopClosure* f) {
a61af66fc99e Initial load duke parents: diff changeset	214 int len = _elements->length();
a61af66fc99e Initial load duke parents: diff changeset	215 for (int i=0; i<len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	216 GrowableElement *e = _elements->at(i);
a61af66fc99e Initial load duke parents: diff changeset	217 e->oops_do(f);
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	218 }
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	219 }
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	220
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	221 void GrowableCache::gc_epilogue() {
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	222 int len = _elements->length();
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	223 for (int i=0; i<len; i++) {
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	224 _cache[i] = _elements->at(i)->getCacheValue();
0 a61af66fc99e Initial load duke parents: diff changeset	225 }
a61af66fc99e Initial load duke parents: diff changeset	226 }
a61af66fc99e Initial load duke parents: diff changeset	227
a61af66fc99e Initial load duke parents: diff changeset	228 //
a61af66fc99e Initial load duke parents: diff changeset	229 // class JvmtiBreakpoint
a61af66fc99e Initial load duke parents: diff changeset	230 //
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 JvmtiBreakpoint::JvmtiBreakpoint() {
a61af66fc99e Initial load duke parents: diff changeset	233 _method = NULL;
a61af66fc99e Initial load duke parents: diff changeset	234 _bci = 0;
a61af66fc99e Initial load duke parents: diff changeset	235 #ifdef CHECK_UNHANDLED_OOPS
a61af66fc99e Initial load duke parents: diff changeset	236 // This one is always allocated with new, but check it just in case.
a61af66fc99e Initial load duke parents: diff changeset	237 Thread *thread = Thread::current();
a61af66fc99e Initial load duke parents: diff changeset	238 if (thread->is_in_stack((address)&_method)) {
a61af66fc99e Initial load duke parents: diff changeset	239 thread->allow_unhandled_oop((oop*)&_method);
a61af66fc99e Initial load duke parents: diff changeset	240 }
a61af66fc99e Initial load duke parents: diff changeset	241 #endif // CHECK_UNHANDLED_OOPS
a61af66fc99e Initial load duke parents: diff changeset	242 }
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 JvmtiBreakpoint::JvmtiBreakpoint(methodOop m_method, jlocation location) {
a61af66fc99e Initial load duke parents: diff changeset	245 _method = m_method;
a61af66fc99e Initial load duke parents: diff changeset	246 assert(_method != NULL, "_method != NULL");
a61af66fc99e Initial load duke parents: diff changeset	247 _bci = (int) location;
a61af66fc99e Initial load duke parents: diff changeset	248 #ifdef CHECK_UNHANDLED_OOPS
a61af66fc99e Initial load duke parents: diff changeset	249 // Could be allocated with new and wouldn't be on the unhandled oop list.
a61af66fc99e Initial load duke parents: diff changeset	250 Thread *thread = Thread::current();
a61af66fc99e Initial load duke parents: diff changeset	251 if (thread->is_in_stack((address)&_method)) {
a61af66fc99e Initial load duke parents: diff changeset	252 thread->allow_unhandled_oop(&_method);
a61af66fc99e Initial load duke parents: diff changeset	253 }
a61af66fc99e Initial load duke parents: diff changeset	254 #endif // CHECK_UNHANDLED_OOPS
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 assert(_bci >= 0, "_bci >= 0");
a61af66fc99e Initial load duke parents: diff changeset	257 }
a61af66fc99e Initial load duke parents: diff changeset	258
a61af66fc99e Initial load duke parents: diff changeset	259 void JvmtiBreakpoint::copy(JvmtiBreakpoint& bp) {
a61af66fc99e Initial load duke parents: diff changeset	260 _method = bp._method;
a61af66fc99e Initial load duke parents: diff changeset	261 _bci = bp._bci;
a61af66fc99e Initial load duke parents: diff changeset	262 }
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 bool JvmtiBreakpoint::lessThan(JvmtiBreakpoint& bp) {
a61af66fc99e Initial load duke parents: diff changeset	265 Unimplemented();
a61af66fc99e Initial load duke parents: diff changeset	266 return false;
a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268
a61af66fc99e Initial load duke parents: diff changeset	269 bool JvmtiBreakpoint::equals(JvmtiBreakpoint& bp) {
a61af66fc99e Initial load duke parents: diff changeset	270 return _method == bp._method
a61af66fc99e Initial load duke parents: diff changeset	271 && _bci == bp._bci;
a61af66fc99e Initial load duke parents: diff changeset	272 }
a61af66fc99e Initial load duke parents: diff changeset	273
a61af66fc99e Initial load duke parents: diff changeset	274 bool JvmtiBreakpoint::is_valid() {
a61af66fc99e Initial load duke parents: diff changeset	275 return _method != NULL &&
a61af66fc99e Initial load duke parents: diff changeset	276 _bci >= 0;
a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 address JvmtiBreakpoint::getBcp() {
a61af66fc99e Initial load duke parents: diff changeset	280 return _method->bcp_from(_bci);
a61af66fc99e Initial load duke parents: diff changeset	281 }
a61af66fc99e Initial load duke parents: diff changeset	282
a61af66fc99e Initial load duke parents: diff changeset	283 void JvmtiBreakpoint::each_method_version_do(method_action meth_act) {
a61af66fc99e Initial load duke parents: diff changeset	284 ((methodOopDesc)_method->meth_act)(_bci);
a61af66fc99e Initial load duke parents: diff changeset	285
a61af66fc99e Initial load duke parents: diff changeset	286 // add/remove breakpoint to/from versions of the method that
a61af66fc99e Initial load duke parents: diff changeset	287 // are EMCP. Directly or transitively obsolete methods are
a61af66fc99e Initial load duke parents: diff changeset	288 // not saved in the PreviousVersionInfo.
a61af66fc99e Initial load duke parents: diff changeset	289 Thread *thread = Thread::current();
a61af66fc99e Initial load duke parents: diff changeset	290 instanceKlassHandle ikh = instanceKlassHandle(thread, _method->method_holder());
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	291 Symbol* m_name = _method->name();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	292 Symbol* m_signature = _method->signature();
0 a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294 {
a61af66fc99e Initial load duke parents: diff changeset	295 ResourceMark rm(thread);
a61af66fc99e Initial load duke parents: diff changeset	296 // PreviousVersionInfo objects returned via PreviousVersionWalker
a61af66fc99e Initial load duke parents: diff changeset	297 // contain a GrowableArray of handles. We have to clean up the
a61af66fc99e Initial load duke parents: diff changeset	298 // GrowableArray _after_ the PreviousVersionWalker destructor
a61af66fc99e Initial load duke parents: diff changeset	299 // has destroyed the handles.
a61af66fc99e Initial load duke parents: diff changeset	300 {
a61af66fc99e Initial load duke parents: diff changeset	301 // search previous versions if they exist
a61af66fc99e Initial load duke parents: diff changeset	302 PreviousVersionWalker pvw((instanceKlass *)ikh()->klass_part());
a61af66fc99e Initial load duke parents: diff changeset	303 for (PreviousVersionInfo * pv_info = pvw.next_previous_version();
a61af66fc99e Initial load duke parents: diff changeset	304 pv_info != NULL; pv_info = pvw.next_previous_version()) {
a61af66fc99e Initial load duke parents: diff changeset	305 GrowableArray<methodHandle>* methods =
a61af66fc99e Initial load duke parents: diff changeset	306 pv_info->prev_EMCP_method_handles();
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 if (methods == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	309 // We have run into a PreviousVersion generation where
a61af66fc99e Initial load duke parents: diff changeset	310 // all methods were made obsolete during that generation's
a61af66fc99e Initial load duke parents: diff changeset	311 // RedefineClasses() operation. At the time of that
a61af66fc99e Initial load duke parents: diff changeset	312 // operation, all EMCP methods were flushed so we don't
a61af66fc99e Initial load duke parents: diff changeset	313 // have to go back any further.
a61af66fc99e Initial load duke parents: diff changeset	314 //
a61af66fc99e Initial load duke parents: diff changeset	315 // A NULL methods array is different than an empty methods
a61af66fc99e Initial load duke parents: diff changeset	316 // array. We cannot infer any optimizations about older
a61af66fc99e Initial load duke parents: diff changeset	317 // generations from an empty methods array for the current
a61af66fc99e Initial load duke parents: diff changeset	318 // generation.
a61af66fc99e Initial load duke parents: diff changeset	319 break;
a61af66fc99e Initial load duke parents: diff changeset	320 }
a61af66fc99e Initial load duke parents: diff changeset	321
a61af66fc99e Initial load duke parents: diff changeset	322 for (int i = methods->length() - 1; i >= 0; i--) {
a61af66fc99e Initial load duke parents: diff changeset	323 methodHandle method = methods->at(i);
a61af66fc99e Initial load duke parents: diff changeset	324 if (method->name() == m_name && method->signature() == m_signature) {
a61af66fc99e Initial load duke parents: diff changeset	325 RC_TRACE(0x00000800, ("%sing breakpoint in %s(%s)",
a61af66fc99e Initial load duke parents: diff changeset	326 meth_act == &methodOopDesc::set_breakpoint ? "sett" : "clear",
a61af66fc99e Initial load duke parents: diff changeset	327 method->name()->as_C_string(),
a61af66fc99e Initial load duke parents: diff changeset	328 method->signature()->as_C_string()));
a61af66fc99e Initial load duke parents: diff changeset	329 assert(!method->is_obsolete(), "only EMCP methods here");
a61af66fc99e Initial load duke parents: diff changeset	330
a61af66fc99e Initial load duke parents: diff changeset	331 ((methodOopDesc)method()->meth_act)(_bci);
a61af66fc99e Initial load duke parents: diff changeset	332 break;
a61af66fc99e Initial load duke parents: diff changeset	333 }
a61af66fc99e Initial load duke parents: diff changeset	334 }
a61af66fc99e Initial load duke parents: diff changeset	335 }
a61af66fc99e Initial load duke parents: diff changeset	336 } // pvw is cleaned up
a61af66fc99e Initial load duke parents: diff changeset	337 } // rm is cleaned up
a61af66fc99e Initial load duke parents: diff changeset	338 }
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 void JvmtiBreakpoint::set() {
a61af66fc99e Initial load duke parents: diff changeset	341 each_method_version_do(&methodOopDesc::set_breakpoint);
a61af66fc99e Initial load duke parents: diff changeset	342 }
a61af66fc99e Initial load duke parents: diff changeset	343
a61af66fc99e Initial load duke parents: diff changeset	344 void JvmtiBreakpoint::clear() {
a61af66fc99e Initial load duke parents: diff changeset	345 each_method_version_do(&methodOopDesc::clear_breakpoint);
a61af66fc99e Initial load duke parents: diff changeset	346 }
a61af66fc99e Initial load duke parents: diff changeset	347
a61af66fc99e Initial load duke parents: diff changeset	348 void JvmtiBreakpoint::print() {
a61af66fc99e Initial load duke parents: diff changeset	349 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	350 const char *class_name = (_method == NULL) ? "NULL" : _method->klass_name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	351 const char *method_name = (_method == NULL) ? "NULL" : _method->name()->as_C_string();
a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 tty->print("Breakpoint(%s,%s,%d,%p)",class_name, method_name, _bci, getBcp());
a61af66fc99e Initial load duke parents: diff changeset	354 #endif
a61af66fc99e Initial load duke parents: diff changeset	355 }
a61af66fc99e Initial load duke parents: diff changeset	356
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358 //
a61af66fc99e Initial load duke parents: diff changeset	359 // class VM_ChangeBreakpoints
a61af66fc99e Initial load duke parents: diff changeset	360 //
a61af66fc99e Initial load duke parents: diff changeset	361 // Modify the Breakpoints data structure at a safepoint
a61af66fc99e Initial load duke parents: diff changeset	362 //
a61af66fc99e Initial load duke parents: diff changeset	363
a61af66fc99e Initial load duke parents: diff changeset	364 void VM_ChangeBreakpoints::doit() {
a61af66fc99e Initial load duke parents: diff changeset	365 switch (_operation) {
a61af66fc99e Initial load duke parents: diff changeset	366 case SET_BREAKPOINT:
a61af66fc99e Initial load duke parents: diff changeset	367 _breakpoints->set_at_safepoint(*_bp);
a61af66fc99e Initial load duke parents: diff changeset	368 break;
a61af66fc99e Initial load duke parents: diff changeset	369 case CLEAR_BREAKPOINT:
a61af66fc99e Initial load duke parents: diff changeset	370 _breakpoints->clear_at_safepoint(*_bp);
a61af66fc99e Initial load duke parents: diff changeset	371 break;
a61af66fc99e Initial load duke parents: diff changeset	372 case CLEAR_ALL_BREAKPOINT:
a61af66fc99e Initial load duke parents: diff changeset	373 _breakpoints->clearall_at_safepoint();
a61af66fc99e Initial load duke parents: diff changeset	374 break;
a61af66fc99e Initial load duke parents: diff changeset	375 default:
a61af66fc99e Initial load duke parents: diff changeset	376 assert(false, "Unknown operation");
a61af66fc99e Initial load duke parents: diff changeset	377 }
a61af66fc99e Initial load duke parents: diff changeset	378 }
a61af66fc99e Initial load duke parents: diff changeset	379
a61af66fc99e Initial load duke parents: diff changeset	380 void VM_ChangeBreakpoints::oops_do(OopClosure* f) {
a61af66fc99e Initial load duke parents: diff changeset	381 // This operation keeps breakpoints alive
a61af66fc99e Initial load duke parents: diff changeset	382 if (_breakpoints != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	383 _breakpoints->oops_do(f);
a61af66fc99e Initial load duke parents: diff changeset	384 }
a61af66fc99e Initial load duke parents: diff changeset	385 if (_bp != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	386 _bp->oops_do(f);
a61af66fc99e Initial load duke parents: diff changeset	387 }
a61af66fc99e Initial load duke parents: diff changeset	388 }
a61af66fc99e Initial load duke parents: diff changeset	389
a61af66fc99e Initial load duke parents: diff changeset	390 //
a61af66fc99e Initial load duke parents: diff changeset	391 // class JvmtiBreakpoints
a61af66fc99e Initial load duke parents: diff changeset	392 //
a61af66fc99e Initial load duke parents: diff changeset	393 // a JVMTI internal collection of JvmtiBreakpoint
a61af66fc99e Initial load duke parents: diff changeset	394 //
a61af66fc99e Initial load duke parents: diff changeset	395
a61af66fc99e Initial load duke parents: diff changeset	396 JvmtiBreakpoints::JvmtiBreakpoints(void listener_fun(void ,address )) {
a61af66fc99e Initial load duke parents: diff changeset	397 _bps.initialize(this,listener_fun);
a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399
a61af66fc99e Initial load duke parents: diff changeset	400 JvmtiBreakpoints:: ~JvmtiBreakpoints() {}
a61af66fc99e Initial load duke parents: diff changeset	401
a61af66fc99e Initial load duke parents: diff changeset	402 void JvmtiBreakpoints::oops_do(OopClosure* f) {
a61af66fc99e Initial load duke parents: diff changeset	403 _bps.oops_do(f);
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	406 void JvmtiBreakpoints::gc_epilogue() {
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	407 _bps.gc_epilogue();
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	408 }
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	409
0 a61af66fc99e Initial load duke parents: diff changeset	410 void JvmtiBreakpoints::print() {
a61af66fc99e Initial load duke parents: diff changeset	411 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	412 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	413
a61af66fc99e Initial load duke parents: diff changeset	414 int n = _bps.length();
a61af66fc99e Initial load duke parents: diff changeset	415 for (int i=0; i<n; i++) {
a61af66fc99e Initial load duke parents: diff changeset	416 JvmtiBreakpoint& bp = _bps.at(i);
a61af66fc99e Initial load duke parents: diff changeset	417 tty->print("%d: ", i);
a61af66fc99e Initial load duke parents: diff changeset	418 bp.print();
a61af66fc99e Initial load duke parents: diff changeset	419 tty->print_cr("");
a61af66fc99e Initial load duke parents: diff changeset	420 }
a61af66fc99e Initial load duke parents: diff changeset	421 #endif
a61af66fc99e Initial load duke parents: diff changeset	422 }
a61af66fc99e Initial load duke parents: diff changeset	423
a61af66fc99e Initial load duke parents: diff changeset	424
a61af66fc99e Initial load duke parents: diff changeset	425 void JvmtiBreakpoints::set_at_safepoint(JvmtiBreakpoint& bp) {
a61af66fc99e Initial load duke parents: diff changeset	426 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	427
a61af66fc99e Initial load duke parents: diff changeset	428 int i = _bps.find(bp);
a61af66fc99e Initial load duke parents: diff changeset	429 if (i == -1) {
a61af66fc99e Initial load duke parents: diff changeset	430 _bps.append(bp);
a61af66fc99e Initial load duke parents: diff changeset	431 bp.set();
a61af66fc99e Initial load duke parents: diff changeset	432 }
a61af66fc99e Initial load duke parents: diff changeset	433 }
a61af66fc99e Initial load duke parents: diff changeset	434
a61af66fc99e Initial load duke parents: diff changeset	435 void JvmtiBreakpoints::clear_at_safepoint(JvmtiBreakpoint& bp) {
a61af66fc99e Initial load duke parents: diff changeset	436 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	437
a61af66fc99e Initial load duke parents: diff changeset	438 int i = _bps.find(bp);
a61af66fc99e Initial load duke parents: diff changeset	439 if (i != -1) {
a61af66fc99e Initial load duke parents: diff changeset	440 _bps.remove(i);
a61af66fc99e Initial load duke parents: diff changeset	441 bp.clear();
a61af66fc99e Initial load duke parents: diff changeset	442 }
a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444
a61af66fc99e Initial load duke parents: diff changeset	445 void JvmtiBreakpoints::clearall_at_safepoint() {
a61af66fc99e Initial load duke parents: diff changeset	446 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
a61af66fc99e Initial load duke parents: diff changeset	447
a61af66fc99e Initial load duke parents: diff changeset	448 int len = _bps.length();
a61af66fc99e Initial load duke parents: diff changeset	449 for (int i=0; i<len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	450 _bps.at(i).clear();
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 _bps.clear();
a61af66fc99e Initial load duke parents: diff changeset	453 }
a61af66fc99e Initial load duke parents: diff changeset	454
a61af66fc99e Initial load duke parents: diff changeset	455 int JvmtiBreakpoints::length() { return _bps.length(); }
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 int JvmtiBreakpoints::set(JvmtiBreakpoint& bp) {
a61af66fc99e Initial load duke parents: diff changeset	458 if ( _bps.find(bp) != -1) {
a61af66fc99e Initial load duke parents: diff changeset	459 return JVMTI_ERROR_DUPLICATE;
a61af66fc99e Initial load duke parents: diff changeset	460 }
a61af66fc99e Initial load duke parents: diff changeset	461 VM_ChangeBreakpoints set_breakpoint(this,VM_ChangeBreakpoints::SET_BREAKPOINT, &bp);
a61af66fc99e Initial load duke parents: diff changeset	462 VMThread::execute(&set_breakpoint);
a61af66fc99e Initial load duke parents: diff changeset	463 return JVMTI_ERROR_NONE;
a61af66fc99e Initial load duke parents: diff changeset	464 }
a61af66fc99e Initial load duke parents: diff changeset	465
a61af66fc99e Initial load duke parents: diff changeset	466 int JvmtiBreakpoints::clear(JvmtiBreakpoint& bp) {
a61af66fc99e Initial load duke parents: diff changeset	467 if ( _bps.find(bp) == -1) {
a61af66fc99e Initial load duke parents: diff changeset	468 return JVMTI_ERROR_NOT_FOUND;
a61af66fc99e Initial load duke parents: diff changeset	469 }
a61af66fc99e Initial load duke parents: diff changeset	470
a61af66fc99e Initial load duke parents: diff changeset	471 VM_ChangeBreakpoints clear_breakpoint(this,VM_ChangeBreakpoints::CLEAR_BREAKPOINT, &bp);
a61af66fc99e Initial load duke parents: diff changeset	472 VMThread::execute(&clear_breakpoint);
a61af66fc99e Initial load duke parents: diff changeset	473 return JVMTI_ERROR_NONE;
a61af66fc99e Initial load duke parents: diff changeset	474 }
a61af66fc99e Initial load duke parents: diff changeset	475
a61af66fc99e Initial load duke parents: diff changeset	476 void JvmtiBreakpoints::clearall_in_class_at_safepoint(klassOop klass) {
a61af66fc99e Initial load duke parents: diff changeset	477 bool changed = true;
a61af66fc99e Initial load duke parents: diff changeset	478 // We are going to run thru the list of bkpts
a61af66fc99e Initial load duke parents: diff changeset	479 // and delete some. This deletion probably alters
a61af66fc99e Initial load duke parents: diff changeset	480 // the list in some implementation defined way such
a61af66fc99e Initial load duke parents: diff changeset	481 // that when we delete entry i, the next entry might
a61af66fc99e Initial load duke parents: diff changeset	482 // no longer be at i+1. To be safe, each time we delete
a61af66fc99e Initial load duke parents: diff changeset	483 // an entry, we'll just start again from the beginning.
a61af66fc99e Initial load duke parents: diff changeset	484 // We'll stop when we make a pass thru the whole list without
a61af66fc99e Initial load duke parents: diff changeset	485 // deleting anything.
a61af66fc99e Initial load duke parents: diff changeset	486 while (changed) {
a61af66fc99e Initial load duke parents: diff changeset	487 int len = _bps.length();
a61af66fc99e Initial load duke parents: diff changeset	488 changed = false;
a61af66fc99e Initial load duke parents: diff changeset	489 for (int i = 0; i < len; i++) {
a61af66fc99e Initial load duke parents: diff changeset	490 JvmtiBreakpoint& bp = _bps.at(i);
a61af66fc99e Initial load duke parents: diff changeset	491 if (bp.method()->method_holder() == klass) {
a61af66fc99e Initial load duke parents: diff changeset	492 bp.clear();
a61af66fc99e Initial load duke parents: diff changeset	493 _bps.remove(i);
a61af66fc99e Initial load duke parents: diff changeset	494 // This changed 'i' so we have to start over.
a61af66fc99e Initial load duke parents: diff changeset	495 changed = true;
a61af66fc99e Initial load duke parents: diff changeset	496 break;
a61af66fc99e Initial load duke parents: diff changeset	497 }
a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499 }
a61af66fc99e Initial load duke parents: diff changeset	500 }
a61af66fc99e Initial load duke parents: diff changeset	501
a61af66fc99e Initial load duke parents: diff changeset	502 void JvmtiBreakpoints::clearall() {
a61af66fc99e Initial load duke parents: diff changeset	503 VM_ChangeBreakpoints clearall_breakpoint(this,VM_ChangeBreakpoints::CLEAR_ALL_BREAKPOINT);
a61af66fc99e Initial load duke parents: diff changeset	504 VMThread::execute(&clearall_breakpoint);
a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506
a61af66fc99e Initial load duke parents: diff changeset	507 //
a61af66fc99e Initial load duke parents: diff changeset	508 // class JvmtiCurrentBreakpoints
a61af66fc99e Initial load duke parents: diff changeset	509 //
a61af66fc99e Initial load duke parents: diff changeset	510
a61af66fc99e Initial load duke parents: diff changeset	511 JvmtiBreakpoints *JvmtiCurrentBreakpoints::_jvmti_breakpoints = NULL;
a61af66fc99e Initial load duke parents: diff changeset	512 address * JvmtiCurrentBreakpoints::_breakpoint_list = NULL;
a61af66fc99e Initial load duke parents: diff changeset	513
a61af66fc99e Initial load duke parents: diff changeset	514
a61af66fc99e Initial load duke parents: diff changeset	515 JvmtiBreakpoints& JvmtiCurrentBreakpoints::get_jvmti_breakpoints() {
a61af66fc99e Initial load duke parents: diff changeset	516 if (_jvmti_breakpoints != NULL) return (*_jvmti_breakpoints);
a61af66fc99e Initial load duke parents: diff changeset	517 _jvmti_breakpoints = new JvmtiBreakpoints(listener_fun);
a61af66fc99e Initial load duke parents: diff changeset	518 assert(_jvmti_breakpoints != NULL, "_jvmti_breakpoints != NULL");
a61af66fc99e Initial load duke parents: diff changeset	519 return (*_jvmti_breakpoints);
a61af66fc99e Initial load duke parents: diff changeset	520 }
a61af66fc99e Initial load duke parents: diff changeset	521
a61af66fc99e Initial load duke parents: diff changeset	522 void JvmtiCurrentBreakpoints::listener_fun(void this_obj, address cache) {
a61af66fc99e Initial load duke parents: diff changeset	523 JvmtiBreakpoints this_jvmti = (JvmtiBreakpoints ) this_obj;
a61af66fc99e Initial load duke parents: diff changeset	524 assert(this_jvmti != NULL, "this_jvmti != NULL");
a61af66fc99e Initial load duke parents: diff changeset	525
a61af66fc99e Initial load duke parents: diff changeset	526 debug_only(int n = this_jvmti->length(););
a61af66fc99e Initial load duke parents: diff changeset	527 assert(cache[n] == NULL, "cache must be NULL terminated");
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529 set_breakpoint_list(cache);
a61af66fc99e Initial load duke parents: diff changeset	530 }
a61af66fc99e Initial load duke parents: diff changeset	531
a61af66fc99e Initial load duke parents: diff changeset	532
a61af66fc99e Initial load duke parents: diff changeset	533 void JvmtiCurrentBreakpoints::oops_do(OopClosure* f) {
a61af66fc99e Initial load duke parents: diff changeset	534 if (_jvmti_breakpoints != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	535 _jvmti_breakpoints->oops_do(f);
a61af66fc99e Initial load duke parents: diff changeset	536 }
a61af66fc99e Initial load duke parents: diff changeset	537 }
a61af66fc99e Initial load duke parents: diff changeset	538
2147 9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	539 void JvmtiCurrentBreakpoints::gc_epilogue() {
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	540 if (_jvmti_breakpoints != NULL) {
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	541 _jvmti_breakpoints->gc_epilogue();
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	542 }
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	543 }
9afee0b9fc1d 7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220) kamg parents: 2125 diff changeset	544
0 a61af66fc99e Initial load duke parents: diff changeset	545 ///////////////////////////////////////////////////////////////
a61af66fc99e Initial load duke parents: diff changeset	546 //
a61af66fc99e Initial load duke parents: diff changeset	547 // class VM_GetOrSetLocal
a61af66fc99e Initial load duke parents: diff changeset	548 //
a61af66fc99e Initial load duke parents: diff changeset	549
a61af66fc99e Initial load duke parents: diff changeset	550 // Constructor for non-object getter
a61af66fc99e Initial load duke parents: diff changeset	551 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, int index, BasicType type)
a61af66fc99e Initial load duke parents: diff changeset	552 : _thread(thread)
a61af66fc99e Initial load duke parents: diff changeset	553 , _calling_thread(NULL)
a61af66fc99e Initial load duke parents: diff changeset	554 , _depth(depth)
a61af66fc99e Initial load duke parents: diff changeset	555 , _index(index)
a61af66fc99e Initial load duke parents: diff changeset	556 , _type(type)
a61af66fc99e Initial load duke parents: diff changeset	557 , _set(false)
a61af66fc99e Initial load duke parents: diff changeset	558 , _jvf(NULL)
a61af66fc99e Initial load duke parents: diff changeset	559 , _result(JVMTI_ERROR_NONE)
a61af66fc99e Initial load duke parents: diff changeset	560 {
a61af66fc99e Initial load duke parents: diff changeset	561 }
a61af66fc99e Initial load duke parents: diff changeset	562
a61af66fc99e Initial load duke parents: diff changeset	563 // Constructor for object or non-object setter
a61af66fc99e Initial load duke parents: diff changeset	564 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, int index, BasicType type, jvalue value)
a61af66fc99e Initial load duke parents: diff changeset	565 : _thread(thread)
a61af66fc99e Initial load duke parents: diff changeset	566 , _calling_thread(NULL)
a61af66fc99e Initial load duke parents: diff changeset	567 , _depth(depth)
a61af66fc99e Initial load duke parents: diff changeset	568 , _index(index)
a61af66fc99e Initial load duke parents: diff changeset	569 , _type(type)
a61af66fc99e Initial load duke parents: diff changeset	570 , _value(value)
a61af66fc99e Initial load duke parents: diff changeset	571 , _set(true)
a61af66fc99e Initial load duke parents: diff changeset	572 , _jvf(NULL)
a61af66fc99e Initial load duke parents: diff changeset	573 , _result(JVMTI_ERROR_NONE)
a61af66fc99e Initial load duke parents: diff changeset	574 {
a61af66fc99e Initial load duke parents: diff changeset	575 }
a61af66fc99e Initial load duke parents: diff changeset	576
a61af66fc99e Initial load duke parents: diff changeset	577 // Constructor for object getter
a61af66fc99e Initial load duke parents: diff changeset	578 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_thread, jint depth, int index)
a61af66fc99e Initial load duke parents: diff changeset	579 : _thread(thread)
a61af66fc99e Initial load duke parents: diff changeset	580 , _calling_thread(calling_thread)
a61af66fc99e Initial load duke parents: diff changeset	581 , _depth(depth)
a61af66fc99e Initial load duke parents: diff changeset	582 , _index(index)
a61af66fc99e Initial load duke parents: diff changeset	583 , _type(T_OBJECT)
a61af66fc99e Initial load duke parents: diff changeset	584 , _set(false)
a61af66fc99e Initial load duke parents: diff changeset	585 , _jvf(NULL)
a61af66fc99e Initial load duke parents: diff changeset	586 , _result(JVMTI_ERROR_NONE)
a61af66fc99e Initial load duke parents: diff changeset	587 {
a61af66fc99e Initial load duke parents: diff changeset	588 }
a61af66fc99e Initial load duke parents: diff changeset	589
a61af66fc99e Initial load duke parents: diff changeset	590 vframe *VM_GetOrSetLocal::get_vframe() {
a61af66fc99e Initial load duke parents: diff changeset	591 if (!_thread->has_last_Java_frame()) {
a61af66fc99e Initial load duke parents: diff changeset	592 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	593 }
a61af66fc99e Initial load duke parents: diff changeset	594 RegisterMap reg_map(_thread);
a61af66fc99e Initial load duke parents: diff changeset	595 vframe *vf = _thread->last_java_vframe(&reg_map);
a61af66fc99e Initial load duke parents: diff changeset	596 int d = 0;
a61af66fc99e Initial load duke parents: diff changeset	597 while ((vf != NULL) && (d < _depth)) {
a61af66fc99e Initial load duke parents: diff changeset	598 vf = vf->java_sender();
a61af66fc99e Initial load duke parents: diff changeset	599 d++;
a61af66fc99e Initial load duke parents: diff changeset	600 }
a61af66fc99e Initial load duke parents: diff changeset	601 return vf;
a61af66fc99e Initial load duke parents: diff changeset	602 }
a61af66fc99e Initial load duke parents: diff changeset	603
a61af66fc99e Initial load duke parents: diff changeset	604 javaVFrame *VM_GetOrSetLocal::get_java_vframe() {
a61af66fc99e Initial load duke parents: diff changeset	605 vframe* vf = get_vframe();
a61af66fc99e Initial load duke parents: diff changeset	606 if (vf == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	607 _result = JVMTI_ERROR_NO_MORE_FRAMES;
a61af66fc99e Initial load duke parents: diff changeset	608 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610 javaVFrame jvf = (javaVFrame)vf;
a61af66fc99e Initial load duke parents: diff changeset	611
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	612 if (!vf->is_java_frame()) {
0 a61af66fc99e Initial load duke parents: diff changeset	613 _result = JVMTI_ERROR_OPAQUE_FRAME;
a61af66fc99e Initial load duke parents: diff changeset	614 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	615 }
a61af66fc99e Initial load duke parents: diff changeset	616 return jvf;
a61af66fc99e Initial load duke parents: diff changeset	617 }
a61af66fc99e Initial load duke parents: diff changeset	618
a61af66fc99e Initial load duke parents: diff changeset	619 // Check that the klass is assignable to a type with the given signature.
a61af66fc99e Initial load duke parents: diff changeset	620 // Another solution could be to use the function Klass::is_subtype_of(type).
a61af66fc99e Initial load duke parents: diff changeset	621 // But the type class can be forced to load/initialize eagerly in such a case.
a61af66fc99e Initial load duke parents: diff changeset	622 // This may cause unexpected consequences like CFLH or class-init JVMTI events.
a61af66fc99e Initial load duke parents: diff changeset	623 // It is better to avoid such a behavior.
a61af66fc99e Initial load duke parents: diff changeset	624 bool VM_GetOrSetLocal::is_assignable(const char* ty_sign, Klass* klass, Thread* thread) {
a61af66fc99e Initial load duke parents: diff changeset	625 assert(ty_sign != NULL, "type signature must not be NULL");
a61af66fc99e Initial load duke parents: diff changeset	626 assert(thread != NULL, "thread must not be NULL");
a61af66fc99e Initial load duke parents: diff changeset	627 assert(klass != NULL, "klass must not be NULL");
a61af66fc99e Initial load duke parents: diff changeset	628
a61af66fc99e Initial load duke parents: diff changeset	629 int len = (int) strlen(ty_sign);
a61af66fc99e Initial load duke parents: diff changeset	630 if (ty_sign[0] == 'L' && ty_sign[len-1] == ';') { // Need pure class/interface name
a61af66fc99e Initial load duke parents: diff changeset	631 ty_sign++;
a61af66fc99e Initial load duke parents: diff changeset	632 len -= 2;
a61af66fc99e Initial load duke parents: diff changeset	633 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	634 TempNewSymbol ty_sym = SymbolTable::new_symbol(ty_sign, len, thread);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	635 if (klass->name() == ty_sym) {
0 a61af66fc99e Initial load duke parents: diff changeset	636 return true;
a61af66fc99e Initial load duke parents: diff changeset	637 }
a61af66fc99e Initial load duke parents: diff changeset	638 // Compare primary supers
a61af66fc99e Initial load duke parents: diff changeset	639 int super_depth = klass->super_depth();
a61af66fc99e Initial load duke parents: diff changeset	640 int idx;
a61af66fc99e Initial load duke parents: diff changeset	641 for (idx = 0; idx < super_depth; idx++) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	642 if (Klass::cast(klass->primary_super_of_depth(idx))->name() == ty_sym) {
0 a61af66fc99e Initial load duke parents: diff changeset	643 return true;
a61af66fc99e Initial load duke parents: diff changeset	644 }
a61af66fc99e Initial load duke parents: diff changeset	645 }
a61af66fc99e Initial load duke parents: diff changeset	646 // Compare secondary supers
a61af66fc99e Initial load duke parents: diff changeset	647 objArrayOop sec_supers = klass->secondary_supers();
a61af66fc99e Initial load duke parents: diff changeset	648 for (idx = 0; idx < sec_supers->length(); idx++) {
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	649 if (Klass::cast((klassOop) sec_supers->obj_at(idx))->name() == ty_sym) {
0 a61af66fc99e Initial load duke parents: diff changeset	650 return true;
a61af66fc99e Initial load duke parents: diff changeset	651 }
a61af66fc99e Initial load duke parents: diff changeset	652 }
a61af66fc99e Initial load duke parents: diff changeset	653 return false;
a61af66fc99e Initial load duke parents: diff changeset	654 }
a61af66fc99e Initial load duke parents: diff changeset	655
a61af66fc99e Initial load duke parents: diff changeset	656 // Checks error conditions:
a61af66fc99e Initial load duke parents: diff changeset	657 // JVMTI_ERROR_INVALID_SLOT
a61af66fc99e Initial load duke parents: diff changeset	658 // JVMTI_ERROR_TYPE_MISMATCH
a61af66fc99e Initial load duke parents: diff changeset	659 // Returns: 'true' - everything is Ok, 'false' - error code
a61af66fc99e Initial load duke parents: diff changeset	660
a61af66fc99e Initial load duke parents: diff changeset	661 bool VM_GetOrSetLocal::check_slot_type(javaVFrame* jvf) {
a61af66fc99e Initial load duke parents: diff changeset	662 methodOop method_oop = jvf->method();
a61af66fc99e Initial load duke parents: diff changeset	663 if (!method_oop->has_localvariable_table()) {
a61af66fc99e Initial load duke parents: diff changeset	664 // Just to check index boundaries
a61af66fc99e Initial load duke parents: diff changeset	665 jint extra_slot = (_type == T_LONG \|\| _type == T_DOUBLE) ? 1 : 0;
a61af66fc99e Initial load duke parents: diff changeset	666 if (_index < 0 \|\| _index + extra_slot >= method_oop->max_locals()) {
a61af66fc99e Initial load duke parents: diff changeset	667 _result = JVMTI_ERROR_INVALID_SLOT;
a61af66fc99e Initial load duke parents: diff changeset	668 return false;
a61af66fc99e Initial load duke parents: diff changeset	669 }
a61af66fc99e Initial load duke parents: diff changeset	670 return true;
a61af66fc99e Initial load duke parents: diff changeset	671 }
a61af66fc99e Initial load duke parents: diff changeset	672
a61af66fc99e Initial load duke parents: diff changeset	673 jint num_entries = method_oop->localvariable_table_length();
a61af66fc99e Initial load duke parents: diff changeset	674 if (num_entries == 0) {
a61af66fc99e Initial load duke parents: diff changeset	675 _result = JVMTI_ERROR_INVALID_SLOT;
a61af66fc99e Initial load duke parents: diff changeset	676 return false; // There are no slots
a61af66fc99e Initial load duke parents: diff changeset	677 }
a61af66fc99e Initial load duke parents: diff changeset	678 int signature_idx = -1;
a61af66fc99e Initial load duke parents: diff changeset	679 int vf_bci = jvf->bci();
a61af66fc99e Initial load duke parents: diff changeset	680 LocalVariableTableElement* table = method_oop->localvariable_table_start();
a61af66fc99e Initial load duke parents: diff changeset	681 for (int i = 0; i < num_entries; i++) {
a61af66fc99e Initial load duke parents: diff changeset	682 int start_bci = table[i].start_bci;
a61af66fc99e Initial load duke parents: diff changeset	683 int end_bci = start_bci + table[i].length;
a61af66fc99e Initial load duke parents: diff changeset	684
a61af66fc99e Initial load duke parents: diff changeset	685 // Here we assume that locations of LVT entries
a61af66fc99e Initial load duke parents: diff changeset	686 // with the same slot number cannot be overlapped
a61af66fc99e Initial load duke parents: diff changeset	687 if (_index == (jint) table[i].slot && start_bci <= vf_bci && vf_bci <= end_bci) {
a61af66fc99e Initial load duke parents: diff changeset	688 signature_idx = (int) table[i].descriptor_cp_index;
a61af66fc99e Initial load duke parents: diff changeset	689 break;
a61af66fc99e Initial load duke parents: diff changeset	690 }
a61af66fc99e Initial load duke parents: diff changeset	691 }
a61af66fc99e Initial load duke parents: diff changeset	692 if (signature_idx == -1) {
a61af66fc99e Initial load duke parents: diff changeset	693 _result = JVMTI_ERROR_INVALID_SLOT;
a61af66fc99e Initial load duke parents: diff changeset	694 return false; // Incorrect slot index
a61af66fc99e Initial load duke parents: diff changeset	695 }
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 2147 diff changeset	696 Symbol* sign_sym = method_oop->constants()->symbol_at(signature_idx);
0 a61af66fc99e Initial load duke parents: diff changeset	697 const char* signature = (const char *) sign_sym->as_utf8();
a61af66fc99e Initial load duke parents: diff changeset	698 BasicType slot_type = char2type(signature[0]);
a61af66fc99e Initial load duke parents: diff changeset	699
a61af66fc99e Initial load duke parents: diff changeset	700 switch (slot_type) {
a61af66fc99e Initial load duke parents: diff changeset	701 case T_BYTE:
a61af66fc99e Initial load duke parents: diff changeset	702 case T_SHORT:
a61af66fc99e Initial load duke parents: diff changeset	703 case T_CHAR:
a61af66fc99e Initial load duke parents: diff changeset	704 case T_BOOLEAN:
a61af66fc99e Initial load duke parents: diff changeset	705 slot_type = T_INT;
a61af66fc99e Initial load duke parents: diff changeset	706 break;
a61af66fc99e Initial load duke parents: diff changeset	707 case T_ARRAY:
a61af66fc99e Initial load duke parents: diff changeset	708 slot_type = T_OBJECT;
a61af66fc99e Initial load duke parents: diff changeset	709 break;
a61af66fc99e Initial load duke parents: diff changeset	710 };
a61af66fc99e Initial load duke parents: diff changeset	711 if (_type != slot_type) {
a61af66fc99e Initial load duke parents: diff changeset	712 _result = JVMTI_ERROR_TYPE_MISMATCH;
a61af66fc99e Initial load duke parents: diff changeset	713 return false;
a61af66fc99e Initial load duke parents: diff changeset	714 }
a61af66fc99e Initial load duke parents: diff changeset	715
a61af66fc99e Initial load duke parents: diff changeset	716 jobject jobj = _value.l;
a61af66fc99e Initial load duke parents: diff changeset	717 if (_set && slot_type == T_OBJECT && jobj != NULL) { // NULL reference is allowed
a61af66fc99e Initial load duke parents: diff changeset	718 // Check that the jobject class matches the return type signature.
a61af66fc99e Initial load duke parents: diff changeset	719 JavaThread* cur_thread = JavaThread::current();
a61af66fc99e Initial load duke parents: diff changeset	720 HandleMark hm(cur_thread);
a61af66fc99e Initial load duke parents: diff changeset	721
a61af66fc99e Initial load duke parents: diff changeset	722 Handle obj = Handle(cur_thread, JNIHandles::resolve_external_guard(jobj));
a61af66fc99e Initial load duke parents: diff changeset	723 NULL_CHECK(obj, (_result = JVMTI_ERROR_INVALID_OBJECT, false));
a61af66fc99e Initial load duke parents: diff changeset	724 KlassHandle ob_kh = KlassHandle(cur_thread, obj->klass());
a61af66fc99e Initial load duke parents: diff changeset	725 NULL_CHECK(ob_kh, (_result = JVMTI_ERROR_INVALID_OBJECT, false));
a61af66fc99e Initial load duke parents: diff changeset	726
a61af66fc99e Initial load duke parents: diff changeset	727 if (!is_assignable(signature, Klass::cast(ob_kh()), cur_thread)) {
a61af66fc99e Initial load duke parents: diff changeset	728 _result = JVMTI_ERROR_TYPE_MISMATCH;
a61af66fc99e Initial load duke parents: diff changeset	729 return false;
a61af66fc99e Initial load duke parents: diff changeset	730 }
a61af66fc99e Initial load duke parents: diff changeset	731 }
a61af66fc99e Initial load duke parents: diff changeset	732 return true;
a61af66fc99e Initial load duke parents: diff changeset	733 }
a61af66fc99e Initial load duke parents: diff changeset	734
a61af66fc99e Initial load duke parents: diff changeset	735 static bool can_be_deoptimized(vframe* vf) {
a61af66fc99e Initial load duke parents: diff changeset	736 return (vf->is_compiled_frame() && vf->fr().can_be_deoptimized());
a61af66fc99e Initial load duke parents: diff changeset	737 }
a61af66fc99e Initial load duke parents: diff changeset	738
a61af66fc99e Initial load duke parents: diff changeset	739 bool VM_GetOrSetLocal::doit_prologue() {
a61af66fc99e Initial load duke parents: diff changeset	740 _jvf = get_java_vframe();
a61af66fc99e Initial load duke parents: diff changeset	741 NULL_CHECK(_jvf, false);
a61af66fc99e Initial load duke parents: diff changeset	742
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	743 if (_jvf->method()->is_native()) {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	744 if (getting_receiver() && !_jvf->method()->is_static()) {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	745 return true;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	746 } else {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	747 _result = JVMTI_ERROR_OPAQUE_FRAME;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	748 return false;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	749 }
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	750 }
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	751
0 a61af66fc99e Initial load duke parents: diff changeset	752 if (!check_slot_type(_jvf)) {
a61af66fc99e Initial load duke parents: diff changeset	753 return false;
a61af66fc99e Initial load duke parents: diff changeset	754 }
a61af66fc99e Initial load duke parents: diff changeset	755 return true;
a61af66fc99e Initial load duke parents: diff changeset	756 }
a61af66fc99e Initial load duke parents: diff changeset	757
a61af66fc99e Initial load duke parents: diff changeset	758 void VM_GetOrSetLocal::doit() {
a61af66fc99e Initial load duke parents: diff changeset	759 if (_set) {
a61af66fc99e Initial load duke parents: diff changeset	760 // Force deoptimization of frame if compiled because it's
a61af66fc99e Initial load duke parents: diff changeset	761 // possible the compiler emitted some locals as constant values,
a61af66fc99e Initial load duke parents: diff changeset	762 // meaning they are not mutable.
a61af66fc99e Initial load duke parents: diff changeset	763 if (can_be_deoptimized(_jvf)) {
a61af66fc99e Initial load duke parents: diff changeset	764
a61af66fc99e Initial load duke parents: diff changeset	765 // Schedule deoptimization so that eventually the local
a61af66fc99e Initial load duke parents: diff changeset	766 // update will be written to an interpreter frame.
1905 ce6848d0666d 6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places never parents: 1552 diff changeset	767 Deoptimization::deoptimize_frame(_jvf->thread(), _jvf->fr().id());
0 a61af66fc99e Initial load duke parents: diff changeset	768
a61af66fc99e Initial load duke parents: diff changeset	769 // Now store a new value for the local which will be applied
a61af66fc99e Initial load duke parents: diff changeset	770 // once deoptimization occurs. Note however that while this
a61af66fc99e Initial load duke parents: diff changeset	771 // write is deferred until deoptimization actually happens
a61af66fc99e Initial load duke parents: diff changeset	772 // can vframe created after this point will have its locals
a61af66fc99e Initial load duke parents: diff changeset	773 // reflecting this update so as far as anyone can see the
a61af66fc99e Initial load duke parents: diff changeset	774 // write has already taken place.
a61af66fc99e Initial load duke parents: diff changeset	775
a61af66fc99e Initial load duke parents: diff changeset	776 // If we are updating an oop then get the oop from the handle
a61af66fc99e Initial load duke parents: diff changeset	777 // since the handle will be long gone by the time the deopt
a61af66fc99e Initial load duke parents: diff changeset	778 // happens. The oop stored in the deferred local will be
a61af66fc99e Initial load duke parents: diff changeset	779 // gc'd on its own.
a61af66fc99e Initial load duke parents: diff changeset	780 if (_type == T_OBJECT) {
a61af66fc99e Initial load duke parents: diff changeset	781 _value.l = (jobject) (JNIHandles::resolve_external_guard(_value.l));
a61af66fc99e Initial load duke parents: diff changeset	782 }
a61af66fc99e Initial load duke parents: diff changeset	783 // Re-read the vframe so we can see that it is deoptimized
a61af66fc99e Initial load duke parents: diff changeset	784 // [ Only need because of assert in update_local() ]
a61af66fc99e Initial load duke parents: diff changeset	785 _jvf = get_java_vframe();
a61af66fc99e Initial load duke parents: diff changeset	786 ((compiledVFrame*)_jvf)->update_local(_type, _index, _value);
a61af66fc99e Initial load duke parents: diff changeset	787 return;
a61af66fc99e Initial load duke parents: diff changeset	788 }
a61af66fc99e Initial load duke parents: diff changeset	789 StackValueCollection *locals = _jvf->locals();
a61af66fc99e Initial load duke parents: diff changeset	790 HandleMark hm;
a61af66fc99e Initial load duke parents: diff changeset	791
a61af66fc99e Initial load duke parents: diff changeset	792 switch (_type) {
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	793 case T_INT: locals->set_int_at (_index, _value.i); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	794 case T_LONG: locals->set_long_at (_index, _value.j); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	795 case T_FLOAT: locals->set_float_at (_index, _value.f); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	796 case T_DOUBLE: locals->set_double_at(_index, _value.d); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	797 case T_OBJECT: {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	798 Handle ob_h(JNIHandles::resolve_external_guard(_value.l));
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	799 locals->set_obj_at (_index, ob_h);
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	800 break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	801 }
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	802 default: ShouldNotReachHere();
0 a61af66fc99e Initial load duke parents: diff changeset	803 }
a61af66fc99e Initial load duke parents: diff changeset	804 _jvf->set_locals(locals);
a61af66fc99e Initial load duke parents: diff changeset	805 } else {
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	806 if (_jvf->method()->is_native() && _jvf->is_compiled_frame()) {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	807 assert(getting_receiver(), "Can only get here when getting receiver");
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	808 oop receiver = _jvf->fr().get_native_receiver();
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	809 _value.l = JNIHandles::make_local(_calling_thread, receiver);
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	810 } else {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	811 StackValueCollection *locals = _jvf->locals();
0 a61af66fc99e Initial load duke parents: diff changeset	812
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	813 if (locals->at(_index)->type() == T_CONFLICT) {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	814 memset(&_value, 0, sizeof(_value));
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	815 _value.l = NULL;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	816 return;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	817 }
0 a61af66fc99e Initial load duke parents: diff changeset	818
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	819 switch (_type) {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	820 case T_INT: _value.i = locals->int_at (_index); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	821 case T_LONG: _value.j = locals->long_at (_index); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	822 case T_FLOAT: _value.f = locals->float_at (_index); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	823 case T_DOUBLE: _value.d = locals->double_at(_index); break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	824 case T_OBJECT: {
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	825 // Wrap the oop to be returned in a local JNI handle since
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	826 // oops_do() no longer applies after doit() is finished.
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	827 oop obj = locals->obj_at(_index)();
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	828 _value.l = JNIHandles::make_local(_calling_thread, obj);
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	829 break;
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	830 }
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	831 default: ShouldNotReachHere();
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	832 }
0 a61af66fc99e Initial load duke parents: diff changeset	833 }
a61af66fc99e Initial load duke parents: diff changeset	834 }
a61af66fc99e Initial load duke parents: diff changeset	835 }
a61af66fc99e Initial load duke parents: diff changeset	836
a61af66fc99e Initial load duke parents: diff changeset	837
a61af66fc99e Initial load duke parents: diff changeset	838 bool VM_GetOrSetLocal::allow_nested_vm_operations() const {
a61af66fc99e Initial load duke parents: diff changeset	839 return true; // May need to deoptimize
a61af66fc99e Initial load duke parents: diff changeset	840 }
a61af66fc99e Initial load duke parents: diff changeset	841
a61af66fc99e Initial load duke parents: diff changeset	842
2019 09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	843 VM_GetReceiver::VM_GetReceiver(
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	844 JavaThread* thread, JavaThread* caller_thread, jint depth)
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	845 : VM_GetOrSetLocal(thread, caller_thread, depth, 0) {}
09b4dd4f152b 7004582: Add GetThisObject() function to JVMTI 1.2 kamg parents: 1972 diff changeset	846
0 a61af66fc99e Initial load duke parents: diff changeset	847 /////////////////////////////////////////////////////////////////////////////////////////
a61af66fc99e Initial load duke parents: diff changeset	848
a61af66fc99e Initial load duke parents: diff changeset	849 //
a61af66fc99e Initial load duke parents: diff changeset	850 // class JvmtiSuspendControl - see comments in jvmtiImpl.hpp
a61af66fc99e Initial load duke parents: diff changeset	851 //
a61af66fc99e Initial load duke parents: diff changeset	852
a61af66fc99e Initial load duke parents: diff changeset	853 bool JvmtiSuspendControl::suspend(JavaThread *java_thread) {
a61af66fc99e Initial load duke parents: diff changeset	854 // external suspend should have caught suspending a thread twice
a61af66fc99e Initial load duke parents: diff changeset	855
a61af66fc99e Initial load duke parents: diff changeset	856 // Immediate suspension required for JPDA back-end so JVMTI agent threads do
a61af66fc99e Initial load duke parents: diff changeset	857 // not deadlock due to later suspension on transitions while holding
a61af66fc99e Initial load duke parents: diff changeset	858 // raw monitors. Passing true causes the immediate suspension.
a61af66fc99e Initial load duke parents: diff changeset	859 // java_suspend() will catch threads in the process of exiting
a61af66fc99e Initial load duke parents: diff changeset	860 // and will ignore them.
a61af66fc99e Initial load duke parents: diff changeset	861 java_thread->java_suspend();
a61af66fc99e Initial load duke parents: diff changeset	862
a61af66fc99e Initial load duke parents: diff changeset	863 // It would be nice to have the following assertion in all the time,
a61af66fc99e Initial load duke parents: diff changeset	864 // but it is possible for a racing resume request to have resumed
a61af66fc99e Initial load duke parents: diff changeset	865 // this thread right after we suspended it. Temporarily enable this
a61af66fc99e Initial load duke parents: diff changeset	866 // assertion if you are chasing a different kind of bug.
a61af66fc99e Initial load duke parents: diff changeset	867 //
a61af66fc99e Initial load duke parents: diff changeset	868 // assert(java_lang_Thread::thread(java_thread->threadObj()) == NULL \|\|
a61af66fc99e Initial load duke parents: diff changeset	869 // java_thread->is_being_ext_suspended(), "thread is not suspended");
a61af66fc99e Initial load duke parents: diff changeset	870
a61af66fc99e Initial load duke parents: diff changeset	871 if (java_lang_Thread::thread(java_thread->threadObj()) == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	872 // check again because we can get delayed in java_suspend():
a61af66fc99e Initial load duke parents: diff changeset	873 // the thread is in process of exiting.
a61af66fc99e Initial load duke parents: diff changeset	874 return false;
a61af66fc99e Initial load duke parents: diff changeset	875 }
a61af66fc99e Initial load duke parents: diff changeset	876
a61af66fc99e Initial load duke parents: diff changeset	877 return true;
a61af66fc99e Initial load duke parents: diff changeset	878 }
a61af66fc99e Initial load duke parents: diff changeset	879
a61af66fc99e Initial load duke parents: diff changeset	880 bool JvmtiSuspendControl::resume(JavaThread *java_thread) {
a61af66fc99e Initial load duke parents: diff changeset	881 // external suspend should have caught resuming a thread twice
a61af66fc99e Initial load duke parents: diff changeset	882 assert(java_thread->is_being_ext_suspended(), "thread should be suspended");
a61af66fc99e Initial load duke parents: diff changeset	883
a61af66fc99e Initial load duke parents: diff changeset	884 // resume thread
a61af66fc99e Initial load duke parents: diff changeset	885 {
a61af66fc99e Initial load duke parents: diff changeset	886 // must always grab Threads_lock, see JVM_SuspendThread
a61af66fc99e Initial load duke parents: diff changeset	887 MutexLocker ml(Threads_lock);
a61af66fc99e Initial load duke parents: diff changeset	888 java_thread->java_resume();
a61af66fc99e Initial load duke parents: diff changeset	889 }
a61af66fc99e Initial load duke parents: diff changeset	890
a61af66fc99e Initial load duke parents: diff changeset	891 return true;
a61af66fc99e Initial load duke parents: diff changeset	892 }
a61af66fc99e Initial load duke parents: diff changeset	893
a61af66fc99e Initial load duke parents: diff changeset	894
a61af66fc99e Initial load duke parents: diff changeset	895 void JvmtiSuspendControl::print() {
a61af66fc99e Initial load duke parents: diff changeset	896 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	897 MutexLocker mu(Threads_lock);
a61af66fc99e Initial load duke parents: diff changeset	898 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	899
a61af66fc99e Initial load duke parents: diff changeset	900 tty->print("Suspended Threads: [");
a61af66fc99e Initial load duke parents: diff changeset	901 for (JavaThread *thread = Threads::first(); thread != NULL; thread = thread->next()) {
a61af66fc99e Initial load duke parents: diff changeset	902 #if JVMTI_TRACE
a61af66fc99e Initial load duke parents: diff changeset	903 const char *name = JvmtiTrace::safe_get_thread_name(thread);
a61af66fc99e Initial load duke parents: diff changeset	904 #else
a61af66fc99e Initial load duke parents: diff changeset	905 const char *name = "";
a61af66fc99e Initial load duke parents: diff changeset	906 #endif /JVMTI_TRACE /
a61af66fc99e Initial load duke parents: diff changeset	907 tty->print("%s(%c ", name, thread->is_being_ext_suspended() ? 'S' : '_');
a61af66fc99e Initial load duke parents: diff changeset	908 if (!thread->has_last_Java_frame()) {
a61af66fc99e Initial load duke parents: diff changeset	909 tty->print("no stack");
a61af66fc99e Initial load duke parents: diff changeset	910 }
a61af66fc99e Initial load duke parents: diff changeset	911 tty->print(") ");
a61af66fc99e Initial load duke parents: diff changeset	912 }
a61af66fc99e Initial load duke parents: diff changeset	913 tty->print_cr("]");
a61af66fc99e Initial load duke parents: diff changeset	914 #endif
a61af66fc99e Initial load duke parents: diff changeset	915 }
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	916
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	917 #ifndef KERNEL
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	918
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	919 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_load_event(
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	920 nmethod* nm) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	921 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_LOAD);
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	922 event._event_data.compiled_method_load = nm;
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	923 // Keep the nmethod alive until the ServiceThread can process
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	924 // this deferred event.
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	925 nmethodLocker::lock_nmethod(nm);
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	926 return event;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	927 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	928
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	929 JvmtiDeferredEvent JvmtiDeferredEvent::compiled_method_unload_event(
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	930 nmethod* nm, jmethodID id, const void* code) {
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	931 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_COMPILED_METHOD_UNLOAD);
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	932 event._event_data.compiled_method_unload.nm = nm;
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	933 event._event_data.compiled_method_unload.method_id = id;
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	934 event._event_data.compiled_method_unload.code_begin = code;
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	935 // Keep the nmethod alive until the ServiceThread can process
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	936 // this deferred event. This will keep the memory for the
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	937 // generated code from being reused too early. We pass
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	938 // zombie_ok == true here so that our nmethod that was just
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	939 // made into a zombie can be locked.
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	940 nmethodLocker::lock_nmethod(nm, true /* zombie_ok */);
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	941 return event;
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	942 }
3304 0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	943
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	944 JvmtiDeferredEvent JvmtiDeferredEvent::dynamic_code_generated_event(
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	945 const char* name, const void* code_begin, const void* code_end) {
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	946 JvmtiDeferredEvent event = JvmtiDeferredEvent(TYPE_DYNAMIC_CODE_GENERATED);
3304 0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	947 // Need to make a copy of the name since we don't know how long
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	948 // the event poster will keep it around after we enqueue the
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	949 // deferred event and return. strdup() failure is handled in
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	950 // the post() routine below.
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	951 event._event_data.dynamic_code_generated.name = os::strdup(name);
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	952 event._event_data.dynamic_code_generated.code_begin = code_begin;
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	953 event._event_data.dynamic_code_generated.code_end = code_end;
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	954 return event;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	955 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	956
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	957 void JvmtiDeferredEvent::post() {
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	958 assert(ServiceThread::is_service_thread(Thread::current()),
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	959 "Service thread must post enqueued events");
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	960 switch(_type) {
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	961 case TYPE_COMPILED_METHOD_LOAD: {
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	962 nmethod* nm = _event_data.compiled_method_load;
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	963 JvmtiExport::post_compiled_method_load(nm);
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	964 // done with the deferred event so unlock the nmethod
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	965 nmethodLocker::unlock_nmethod(nm);
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	966 break;
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	967 }
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	968 case TYPE_COMPILED_METHOD_UNLOAD: {
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	969 nmethod* nm = _event_data.compiled_method_unload.nm;
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	970 JvmtiExport::post_compiled_method_unload(
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	971 _event_data.compiled_method_unload.method_id,
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	972 _event_data.compiled_method_unload.code_begin);
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	973 // done with the deferred event so unlock the nmethod
46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	974 nmethodLocker::unlock_nmethod(nm);
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	975 break;
2342 46a56fac55c7 7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue dcubed parents: 2301 diff changeset	976 }
3304 0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	977 case TYPE_DYNAMIC_CODE_GENERATED: {
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	978 JvmtiExport::post_dynamic_code_generated_internal(
3304 0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	979 // if strdup failed give the event a default name
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	980 (_event_data.dynamic_code_generated.name == NULL)
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	981 ? "unknown_code" : _event_data.dynamic_code_generated.name,
2301 f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	982 _event_data.dynamic_code_generated.code_begin,
f91db74a6810 7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp kamg parents: 2195 diff changeset	983 _event_data.dynamic_code_generated.code_end);
3304 0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	984 if (_event_data.dynamic_code_generated.name != NULL) {
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	985 // release our copy
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	986 os::free((void *)_event_data.dynamic_code_generated.name);
0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	987 }
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	988 break;
3304 0cddebc420d8 7039447: 2/1 java profiling is broken in build 139 (garbage in function name) dcubed parents: 2342 diff changeset	989 }
2195 bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	990 default:
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	991 ShouldNotReachHere();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	992 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	993 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	994
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	995 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_tail = NULL;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	996 JvmtiDeferredEventQueue::QueueNode* JvmtiDeferredEventQueue::_queue_head = NULL;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	997
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	998 volatile JvmtiDeferredEventQueue::QueueNode*
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	999 JvmtiDeferredEventQueue::_pending_list = NULL;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1000
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1001 bool JvmtiDeferredEventQueue::has_events() {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1002 assert(Service_lock->owned_by_self(), "Must own Service_lock");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1003 return _queue_head != NULL \|\| _pending_list != NULL;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1004 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1005
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1006 void JvmtiDeferredEventQueue::enqueue(const JvmtiDeferredEvent& event) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1007 assert(Service_lock->owned_by_self(), "Must own Service_lock");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1008
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1009 process_pending_events();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1010
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1011 // Events get added to the end of the queue (and are pulled off the front).
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1012 QueueNode* node = new QueueNode(event);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1013 if (_queue_tail == NULL) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1014 _queue_tail = _queue_head = node;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1015 } else {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1016 assert(_queue_tail->next() == NULL, "Must be the last element in the list");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1017 _queue_tail->set_next(node);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1018 _queue_tail = node;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1019 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1020
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1021 Service_lock->notify_all();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1022 assert((_queue_head == NULL) == (_queue_tail == NULL),
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1023 "Inconsistent queue markers");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1024 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1025
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1026 JvmtiDeferredEvent JvmtiDeferredEventQueue::dequeue() {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1027 assert(Service_lock->owned_by_self(), "Must own Service_lock");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1028
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1029 process_pending_events();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1030
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1031 assert(_queue_head != NULL, "Nothing to dequeue");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1032
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1033 if (_queue_head == NULL) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1034 // Just in case this happens in product; it shouldn't but let's not crash
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1035 return JvmtiDeferredEvent();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1036 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1037
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1038 QueueNode* node = _queue_head;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1039 _queue_head = _queue_head->next();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1040 if (_queue_head == NULL) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1041 _queue_tail = NULL;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1042 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1043
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1044 assert((_queue_head == NULL) == (_queue_tail == NULL),
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1045 "Inconsistent queue markers");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1046
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1047 JvmtiDeferredEvent event = node->event();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1048 delete node;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1049 return event;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1050 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1051
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1052 void JvmtiDeferredEventQueue::add_pending_event(
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1053 const JvmtiDeferredEvent& event) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1054
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1055 QueueNode* node = new QueueNode(event);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1056
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1057 bool success = false;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1058 QueueNode* prev_value = (QueueNode*)_pending_list;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1059 do {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1060 node->set_next(prev_value);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1061 prev_value = (QueueNode*)Atomic::cmpxchg_ptr(
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1062 (void)node, (volatile void)&_pending_list, (void*)node->next());
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1063 } while (prev_value != node->next());
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1064 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1065
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1066 // This method transfers any events that were added by someone NOT holding
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1067 // the lock into the mainline queue.
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1068 void JvmtiDeferredEventQueue::process_pending_events() {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1069 assert(Service_lock->owned_by_self(), "Must own Service_lock");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1070
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1071 if (_pending_list != NULL) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1072 QueueNode* head =
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1073 (QueueNode)Atomic::xchg_ptr(NULL, (volatile void)&_pending_list);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1074
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1075 assert((_queue_head == NULL) == (_queue_tail == NULL),
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1076 "Inconsistent queue markers");
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1077
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1078 if (head != NULL) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1079 // Since we've treated the pending list as a stack (with newer
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1080 // events at the beginning), we need to join the bottom of the stack
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1081 // with the 'tail' of the queue in order to get the events in the
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1082 // right order. We do this by reversing the pending list and appending
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1083 // it to the queue.
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1084
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1085 QueueNode* new_tail = head;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1086 QueueNode* new_head = NULL;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1087
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1088 // This reverses the list
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1089 QueueNode* prev = new_tail;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1090 QueueNode* node = new_tail->next();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1091 new_tail->set_next(NULL);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1092 while (node != NULL) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1093 QueueNode* next = node->next();
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1094 node->set_next(prev);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1095 prev = node;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1096 node = next;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1097 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1098 new_head = prev;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1099
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1100 // Now append the new list to the queue
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1101 if (_queue_tail != NULL) {
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1102 _queue_tail->set_next(new_head);
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1103 } else { // _queue_head == NULL
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1104 _queue_head = new_head;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1105 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1106 _queue_tail = new_tail;
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1107 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1108 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1109 }
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1110
bf8517f4e4d0 6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread" kamg parents: 2177 diff changeset	1111 #endif // ndef KERNEL

Mercurial > hg > graal-compiler

annotate src/share/vm/prims/jvmtiImpl.cpp @ 3917:eca1193ca245