Mercurial > hg > graal-jvmci-8
annotate src/share/vm/runtime/jfieldIDWorkaround.hpp @ 3979:4dfb2df418f2
6484982: G1: process references during evacuation pauses
Summary: G1 now uses two reference processors - one is used by concurrent marking and the other is used by STW GCs (both full and incremental evacuation pauses). In an evacuation pause, the reference processor is embedded into the closures used to scan objects. Doing so causes causes reference objects to be 'discovered' by the reference processor. At the end of the evacuation pause, these discovered reference objects are processed - preserving (and copying) referent objects (and their reachable graphs) as appropriate.
Reviewed-by: ysr, jwilhelm, brutisso, stefank, tonyp
author | johnc |
---|---|
date | Thu, 22 Sep 2011 10:57:37 -0700 |
parents | f95d63e2154a |
children | da91efe96a93 |
rev | line source |
---|---|
0 | 1 /* |
1972 | 2 * Copyright (c) 2003, 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_JFIELDIDWORKAROUND_HPP |
26 #define SHARE_VM_RUNTIME_JFIELDIDWORKAROUND_HPP | |
27 | |
0 | 28 class jfieldIDWorkaround: AllStatic { |
29 // This workaround is because JVMTI doesn't have distinct entry points | |
30 // for methods that use static jfieldIDs and instance jfieldIDs. | |
31 // The workaround is to steal a low-order bit: | |
32 // a 1 means the jfieldID is an instance jfieldID, | |
33 // and the rest of the word is the offset of the field. | |
34 // a 0 means the jfieldID is a static jfieldID, | |
35 // and the rest of the word is the JNIid*. | |
36 // | |
37 // Another low-order bit is used to mark if an instance field | |
38 // is accompanied by an indication of which class it applies to. | |
39 // | |
40 // Bit-format of a jfieldID (most significant first): | |
41 // address:30 instance=0:1 checked=0:1 | |
42 // offset:30 instance=1:1 checked=0:1 | |
43 // klass:23 offset:7 instance=1:1 checked=1:1 | |
44 // | |
45 // If the offset does not fit in 7 bits, or if the fieldID is | |
46 // not checked, then the checked bit is zero and the rest of | |
47 // the word (30 bits) contains only the offset. | |
48 // | |
49 private: | |
50 enum { | |
51 checked_bits = 1, | |
52 instance_bits = 1, | |
53 address_bits = BitsPerWord - checked_bits - instance_bits, | |
54 | |
55 large_offset_bits = address_bits, // unioned with address | |
56 small_offset_bits = 7, | |
57 klass_bits = address_bits - small_offset_bits, | |
58 | |
59 checked_shift = 0, | |
60 instance_shift = checked_shift + checked_bits, | |
61 address_shift = instance_shift + instance_bits, | |
62 | |
63 offset_shift = address_shift, // unioned with address | |
64 klass_shift = offset_shift + small_offset_bits, | |
65 | |
66 checked_mask_in_place = right_n_bits(checked_bits) << checked_shift, | |
67 instance_mask_in_place = right_n_bits(instance_bits) << instance_shift, | |
68 #ifndef _WIN64 | |
69 large_offset_mask = right_n_bits(large_offset_bits), | |
70 small_offset_mask = right_n_bits(small_offset_bits), | |
71 klass_mask = right_n_bits(klass_bits) | |
72 #endif | |
73 }; | |
74 | |
75 #ifdef _WIN64 | |
76 // These values are too big for Win64 | |
77 const static uintptr_t large_offset_mask = right_n_bits(large_offset_bits); | |
78 const static uintptr_t small_offset_mask = right_n_bits(small_offset_bits); | |
79 const static uintptr_t klass_mask = right_n_bits(klass_bits); | |
80 #endif | |
81 | |
82 // helper routines: | |
83 static bool is_checked_jfieldID(jfieldID id) { | |
84 uintptr_t as_uint = (uintptr_t) id; | |
85 return ((as_uint & checked_mask_in_place) != 0); | |
86 } | |
87 static intptr_t raw_instance_offset(jfieldID id) { | |
88 uintptr_t result = (uintptr_t) id >> address_shift; | |
89 if (VerifyJNIFields && is_checked_jfieldID(id)) { | |
90 result &= small_offset_mask; // cut off the hash bits | |
91 } | |
92 return (intptr_t)result; | |
93 } | |
94 static intptr_t encode_klass_hash(klassOop k, intptr_t offset); | |
95 static bool klass_hash_ok(klassOop k, jfieldID id); | |
96 static void verify_instance_jfieldID(klassOop k, jfieldID id); | |
97 | |
98 public: | |
99 static bool is_valid_jfieldID(klassOop k, jfieldID id); | |
100 | |
101 static bool is_instance_jfieldID(klassOop k, jfieldID id) { | |
102 uintptr_t as_uint = (uintptr_t) id; | |
103 return ((as_uint & instance_mask_in_place) != 0); | |
104 } | |
105 static bool is_static_jfieldID(jfieldID id) { | |
106 uintptr_t as_uint = (uintptr_t) id; | |
107 return ((as_uint & instance_mask_in_place) == 0); | |
108 } | |
109 | |
110 static jfieldID to_instance_jfieldID(klassOop k, int offset) { | |
111 intptr_t as_uint = ((offset & large_offset_mask) << offset_shift) | instance_mask_in_place; | |
112 if (VerifyJNIFields) { | |
113 as_uint |= encode_klass_hash(k, offset); | |
114 } | |
115 jfieldID result = (jfieldID) as_uint; | |
116 #ifndef ASSERT | |
117 // always verify in debug mode; switchable in anything else | |
118 if (VerifyJNIFields) | |
119 #endif // ASSERT | |
120 { | |
121 verify_instance_jfieldID(k, result); | |
122 } | |
123 assert(raw_instance_offset(result) == (offset & large_offset_mask), "extract right offset"); | |
124 return result; | |
125 } | |
126 | |
127 static intptr_t from_instance_jfieldID(klassOop k, jfieldID id) { | |
128 #ifndef ASSERT | |
129 // always verify in debug mode; switchable in anything else | |
130 if (VerifyJNIFields) | |
131 #endif // ASSERT | |
132 { | |
133 verify_instance_jfieldID(k, id); | |
134 } | |
135 return raw_instance_offset(id); | |
136 } | |
137 | |
138 static jfieldID to_static_jfieldID(JNIid* id) { | |
139 assert(id->is_static_field_id(), "from_JNIid, but not static field id"); | |
140 jfieldID result = (jfieldID) id; | |
141 assert(from_static_jfieldID(result) == id, "must produce the same static id"); | |
142 return result; | |
143 } | |
144 | |
145 static JNIid* from_static_jfieldID(jfieldID id) { | |
146 assert(jfieldIDWorkaround::is_static_jfieldID(id), | |
147 "to_JNIid, but not static jfieldID"); | |
148 JNIid* result = (JNIid*) id; | |
149 assert(result->is_static_field_id(), "to_JNIid, but not static field id"); | |
150 return result; | |
151 } | |
152 | |
153 static jfieldID to_jfieldID(instanceKlassHandle k, int offset, bool is_static) { | |
154 if (is_static) { | |
155 JNIid *id = k->jni_id_for(offset); | |
156 debug_only(id->set_is_static_field_id()); | |
157 return jfieldIDWorkaround::to_static_jfieldID(id); | |
158 } else { | |
159 return jfieldIDWorkaround::to_instance_jfieldID(k(), offset); | |
160 } | |
161 } | |
162 }; | |
1972 | 163 |
164 #endif // SHARE_VM_RUNTIME_JFIELDIDWORKAROUND_HPP |