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