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