Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/synchronizer.hpp @ 7588:f9eb431c3efe
8006005: Fix constant pool index validation and alignment trap for method parameter reflection
Summary: This patch addresses an alignment trap due to the storage format of method parameters data in constMethod. It also adds code to validate constant pool indexes for method parameters data.
Reviewed-by: jrose, dholmes
Contributed-by: eric.mccorkle@oracle.com
author | coleenp |
---|---|
date | Mon, 14 Jan 2013 11:01:39 -0500 |
parents | f95d63e2154a |
children | cc32ccaaf47f |
rev | line source |
---|---|
0 | 1 /* |
1972 | 2 * Copyright (c) 1998, 2010, 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:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
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:
0
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_RUNTIME_SYNCHRONIZER_HPP |
26 #define SHARE_VM_RUNTIME_SYNCHRONIZER_HPP | |
27 | |
28 #include "oops/markOop.hpp" | |
29 #include "runtime/basicLock.hpp" | |
30 #include "runtime/handles.hpp" | |
31 #include "runtime/perfData.hpp" | |
32 #include "utilities/top.hpp" | |
33 | |
0 | 34 |
35 class ObjectMonitor; | |
36 | |
37 class ObjectSynchronizer : AllStatic { | |
38 friend class VMStructs; | |
39 public: | |
40 typedef enum { | |
41 owner_self, | |
42 owner_none, | |
43 owner_other | |
44 } LockOwnership; | |
45 // exit must be implemented non-blocking, since the compiler cannot easily handle | |
46 // deoptimization at monitor exit. Hence, it does not take a Handle argument. | |
47 | |
48 // This is full version of monitor enter and exit. I choose not | |
49 // to use enter() and exit() in order to make sure user be ware | |
50 // of the performance and semantics difference. They are normally | |
51 // used by ObjectLocker etc. The interpreter and compiler use | |
52 // assembly copies of these routines. Please keep them synchornized. | |
53 // | |
54 // attempt_rebias flag is used by UseBiasedLocking implementation | |
55 static void fast_enter (Handle obj, BasicLock* lock, bool attempt_rebias, TRAPS); | |
56 static void fast_exit (oop obj, BasicLock* lock, Thread* THREAD); | |
57 | |
58 // WARNING: They are ONLY used to handle the slow cases. They should | |
59 // only be used when the fast cases failed. Use of these functions | |
60 // without previous fast case check may cause fatal error. | |
61 static void slow_enter (Handle obj, BasicLock* lock, TRAPS); | |
62 static void slow_exit (oop obj, BasicLock* lock, Thread* THREAD); | |
63 | |
64 // Used only to handle jni locks or other unmatched monitor enter/exit | |
65 // Internally they will use heavy weight monitor. | |
66 static void jni_enter (Handle obj, TRAPS); | |
67 static bool jni_try_enter(Handle obj, Thread* THREAD); // Implements Unsafe.tryMonitorEnter | |
68 static void jni_exit (oop obj, Thread* THREAD); | |
69 | |
70 // Handle all interpreter, compiler and jni cases | |
71 static void wait (Handle obj, jlong millis, TRAPS); | |
72 static void notify (Handle obj, TRAPS); | |
73 static void notifyall (Handle obj, TRAPS); | |
74 | |
75 // Special internal-use-only method for use by JVM infrastructure | |
76 // that needs to wait() on a java-level object but that can't risk | |
77 // throwing unexpected InterruptedExecutionExceptions. | |
78 static void waitUninterruptibly (Handle obj, jlong Millis, Thread * THREAD) ; | |
79 | |
80 // used by classloading to free classloader object lock, | |
81 // wait on an internal lock, and reclaim original lock | |
82 // with original recursion count | |
83 static intptr_t complete_exit (Handle obj, TRAPS); | |
84 static void reenter (Handle obj, intptr_t recursion, TRAPS); | |
85 | |
86 // thread-specific and global objectMonitor free list accessors | |
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
87 // static void verifyInUse (Thread * Self) ; too slow for general assert/debug |
0 | 88 static ObjectMonitor * omAlloc (Thread * Self) ; |
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
89 static void omRelease (Thread * Self, ObjectMonitor * m, bool FromPerThreadAlloc) ; |
0 | 90 static void omFlush (Thread * Self) ; |
91 | |
92 // Inflate light weight monitor to heavy weight monitor | |
93 static ObjectMonitor* inflate(Thread * Self, oop obj); | |
94 // This version is only for internal use | |
95 static ObjectMonitor* inflate_helper(oop obj); | |
96 | |
97 // Returns the identity hash value for an oop | |
98 // NOTE: It may cause monitor inflation | |
99 static intptr_t identity_hash_value_for(Handle obj); | |
100 static intptr_t FastHashCode (Thread * Self, oop obj) ; | |
101 | |
102 // java.lang.Thread support | |
103 static bool current_thread_holds_lock(JavaThread* thread, Handle h_obj); | |
104 static LockOwnership query_lock_ownership(JavaThread * self, Handle h_obj); | |
105 | |
106 static JavaThread* get_lock_owner(Handle h_obj, bool doLock); | |
107 | |
108 // JNI detach support | |
109 static void release_monitors_owned_by_thread(TRAPS); | |
110 static void monitors_iterate(MonitorClosure* m); | |
111 | |
112 // GC: we current use aggressive monitor deflation policy | |
113 // Basically we deflate all monitors that are not busy. | |
114 // An adaptive profile-based deflation policy could be used if needed | |
115 static void deflate_idle_monitors(); | |
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
116 static int walk_monitor_list(ObjectMonitor** listheadp, |
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
117 ObjectMonitor** FreeHeadp, |
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
118 ObjectMonitor** FreeTailp); |
1587 | 119 static bool deflate_monitor(ObjectMonitor* mid, oop obj, ObjectMonitor** FreeHeadp, |
120 ObjectMonitor** FreeTailp); | |
0 | 121 static void oops_do(OopClosure* f); |
122 | |
123 // debugging | |
124 static void trace_locking(Handle obj, bool is_compiled, bool is_method, bool is_locking) PRODUCT_RETURN; | |
125 static void verify() PRODUCT_RETURN; | |
126 static int verify_objmon_isinpool(ObjectMonitor *addr) PRODUCT_RETURN0; | |
127 | |
1878 | 128 static void RegisterSpinCallback (int (*)(intptr_t, int), intptr_t) ; |
129 | |
0 | 130 private: |
131 enum { _BLOCKSIZE = 128 }; | |
132 static ObjectMonitor* gBlockList; | |
133 static ObjectMonitor * volatile gFreeList; | |
1640
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
134 static ObjectMonitor * volatile gOmInUseList; // for moribund thread, so monitors they inflated still get scanned |
bfc89697cccb
6964164: MonitorInUseLists leak of contended objects
acorn
parents:
1589
diff
changeset
|
135 static int gOmInUseCount; |
0 | 136 |
137 }; | |
138 | |
139 // ObjectLocker enforced balanced locking and can never thrown an | |
140 // IllegalMonitorStateException. However, a pending exception may | |
141 // have to pass through, and we must also be able to deal with | |
142 // asynchronous exceptions. The caller is responsible for checking | |
143 // the threads pending exception if needed. | |
144 // doLock was added to support classloading with UnsyncloadClass which | |
145 // requires flag based choice of locking the classloader lock. | |
146 class ObjectLocker : public StackObj { | |
147 private: | |
148 Thread* _thread; | |
149 Handle _obj; | |
150 BasicLock _lock; | |
151 bool _dolock; // default true | |
152 public: | |
153 ObjectLocker(Handle obj, Thread* thread, bool doLock = true); | |
154 ~ObjectLocker(); | |
155 | |
156 // Monitor behavior | |
157 void wait (TRAPS) { ObjectSynchronizer::wait (_obj, 0, CHECK); } // wait forever | |
158 void notify_all(TRAPS) { ObjectSynchronizer::notifyall(_obj, CHECK); } | |
159 void waitUninterruptibly (TRAPS) { ObjectSynchronizer::waitUninterruptibly (_obj, 0, CHECK);} | |
160 // complete_exit gives up lock completely, returning recursion count | |
161 // reenter reclaims lock with original recursion count | |
162 intptr_t complete_exit(TRAPS) { return ObjectSynchronizer::complete_exit(_obj, CHECK_0); } | |
163 void reenter(intptr_t recursion, TRAPS) { ObjectSynchronizer::reenter(_obj, recursion, CHECK); } | |
164 }; | |
1972 | 165 |
166 #endif // SHARE_VM_RUNTIME_SYNCHRONIZER_HPP |