Mercurial > hg > truffle
annotate src/share/vm/prims/jvmtiImpl.hpp @ 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 | 77b028ba548c |
| children |
| 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; | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
72 virtual void metadata_do(void f(Metadata*)) =0; |
| 0 | 73 }; |
| 74 | |
| 75 class GrowableCache VALUE_OBJ_CLASS_SPEC { | |
| 76 | |
| 77 private: | |
| 78 // Object pointer passed into cache & listener functions. | |
| 79 void *_this_obj; | |
| 80 | |
| 81 // Array of elements in the collection | |
| 82 GrowableArray<GrowableElement *> *_elements; | |
| 83 | |
| 84 // Parallel array of cached values | |
| 85 address *_cache; | |
| 86 | |
| 87 // Listener for changes to the _cache field. | |
| 88 // Called whenever the _cache field has it's value changed | |
| 89 // (but NOT when cached elements are recomputed). | |
| 90 void (*_listener_fun)(void *, address*); | |
| 91 | |
| 92 static bool equals(void *, GrowableElement *); | |
| 93 | |
| 94 // recache all elements after size change, notify listener | |
| 95 void recache(); | |
| 96 | |
| 97 public: | |
| 98 GrowableCache(); | |
| 99 ~GrowableCache(); | |
| 100 | |
| 101 void initialize(void *this_obj, void listener_fun(void *, address*) ); | |
| 102 | |
| 103 // number of elements in the collection | |
| 104 int length(); | |
| 105 // get the value of the index element in the collection | |
| 106 GrowableElement* at(int index); | |
| 107 // find the index of the element, -1 if it doesn't exist | |
| 108 int find(GrowableElement* e); | |
| 109 // append a copy of the element to the end of the collection, notify listener | |
| 110 void append(GrowableElement* e); | |
| 111 // insert a copy of the element using lessthan(), notify listener | |
| 112 void insert(GrowableElement* e); | |
| 113 // remove the element at index, notify listener | |
| 114 void remove (int index); | |
| 115 // clear out all elements and release all heap space, notify listener | |
| 116 void clear(); | |
| 117 // apply f to every element and update the cache | |
| 118 void oops_do(OopClosure* f); | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
119 // walk metadata to preserve for RedefineClasses |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
120 void metadata_do(void f(Metadata*)); |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
121 // 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
|
122 void gc_epilogue(); |
| 0 | 123 }; |
| 124 | |
| 125 | |
| 126 /////////////////////////////////////////////////////////////// | |
| 127 // | |
| 128 // class JvmtiBreakpointCache | |
| 129 // Used by : JvmtiBreakpoints | |
| 130 // Used by JVMTI methods: none directly. | |
| 131 // Note : typesafe wrapper for GrowableCache of JvmtiBreakpoint | |
| 132 // | |
| 133 | |
| 6197 | 134 class JvmtiBreakpointCache : public CHeapObj<mtInternal> { |
| 0 | 135 |
| 136 private: | |
| 137 GrowableCache _cache; | |
| 138 | |
| 139 public: | |
| 140 JvmtiBreakpointCache() {} | |
| 141 ~JvmtiBreakpointCache() {} | |
| 142 | |
| 143 void initialize(void *this_obj, void listener_fun(void *, address*) ) { | |
| 144 _cache.initialize(this_obj,listener_fun); | |
| 145 } | |
| 146 | |
| 147 int length() { return _cache.length(); } | |
| 148 JvmtiBreakpoint& at(int index) { return (JvmtiBreakpoint&) *(_cache.at(index)); } | |
| 149 int find(JvmtiBreakpoint& e) { return _cache.find((GrowableElement *) &e); } | |
| 150 void append(JvmtiBreakpoint& e) { _cache.append((GrowableElement *) &e); } | |
| 151 void remove (int index) { _cache.remove(index); } | |
| 152 void clear() { _cache.clear(); } | |
| 153 void oops_do(OopClosure* f) { _cache.oops_do(f); } | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
154 void metadata_do(void f(Metadata*)) { _cache.metadata_do(f); } |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
155 void gc_epilogue() { _cache.gc_epilogue(); } |
| 0 | 156 }; |
| 157 | |
| 158 | |
| 159 /////////////////////////////////////////////////////////////// | |
| 160 // | |
| 161 // class JvmtiBreakpoint | |
| 162 // Used by : JvmtiBreakpoints | |
| 163 // Used by JVMTI methods: SetBreakpoint, ClearBreakpoint, ClearAllBreakpoints | |
| 164 // Note: Extends GrowableElement for use in a GrowableCache | |
| 165 // | |
| 166 // A JvmtiBreakpoint describes a location (class, method, bci) to break at. | |
| 167 // | |
| 168 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
169 typedef void (Method::*method_action)(int _bci); |
| 0 | 170 |
| 171 class JvmtiBreakpoint : public GrowableElement { | |
| 172 private: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
173 Method* _method; |
| 0 | 174 int _bci; |
| 175 Bytecodes::Code _orig_bytecode; | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
176 oop _class_holder; // keeps _method memory from being deallocated |
| 0 | 177 |
| 178 public: | |
| 179 JvmtiBreakpoint(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
180 JvmtiBreakpoint(Method* m_method, jlocation location); |
| 0 | 181 bool equals(JvmtiBreakpoint& bp); |
| 182 bool lessThan(JvmtiBreakpoint &bp); | |
| 183 void copy(JvmtiBreakpoint& bp); | |
| 184 bool is_valid(); | |
| 185 address getBcp(); | |
| 186 void each_method_version_do(method_action meth_act); | |
| 187 void set(); | |
| 188 void clear(); | |
| 189 void print(); | |
| 190 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
191 Method* method() { return _method; } |
| 0 | 192 |
| 193 // GrowableElement implementation | |
| 194 address getCacheValue() { return getBcp(); } | |
| 195 bool lessThan(GrowableElement* e) { Unimplemented(); return false; } | |
| 196 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
|
197 void oops_do(OopClosure* f) { |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
198 // Mark the method loader as live so the Method* class loader doesn't get |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
199 // unloaded and Method* memory reclaimed. |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
200 f->do_oop(&_class_holder); |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
201 } |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
202 void metadata_do(void f(Metadata*)) { |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
203 // walk metadata to preserve for RedefineClasses |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
204 f(_method); |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
205 } |
|
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
206 |
| 0 | 207 GrowableElement *clone() { |
| 208 JvmtiBreakpoint *bp = new JvmtiBreakpoint(); | |
| 209 bp->copy(*this); | |
| 210 return bp; | |
| 211 } | |
| 212 }; | |
| 213 | |
| 214 | |
| 215 /////////////////////////////////////////////////////////////// | |
| 216 // | |
| 217 // class JvmtiBreakpoints | |
| 218 // Used by : JvmtiCurrentBreakpoints | |
| 219 // Used by JVMTI methods: none directly | |
| 220 // Note: A Helper class | |
| 221 // | |
| 222 // JvmtiBreakpoints is a GrowableCache of JvmtiBreakpoint. | |
| 223 // All changes to the GrowableCache occur at a safepoint using VM_ChangeBreakpoints. | |
| 224 // | |
| 225 // Because _bps is only modified at safepoints, its possible to always use the | |
| 226 // cached byte code pointers from _bps without doing any synchronization (see JvmtiCurrentBreakpoints). | |
| 227 // | |
| 228 // It would be possible to make JvmtiBreakpoints a static class, but I've made it | |
| 229 // CHeap allocated to emphasize its similarity to JvmtiFramePops. | |
| 230 // | |
| 231 | |
| 6197 | 232 class JvmtiBreakpoints : public CHeapObj<mtInternal> { |
| 0 | 233 private: |
| 234 | |
| 235 JvmtiBreakpointCache _bps; | |
| 236 | |
| 237 // These should only be used by VM_ChangeBreakpoints | |
| 238 // to insure they only occur at safepoints. | |
| 239 // Todo: add checks for safepoint | |
| 240 friend class VM_ChangeBreakpoints; | |
| 241 void set_at_safepoint(JvmtiBreakpoint& bp); | |
| 242 void clear_at_safepoint(JvmtiBreakpoint& bp); | |
| 243 | |
| 244 static void do_element(GrowableElement *e); | |
| 245 | |
| 246 public: | |
| 247 JvmtiBreakpoints(void listener_fun(void *, address *)); | |
| 248 ~JvmtiBreakpoints(); | |
| 249 | |
| 250 int length(); | |
| 251 void oops_do(OopClosure* f); | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
252 void metadata_do(void f(Metadata*)); |
| 0 | 253 void print(); |
| 254 | |
| 255 int set(JvmtiBreakpoint& bp); | |
| 256 int clear(JvmtiBreakpoint& bp); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
257 void clearall_in_class_at_safepoint(Klass* klass); |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
258 void gc_epilogue(); |
| 0 | 259 }; |
| 260 | |
| 261 | |
| 262 /////////////////////////////////////////////////////////////// | |
| 263 // | |
| 264 // class JvmtiCurrentBreakpoints | |
| 265 // | |
| 266 // A static wrapper class for the JvmtiBreakpoints that provides: | |
| 267 // 1. a fast inlined function to check if a byte code pointer is a breakpoint (is_breakpoint). | |
| 268 // 2. a function for lazily creating the JvmtiBreakpoints class (this is not strictly necessary, | |
| 269 // but I'm copying the code from JvmtiThreadState which needs to lazily initialize | |
| 270 // JvmtiFramePops). | |
| 271 // 3. An oops_do entry point for GC'ing the breakpoint array. | |
| 272 // | |
| 273 | |
| 274 class JvmtiCurrentBreakpoints : public AllStatic { | |
| 275 | |
| 276 private: | |
| 277 | |
| 278 // Current breakpoints, lazily initialized by get_jvmti_breakpoints(); | |
| 279 static JvmtiBreakpoints *_jvmti_breakpoints; | |
| 280 | |
| 281 // NULL terminated cache of byte-code pointers corresponding to current breakpoints. | |
| 282 // Updated only at safepoints (with listener_fun) when the cache is moved. | |
| 283 // It exists only to make is_breakpoint fast. | |
| 284 static address *_breakpoint_list; | |
| 285 static inline void set_breakpoint_list(address *breakpoint_list) { _breakpoint_list = breakpoint_list; } | |
| 286 static inline address *get_breakpoint_list() { return _breakpoint_list; } | |
| 287 | |
| 288 // Listener for the GrowableCache in _jvmti_breakpoints, updates _breakpoint_list. | |
| 289 static void listener_fun(void *this_obj, address *cache); | |
| 290 | |
| 291 public: | |
| 292 static void initialize(); | |
| 293 static void destroy(); | |
| 294 | |
| 295 // lazily create _jvmti_breakpoints and _breakpoint_list | |
| 296 static JvmtiBreakpoints& get_jvmti_breakpoints(); | |
| 297 | |
| 298 // quickly test whether the bcp matches a cached breakpoint in the list | |
| 299 static inline bool is_breakpoint(address bcp); | |
| 300 | |
| 301 static void oops_do(OopClosure* f); | |
|
13409
77b028ba548c
8028396: Minimal VM: undefined symbol: _ZN23JvmtiCurrentBreakpoints11metadata_doEPFvP8MetadataE
jprovino
parents:
13038
diff
changeset
|
302 static void metadata_do(void f(Metadata*)) NOT_JVMTI_RETURN; |
|
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
303 static void gc_epilogue(); |
| 0 | 304 }; |
| 305 | |
| 306 // quickly test whether the bcp matches a cached breakpoint in the list | |
| 307 bool JvmtiCurrentBreakpoints::is_breakpoint(address bcp) { | |
| 308 address *bps = get_breakpoint_list(); | |
| 309 if (bps == NULL) return false; | |
| 310 for ( ; (*bps) != NULL; bps++) { | |
| 311 if ((*bps) == bcp) return true; | |
| 312 } | |
| 313 return false; | |
| 314 } | |
| 315 | |
| 10405 | 316 |
| 317 /////////////////////////////////////////////////////////////// | |
| 318 // | |
| 319 // class VM_ChangeBreakpoints | |
| 320 // Used by : JvmtiBreakpoints | |
| 321 // Used by JVMTI methods: none directly. | |
| 322 // Note: A Helper class. | |
| 323 // | |
| 324 // VM_ChangeBreakpoints implements a VM_Operation for ALL modifications to the JvmtiBreakpoints class. | |
| 325 // | |
| 326 | |
| 327 class VM_ChangeBreakpoints : public VM_Operation { | |
| 328 private: | |
| 329 JvmtiBreakpoints* _breakpoints; | |
| 330 int _operation; | |
| 331 JvmtiBreakpoint* _bp; | |
| 332 | |
| 333 public: | |
| 334 enum { SET_BREAKPOINT=0, CLEAR_BREAKPOINT=1 }; | |
| 335 | |
| 336 VM_ChangeBreakpoints(int operation, JvmtiBreakpoint *bp) { | |
| 337 JvmtiBreakpoints& current_bps = JvmtiCurrentBreakpoints::get_jvmti_breakpoints(); | |
| 338 _breakpoints = ¤t_bps; | |
| 339 _bp = bp; | |
| 340 _operation = operation; | |
| 341 assert(bp != NULL, "bp != NULL"); | |
| 342 } | |
| 343 | |
| 344 VMOp_Type type() const { return VMOp_ChangeBreakpoints; } | |
| 345 void doit(); | |
| 346 void oops_do(OopClosure* f); | |
|
13038
910026b800b8
8026946: JvmtiEnv::SetBreakpoint and JvmtiEnv::ClearBreakpoint should use MethodHandle
coleenp
parents:
10405
diff
changeset
|
347 void metadata_do(void f(Metadata*)); |
| 10405 | 348 }; |
| 349 | |
| 350 | |
| 0 | 351 /////////////////////////////////////////////////////////////// |
| 352 // The get/set local operations must only be done by the VM thread | |
| 353 // because the interpreter version needs to access oop maps, which can | |
| 354 // only safely be done by the VM thread | |
| 355 // | |
| 356 // I'm told that in 1.5 oop maps are now protected by a lock and | |
| 357 // we could get rid of the VM op | |
| 358 // However if the VM op is removed then the target thread must | |
| 359 // be suspended AND a lock will be needed to prevent concurrent | |
| 360 // setting of locals to the same java thread. This lock is needed | |
| 361 // to prevent compiledVFrames from trying to add deferred updates | |
| 362 // to the thread simultaneously. | |
| 363 // | |
| 364 class VM_GetOrSetLocal : public VM_Operation { | |
| 2019 | 365 protected: |
| 0 | 366 JavaThread* _thread; |
| 367 JavaThread* _calling_thread; | |
| 368 jint _depth; | |
| 369 jint _index; | |
| 370 BasicType _type; | |
| 371 jvalue _value; | |
| 372 javaVFrame* _jvf; | |
| 373 bool _set; | |
| 374 | |
| 2019 | 375 // It is possible to get the receiver out of a non-static native wrapper |
| 376 // frame. Use VM_GetReceiver to do this. | |
| 377 virtual bool getting_receiver() const { return false; } | |
| 378 | |
| 0 | 379 jvmtiError _result; |
| 380 | |
| 381 vframe* get_vframe(); | |
| 382 javaVFrame* get_java_vframe(); | |
| 383 bool check_slot_type(javaVFrame* vf); | |
| 384 | |
| 385 public: | |
| 386 // Constructor for non-object getter | |
| 387 VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type); | |
| 388 | |
| 389 // Constructor for object or non-object setter | |
| 390 VM_GetOrSetLocal(JavaThread* thread, jint depth, jint index, BasicType type, jvalue value); | |
| 391 | |
| 392 // Constructor for object getter | |
| 393 VM_GetOrSetLocal(JavaThread* thread, JavaThread* calling_thread, jint depth, | |
| 394 int index); | |
| 395 | |
| 396 VMOp_Type type() const { return VMOp_GetOrSetLocal; } | |
| 397 jvalue value() { return _value; } | |
| 398 jvmtiError result() { return _result; } | |
| 399 | |
| 400 bool doit_prologue(); | |
| 401 void doit(); | |
| 402 bool allow_nested_vm_operations() const; | |
| 403 const char* name() const { return "get/set locals"; } | |
| 404 | |
| 405 // Check that the klass is assignable to a type with the given signature. | |
| 406 static bool is_assignable(const char* ty_sign, Klass* klass, Thread* thread); | |
| 407 }; | |
| 408 | |
| 2019 | 409 class VM_GetReceiver : public VM_GetOrSetLocal { |
| 410 protected: | |
| 411 virtual bool getting_receiver() const { return true; } | |
| 412 | |
| 413 public: | |
| 414 VM_GetReceiver(JavaThread* thread, JavaThread* calling_thread, jint depth); | |
| 415 const char* name() const { return "get receiver"; } | |
| 416 }; | |
| 417 | |
| 0 | 418 |
| 419 /////////////////////////////////////////////////////////////// | |
| 420 // | |
| 421 // class JvmtiSuspendControl | |
| 422 // | |
| 423 // Convenience routines for suspending and resuming threads. | |
| 424 // | |
| 425 // All attempts by JVMTI to suspend and resume threads must go through the | |
| 426 // JvmtiSuspendControl interface. | |
| 427 // | |
| 428 // methods return true if successful | |
| 429 // | |
| 430 class JvmtiSuspendControl : public AllStatic { | |
| 431 public: | |
| 432 // suspend the thread, taking it to a safepoint | |
| 433 static bool suspend(JavaThread *java_thread); | |
| 434 // resume the thread | |
| 435 static bool resume(JavaThread *java_thread); | |
| 436 | |
| 437 static void print(); | |
| 438 }; | |
| 439 | |
|
1983
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
440 |
|
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
441 /** |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
442 * 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
|
443 * 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
|
444 * 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
|
445 * 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
|
446 * 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
|
447 * 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
|
448 * |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
449 * 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
|
450 * 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
|
451 */ |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
452 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
|
453 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
|
454 private: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
455 typedef enum { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
456 TYPE_NONE, |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
457 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
|
458 TYPE_COMPILED_METHOD_UNLOAD, |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
459 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
|
460 } Type; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
461 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
462 Type _type; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
463 union { |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
464 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
|
465 struct { |
|
2342
46a56fac55c7
7024970: 2/3 assert(ServiceThread::is_service_thread(Thread::current())) failed: Service thread must post enqueue
dcubed
parents:
2301
diff
changeset
|
466 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
|
467 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
|
468 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
|
469 } compiled_method_unload; |
|
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
470 struct { |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
471 const char* name; |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
472 const void* code_begin; |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
473 const void* code_end; |
|
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
474 } 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
|
475 } _event_data; |
|
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 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
|
478 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
479 public: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
480 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
481 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
|
482 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
483 // Factory methods |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
484 static JvmtiDeferredEvent compiled_method_load_event(nmethod* nm) |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
485 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
|
486 static JvmtiDeferredEvent compiled_method_unload_event(nmethod* nm, |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
487 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
|
488 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
|
489 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
|
490 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
|
491 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
492 // Actually posts the event. |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
493 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
|
494 }; |
|
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 /** |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
497 * 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
|
498 * 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
|
499 * 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
|
500 */ |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
501 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
|
502 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
|
503 private: |
| 6197 | 504 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
|
505 private: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
506 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 QueueNode* _next; |
|
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 public: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
510 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
|
511 : _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
|
512 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
513 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
|
514 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
|
515 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
516 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
|
517 }; |
|
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 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
|
520 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
|
521 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
|
522 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
523 // 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
|
524 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
|
525 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
526 public: |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
527 // Must be holding Service_lock when calling these |
|
6854
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
528 static bool has_events() NOT_JVMTI_RETURN_(false); |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
529 static void enqueue(const JvmtiDeferredEvent& event) NOT_JVMTI_RETURN; |
|
fb19af007ffc
7189254: Change makefiles for more flexibility to override defaults
jprovino
parents:
6725
diff
changeset
|
530 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
|
531 |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
532 // 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
|
533 // 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
|
534 // |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
535 // 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
|
536 // 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
|
537 // 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
|
538 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
|
539 }; |
|
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2147
diff
changeset
|
540 |
| 0 | 541 // Utility macro that checks for NULL pointers: |
| 542 #define NULL_CHECK(X, Y) if ((X) == NULL) { return (Y); } | |
| 1972 | 543 |
| 544 #endif // SHARE_VM_PRIMS_JVMTIIMPL_HPP |