Mercurial > hg > graal-compiler
annotate src/share/vm/prims/jvmtiImpl.hpp @ 3992:d1bdeef3e3e2
7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing.
Reviewed-by: tonyp, brutisso, ysr
| author | johnc |
|---|---|
| date | Wed, 12 Oct 2011 10:25:51 -0700 |
| parents | 46a56fac55c7 |
| children | d2a62e0f25eb |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
2 * Copyright (c) 1999, 2011, 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 #ifndef SHARE_VM_PRIMS_JVMTIIMPL_HPP |
| 26 #define SHARE_VM_PRIMS_JVMTIIMPL_HPP | |
| 27 | |
| 28 #ifndef JVMTI_KERNEL | |
|
1983
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
29 |
| 1972 | 30 #include "classfile/systemDictionary.hpp" |
| 31 #include "jvmtifiles/jvmti.h" | |
| 32 #include "oops/objArrayOop.hpp" | |
| 33 #include "prims/jvmtiEnvThreadState.hpp" | |
| 34 #include "prims/jvmtiEventController.hpp" | |
| 35 #include "prims/jvmtiTrace.hpp" | |
| 36 #include "prims/jvmtiUtil.hpp" | |
| 37 #include "runtime/stackValueCollection.hpp" | |
| 38 #include "runtime/vm_operations.hpp" | |
| 39 | |
| 0 | 40 // |
| 41 // Forward Declarations | |
| 42 // | |
| 43 | |
| 44 class JvmtiBreakpoint; | |
| 45 class JvmtiBreakpoints; | |
| 46 | |
| 47 | |
| 48 /////////////////////////////////////////////////////////////// | |
| 49 // | |
| 50 // class GrowableCache, GrowableElement | |
| 51 // Used by : JvmtiBreakpointCache | |
| 52 // Used by JVMTI methods: none directly. | |
| 53 // | |
| 54 // GrowableCache is a permanent CHeap growable array of <GrowableElement *> | |
| 55 // | |
| 56 // In addition, the GrowableCache maintains a NULL terminated cache array of type address | |
| 57 // that's created from the element array using the function: | |
| 58 // address GrowableElement::getCacheValue(). | |
| 59 // | |
| 60 // Whenever the GrowableArray changes size, the cache array gets recomputed into a new C_HEAP allocated | |
| 61 // block of memory. Additionally, every time the cache changes its position in memory, the | |
| 62 // void (*_listener_fun)(void *this_obj, address* cache) | |
| 63 // gets called with the cache's new address. This gives the user of the GrowableCache a callback | |
| 64 // to update its pointer to the address cache. | |
| 65 // | |
| 66 | |
| 67 class GrowableElement : public CHeapObj { | |
| 68 public: | |
| 69 virtual address getCacheValue() =0; | |
| 70 virtual bool equals(GrowableElement* e) =0; | |
| 71 virtual bool lessThan(GrowableElement *e)=0; | |
| 72 virtual GrowableElement *clone() =0; | |
| 73 virtual void oops_do(OopClosure* f) =0; | |
| 74 }; | |
| 75 | |
| 76 class GrowableCache VALUE_OBJ_CLASS_SPEC { | |
| 77 | |
| 78 private: | |
| 79 // Object pointer passed into cache & listener functions. | |
| 80 void *_this_obj; | |
| 81 | |
| 82 // Array of elements in the collection | |
| 83 GrowableArray<GrowableElement *> *_elements; | |
| 84 | |
| 85 // Parallel array of cached values | |
| 86 address *_cache; | |
| 87 | |
| 88 // Listener for changes to the _cache field. | |
| 89 // Called whenever the _cache field has it's value changed | |
| 90 // (but NOT when cached elements are recomputed). | |
| 91 void (*_listener_fun)(void *, address*); | |
| 92 | |
| 93 static bool equals(void *, GrowableElement *); | |
| 94 | |
| 95 // recache all elements after size change, notify listener | |
| 96 void recache(); | |
| 97 | |
| 98 public: | |
| 99 GrowableCache(); | |
| 100 ~GrowableCache(); | |
| 101 | |
| 102 void initialize(void *this_obj, void listener_fun(void *, address*) ); | |
| 103 | |
| 104 // number of elements in the collection | |
| 105 int length(); | |
| 106 // get the value of the index element in the collection | |
| 107 GrowableElement* at(int index); | |
| 108 // find the index of the element, -1 if it doesn't exist | |
| 109 int find(GrowableElement* e); | |
| 110 // append a copy of the element to the end of the collection, notify listener | |
| 111 void append(GrowableElement* e); | |
| 112 // insert a copy of the element using lessthan(), notify listener | |
| 113 void insert(GrowableElement* e); | |
| 114 // remove the element at index, notify listener | |
| 115 void remove (int index); | |
| 116 // clear out all elements and release all heap space, notify listener | |
| 117 void clear(); | |
| 118 // apply f to every element and update the cache | |
| 119 void oops_do(OopClosure* f); | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
120 // update the cache after a full gc |
|
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
121 void gc_epilogue(); |
| 0 | 122 }; |
| 123 | |
| 124 | |
| 125 /////////////////////////////////////////////////////////////// | |
| 126 // | |
| 127 // class JvmtiBreakpointCache | |
| 128 // Used by : JvmtiBreakpoints | |
| 129 // Used by JVMTI methods: none directly. | |
| 130 // Note : typesafe wrapper for GrowableCache of JvmtiBreakpoint | |
| 131 // | |
| 132 | |
| 133 class JvmtiBreakpointCache : public CHeapObj { | |
| 134 | |
| 135 private: | |
| 136 GrowableCache _cache; | |
| 137 | |
| 138 public: | |
| 139 JvmtiBreakpointCache() {} | |
| 140 ~JvmtiBreakpointCache() {} | |
| 141 | |
| 142 void initialize(void *this_obj, void listener_fun(void *, address*) ) { | |
| 143 _cache.initialize(this_obj,listener_fun); | |
| 144 } | |
| 145 | |
| 146 int length() { return _cache.length(); } | |
| 147 JvmtiBreakpoint& at(int index) { return (JvmtiBreakpoint&) *(_cache.at(index)); } | |
| 148 int find(JvmtiBreakpoint& e) { return _cache.find((GrowableElement *) &e); } | |
| 149 void append(JvmtiBreakpoint& e) { _cache.append((GrowableElement *) &e); } | |
| 150 void remove (int index) { _cache.remove(index); } | |
| 151 void clear() { _cache.clear(); } | |
| 152 void oops_do(OopClosure* f) { _cache.oops_do(f); } | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
153 void gc_epilogue() { _cache.gc_epilogue(); } |
| 0 | 154 }; |
| 155 | |
| 156 | |
| 157 /////////////////////////////////////////////////////////////// | |
| 158 // | |
| 159 // class JvmtiBreakpoint | |
| 160 // Used by : JvmtiBreakpoints | |
| 161 // Used by JVMTI methods: SetBreakpoint, ClearBreakpoint, ClearAllBreakpoints | |
| 162 // Note: Extends GrowableElement for use in a GrowableCache | |
| 163 // | |
| 164 // A JvmtiBreakpoint describes a location (class, method, bci) to break at. | |
| 165 // | |
| 166 | |
| 167 typedef void (methodOopDesc::*method_action)(int _bci); | |
| 168 | |
| 169 class JvmtiBreakpoint : public GrowableElement { | |
| 170 private: | |
| 171 methodOop _method; | |
| 172 int _bci; | |
| 173 Bytecodes::Code _orig_bytecode; | |
| 174 | |
| 175 public: | |
| 176 JvmtiBreakpoint(); | |
| 177 JvmtiBreakpoint(methodOop m_method, jlocation location); | |
| 178 bool equals(JvmtiBreakpoint& bp); | |
| 179 bool lessThan(JvmtiBreakpoint &bp); | |
| 180 void copy(JvmtiBreakpoint& bp); | |
| 181 bool is_valid(); | |
| 182 address getBcp(); | |
| 183 void each_method_version_do(method_action meth_act); | |
| 184 void set(); | |
| 185 void clear(); | |
| 186 void print(); | |
| 187 | |
| 188 methodOop method() { return _method; } | |
| 189 | |
| 190 // GrowableElement implementation | |
| 191 address getCacheValue() { return getBcp(); } | |
| 192 bool lessThan(GrowableElement* e) { Unimplemented(); return false; } | |
| 193 bool equals(GrowableElement* e) { return equals((JvmtiBreakpoint&) *e); } | |
| 194 void oops_do(OopClosure* f) { f->do_oop((oop *) &_method); } | |
| 195 GrowableElement *clone() { | |
| 196 JvmtiBreakpoint *bp = new JvmtiBreakpoint(); | |
| 197 bp->copy(*this); | |
| 198 return bp; | |
| 199 } | |
| 200 }; | |
| 201 | |
| 202 | |
| 203 /////////////////////////////////////////////////////////////// | |
| 204 // | |
| 205 // class VM_ChangeBreakpoints | |
| 206 // Used by : JvmtiBreakpoints | |
| 207 // Used by JVMTI methods: none directly. | |
| 208 // Note: A Helper class. | |
| 209 // | |
| 210 // VM_ChangeBreakpoints implements a VM_Operation for ALL modifications to the JvmtiBreakpoints class. | |
| 211 // | |
| 212 | |
| 213 class VM_ChangeBreakpoints : public VM_Operation { | |
| 214 private: | |
| 215 JvmtiBreakpoints* _breakpoints; | |
| 216 int _operation; | |
| 217 JvmtiBreakpoint* _bp; | |
| 218 | |
| 219 public: | |
| 220 enum { SET_BREAKPOINT=0, CLEAR_BREAKPOINT=1, CLEAR_ALL_BREAKPOINT=2 }; | |
| 221 | |
| 222 VM_ChangeBreakpoints(JvmtiBreakpoints* breakpoints, int operation) { | |
| 223 _breakpoints = breakpoints; | |
| 224 _bp = NULL; | |
| 225 _operation = operation; | |
| 226 assert(breakpoints != NULL, "breakpoints != NULL"); | |
| 227 assert(operation == CLEAR_ALL_BREAKPOINT, "unknown breakpoint operation"); | |
| 228 } | |
| 229 VM_ChangeBreakpoints(JvmtiBreakpoints* breakpoints, int operation, JvmtiBreakpoint *bp) { | |
| 230 _breakpoints = breakpoints; | |
| 231 _bp = bp; | |
| 232 _operation = operation; | |
| 233 assert(breakpoints != NULL, "breakpoints != NULL"); | |
| 234 assert(bp != NULL, "bp != NULL"); | |
| 235 assert(operation == SET_BREAKPOINT || operation == CLEAR_BREAKPOINT , "unknown breakpoint operation"); | |
| 236 } | |
| 237 | |
| 238 VMOp_Type type() const { return VMOp_ChangeBreakpoints; } | |
| 239 void doit(); | |
| 240 void oops_do(OopClosure* f); | |
| 241 }; | |
| 242 | |
| 243 | |
| 244 /////////////////////////////////////////////////////////////// | |
| 245 // | |
| 246 // class JvmtiBreakpoints | |
| 247 // Used by : JvmtiCurrentBreakpoints | |
| 248 // Used by JVMTI methods: none directly | |
| 249 // Note: A Helper class | |
| 250 // | |
| 251 // JvmtiBreakpoints is a GrowableCache of JvmtiBreakpoint. | |
| 252 // All changes to the GrowableCache occur at a safepoint using VM_ChangeBreakpoints. | |
| 253 // | |
| 254 // Because _bps is only modified at safepoints, its possible to always use the | |
| 255 // cached byte code pointers from _bps without doing any synchronization (see JvmtiCurrentBreakpoints). | |
| 256 // | |
| 257 // It would be possible to make JvmtiBreakpoints a static class, but I've made it | |
| 258 // CHeap allocated to emphasize its similarity to JvmtiFramePops. | |
| 259 // | |
| 260 | |
| 261 class JvmtiBreakpoints : public CHeapObj { | |
| 262 private: | |
| 263 | |
| 264 JvmtiBreakpointCache _bps; | |
| 265 | |
| 266 // These should only be used by VM_ChangeBreakpoints | |
| 267 // to insure they only occur at safepoints. | |
| 268 // Todo: add checks for safepoint | |
| 269 friend class VM_ChangeBreakpoints; | |
| 270 void set_at_safepoint(JvmtiBreakpoint& bp); | |
| 271 void clear_at_safepoint(JvmtiBreakpoint& bp); | |
| 272 void clearall_at_safepoint(); | |
| 273 | |
| 274 static void do_element(GrowableElement *e); | |
| 275 | |
| 276 public: | |
| 277 JvmtiBreakpoints(void listener_fun(void *, address *)); | |
| 278 ~JvmtiBreakpoints(); | |
| 279 | |
| 280 int length(); | |
| 281 void oops_do(OopClosure* f); | |
| 282 void print(); | |
| 283 | |
| 284 int set(JvmtiBreakpoint& bp); | |
| 285 int clear(JvmtiBreakpoint& bp); | |
| 286 void clearall_in_class_at_safepoint(klassOop klass); | |
| 287 void clearall(); | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
288 void gc_epilogue(); |
| 0 | 289 }; |
| 290 | |
| 291 | |
| 292 /////////////////////////////////////////////////////////////// | |
| 293 // | |
| 294 // class JvmtiCurrentBreakpoints | |
| 295 // | |
| 296 // A static wrapper class for the JvmtiBreakpoints that provides: | |
| 297 // 1. a fast inlined function to check if a byte code pointer is a breakpoint (is_breakpoint). | |
| 298 // 2. a function for lazily creating the JvmtiBreakpoints class (this is not strictly necessary, | |
| 299 // but I'm copying the code from JvmtiThreadState which needs to lazily initialize | |
| 300 // JvmtiFramePops). | |
| 301 // 3. An oops_do entry point for GC'ing the breakpoint array. | |
| 302 // | |
| 303 | |
| 304 class JvmtiCurrentBreakpoints : public AllStatic { | |
| 305 | |
| 306 private: | |
| 307 | |
| 308 // Current breakpoints, lazily initialized by get_jvmti_breakpoints(); | |
| 309 static JvmtiBreakpoints *_jvmti_breakpoints; | |
| 310 | |
| 311 // NULL terminated cache of byte-code pointers corresponding to current breakpoints. | |
| 312 // Updated only at safepoints (with listener_fun) when the cache is moved. | |
| 313 // It exists only to make is_breakpoint fast. | |
| 314 static address *_breakpoint_list; | |
| 315 static inline void set_breakpoint_list(address *breakpoint_list) { _breakpoint_list = breakpoint_list; } | |
| 316 static inline address *get_breakpoint_list() { return _breakpoint_list; } | |
| 317 | |
| 318 // Listener for the GrowableCache in _jvmti_breakpoints, updates _breakpoint_list. | |
| 319 static void listener_fun(void *this_obj, address *cache); | |
| 320 | |
| 321 public: | |
| 322 static void initialize(); | |
| 323 static void destroy(); | |
| 324 | |
| 325 // lazily create _jvmti_breakpoints and _breakpoint_list | |
| 326 static JvmtiBreakpoints& get_jvmti_breakpoints(); | |
| 327 | |
| 328 // quickly test whether the bcp matches a cached breakpoint in the list | |
| 329 static inline bool is_breakpoint(address bcp); | |
| 330 | |
| 331 static void oops_do(OopClosure* f); | |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
332 static void gc_epilogue(); |
| 0 | 333 }; |
| 334 | |
| 335 // quickly test whether the bcp matches a cached breakpoint in the list | |
| 336 bool JvmtiCurrentBreakpoints::is_breakpoint(address bcp) { | |
| 337 address *bps = get_breakpoint_list(); | |
| 338 if (bps == NULL) return false; | |
| 339 for ( ; (*bps) != NULL; bps++) { | |
| 340 if ((*bps) == bcp) return true; | |
| 341 } | |
| 342 return false; | |
| 343 } | |
| 344 | |
| 345 /////////////////////////////////////////////////////////////// | |
| 346 // The get/set local operations must only be done by the VM thread | |
| 347 // because the interpreter version needs to access oop maps, which can | |
| 348 // only safely be done by the VM thread | |
| 349 // | |
| 350 // I'm told that in 1.5 oop maps are now protected by a lock and | |
| 351 // we could get rid of the VM op | |
| 352 // However if the VM op is removed then the target thread must | |
| 353 // be suspended AND a lock will be needed to prevent concurrent | |
| 354 // setting of locals to the same java thread. This lock is needed | |
| 355 // to prevent compiledVFrames from trying to add deferred updates | |
| 356 // to the thread simultaneously. | |
| 357 // | |
| 358 class VM_GetOrSetLocal : public VM_Operation { | |
| 2019 | 359 protected: |
| 0 | 360 JavaThread* _thread; |
| 361 JavaThread* _calling_thread; | |
| 362 jint _depth; | |
| 363 jint _index; | |
| 364 BasicType _type; | |
| 365 jvalue _value; | |
| 366 javaVFrame* _jvf; | |
| 367 bool _set; | |
| 368 | |
| 2019 | 369 // It is possible to get the receiver out of a non-static native wrapper |
| 370 // frame. Use VM_GetReceiver to do this. | |
| 371 virtual bool getting_receiver() const { return false; } | |
| 372 | |
| 0 | 373 jvmtiError _result; |
| 374 | |
| 375 vframe* get_vframe(); | |
| 376 javaVFrame* get_java_vframe(); | |
| 377 bool check_slot_type(javaVFrame* vf); | |
| 378 | |
| 379 public: | |
| 380 // Constructor for non-object getter | |
| 381 VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type); | |
| 382 | |
| 383 // Constructor for object or non-object setter | |
| 384 VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type, jvalue value); | |
| 385 | |
| 386 // Constructor for object getter | |
| 387 VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_thread, jint depth, | |
| 388 int index); | |
| 389 | |
| 390 VMOp_Type type() const { return VMOp_GetOrSetLocal; } | |
| 391 jvalue value() { return _value; } | |
| 392 jvmtiError result() { return _result; } | |
| 393 | |
| 394 bool doit_prologue(); | |
| 395 void doit(); | |
| 396 bool allow_nested_vm_operations() const; | |
| 397 const char* name() const { return "get/set locals"; } | |
| 398 | |
| 399 // Check that the klass is assignable to a type with the given signature. | |
| 400 static bool is_assignable(const char* ty_sign, Klass* klass, Thread* thread); | |
| 401 }; | |
| 402 | |
| 2019 | 403 class VM_GetReceiver : public VM_GetOrSetLocal { |
| 404 protected: | |
| 405 virtual bool getting_receiver() const { return true; } | |
| 406 | |
| 407 public: | |
| 408 VM_GetReceiver(JavaThread* thread, JavaThread* calling_thread, jint depth); | |
| 409 const char* name() const { return "get receiver"; } | |
| 410 }; | |
| 411 | |
| 0 | 412 |
| 413 /////////////////////////////////////////////////////////////// | |
| 414 // | |
| 415 // class JvmtiSuspendControl | |
| 416 // | |
| 417 // Convenience routines for suspending and resuming threads. | |
| 418 // | |
| 419 // All attempts by JVMTI to suspend and resume threads must go through the | |
| 420 // JvmtiSuspendControl interface. | |
| 421 // | |
| 422 // methods return true if successful | |
| 423 // | |
| 424 class JvmtiSuspendControl : public AllStatic { | |
| 425 public: | |
| 426 // suspend the thread, taking it to a safepoint | |
| 427 static bool suspend(JavaThread *java_thread); | |
| 428 // resume the thread | |
| 429 static bool resume(JavaThread *java_thread); | |
| 430 | |
| 431 static void print(); | |
| 432 }; | |
| 433 | |
|
1983
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
434 #endif // !JVMTI_KERNEL |
|
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
435 |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
436 /** |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
437 * When a thread (such as the compiler thread or VM thread) cannot post a |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
438 * JVMTI event itself because the event needs to be posted from a Java |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
439 * thread, then it can defer the event to the Service thread for posting. |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
440 * The information needed to post the event is encapsulated into this class |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
441 * and then enqueued onto the JvmtiDeferredEventQueue, where the Service |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
442 * thread will pick it up and post it. |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
443 * |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
444 * This is currently only used for posting compiled-method-load and unload |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
445 * events, which we don't want posted from the compiler thread. |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
446 */ |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
447 class JvmtiDeferredEvent VALUE_OBJ_CLASS_SPEC { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
448 friend class JvmtiDeferredEventQueue; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
449 private: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
450 typedef enum { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
451 TYPE_NONE, |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
452 TYPE_COMPILED_METHOD_LOAD, |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
453 TYPE_COMPILED_METHOD_UNLOAD, |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
454 TYPE_DYNAMIC_CODE_GENERATED |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
455 } Type; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
456 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
457 Type _type; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
458 union { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
459 nmethod* compiled_method_load; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
460 struct { |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2301
diff
changeset
|
461 nmethod* nm; |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
462 jmethodID method_id; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
463 const void* code_begin; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
464 } compiled_method_unload; |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
465 struct { |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
466 const char* name; |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
467 const void* code_begin; |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
468 const void* code_end; |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
469 } dynamic_code_generated; |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
470 } _event_data; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
471 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
472 JvmtiDeferredEvent(Type t) : _type(t) {} |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
473 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
474 public: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
475 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
476 JvmtiDeferredEvent() : _type(TYPE_NONE) {} |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
477 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
478 // Factory methods |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
479 static JvmtiDeferredEvent compiled_method_load_event(nmethod* nm) |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
480 KERNEL_RETURN_(JvmtiDeferredEvent()); |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2301
diff
changeset
|
481 static JvmtiDeferredEvent compiled_method_unload_event(nmethod* nm, |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
482 jmethodID id, const void* code) KERNEL_RETURN_(JvmtiDeferredEvent()); |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
483 static JvmtiDeferredEvent dynamic_code_generated_event( |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
484 const char* name, const void* begin, const void* end) |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
485 KERNEL_RETURN_(JvmtiDeferredEvent()); |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
486 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
487 // Actually posts the event. |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
488 void post() KERNEL_RETURN; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
489 }; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
490 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
491 /** |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
492 * Events enqueued on this queue wake up the Service thread which dequeues |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
493 * and posts the events. The Service_lock is required to be held |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
494 * when operating on the queue (except for the "pending" events). |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
495 */ |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
496 class JvmtiDeferredEventQueue : AllStatic { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
497 friend class JvmtiDeferredEvent; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
498 private: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
499 class QueueNode : public CHeapObj { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
500 private: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
501 JvmtiDeferredEvent _event; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
502 QueueNode* _next; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
503 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
504 public: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
505 QueueNode(const JvmtiDeferredEvent& event) |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
506 : _event(event), _next(NULL) {} |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
507 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
508 const JvmtiDeferredEvent& event() const { return _event; } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
509 QueueNode* next() const { return _next; } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
510 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
511 void set_next(QueueNode* next) { _next = next; } |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
512 }; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
513 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
514 static QueueNode* _queue_head; // Hold Service_lock to access |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
515 static QueueNode* _queue_tail; // Hold Service_lock to access |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
516 static volatile QueueNode* _pending_list; // Uses CAS for read/update |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
517 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
518 // Transfers events from the _pending_list to the _queue. |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
519 static void process_pending_events() KERNEL_RETURN; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
520 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
521 public: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
522 // Must be holding Service_lock when calling these |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
523 static bool has_events() KERNEL_RETURN_(false); |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
524 static void enqueue(const JvmtiDeferredEvent& event) KERNEL_RETURN; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
525 static JvmtiDeferredEvent dequeue() KERNEL_RETURN_(JvmtiDeferredEvent()); |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
526 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
527 // Used to enqueue events without using a lock, for times (such as during |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
528 // safepoint) when we can't or don't want to lock the Service_lock. |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
529 // |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
530 // Events will be held off to the side until there's a call to |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
531 // dequeue(), enqueue(), or process_pending_events() (all of which require |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
532 // the holding of the Service_lock), and will be enqueued at that time. |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
533 static void add_pending_event(const JvmtiDeferredEvent&) KERNEL_RETURN; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
534 }; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
535 |
| 0 | 536 // Utility macro that checks for NULL pointers: |
| 537 #define NULL_CHECK(X, Y) if ((X) == NULL) { return (Y); } | |
| 1972 | 538 |
| 539 #endif // SHARE_VM_PRIMS_JVMTIIMPL_HPP |