Mercurial > hg > truffle
annotate src/share/vm/ci/ciField.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | 06f017f7daa7 3582bf76420e |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1999, 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:
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 | |
| 70 ciField::ciField(ciInstanceKlass* klass, int index): _known_to_link_with(NULL) { | |
| 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 _cp_index = index; | |
| 79 constantPoolHandle cpool(thread, klass->get_instanceKlass()->constants()); | |
| 80 | |
| 81 // Get the field's name, signature, and type. | |
| 82 symbolHandle name (thread, cpool->name_ref_at(index)); | |
| 83 _name = ciEnv::current(thread)->get_object(name())->as_symbol(); | |
| 84 | |
| 85 int nt_index = cpool->name_and_type_ref_index_at(index); | |
| 86 int sig_index = cpool->signature_ref_index_at(nt_index); | |
| 87 symbolHandle signature (thread, cpool->symbol_at(sig_index)); | |
| 88 _signature = ciEnv::current(thread)->get_object(signature())->as_symbol(); | |
| 89 | |
| 90 BasicType field_type = FieldType::basic_type(signature()); | |
| 91 | |
| 92 // If the field is a pointer type, get the klass of the | |
| 93 // field. | |
| 94 if (field_type == T_OBJECT || field_type == T_ARRAY) { | |
| 95 bool ignore; | |
| 96 // This is not really a class reference; the index always refers to the | |
| 97 // 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
|
98 _type = ciEnv::current(thread)->get_klass_by_index(cpool, sig_index, ignore, klass); |
| 0 | 99 } else { |
| 100 _type = ciType::make(field_type); | |
| 101 } | |
| 102 | |
| 103 _name = (ciSymbol*)ciEnv::current(thread)->get_object(name()); | |
| 104 | |
| 105 // Get the field's declared holder. | |
| 106 // | |
| 107 // Note: we actually create a ciInstanceKlass for this klass, | |
| 108 // even though we may not need to. | |
| 109 int holder_index = cpool->klass_ref_index_at(index); | |
| 110 bool holder_is_accessible; | |
| 111 ciInstanceKlass* declared_holder = | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
112 ciEnv::current(thread)->get_klass_by_index(cpool, holder_index, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
113 holder_is_accessible, |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
114 klass)->as_instance_klass(); |
| 0 | 115 |
| 116 // The declared holder of this field may not have been loaded. | |
| 117 // Bail out with partial field information. | |
| 118 if (!holder_is_accessible) { | |
| 119 // _cp_index and _type have already been set. | |
| 120 // The default values for _flags and _constant_value will suffice. | |
| 121 // We need values for _holder, _offset, and _is_constant, | |
| 122 _holder = declared_holder; | |
| 123 _offset = -1; | |
| 124 _is_constant = false; | |
| 125 return; | |
| 126 } | |
| 127 | |
| 128 instanceKlass* loaded_decl_holder = declared_holder->get_instanceKlass(); | |
| 129 | |
| 130 // Perform the field lookup. | |
| 131 fieldDescriptor field_desc; | |
| 132 klassOop canonical_holder = | |
| 133 loaded_decl_holder->find_field(name(), signature(), &field_desc); | |
| 134 if (canonical_holder == NULL) { | |
| 135 // Field lookup failed. Will be detected by will_link. | |
| 136 _holder = declared_holder; | |
| 137 _offset = -1; | |
| 138 _is_constant = false; | |
| 139 return; | |
| 140 } | |
| 141 | |
| 142 assert(canonical_holder == field_desc.field_holder(), "just checking"); | |
| 143 initialize_from(&field_desc); | |
| 144 } | |
| 145 | |
| 146 ciField::ciField(fieldDescriptor *fd): _known_to_link_with(NULL) { | |
| 147 ASSERT_IN_VM; | |
| 148 | |
| 149 _cp_index = -1; | |
| 150 | |
| 151 // Get the field's name, signature, and type. | |
| 152 ciEnv* env = CURRENT_ENV; | |
| 153 _name = env->get_object(fd->name())->as_symbol(); | |
| 154 _signature = env->get_object(fd->signature())->as_symbol(); | |
| 155 | |
| 156 BasicType field_type = fd->field_type(); | |
| 157 | |
| 158 // If the field is a pointer type, get the klass of the | |
| 159 // field. | |
| 160 if (field_type == T_OBJECT || field_type == T_ARRAY) { | |
| 161 _type = NULL; // must call compute_type on first access | |
| 162 } else { | |
| 163 _type = ciType::make(field_type); | |
| 164 } | |
| 165 | |
| 166 initialize_from(fd); | |
| 167 | |
| 168 // Either (a) it is marked shared, or else (b) we are done bootstrapping. | |
| 169 assert(is_shared() || ciObjectFactory::is_initialized(), | |
| 170 "bootstrap classes must not create & cache unshared fields"); | |
| 171 } | |
| 172 | |
|
1173
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
173 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
|
174 if (holder == NULL) |
|
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 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
|
177 // 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
|
178 return false; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
179 // Even if general trusting is disabled, trust system-built closures in these packages. |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
180 if (holder->is_in_package("java/dyn") || holder->is_in_package("sun/dyn")) |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
181 return true; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
182 return TrustFinalNonStaticFields; |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
183 } |
|
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
184 |
| 0 | 185 void ciField::initialize_from(fieldDescriptor* fd) { |
| 186 // Get the flags, offset, and canonical holder of the field. | |
| 187 _flags = ciFlags(fd->access_flags()); | |
| 188 _offset = fd->offset(); | |
| 189 _holder = CURRENT_ENV->get_object(fd->field_holder())->as_instance_klass(); | |
| 190 | |
| 191 // Check to see if the field is constant. | |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
192 if (_holder->is_initialized() && this->is_final()) { |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
193 if (!this->is_static()) { |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
194 // A field can be constant if it's a final static field or if it's |
|
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
0
diff
changeset
|
195 // a final non-static field of a trusted class ({java,sun}.dyn). |
|
1173
73b22f919c34
6912065: final fields in objects need to support inlining optimizations for JSR 292
jrose
parents:
1142
diff
changeset
|
196 if (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 | |
| 215 klassOop k = _holder->get_klassOop(); | |
| 1142 | 216 assert( SystemDictionary::System_klass() != NULL, "Check once per vm"); |
| 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 | |
| 227 _is_constant = true; | |
| 228 switch(type()->basic_type()) { | |
| 229 case T_BYTE: | |
| 230 _constant_value = ciConstant(type()->basic_type(), k->byte_field(_offset)); | |
| 231 break; | |
| 232 case T_CHAR: | |
| 233 _constant_value = ciConstant(type()->basic_type(), k->char_field(_offset)); | |
| 234 break; | |
| 235 case T_SHORT: | |
| 236 _constant_value = ciConstant(type()->basic_type(), k->short_field(_offset)); | |
| 237 break; | |
| 238 case T_BOOLEAN: | |
| 239 _constant_value = ciConstant(type()->basic_type(), k->bool_field(_offset)); | |
| 240 break; | |
| 241 case T_INT: | |
| 242 _constant_value = ciConstant(type()->basic_type(), k->int_field(_offset)); | |
| 243 break; | |
| 244 case T_FLOAT: | |
| 245 _constant_value = ciConstant(k->float_field(_offset)); | |
| 246 break; | |
| 247 case T_DOUBLE: | |
| 248 _constant_value = ciConstant(k->double_field(_offset)); | |
| 249 break; | |
| 250 case T_LONG: | |
| 251 _constant_value = ciConstant(k->long_field(_offset)); | |
| 252 break; | |
| 253 case T_OBJECT: | |
| 254 case T_ARRAY: | |
| 255 { | |
| 256 oop o = k->obj_field(_offset); | |
| 257 | |
| 258 // A field will be "constant" if it is known always to be | |
| 259 // a non-null reference to an instance of a particular class, | |
| 260 // or to a particular array. This can happen even if the instance | |
| 261 // or array is not perm. In such a case, an "unloaded" ciArray | |
| 262 // or ciInstance is created. The compiler may be able to use | |
| 263 // information about the object's class (which is exact) or length. | |
| 264 | |
| 265 if (o == NULL) { | |
| 266 _constant_value = ciConstant(type()->basic_type(), ciNullObject::make()); | |
| 267 } else { | |
| 268 _constant_value = ciConstant(type()->basic_type(), CURRENT_ENV->get_object(o)); | |
| 269 assert(_constant_value.as_object() == CURRENT_ENV->get_object(o), "check interning"); | |
| 270 } | |
| 271 } | |
| 272 } | |
| 273 } else { | |
| 274 _is_constant = false; | |
| 275 } | |
| 276 } | |
| 277 | |
| 278 // ------------------------------------------------------------------ | |
| 279 // ciField::compute_type | |
| 280 // | |
| 281 // Lazily compute the type, if it is an instance klass. | |
| 282 ciType* ciField::compute_type() { | |
| 283 GUARDED_VM_ENTRY(return compute_type_impl();) | |
| 284 } | |
| 285 | |
| 286 ciType* ciField::compute_type_impl() { | |
| 287 ciKlass* type = CURRENT_ENV->get_klass_by_name_impl(_holder, _signature, false); | |
| 288 if (!type->is_primitive_type() && is_shared()) { | |
| 289 // We must not cache a pointer to an unshared type, in a shared field. | |
| 290 bool type_is_also_shared = false; | |
| 291 if (type->is_type_array_klass()) { | |
| 292 type_is_also_shared = true; // int[] etc. are explicitly bootstrapped | |
| 293 } else if (type->is_instance_klass()) { | |
| 294 type_is_also_shared = type->as_instance_klass()->is_shared(); | |
| 295 } else { | |
| 296 // Currently there is no 'shared' query for array types. | |
| 297 type_is_also_shared = !ciObjectFactory::is_initialized(); | |
| 298 } | |
| 299 if (!type_is_also_shared) | |
| 300 return type; // Bummer. | |
| 301 } | |
| 302 _type = type; | |
| 303 return type; | |
| 304 } | |
| 305 | |
| 306 | |
| 307 // ------------------------------------------------------------------ | |
| 308 // ciField::will_link | |
| 309 // | |
| 310 // Can a specific access to this field be made without causing | |
| 311 // link errors? | |
| 312 bool ciField::will_link(ciInstanceKlass* accessing_klass, | |
| 313 Bytecodes::Code bc) { | |
| 314 VM_ENTRY_MARK; | |
| 315 if (_offset == -1) { | |
| 316 // at creation we couldn't link to our holder so we need to | |
| 317 // maintain that stance, otherwise there's no safe way to use this | |
| 318 // ciField. | |
| 319 return false; | |
| 320 } | |
| 321 | |
| 322 if (_known_to_link_with == accessing_klass) { | |
| 323 return true; | |
| 324 } | |
| 325 | |
| 326 FieldAccessInfo result; | |
| 327 constantPoolHandle c_pool(THREAD, | |
| 328 accessing_klass->get_instanceKlass()->constants()); | |
| 329 LinkResolver::resolve_field(result, c_pool, _cp_index, | |
| 330 Bytecodes::java_code(bc), | |
| 331 true, false, KILL_COMPILE_ON_FATAL_(false)); | |
| 332 | |
| 333 // update the hit-cache, unless there is a problem with memory scoping: | |
| 334 if (accessing_klass->is_shared() || !is_shared()) | |
| 335 _known_to_link_with = accessing_klass; | |
| 336 | |
| 337 return true; | |
| 338 } | |
| 339 | |
| 340 // ------------------------------------------------------------------ | |
| 341 // ciField::print | |
| 342 void ciField::print() { | |
| 343 tty->print("<ciField "); | |
| 344 _holder->print_name(); | |
| 345 tty->print("."); | |
| 346 _name->print_symbol(); | |
| 347 tty->print(" offset=%d type=", _offset); | |
| 348 if (_type != NULL) _type->print_name(); | |
| 349 else tty->print("(reference)"); | |
| 350 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
|
351 if (_is_constant && is_static()) { |
| 0 | 352 tty->print(" constant_value="); |
| 353 _constant_value.print(); | |
| 354 } | |
| 355 tty->print(">"); | |
| 356 } | |
| 357 | |
| 358 // ------------------------------------------------------------------ | |
| 359 // ciField::print_name_on | |
| 360 // | |
| 361 // Print the name of this field | |
| 362 void ciField::print_name_on(outputStream* st) { | |
| 363 name()->print_symbol_on(st); | |
| 364 } |