Mercurial > hg > truffle
annotate src/share/vm/ci/ciField.cpp @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Wed, 26 Feb 2014 15:20:41 -0800 |
| parents | b2e698d2276c |
| children | cefad50507d8 63a4eb8bcd23 00cf2b6f51b9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
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:
1173
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1173
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:
1173
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "ci/ciField.hpp" | |
| 27 #include "ci/ciInstanceKlass.hpp" | |
| 28 #include "ci/ciUtilities.hpp" | |
| 29 #include "classfile/systemDictionary.hpp" | |
| 30 #include "gc_interface/collectedHeap.inline.hpp" | |
| 31 #include "interpreter/linkResolver.hpp" | |
| 32 #include "memory/universe.inline.hpp" | |
| 33 #include "oops/oop.inline.hpp" | |
| 34 #include "oops/oop.inline2.hpp" | |
| 35 #include "runtime/fieldDescriptor.hpp" | |
| 0 | 36 |
| 37 // ciField | |
| 38 // | |
| 39 // This class represents the result of a field lookup in the VM. | |
| 40 // The lookup may not succeed, in which case the information in | |
| 41 // the ciField will be incomplete. | |
| 42 | |
| 43 // The ciObjectFactory cannot create circular data structures in one query. | |
| 44 // To avoid vicious circularities, we initialize ciField::_type to NULL | |
| 45 // for reference types and derive it lazily from the ciField::_signature. | |
| 46 // Primitive types are eagerly initialized, and basic layout queries | |
| 47 // can succeed without initialization, using only the BasicType of the field. | |
| 48 | |
| 49 // Notes on bootstrapping and shared CI objects: A field is shared if and | |
| 50 // only if it is (a) non-static and (b) declared by a shared instance klass. | |
| 51 // This allows non-static field lists to be cached on shared types. | |
| 52 // Because the _type field is lazily initialized, however, there is a | |
| 53 // special restriction that a shared field cannot cache an unshared type. | |
| 54 // This puts a small performance penalty on shared fields with unshared | |
| 55 // types, such as StackTraceElement[] Throwable.stackTrace. | |
| 56 // (Throwable is shared because ClassCastException is shared, but | |
| 57 // StackTraceElement is not presently shared.) | |
| 58 | |
| 59 // It is not a vicious circularity for a ciField to recursively create | |
| 60 // the ciSymbols necessary to represent its name and signature. | |
| 61 // Therefore, these items are created eagerly, and the name and signature | |
| 62 // of a shared field are themselves shared symbols. This somewhat | |
| 63 // pollutes the set of shared CI objects: It grows from 50 to 93 items, | |
| 64 // with all of the additional 43 being uninteresting shared ciSymbols. | |
| 65 // This adds at most one step to the binary search, an amount which | |
| 66 // decreases for complex compilation tasks. | |
| 67 | |
| 68 // ------------------------------------------------------------------ | |
| 69 // ciField::ciField | |
| 6151 | 70 ciField::ciField(ciInstanceKlass* klass, int index): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) { |
| 0 | 71 ASSERT_IN_VM; |
| 72 CompilerThread *thread = CompilerThread::current(); | |
| 73 | |
| 74 assert(ciObjectFactory::is_initialized(), "not a shared field"); | |
| 75 | |
| 76 assert(klass->get_instanceKlass()->is_linked(), "must be linked before using its constan-pool"); | |
| 77 | |
| 78 constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants()); | |
| 79 | |
| 80 // Get the field's name, signature, and type. | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
81 Symbol* name = cpool->name_ref_at(index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
82 _name = ciEnv::current(thread)->get_symbol(name); |
| 0 | 83 |
| 84 int nt_index = cpool->name_and_type_ref_index_at(index); | |
| 85 int sig_index = cpool->signature_ref_index_at(nt_index); | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
86 Symbol* signature = cpool->symbol_at(sig_index); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
87 _signature = ciEnv::current(thread)->get_symbol(signature); |
| 0 | 88 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
89 BasicType field_type = FieldType::basic_type(signature); |
| 0 | 90 |
| 91 // If the field is a pointer type, get the klass of the | |
| 92 // field. | |
| 93 if (field_type == T_OBJECT || field_type == T_ARRAY) { | |
| 94 bool ignore; | |
| 95 // This is not really a class reference; the index always refers to the | |
| 96 // field's type signature, as a symbol. Linkage checks do not apply. | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
97 _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass); |
| 0 | 98 } else { |
| 99 _type = ciType::make(field_type); | |
| 100 } | |
| 101 | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
102 _name = (ciSymbol*)ciEnv::current(thread)->get_symbol(name); |
| 0 | 103 |
| 104 // Get the field's declared holder. | |
| 105 // | |
| 106 // Note: we actually create a ciInstanceKlass for this klass, | |
| 107 // even though we may not need to. | |
| 108 int holder_index = cpool->klass_ref_index_at(index); | |
| 109 bool holder_is_accessible; | |
| 110 ciInstanceKlass* declared_holder = | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
111 ciEnv::current(thread)->get_klass_by_index(cpool, holder_index, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
112 holder_is_accessible, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
113 klass)->as_instance_klass(); |
| 0 | 114 |
| 115 // The declared holder of this field may not have been loaded. | |
| 116 // Bail out with partial field information. | |
| 117 if (!holder_is_accessible) { | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
118 // _type has already been set. |
| 0 | 119 // The default values for _flags and _constant_value will suffice. |
| 120 // We need values for _holder, _offset, and _is_constant, | |
| 121 _holder = declared_holder; | |
| 122 _offset = -1; | |
| 123 _is_constant = false; | |
| 124 return; | |
| 125 } | |
| 126 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6153
diff
changeset
|
127 InstanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass(); |
| 0 | 128 |
| 129 // Perform the field lookup. | |
| 130 fieldDescriptor field_desc; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6153
diff
changeset
|
131 Klass* canonical_holder = |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
132 loaded_decl_holder->find_field(name, signature, &field_desc); |
| 0 | 133 if (canonical_holder == NULL) { |
| 134 // Field lookup failed. Will be detected by will_link. | |
| 135 _holder = declared_holder; | |
| 136 _offset = -1; | |
| 137 _is_constant = false; | |
| 138 return; | |
| 139 } | |
| 140 | |
| 141 assert(canonical_holder == field_desc.field_holder(), "just checking"); | |
| 142 initialize_from(&field_desc); | |
| 143 } | |
| 144 | |
| 6151 | 145 ciField::ciField(fieldDescriptor *fd): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) { |
| 0 | 146 ASSERT_IN_VM; |
| 147 | |
| 148 // Get the field's name, signature, and type. | |
| 149 ciEnv* env = CURRENT_ENV; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
150 _name = env->get_symbol(fd->name()); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
151 _signature = env->get_symbol(fd->signature()); |
| 0 | 152 |
| 153 BasicType field_type = fd->field_type(); | |
| 154 | |
| 155 // If the field is a pointer type, get the klass of the | |
| 156 // field. | |
| 157 if (field_type == T_OBJECT || field_type == T_ARRAY) { | |
| 158 _type = NULL; // must call compute_type on first access | |
| 159 } else { | |
| 160 _type = ciType::make(field_type); | |
| 161 } | |
| 162 | |
| 163 initialize_from(fd); | |
| 164 | |
| 165 // Either (a) it is marked shared, or else (b) we are done bootstrapping. | |
| 166 assert(is_shared() || ciObjectFactory::is_initialized(), | |
| 167 "bootstrap classes must not create & cache unshared fields"); | |
| 168 } | |
| 169 | |
|
1173
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
170 static bool trust_final_non_static_fields(ciInstanceKlass* holder) { |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
171 if (holder == NULL) |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
172 return false; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
173 if (holder->name() == ciSymbol::java_lang_System()) |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
174 // Never trust strangely unstable finals: System.out, etc. |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
175 return false; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
176 // Even if general trusting is disabled, trust system-built closures in these packages. |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2261
diff
changeset
|
177 if (holder->is_in_package("java/lang/invoke") || holder->is_in_package("sun/invoke")) |
|
1173
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
178 return true; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
179 return TrustFinalNonStaticFields; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
180 } |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
181 |
| 0 | 182 void ciField::initialize_from(fieldDescriptor* fd) { |
| 183 // Get the flags, offset, and canonical holder of the field. | |
| 184 _flags = ciFlags(fd->access_flags()); | |
| 185 _offset = fd->offset(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6153
diff
changeset
|
186 _holder = CURRENT_ENV->get_instance_klass(fd->field_holder()); |
| 0 | 187 |
| 188 // Check to see if the field is constant. | |
|
12190
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
189 bool is_final = this->is_final(); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
190 bool is_stable = FoldStableValues && this->is_stable(); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
191 if (_holder->is_initialized() && (is_final || is_stable)) { |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
192 if (!this->is_static()) { |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2261
diff
changeset
|
193 // A field can be constant if it's a final static field or if |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2261
diff
changeset
|
194 // it's a final non-static field of a trusted class (classes in |
|
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2261
diff
changeset
|
195 // java.lang.invoke and sun.invoke packages and subpackages). |
|
12190
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
196 if (is_stable || trust_final_non_static_fields(_holder)) { |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
197 _is_constant = true; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
198 return; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
199 } |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
200 _is_constant = false; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
201 return; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
202 } |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
203 |
| 0 | 204 // This field just may be constant. The only cases where it will |
| 205 // not be constant are: | |
| 206 // | |
| 207 // 1. The field holds a non-perm-space oop. The field is, strictly | |
| 208 // speaking, constant but we cannot embed non-perm-space oops into | |
| 209 // generated code. For the time being we need to consider the | |
| 210 // field to be not constant. | |
| 211 // 2. The field is a *special* static&final field whose value | |
| 212 // may change. The three examples are java.lang.System.in, | |
| 213 // java.lang.System.out, and java.lang.System.err. | |
| 214 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6153
diff
changeset
|
215 KlassHandle k = _holder->get_Klass(); |
| 1142 | 216 assert( SystemDictionary::System_klass() != NULL, "Check once per vm"); |
| 2261 | 217 if( k() == SystemDictionary::System_klass() ) { |
| 0 | 218 // Check offsets for case 2: System.in, System.out, or System.err |
| 219 if( _offset == java_lang_System::in_offset_in_bytes() || | |
| 220 _offset == java_lang_System::out_offset_in_bytes() || | |
| 221 _offset == java_lang_System::err_offset_in_bytes() ) { | |
| 222 _is_constant = false; | |
| 223 return; | |
| 224 } | |
| 225 } | |
| 226 | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
227 Handle mirror = k->java_mirror(); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
228 |
| 0 | 229 switch(type()->basic_type()) { |
| 230 case T_BYTE: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
231 _constant_value = ciConstant(type()->basic_type(), mirror->byte_field(_offset)); |
| 0 | 232 break; |
| 233 case T_CHAR: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
234 _constant_value = ciConstant(type()->basic_type(), mirror->char_field(_offset)); |
| 0 | 235 break; |
| 236 case T_SHORT: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
237 _constant_value = ciConstant(type()->basic_type(), mirror->short_field(_offset)); |
| 0 | 238 break; |
| 239 case T_BOOLEAN: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
240 _constant_value = ciConstant(type()->basic_type(), mirror->bool_field(_offset)); |
| 0 | 241 break; |
| 242 case T_INT: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
243 _constant_value = ciConstant(type()->basic_type(), mirror->int_field(_offset)); |
| 0 | 244 break; |
| 245 case T_FLOAT: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
246 _constant_value = ciConstant(mirror->float_field(_offset)); |
| 0 | 247 break; |
| 248 case T_DOUBLE: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
249 _constant_value = ciConstant(mirror->double_field(_offset)); |
| 0 | 250 break; |
| 251 case T_LONG: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
252 _constant_value = ciConstant(mirror->long_field(_offset)); |
| 0 | 253 break; |
| 254 case T_OBJECT: | |
| 255 case T_ARRAY: | |
| 256 { | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
257 oop o = mirror->obj_field(_offset); |
| 0 | 258 |
| 259 // A field will be "constant" if it is known always to be | |
| 260 // a non-null reference to an instance of a particular class, | |
| 261 // or to a particular array. This can happen even if the instance | |
| 262 // or array is not perm. In such a case, an "unloaded" ciArray | |
| 263 // or ciInstance is created. The compiler may be able to use | |
| 264 // information about the object's class (which is exact) or length. | |
| 265 | |
| 266 if (o == NULL) { | |
| 267 _constant_value = ciConstant(type()->basic_type(), ciNullObject::make()); | |
| 268 } else { | |
| 269 _constant_value = ciConstant(type()->basic_type(), CURRENT_ENV->get_object(o)); | |
| 270 assert(_constant_value.as_object() == CURRENT_ENV->get_object(o), "check interning"); | |
| 271 } | |
| 272 } | |
| 273 } | |
|
12190
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
274 if (is_stable && _constant_value.is_null_or_zero()) { |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
275 // It is not a constant after all; treat it as uninitialized. |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
276 _is_constant = false; |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
277 } else { |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
278 _is_constant = true; |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
279 } |
| 0 | 280 } else { |
| 281 _is_constant = false; | |
| 282 } | |
| 283 } | |
| 284 | |
| 285 // ------------------------------------------------------------------ | |
| 286 // ciField::compute_type | |
| 287 // | |
| 288 // Lazily compute the type, if it is an instance klass. | |
| 289 ciType* ciField::compute_type() { | |
| 290 GUARDED_VM_ENTRY(return compute_type_impl();) | |
| 291 } | |
| 292 | |
| 293 ciType* ciField::compute_type_impl() { | |
|
3785
ddd894528dbc
7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents:
2376
diff
changeset
|
294 ciKlass* type = CURRENT_ENV->get_klass_by_name_impl(_holder, constantPoolHandle(), _signature, false); |
| 0 | 295 if (!type->is_primitive_type() && is_shared()) { |
| 296 // We must not cache a pointer to an unshared type, in a shared field. | |
| 297 bool type_is_also_shared = false; | |
| 298 if (type->is_type_array_klass()) { | |
| 299 type_is_also_shared = true; // int[] etc. are explicitly bootstrapped | |
| 300 } else if (type->is_instance_klass()) { | |
| 301 type_is_also_shared = type->as_instance_klass()->is_shared(); | |
| 302 } else { | |
| 303 // Currently there is no 'shared' query for array types. | |
| 304 type_is_also_shared = !ciObjectFactory::is_initialized(); | |
| 305 } | |
| 306 if (!type_is_also_shared) | |
| 307 return type; // Bummer. | |
| 308 } | |
| 309 _type = type; | |
| 310 return type; | |
| 311 } | |
| 312 | |
| 313 | |
| 314 // ------------------------------------------------------------------ | |
| 315 // ciField::will_link | |
| 316 // | |
| 317 // Can a specific access to this field be made without causing | |
| 318 // link errors? | |
| 319 bool ciField::will_link(ciInstanceKlass* accessing_klass, | |
| 320 Bytecodes::Code bc) { | |
| 321 VM_ENTRY_MARK; | |
| 6151 | 322 assert(bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic || |
| 323 bc == Bytecodes::_getfield || bc == Bytecodes::_putfield, | |
| 324 "unexpected bytecode"); | |
| 325 | |
| 0 | 326 if (_offset == -1) { |
| 327 // at creation we couldn't link to our holder so we need to | |
| 328 // maintain that stance, otherwise there's no safe way to use this | |
| 329 // ciField. | |
| 330 return false; | |
| 331 } | |
| 332 | |
| 6151 | 333 // Check for static/nonstatic mismatch |
| 334 bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic); | |
| 335 if (is_static != this->is_static()) { | |
| 336 return false; | |
| 337 } | |
| 338 | |
| 339 // Get and put can have different accessibility rules | |
| 340 bool is_put = (bc == Bytecodes::_putfield || bc == Bytecodes::_putstatic); | |
| 341 if (is_put) { | |
| 342 if (_known_to_link_with_put == accessing_klass) { | |
| 343 return true; | |
| 344 } | |
| 6153 | 345 } else { |
| 6151 | 346 if (_known_to_link_with_get == accessing_klass) { |
| 347 return true; | |
| 348 } | |
| 0 | 349 } |
| 350 | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
351 fieldDescriptor result; |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
352 LinkResolver::resolve_field(result, _holder->get_instanceKlass(), |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
353 _name->get_symbol(), _signature->get_symbol(), |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
354 accessing_klass->get_Klass(), bc, true, false, |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
355 KILL_COMPILE_ON_FATAL_(false)); |
| 0 | 356 |
| 357 // update the hit-cache, unless there is a problem with memory scoping: | |
| 6151 | 358 if (accessing_klass->is_shared() || !is_shared()) { |
| 359 if (is_put) { | |
| 360 _known_to_link_with_put = accessing_klass; | |
| 361 } else { | |
| 362 _known_to_link_with_get = accessing_klass; | |
| 363 } | |
| 364 } | |
| 0 | 365 |
| 366 return true; | |
| 367 } | |
| 368 | |
| 369 // ------------------------------------------------------------------ | |
| 370 // ciField::print | |
| 371 void ciField::print() { | |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6725
diff
changeset
|
372 tty->print("<ciField name="); |
| 0 | 373 _holder->print_name(); |
| 374 tty->print("."); | |
| 375 _name->print_symbol(); | |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6725
diff
changeset
|
376 tty->print(" signature="); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6725
diff
changeset
|
377 _signature->print_symbol(); |
| 0 | 378 tty->print(" offset=%d type=", _offset); |
|
12190
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
379 if (_type != NULL) |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
380 _type->print_name(); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
381 else |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
382 tty->print("(reference)"); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
383 tty->print(" flags=%04x", flags().as_int()); |
| 0 | 384 tty->print(" is_constant=%s", bool_to_str(_is_constant)); |
|
1682
e5dfb3ccb88b
6969569: assert(is_static() && is_constant()) failed: illegal call to constant_value()
kvn
parents:
1552
diff
changeset
|
385 if (_is_constant && is_static()) { |
| 0 | 386 tty->print(" constant_value="); |
| 387 _constant_value.print(); | |
| 388 } | |
| 389 tty->print(">"); | |
| 390 } | |
| 391 | |
| 392 // ------------------------------------------------------------------ | |
| 393 // ciField::print_name_on | |
| 394 // | |
| 395 // Print the name of this field | |
| 396 void ciField::print_name_on(outputStream* st) { | |
| 397 name()->print_symbol_on(st); | |
| 398 } |