Mercurial > hg > truffle
annotate src/share/vm/prims/jvmtiImpl.cpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | 78bbf4d43a14 |
| children | 52b4284cb496 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
13038
diff
changeset
|
2 * Copyright (c) 2003, 2014, 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 |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
213 void GrowableCache::metadata_do(void f(Metadata*)) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
214 int len = _elements->length(); |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
215 for (int i=0; i<len; i++) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
216 GrowableElement *e = _elements->at(i); |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
217 e->metadata_do(f); |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
218 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
219 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
220 |
|
2147
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 | 225 } |
| 226 } | |
| 227 | |
| 228 // | |
| 229 // class JvmtiBreakpoint | |
| 230 // | |
| 231 | |
| 232 JvmtiBreakpoint::JvmtiBreakpoint() { | |
| 233 _method = NULL; | |
| 234 _bci = 0; | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
235 _class_holder = NULL; |
| 0 | 236 } |
| 237 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
238 JvmtiBreakpoint::JvmtiBreakpoint(Method* m_method, jlocation location) { |
| 0 | 239 _method = m_method; |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
240 _class_holder = _method->method_holder()->klass_holder(); |
|
12983
2fab5b7e6140
8025834: NPE in Parallel Scavenge with -XX:+CheckUnhandledOops
ehelin
parents:
12281
diff
changeset
|
241 #ifdef CHECK_UNHANDLED_OOPS |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
242 // _class_holder can't be wrapped in a Handle, because JvmtiBreakpoints are |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
243 // sometimes allocated on the heap. |
|
12983
2fab5b7e6140
8025834: NPE in Parallel Scavenge with -XX:+CheckUnhandledOops
ehelin
parents:
12281
diff
changeset
|
244 // |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
245 // The code handling JvmtiBreakpoints allocated on the stack can't be |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
246 // interrupted by a GC until _class_holder is reachable by the GC via the |
|
12983
2fab5b7e6140
8025834: NPE in Parallel Scavenge with -XX:+CheckUnhandledOops
ehelin
parents:
12281
diff
changeset
|
247 // oops_do method. |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
248 Thread::current()->allow_unhandled_oop(&_class_holder); |
|
12983
2fab5b7e6140
8025834: NPE in Parallel Scavenge with -XX:+CheckUnhandledOops
ehelin
parents:
12281
diff
changeset
|
249 #endif // CHECK_UNHANDLED_OOPS |
| 0 | 250 assert(_method != NULL, "_method != NULL"); |
| 251 _bci = (int) location; | |
| 252 assert(_bci >= 0, "_bci >= 0"); | |
| 253 } | |
| 254 | |
| 255 void JvmtiBreakpoint::copy(JvmtiBreakpoint& bp) { | |
| 256 _method = bp._method; | |
| 257 _bci = bp._bci; | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
258 _class_holder = bp._class_holder; |
| 0 | 259 } |
| 260 | |
| 261 bool JvmtiBreakpoint::lessThan(JvmtiBreakpoint& bp) { | |
| 262 Unimplemented(); | |
| 263 return false; | |
| 264 } | |
| 265 | |
| 266 bool JvmtiBreakpoint::equals(JvmtiBreakpoint& bp) { | |
| 267 return _method == bp._method | |
| 268 && _bci == bp._bci; | |
| 269 } | |
| 270 | |
| 271 bool JvmtiBreakpoint::is_valid() { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
272 // class loader can be NULL |
| 0 | 273 return _method != NULL && |
| 274 _bci >= 0; | |
| 275 } | |
| 276 | |
| 277 address JvmtiBreakpoint::getBcp() { | |
| 278 return _method->bcp_from(_bci); | |
| 279 } | |
| 280 | |
| 281 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
|
282 ((Method*)_method->*meth_act)(_bci); |
| 0 | 283 |
| 284 // add/remove breakpoint to/from versions of the method that | |
| 285 // are EMCP. Directly or transitively obsolete methods are | |
|
12281
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
286 // not saved in the PreviousVersionNodes. |
| 0 | 287 Thread *thread = Thread::current(); |
| 288 instanceKlassHandle ikh = instanceKlassHandle(thread, _method->method_holder()); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
289 Symbol* m_name = _method->name(); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
290 Symbol* m_signature = _method->signature(); |
| 0 | 291 |
|
12281
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
292 // search previous versions if they exist |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
293 PreviousVersionWalker pvw(thread, (InstanceKlass *)ikh()); |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
294 for (PreviousVersionNode * pv_node = pvw.next_previous_version(); |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
295 pv_node != NULL; pv_node = pvw.next_previous_version()) { |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
296 GrowableArray<Method*>* methods = pv_node->prev_EMCP_methods(); |
| 0 | 297 |
|
12281
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
298 if (methods == NULL) { |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
299 // We have run into a PreviousVersion generation where |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
300 // all methods were made obsolete during that generation's |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
301 // RedefineClasses() operation. At the time of that |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
302 // operation, all EMCP methods were flushed so we don't |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
303 // have to go back any further. |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
304 // |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
305 // A NULL methods array is different than an empty methods |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
306 // array. We cannot infer any optimizations about older |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
307 // generations from an empty methods array for the current |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
308 // generation. |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
309 break; |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
310 } |
| 0 | 311 |
|
12281
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
312 for (int i = methods->length() - 1; i >= 0; i--) { |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
313 Method* method = methods->at(i); |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
314 // obsolete methods that are running are not deleted from |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
315 // previous version array, but they are skipped here. |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
316 if (!method->is_obsolete() && |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
317 method->name() == m_name && |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
318 method->signature() == m_signature) { |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
319 RC_TRACE(0x00000800, ("%sing breakpoint in %s(%s)", |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
320 meth_act == &Method::set_breakpoint ? "sett" : "clear", |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
321 method->name()->as_C_string(), |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
322 method->signature()->as_C_string())); |
| 0 | 323 |
|
12281
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
324 (method->*meth_act)(_bci); |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
325 break; |
| 0 | 326 } |
|
12281
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
327 } |
|
4f9a42c33738
8022887: Assertion hit while using class and redefining it with RedefineClasses simultaneously
coleenp
parents:
10405
diff
changeset
|
328 } |
| 0 | 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 default: | |
| 364 assert(false, "Unknown operation"); | |
| 365 } | |
| 366 } | |
| 367 | |
| 368 void VM_ChangeBreakpoints::oops_do(OopClosure* f) { | |
| 10405 | 369 // The JvmtiBreakpoints in _breakpoints will be visited via |
| 370 // JvmtiExport::oops_do. | |
| 0 | 371 if (_bp != NULL) { |
| 372 _bp->oops_do(f); | |
| 373 } | |
| 374 } | |
| 375 | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
376 void VM_ChangeBreakpoints::metadata_do(void f(Metadata*)) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
377 // Walk metadata in breakpoints to keep from being deallocated with RedefineClasses |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
378 if (_bp != NULL) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
379 _bp->metadata_do(f); |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
380 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
381 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
382 |
| 0 | 383 // |
| 384 // class JvmtiBreakpoints | |
| 385 // | |
| 386 // a JVMTI internal collection of JvmtiBreakpoint | |
| 387 // | |
| 388 | |
| 389 JvmtiBreakpoints::JvmtiBreakpoints(void listener_fun(void *,address *)) { | |
| 390 _bps.initialize(this,listener_fun); | |
| 391 } | |
| 392 | |
| 393 JvmtiBreakpoints:: ~JvmtiBreakpoints() {} | |
| 394 | |
| 395 void JvmtiBreakpoints::oops_do(OopClosure* f) { | |
| 396 _bps.oops_do(f); | |
| 397 } | |
| 398 | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
399 void JvmtiBreakpoints::metadata_do(void f(Metadata*)) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
400 _bps.metadata_do(f); |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
401 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
402 |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
403 void JvmtiBreakpoints::gc_epilogue() { |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
404 _bps.gc_epilogue(); |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
405 } |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
406 |
| 0 | 407 void JvmtiBreakpoints::print() { |
| 408 #ifndef PRODUCT | |
| 409 ResourceMark rm; | |
| 410 | |
| 411 int n = _bps.length(); | |
| 412 for (int i=0; i<n; i++) { | |
| 413 JvmtiBreakpoint& bp = _bps.at(i); | |
| 414 tty->print("%d: ", i); | |
| 415 bp.print(); | |
|
17937
78bbf4d43a14
8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents:
13038
diff
changeset
|
416 tty->cr(); |
| 0 | 417 } |
| 418 #endif | |
| 419 } | |
| 420 | |
| 421 | |
| 422 void JvmtiBreakpoints::set_at_safepoint(JvmtiBreakpoint& bp) { | |
| 423 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); | |
| 424 | |
| 425 int i = _bps.find(bp); | |
| 426 if (i == -1) { | |
| 427 _bps.append(bp); | |
| 428 bp.set(); | |
| 429 } | |
| 430 } | |
| 431 | |
| 432 void JvmtiBreakpoints::clear_at_safepoint(JvmtiBreakpoint& bp) { | |
| 433 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); | |
| 434 | |
| 435 int i = _bps.find(bp); | |
| 436 if (i != -1) { | |
| 437 _bps.remove(i); | |
| 438 bp.clear(); | |
| 439 } | |
| 440 } | |
| 441 | |
| 442 int JvmtiBreakpoints::length() { return _bps.length(); } | |
| 443 | |
| 444 int JvmtiBreakpoints::set(JvmtiBreakpoint& bp) { | |
| 445 if ( _bps.find(bp) != -1) { | |
| 446 return JVMTI_ERROR_DUPLICATE; | |
| 447 } | |
| 10405 | 448 VM_ChangeBreakpoints set_breakpoint(VM_ChangeBreakpoints::SET_BREAKPOINT, &bp); |
| 0 | 449 VMThread::execute(&set_breakpoint); |
| 450 return JVMTI_ERROR_NONE; | |
| 451 } | |
| 452 | |
| 453 int JvmtiBreakpoints::clear(JvmtiBreakpoint& bp) { | |
| 454 if ( _bps.find(bp) == -1) { | |
| 455 return JVMTI_ERROR_NOT_FOUND; | |
| 456 } | |
| 457 | |
| 10405 | 458 VM_ChangeBreakpoints clear_breakpoint(VM_ChangeBreakpoints::CLEAR_BREAKPOINT, &bp); |
| 0 | 459 VMThread::execute(&clear_breakpoint); |
| 460 return JVMTI_ERROR_NONE; | |
| 461 } | |
| 462 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
463 void JvmtiBreakpoints::clearall_in_class_at_safepoint(Klass* klass) { |
| 0 | 464 bool changed = true; |
| 465 // We are going to run thru the list of bkpts | |
| 466 // and delete some. This deletion probably alters | |
| 467 // the list in some implementation defined way such | |
| 468 // that when we delete entry i, the next entry might | |
| 469 // no longer be at i+1. To be safe, each time we delete | |
| 470 // an entry, we'll just start again from the beginning. | |
| 471 // We'll stop when we make a pass thru the whole list without | |
| 472 // deleting anything. | |
| 473 while (changed) { | |
| 474 int len = _bps.length(); | |
| 475 changed = false; | |
| 476 for (int i = 0; i < len; i++) { | |
| 477 JvmtiBreakpoint& bp = _bps.at(i); | |
| 478 if (bp.method()->method_holder() == klass) { | |
| 479 bp.clear(); | |
| 480 _bps.remove(i); | |
| 481 // This changed 'i' so we have to start over. | |
| 482 changed = true; | |
| 483 break; | |
| 484 } | |
| 485 } | |
| 486 } | |
| 487 } | |
| 488 | |
| 489 // | |
| 490 // class JvmtiCurrentBreakpoints | |
| 491 // | |
| 492 | |
| 493 JvmtiBreakpoints *JvmtiCurrentBreakpoints::_jvmti_breakpoints = NULL; | |
| 494 address * JvmtiCurrentBreakpoints::_breakpoint_list = NULL; | |
| 495 | |
| 496 | |
| 497 JvmtiBreakpoints& JvmtiCurrentBreakpoints::get_jvmti_breakpoints() { | |
| 498 if (_jvmti_breakpoints != NULL) return (*_jvmti_breakpoints); | |
| 499 _jvmti_breakpoints = new JvmtiBreakpoints(listener_fun); | |
| 500 assert(_jvmti_breakpoints != NULL, "_jvmti_breakpoints != NULL"); | |
| 501 return (*_jvmti_breakpoints); | |
| 502 } | |
| 503 | |
| 504 void JvmtiCurrentBreakpoints::listener_fun(void *this_obj, address *cache) { | |
| 505 JvmtiBreakpoints *this_jvmti = (JvmtiBreakpoints *) this_obj; | |
| 506 assert(this_jvmti != NULL, "this_jvmti != NULL"); | |
| 507 | |
| 508 debug_only(int n = this_jvmti->length();); | |
| 509 assert(cache[n] == NULL, "cache must be NULL terminated"); | |
| 510 | |
| 511 set_breakpoint_list(cache); | |
| 512 } | |
| 513 | |
| 514 | |
| 515 void JvmtiCurrentBreakpoints::oops_do(OopClosure* f) { | |
| 516 if (_jvmti_breakpoints != NULL) { | |
| 517 _jvmti_breakpoints->oops_do(f); | |
| 518 } | |
| 519 } | |
| 520 | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
521 void JvmtiCurrentBreakpoints::metadata_do(void f(Metadata*)) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
522 if (_jvmti_breakpoints != NULL) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
523 _jvmti_breakpoints->metadata_do(f); |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
524 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
525 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
12983
diff
changeset
|
526 |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
527 void JvmtiCurrentBreakpoints::gc_epilogue() { |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
528 if (_jvmti_breakpoints != NULL) { |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
529 _jvmti_breakpoints->gc_epilogue(); |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
530 } |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
531 } |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
532 |
| 0 | 533 /////////////////////////////////////////////////////////////// |
| 534 // | |
| 535 // class VM_GetOrSetLocal | |
| 536 // | |
| 537 | |
| 538 // Constructor for non-object getter | |
| 539 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, int index, BasicType type) | |
| 540 : _thread(thread) | |
| 541 , _calling_thread(NULL) | |
| 542 , _depth(depth) | |
| 543 , _index(index) | |
| 544 , _type(type) | |
| 545 , _set(false) | |
| 546 , _jvf(NULL) | |
| 547 , _result(JVMTI_ERROR_NONE) | |
| 548 { | |
| 549 } | |
| 550 | |
| 551 // Constructor for object or non-object setter | |
| 552 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, jint depth, int index, BasicType type, jvalue value) | |
| 553 : _thread(thread) | |
| 554 , _calling_thread(NULL) | |
| 555 , _depth(depth) | |
| 556 , _index(index) | |
| 557 , _type(type) | |
| 558 , _value(value) | |
| 559 , _set(true) | |
| 560 , _jvf(NULL) | |
| 561 , _result(JVMTI_ERROR_NONE) | |
| 562 { | |
| 563 } | |
| 564 | |
| 565 // Constructor for object getter | |
| 566 VM_GetOrSetLocal::VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_thread, jint depth, int index) | |
| 567 : _thread(thread) | |
| 568 , _calling_thread(calling_thread) | |
| 569 , _depth(depth) | |
| 570 , _index(index) | |
| 571 , _type(T_OBJECT) | |
| 572 , _set(false) | |
| 573 , _jvf(NULL) | |
| 574 , _result(JVMTI_ERROR_NONE) | |
| 575 { | |
| 576 } | |
| 577 | |
| 578 vframe *VM_GetOrSetLocal::get_vframe() { | |
| 579 if (!_thread->has_last_Java_frame()) { | |
| 580 return NULL; | |
| 581 } | |
| 582 RegisterMap reg_map(_thread); | |
| 583 vframe *vf = _thread->last_java_vframe(®_map); | |
| 584 int d = 0; | |
| 585 while ((vf != NULL) && (d < _depth)) { | |
| 586 vf = vf->java_sender(); | |
| 587 d++; | |
| 588 } | |
| 589 return vf; | |
| 590 } | |
| 591 | |
| 592 javaVFrame *VM_GetOrSetLocal::get_java_vframe() { | |
| 593 vframe* vf = get_vframe(); | |
| 594 if (vf == NULL) { | |
| 595 _result = JVMTI_ERROR_NO_MORE_FRAMES; | |
| 596 return NULL; | |
| 597 } | |
| 598 javaVFrame *jvf = (javaVFrame*)vf; | |
| 599 | |
| 2019 | 600 if (!vf->is_java_frame()) { |
| 0 | 601 _result = JVMTI_ERROR_OPAQUE_FRAME; |
| 602 return NULL; | |
| 603 } | |
| 604 return jvf; | |
| 605 } | |
| 606 | |
| 607 // Check that the klass is assignable to a type with the given signature. | |
| 608 // Another solution could be to use the function Klass::is_subtype_of(type). | |
| 609 // But the type class can be forced to load/initialize eagerly in such a case. | |
| 610 // This may cause unexpected consequences like CFLH or class-init JVMTI events. | |
| 611 // It is better to avoid such a behavior. | |
| 612 bool VM_GetOrSetLocal::is_assignable(const char* ty_sign, Klass* klass, Thread* thread) { | |
| 613 assert(ty_sign != NULL, "type signature must not be NULL"); | |
| 614 assert(thread != NULL, "thread must not be NULL"); | |
| 615 assert(klass != NULL, "klass must not be NULL"); | |
| 616 | |
| 617 int len = (int) strlen(ty_sign); | |
| 618 if (ty_sign[0] == 'L' && ty_sign[len-1] == ';') { // Need pure class/interface name | |
| 619 ty_sign++; | |
| 620 len -= 2; | |
| 621 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
622 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
|
623 if (klass->name() == ty_sym) { |
| 0 | 624 return true; |
| 625 } | |
| 626 // Compare primary supers | |
| 627 int super_depth = klass->super_depth(); | |
| 628 int idx; | |
| 629 for (idx = 0; idx < super_depth; idx++) { | |
| 6983 | 630 if (klass->primary_super_of_depth(idx)->name() == ty_sym) { |
| 0 | 631 return true; |
| 632 } | |
| 633 } | |
| 634 // Compare secondary supers | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
635 Array<Klass*>* sec_supers = klass->secondary_supers(); |
| 0 | 636 for (idx = 0; idx < sec_supers->length(); idx++) { |
| 6983 | 637 if (((Klass*) sec_supers->at(idx))->name() == ty_sym) { |
| 0 | 638 return true; |
| 639 } | |
| 640 } | |
| 641 return false; | |
| 642 } | |
| 643 | |
| 644 // Checks error conditions: | |
| 645 // JVMTI_ERROR_INVALID_SLOT | |
| 646 // JVMTI_ERROR_TYPE_MISMATCH | |
| 647 // Returns: 'true' - everything is Ok, 'false' - error code | |
| 648 | |
| 649 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
|
650 Method* method_oop = jvf->method(); |
| 0 | 651 if (!method_oop->has_localvariable_table()) { |
| 652 // Just to check index boundaries | |
| 653 jint extra_slot = (_type == T_LONG || _type == T_DOUBLE) ? 1 : 0; | |
| 654 if (_index < 0 || _index + extra_slot >= method_oop->max_locals()) { | |
| 655 _result = JVMTI_ERROR_INVALID_SLOT; | |
| 656 return false; | |
| 657 } | |
| 658 return true; | |
| 659 } | |
| 660 | |
| 661 jint num_entries = method_oop->localvariable_table_length(); | |
| 662 if (num_entries == 0) { | |
| 663 _result = JVMTI_ERROR_INVALID_SLOT; | |
| 664 return false; // There are no slots | |
| 665 } | |
| 666 int signature_idx = -1; | |
| 667 int vf_bci = jvf->bci(); | |
| 668 LocalVariableTableElement* table = method_oop->localvariable_table_start(); | |
| 669 for (int i = 0; i < num_entries; i++) { | |
| 670 int start_bci = table[i].start_bci; | |
| 671 int end_bci = start_bci + table[i].length; | |
| 672 | |
| 673 // Here we assume that locations of LVT entries | |
| 674 // with the same slot number cannot be overlapped | |
| 675 if (_index == (jint) table[i].slot && start_bci <= vf_bci && vf_bci <= end_bci) { | |
| 676 signature_idx = (int) table[i].descriptor_cp_index; | |
| 677 break; | |
| 678 } | |
| 679 } | |
| 680 if (signature_idx == -1) { | |
| 681 _result = JVMTI_ERROR_INVALID_SLOT; | |
| 682 return false; // Incorrect slot index | |
| 683 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
684 Symbol* sign_sym = method_oop->constants()->symbol_at(signature_idx); |
| 0 | 685 const char* signature = (const char *) sign_sym->as_utf8(); |
| 686 BasicType slot_type = char2type(signature[0]); | |
| 687 | |
| 688 switch (slot_type) { | |
| 689 case T_BYTE: | |
| 690 case T_SHORT: | |
| 691 case T_CHAR: | |
| 692 case T_BOOLEAN: | |
| 693 slot_type = T_INT; | |
| 694 break; | |
| 695 case T_ARRAY: | |
| 696 slot_type = T_OBJECT; | |
| 697 break; | |
| 698 }; | |
| 699 if (_type != slot_type) { | |
| 700 _result = JVMTI_ERROR_TYPE_MISMATCH; | |
| 701 return false; | |
| 702 } | |
| 703 | |
| 704 jobject jobj = _value.l; | |
| 705 if (_set && slot_type == T_OBJECT && jobj != NULL) { // NULL reference is allowed | |
| 706 // Check that the jobject class matches the return type signature. | |
| 707 JavaThread* cur_thread = JavaThread::current(); | |
| 708 HandleMark hm(cur_thread); | |
| 709 | |
| 710 Handle obj = Handle(cur_thread, JNIHandles::resolve_external_guard(jobj)); | |
| 711 NULL_CHECK(obj, (_result = JVMTI_ERROR_INVALID_OBJECT, false)); | |
| 712 KlassHandle ob_kh = KlassHandle(cur_thread, obj->klass()); | |
| 713 NULL_CHECK(ob_kh, (_result = JVMTI_ERROR_INVALID_OBJECT, false)); | |
| 714 | |
| 6983 | 715 if (!is_assignable(signature, ob_kh(), cur_thread)) { |
| 0 | 716 _result = JVMTI_ERROR_TYPE_MISMATCH; |
| 717 return false; | |
| 718 } | |
| 719 } | |
| 720 return true; | |
| 721 } | |
| 722 | |
| 723 static bool can_be_deoptimized(vframe* vf) { | |
| 724 return (vf->is_compiled_frame() && vf->fr().can_be_deoptimized()); | |
| 725 } | |
| 726 | |
| 727 bool VM_GetOrSetLocal::doit_prologue() { | |
| 728 _jvf = get_java_vframe(); | |
| 729 NULL_CHECK(_jvf, false); | |
| 730 | |
| 2019 | 731 if (_jvf->method()->is_native()) { |
| 732 if (getting_receiver() && !_jvf->method()->is_static()) { | |
| 733 return true; | |
| 734 } else { | |
| 735 _result = JVMTI_ERROR_OPAQUE_FRAME; | |
| 736 return false; | |
| 737 } | |
| 738 } | |
| 739 | |
| 0 | 740 if (!check_slot_type(_jvf)) { |
| 741 return false; | |
| 742 } | |
| 743 return true; | |
| 744 } | |
| 745 | |
| 746 void VM_GetOrSetLocal::doit() { | |
| 747 if (_set) { | |
| 748 // Force deoptimization of frame if compiled because it's | |
| 749 // possible the compiler emitted some locals as constant values, | |
| 750 // meaning they are not mutable. | |
| 751 if (can_be_deoptimized(_jvf)) { | |
| 752 | |
| 753 // Schedule deoptimization so that eventually the local | |
| 754 // 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
|
755 Deoptimization::deoptimize_frame(_jvf->thread(), _jvf->fr().id()); |
| 0 | 756 |
| 757 // Now store a new value for the local which will be applied | |
| 758 // once deoptimization occurs. Note however that while this | |
| 759 // write is deferred until deoptimization actually happens | |
| 760 // can vframe created after this point will have its locals | |
| 761 // reflecting this update so as far as anyone can see the | |
| 762 // write has already taken place. | |
| 763 | |
| 764 // If we are updating an oop then get the oop from the handle | |
| 765 // since the handle will be long gone by the time the deopt | |
| 766 // happens. The oop stored in the deferred local will be | |
| 767 // gc'd on its own. | |
| 768 if (_type == T_OBJECT) { | |
| 769 _value.l = (jobject) (JNIHandles::resolve_external_guard(_value.l)); | |
| 770 } | |
| 771 // Re-read the vframe so we can see that it is deoptimized | |
| 772 // [ Only need because of assert in update_local() ] | |
| 773 _jvf = get_java_vframe(); | |
| 774 ((compiledVFrame*)_jvf)->update_local(_type, _index, _value); | |
| 775 return; | |
| 776 } | |
| 777 StackValueCollection *locals = _jvf->locals(); | |
| 778 HandleMark hm; | |
| 779 | |
| 780 switch (_type) { | |
| 2019 | 781 case T_INT: locals->set_int_at (_index, _value.i); break; |
| 782 case T_LONG: locals->set_long_at (_index, _value.j); break; | |
| 783 case T_FLOAT: locals->set_float_at (_index, _value.f); break; | |
| 784 case T_DOUBLE: locals->set_double_at(_index, _value.d); break; | |
| 785 case T_OBJECT: { | |
| 786 Handle ob_h(JNIHandles::resolve_external_guard(_value.l)); | |
| 787 locals->set_obj_at (_index, ob_h); | |
| 788 break; | |
| 789 } | |
| 790 default: ShouldNotReachHere(); | |
| 0 | 791 } |
| 792 _jvf->set_locals(locals); | |
| 793 } else { | |
| 2019 | 794 if (_jvf->method()->is_native() && _jvf->is_compiled_frame()) { |
| 795 assert(getting_receiver(), "Can only get here when getting receiver"); | |
| 796 oop receiver = _jvf->fr().get_native_receiver(); | |
| 797 _value.l = JNIHandles::make_local(_calling_thread, receiver); | |
| 798 } else { | |
| 799 StackValueCollection *locals = _jvf->locals(); | |
| 0 | 800 |
| 2019 | 801 if (locals->at(_index)->type() == T_CONFLICT) { |
| 802 memset(&_value, 0, sizeof(_value)); | |
| 803 _value.l = NULL; | |
| 804 return; | |
| 805 } | |
| 0 | 806 |
| 2019 | 807 switch (_type) { |
| 808 case T_INT: _value.i = locals->int_at (_index); break; | |
| 809 case T_LONG: _value.j = locals->long_at (_index); break; | |
| 810 case T_FLOAT: _value.f = locals->float_at (_index); break; | |
| 811 case T_DOUBLE: _value.d = locals->double_at(_index); break; | |
| 812 case T_OBJECT: { | |
| 813 // Wrap the oop to be returned in a local JNI handle since | |
| 814 // oops_do() no longer applies after doit() is finished. | |
| 815 oop obj = locals->obj_at(_index)(); | |
| 816 _value.l = JNIHandles::make_local(_calling_thread, obj); | |
| 817 break; | |
| 818 } | |
| 819 default: ShouldNotReachHere(); | |
| 820 } | |
| 0 | 821 } |
| 822 } | |
| 823 } | |
| 824 | |
| 825 | |
| 826 bool VM_GetOrSetLocal::allow_nested_vm_operations() const { | |
| 827 return true; // May need to deoptimize | |
| 828 } | |
| 829 | |
| 830 | |
| 2019 | 831 VM_GetReceiver::VM_GetReceiver( |
| 832 JavaThread* thread, JavaThread* caller_thread, jint depth) | |
| 833 : VM_GetOrSetLocal(thread, caller_thread, depth, 0) {} | |
| 834 | |
| 0 | 835 ///////////////////////////////////////////////////////////////////////////////////////// |
| 836 | |
| 837 // | |
| 838 // class JvmtiSuspendControl - see comments in jvmtiImpl.hpp | |
| 839 // | |
| 840 | |
| 841 bool JvmtiSuspendControl::suspend(JavaThread *java_thread) { | |
| 842 // external suspend should have caught suspending a thread twice | |
| 843 | |
| 844 // Immediate suspension required for JPDA back-end so JVMTI agent threads do | |
| 845 // not deadlock due to later suspension on transitions while holding | |
| 846 // raw monitors. Passing true causes the immediate suspension. | |
| 847 // java_suspend() will catch threads in the process of exiting | |
| 848 // and will ignore them. | |
| 849 java_thread->java_suspend(); | |
| 850 | |
| 851 // It would be nice to have the following assertion in all the time, | |
| 852 // but it is possible for a racing resume request to have resumed | |
| 853 // this thread right after we suspended it. Temporarily enable this | |
| 854 // assertion if you are chasing a different kind of bug. | |
| 855 // | |
| 856 // assert(java_lang_Thread::thread(java_thread->threadObj()) == NULL || | |
| 857 // java_thread->is_being_ext_suspended(), "thread is not suspended"); | |
| 858 | |
| 859 if (java_lang_Thread::thread(java_thread->threadObj()) == NULL) { | |
| 860 // check again because we can get delayed in java_suspend(): | |
| 861 // the thread is in process of exiting. | |
| 862 return false; | |
| 863 } | |
| 864 | |
| 865 return true; | |
| 866 } | |
| 867 | |
| 868 bool JvmtiSuspendControl::resume(JavaThread *java_thread) { | |
| 869 // external suspend should have caught resuming a thread twice | |
| 870 assert(java_thread->is_being_ext_suspended(), "thread should be suspended"); | |
| 871 | |
| 872 // resume thread | |
| 873 { | |
| 874 // must always grab Threads_lock, see JVM_SuspendThread | |
| 875 MutexLocker ml(Threads_lock); | |
| 876 java_thread->java_resume(); | |
| 877 } | |
| 878 | |
| 879 return true; | |
| 880 } | |
| 881 | |
| 882 | |
| 883 void JvmtiSuspendControl::print() { | |
| 884 #ifndef PRODUCT | |
| 885 MutexLocker mu(Threads_lock); | |
| 886 ResourceMark rm; | |
| 887 | |
| 888 tty->print("Suspended Threads: ["); | |
| 889 for (JavaThread *thread = Threads::first(); thread != NULL; thread = thread->next()) { | |
| 8721 | 890 #ifdef JVMTI_TRACE |
| 0 | 891 const char *name = JvmtiTrace::safe_get_thread_name(thread); |
| 892 #else | |
| 893 const char *name = ""; | |
| 894 #endif /*JVMTI_TRACE */ | |
| 895 tty->print("%s(%c ", name, thread->is_being_ext_suspended() ? 'S' : '_'); | |
| 896 if (!thread->has_last_Java_frame()) { | |
| 897 tty->print("no stack"); | |
| 898 } | |
| 899 tty->print(") "); | |
| 900 } | |
| 901 tty->print_cr("]"); | |
| 902 #endif | |
| 903 } | |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
904 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
905 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
|
906 nmethod* nm) { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
907 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
|
908 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
|
909 // 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
|
910 // 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
|
911 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
|
912 return event; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
913 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
914 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
915 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
|
916 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
|
917 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
|
918 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
|
919 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
|
920 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
|
921 // 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
|
922 // 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
|
923 // 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
|
924 // 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
|
925 // 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
|
926 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
|
927 return event; |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
928 } |
|
3304
0cddebc420d8
7039447: 2/1 java profiling is broken in build 139 (garbage in function name)
dcubed
parents:
2342
diff
changeset
|
929 |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
930 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
|
931 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
|
932 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
|
933 // 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
|
934 // 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
|
935 // 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
|
936 // the post() routine below. |
|
0cddebc420d8
7039447: 2/1 java profiling is broken in build 139 (garbage in function name)
dcubed
parents:
2342
diff
changeset
|
937 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
|
938 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
|
939 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
|
940 return event; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
941 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
942 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
943 void JvmtiDeferredEvent::post() { |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
944 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
|
945 "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
|
946 switch(_type) { |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
947 case TYPE_COMPILED_METHOD_LOAD: { |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
948 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
|
949 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
|
950 // 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
|
951 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
|
952 break; |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
953 } |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2301
diff
changeset
|
954 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
|
955 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
|
956 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
|
957 _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
|
958 _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
|
959 // 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
|
960 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
|
961 break; |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2301
diff
changeset
|
962 } |
|
3304
0cddebc420d8
7039447: 2/1 java profiling is broken in build 139 (garbage in function name)
dcubed
parents:
2342
diff
changeset
|
963 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
|
964 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
|
965 // 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
|
966 (_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
|
967 ? "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
|
968 _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
|
969 _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
|
970 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
|
971 // release our copy |
|
0cddebc420d8
7039447: 2/1 java profiling is broken in build 139 (garbage in function name)
dcubed
parents:
2342
diff
changeset
|
972 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
|
973 } |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
974 break; |
|
3304
0cddebc420d8
7039447: 2/1 java profiling is broken in build 139 (garbage in function name)
dcubed
parents:
2342
diff
changeset
|
975 } |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
976 default: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
977 ShouldNotReachHere(); |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
978 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
979 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
980 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
981 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
|
982 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
|
983 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
984 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
|
985 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
|
986 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
987 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
|
988 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
|
989 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
|
990 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
991 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
992 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
|
993 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
|
994 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
995 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
|
996 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
997 // 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
|
998 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
|
999 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
|
1000 _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
|
1001 } else { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1002 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
|
1003 _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
|
1004 _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
|
1005 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1006 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1007 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
|
1008 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
|
1009 "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
|
1010 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1011 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1012 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
|
1013 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
|
1014 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1015 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
|
1016 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1017 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
|
1018 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1019 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
|
1020 // 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
|
1021 return JvmtiDeferredEvent(); |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1022 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1023 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1024 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
|
1025 _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
|
1026 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
|
1027 _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
|
1028 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1029 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1030 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
|
1031 "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
|
1032 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1033 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
|
1034 delete node; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1035 return event; |
|
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 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
|
1039 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
|
1040 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1041 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
|
1042 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1043 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
|
1044 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
|
1045 do { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1046 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
|
1047 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
|
1048 (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
|
1049 } 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
|
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 // 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
|
1053 // 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
|
1054 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
|
1055 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
|
1056 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1057 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
|
1058 QueueNode* head = |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1059 (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
|
1060 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1061 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
|
1062 "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
|
1063 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1064 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
|
1065 // 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
|
1066 // 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
|
1067 // 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
|
1068 // 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
|
1069 // 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
|
1070 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1071 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
|
1072 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
|
1073 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1074 // 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
|
1075 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
|
1076 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
|
1077 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
|
1078 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
|
1079 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
|
1080 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
|
1081 prev = node; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1082 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 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1084 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
|
1085 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1086 // 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
|
1087 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
|
1088 _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
|
1089 } 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
|
1090 _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
|
1091 } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
1092 _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
|
1093 } |
|
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 } |