Mercurial > hg > truffle
annotate src/share/vm/ci/ciField.cpp @ 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 | 00cf2b6f51b9 |
| children | 52b4284cb496 |
| 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 | |
| 18036 | 141 // Access check based on declared_holder. canonical_holder should not be used |
| 142 // to check access because it can erroneously succeed. If this check fails, | |
| 143 // propagate the declared holder to will_link() which in turn will bail out | |
| 144 // compilation for this field access. | |
| 145 if (!Reflection::verify_field_access(klass->get_Klass(), declared_holder->get_Klass(), canonical_holder, field_desc.access_flags(), true)) { | |
| 146 _holder = declared_holder; | |
| 147 _offset = -1; | |
| 148 _is_constant = false; | |
| 149 return; | |
| 150 } | |
| 151 | |
| 0 | 152 assert(canonical_holder == field_desc.field_holder(), "just checking"); |
| 153 initialize_from(&field_desc); | |
| 154 } | |
| 155 | |
| 6151 | 156 ciField::ciField(fieldDescriptor *fd): _known_to_link_with_put(NULL), _known_to_link_with_get(NULL) { |
| 0 | 157 ASSERT_IN_VM; |
| 158 | |
| 159 // Get the field's name, signature, and type. | |
| 160 ciEnv* env = CURRENT_ENV; | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
161 _name = env->get_symbol(fd->name()); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
162 _signature = env->get_symbol(fd->signature()); |
| 0 | 163 |
| 164 BasicType field_type = fd->field_type(); | |
| 165 | |
| 166 // If the field is a pointer type, get the klass of the | |
| 167 // field. | |
| 168 if (field_type == T_OBJECT || field_type == T_ARRAY) { | |
| 169 _type = NULL; // must call compute_type on first access | |
| 170 } else { | |
| 171 _type = ciType::make(field_type); | |
| 172 } | |
| 173 | |
| 174 initialize_from(fd); | |
| 175 | |
| 176 // Either (a) it is marked shared, or else (b) we are done bootstrapping. | |
| 177 assert(is_shared() || ciObjectFactory::is_initialized(), | |
| 178 "bootstrap classes must not create & cache unshared fields"); | |
| 179 } | |
| 180 | |
|
1173
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
181 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
|
182 if (holder == NULL) |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
183 return false; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
184 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
|
185 // 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
|
186 return false; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
187 // 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
|
188 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
|
189 return true; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
190 return TrustFinalNonStaticFields; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
191 } |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
192 |
| 0 | 193 void ciField::initialize_from(fieldDescriptor* fd) { |
| 194 // Get the flags, offset, and canonical holder of the field. | |
| 195 _flags = ciFlags(fd->access_flags()); | |
| 196 _offset = fd->offset(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6153
diff
changeset
|
197 _holder = CURRENT_ENV->get_instance_klass(fd->field_holder()); |
| 0 | 198 |
| 199 // 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
|
200 bool is_final = this->is_final(); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
201 bool is_stable = FoldStableValues && this->is_stable(); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
202 if (_holder->is_initialized() && (is_final || is_stable)) { |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
203 if (!this->is_static()) { |
|
2357
8033953d67ff
7012648: move JSR 292 to package java.lang.invoke and adjust names
jrose
parents:
2261
diff
changeset
|
204 // 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
|
205 // 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
|
206 // 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
|
207 if (is_stable || trust_final_non_static_fields(_holder)) { |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
208 _is_constant = true; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
209 return; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
210 } |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
211 _is_constant = false; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
212 return; |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
213 } |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
214 |
| 0 | 215 // This field just may be constant. The only cases where it will |
| 216 // not be constant are: | |
| 217 // | |
| 218 // 1. The field holds a non-perm-space oop. The field is, strictly | |
| 219 // speaking, constant but we cannot embed non-perm-space oops into | |
| 220 // generated code. For the time being we need to consider the | |
| 221 // field to be not constant. | |
| 222 // 2. The field is a *special* static&final field whose value | |
| 223 // may change. The three examples are java.lang.System.in, | |
| 224 // java.lang.System.out, and java.lang.System.err. | |
| 225 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6153
diff
changeset
|
226 KlassHandle k = _holder->get_Klass(); |
| 1142 | 227 assert( SystemDictionary::System_klass() != NULL, "Check once per vm"); |
| 2261 | 228 if( k() == SystemDictionary::System_klass() ) { |
| 0 | 229 // Check offsets for case 2: System.in, System.out, or System.err |
| 230 if( _offset == java_lang_System::in_offset_in_bytes() || | |
| 231 _offset == java_lang_System::out_offset_in_bytes() || | |
| 232 _offset == java_lang_System::err_offset_in_bytes() ) { | |
| 233 _is_constant = false; | |
| 234 return; | |
| 235 } | |
| 236 } | |
| 237 | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
238 Handle mirror = k->java_mirror(); |
|
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
239 |
| 0 | 240 switch(type()->basic_type()) { |
| 241 case T_BYTE: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
242 _constant_value = ciConstant(type()->basic_type(), mirror->byte_field(_offset)); |
| 0 | 243 break; |
| 244 case T_CHAR: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
245 _constant_value = ciConstant(type()->basic_type(), mirror->char_field(_offset)); |
| 0 | 246 break; |
| 247 case T_SHORT: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
248 _constant_value = ciConstant(type()->basic_type(), mirror->short_field(_offset)); |
| 0 | 249 break; |
| 250 case T_BOOLEAN: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
251 _constant_value = ciConstant(type()->basic_type(), mirror->bool_field(_offset)); |
| 0 | 252 break; |
| 253 case T_INT: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
254 _constant_value = ciConstant(type()->basic_type(), mirror->int_field(_offset)); |
| 0 | 255 break; |
| 256 case T_FLOAT: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
257 _constant_value = ciConstant(mirror->float_field(_offset)); |
| 0 | 258 break; |
| 259 case T_DOUBLE: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
260 _constant_value = ciConstant(mirror->double_field(_offset)); |
| 0 | 261 break; |
| 262 case T_LONG: | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
263 _constant_value = ciConstant(mirror->long_field(_offset)); |
| 0 | 264 break; |
| 265 case T_OBJECT: | |
| 266 case T_ARRAY: | |
| 267 { | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2357
diff
changeset
|
268 oop o = mirror->obj_field(_offset); |
| 0 | 269 |
| 270 // A field will be "constant" if it is known always to be | |
| 271 // a non-null reference to an instance of a particular class, | |
| 272 // or to a particular array. This can happen even if the instance | |
| 273 // or array is not perm. In such a case, an "unloaded" ciArray | |
| 274 // or ciInstance is created. The compiler may be able to use | |
| 275 // information about the object's class (which is exact) or length. | |
| 276 | |
| 277 if (o == NULL) { | |
| 278 _constant_value = ciConstant(type()->basic_type(), ciNullObject::make()); | |
| 279 } else { | |
| 280 _constant_value = ciConstant(type()->basic_type(), CURRENT_ENV->get_object(o)); | |
| 281 assert(_constant_value.as_object() == CURRENT_ENV->get_object(o), "check interning"); | |
| 282 } | |
| 283 } | |
| 284 } | |
|
12190
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
285 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
|
286 // 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
|
287 _is_constant = false; |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
288 } else { |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
289 _is_constant = true; |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
290 } |
| 0 | 291 } else { |
| 292 _is_constant = false; | |
| 293 } | |
| 294 } | |
| 295 | |
| 296 // ------------------------------------------------------------------ | |
| 297 // ciField::compute_type | |
| 298 // | |
| 299 // Lazily compute the type, if it is an instance klass. | |
| 300 ciType* ciField::compute_type() { | |
| 301 GUARDED_VM_ENTRY(return compute_type_impl();) | |
| 302 } | |
| 303 | |
| 304 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
|
305 ciKlass* type = CURRENT_ENV->get_klass_by_name_impl(_holder, constantPoolHandle(), _signature, false); |
| 0 | 306 if (!type->is_primitive_type() && is_shared()) { |
| 307 // We must not cache a pointer to an unshared type, in a shared field. | |
| 308 bool type_is_also_shared = false; | |
| 309 if (type->is_type_array_klass()) { | |
| 310 type_is_also_shared = true; // int[] etc. are explicitly bootstrapped | |
| 311 } else if (type->is_instance_klass()) { | |
| 312 type_is_also_shared = type->as_instance_klass()->is_shared(); | |
| 313 } else { | |
| 314 // Currently there is no 'shared' query for array types. | |
| 315 type_is_also_shared = !ciObjectFactory::is_initialized(); | |
| 316 } | |
| 317 if (!type_is_also_shared) | |
| 318 return type; // Bummer. | |
| 319 } | |
| 320 _type = type; | |
| 321 return type; | |
| 322 } | |
| 323 | |
| 324 | |
| 325 // ------------------------------------------------------------------ | |
| 326 // ciField::will_link | |
| 327 // | |
| 328 // Can a specific access to this field be made without causing | |
| 329 // link errors? | |
| 330 bool ciField::will_link(ciInstanceKlass* accessing_klass, | |
| 331 Bytecodes::Code bc) { | |
| 332 VM_ENTRY_MARK; | |
| 6151 | 333 assert(bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic || |
| 334 bc == Bytecodes::_getfield || bc == Bytecodes::_putfield, | |
| 335 "unexpected bytecode"); | |
| 336 | |
| 0 | 337 if (_offset == -1) { |
| 338 // at creation we couldn't link to our holder so we need to | |
| 339 // maintain that stance, otherwise there's no safe way to use this | |
| 340 // ciField. | |
| 341 return false; | |
| 342 } | |
| 343 | |
| 6151 | 344 // Check for static/nonstatic mismatch |
| 345 bool is_static = (bc == Bytecodes::_getstatic || bc == Bytecodes::_putstatic); | |
| 346 if (is_static != this->is_static()) { | |
| 347 return false; | |
| 348 } | |
| 349 | |
| 350 // Get and put can have different accessibility rules | |
| 351 bool is_put = (bc == Bytecodes::_putfield || bc == Bytecodes::_putstatic); | |
| 352 if (is_put) { | |
| 353 if (_known_to_link_with_put == accessing_klass) { | |
| 354 return true; | |
| 355 } | |
| 6153 | 356 } else { |
| 6151 | 357 if (_known_to_link_with_get == accessing_klass) { |
| 358 return true; | |
| 359 } | |
| 0 | 360 } |
| 361 | |
|
12264
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
362 fieldDescriptor result; |
|
b2e698d2276c
8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents:
12190
diff
changeset
|
363 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
|
364 _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
|
365 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
|
366 KILL_COMPILE_ON_FATAL_(false)); |
| 0 | 367 |
| 368 // update the hit-cache, unless there is a problem with memory scoping: | |
| 6151 | 369 if (accessing_klass->is_shared() || !is_shared()) { |
| 370 if (is_put) { | |
| 371 _known_to_link_with_put = accessing_klass; | |
| 372 } else { | |
| 373 _known_to_link_with_get = accessing_klass; | |
| 374 } | |
| 375 } | |
| 0 | 376 |
| 377 return true; | |
| 378 } | |
| 379 | |
| 380 // ------------------------------------------------------------------ | |
| 381 // ciField::print | |
| 382 void ciField::print() { | |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6725
diff
changeset
|
383 tty->print("<ciField name="); |
| 0 | 384 _holder->print_name(); |
| 385 tty->print("."); | |
| 386 _name->print_symbol(); | |
|
7421
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6725
diff
changeset
|
387 tty->print(" signature="); |
|
ad5dd04754ee
8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents:
6725
diff
changeset
|
388 _signature->print_symbol(); |
| 0 | 389 tty->print(" offset=%d type=", _offset); |
|
12190
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
390 if (_type != NULL) |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
391 _type->print_name(); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
392 else |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
393 tty->print("(reference)"); |
|
edb5ab0f3fe5
8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents:
7421
diff
changeset
|
394 tty->print(" flags=%04x", flags().as_int()); |
| 0 | 395 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
|
396 if (_is_constant && is_static()) { |
| 0 | 397 tty->print(" constant_value="); |
| 398 _constant_value.print(); | |
| 399 } | |
| 400 tty->print(">"); | |
| 401 } | |
| 402 | |
| 403 // ------------------------------------------------------------------ | |
| 404 // ciField::print_name_on | |
| 405 // | |
| 406 // Print the name of this field | |
| 407 void ciField::print_name_on(outputStream* st) { | |
| 408 name()->print_symbol_on(st); | |
| 409 } |