Mercurial > hg > truffle
annotate src/share/vm/code/dependencies.cpp @ 1721:413ad0331a0c
6977924: Changes for 6975078 produce build error with certain gcc versions
Summary: The changes introduced for 6975078 assign badHeapOopVal to the _allocation field in the ResourceObj class. In 32 bit linux builds with certain versions of gcc this assignment will be flagged as an error while compiling allocation.cpp. In 32 bit builds the constant value badHeapOopVal (which is cast to an intptr_t) is negative. The _allocation field is typed as an unsigned intptr_t and gcc catches this as an error.
Reviewed-by: jcoomes, ysr, phh
| author | johnc |
|---|---|
| date | Wed, 18 Aug 2010 10:59:06 -0700 |
| parents | c18cbe5936b8 |
| children | f95d63e2154a |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1206
diff
changeset
|
2 * Copyright (c) 2005, 2008, 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:
1206
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1206
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:
1206
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 # include "incls/_precompiled.incl" | |
| 26 # include "incls/_dependencies.cpp.incl" | |
| 27 | |
| 28 | |
| 29 #ifdef ASSERT | |
| 30 static bool must_be_in_vm() { | |
| 31 Thread* thread = Thread::current(); | |
| 32 if (thread->is_Java_thread()) | |
| 33 return ((JavaThread*)thread)->thread_state() == _thread_in_vm; | |
| 34 else | |
| 35 return true; //something like this: thread->is_VM_thread(); | |
| 36 } | |
| 37 #endif //ASSERT | |
| 38 | |
| 39 void Dependencies::initialize(ciEnv* env) { | |
| 40 Arena* arena = env->arena(); | |
| 41 _oop_recorder = env->oop_recorder(); | |
| 42 _log = env->log(); | |
| 43 _dep_seen = new(arena) GrowableArray<int>(arena, 500, 0, 0); | |
| 44 DEBUG_ONLY(_deps[end_marker] = NULL); | |
| 45 for (int i = (int)FIRST_TYPE; i < (int)TYPE_LIMIT; i++) { | |
| 46 _deps[i] = new(arena) GrowableArray<ciObject*>(arena, 10, 0, 0); | |
| 47 } | |
| 48 _content_bytes = NULL; | |
| 49 _size_in_bytes = (size_t)-1; | |
| 50 | |
| 51 assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT), "sanity"); | |
| 52 } | |
| 53 | |
| 54 void Dependencies::assert_evol_method(ciMethod* m) { | |
| 55 assert_common_1(evol_method, m); | |
| 56 } | |
| 57 | |
| 58 void Dependencies::assert_leaf_type(ciKlass* ctxk) { | |
| 59 if (ctxk->is_array_klass()) { | |
| 60 // As a special case, support this assertion on an array type, | |
| 61 // which reduces to an assertion on its element type. | |
| 62 // Note that this cannot be done with assertions that | |
| 63 // relate to concreteness or abstractness. | |
| 64 ciType* elemt = ctxk->as_array_klass()->base_element_type(); | |
| 65 if (!elemt->is_instance_klass()) return; // Ex: int[][] | |
| 66 ctxk = elemt->as_instance_klass(); | |
| 67 //if (ctxk->is_final()) return; // Ex: String[][] | |
| 68 } | |
| 69 check_ctxk(ctxk); | |
| 70 assert_common_1(leaf_type, ctxk); | |
| 71 } | |
| 72 | |
| 73 void Dependencies::assert_abstract_with_unique_concrete_subtype(ciKlass* ctxk, ciKlass* conck) { | |
| 74 check_ctxk_abstract(ctxk); | |
| 75 assert_common_2(abstract_with_unique_concrete_subtype, ctxk, conck); | |
| 76 } | |
| 77 | |
| 78 void Dependencies::assert_abstract_with_no_concrete_subtype(ciKlass* ctxk) { | |
| 79 check_ctxk_abstract(ctxk); | |
| 80 assert_common_1(abstract_with_no_concrete_subtype, ctxk); | |
| 81 } | |
| 82 | |
| 83 void Dependencies::assert_concrete_with_no_concrete_subtype(ciKlass* ctxk) { | |
| 84 check_ctxk_concrete(ctxk); | |
| 85 assert_common_1(concrete_with_no_concrete_subtype, ctxk); | |
| 86 } | |
| 87 | |
| 88 void Dependencies::assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm) { | |
| 89 check_ctxk(ctxk); | |
| 90 assert_common_2(unique_concrete_method, ctxk, uniqm); | |
| 91 } | |
| 92 | |
| 93 void Dependencies::assert_abstract_with_exclusive_concrete_subtypes(ciKlass* ctxk, ciKlass* k1, ciKlass* k2) { | |
| 94 check_ctxk(ctxk); | |
| 95 assert_common_3(abstract_with_exclusive_concrete_subtypes_2, ctxk, k1, k2); | |
| 96 } | |
| 97 | |
| 98 void Dependencies::assert_exclusive_concrete_methods(ciKlass* ctxk, ciMethod* m1, ciMethod* m2) { | |
| 99 check_ctxk(ctxk); | |
| 100 assert_common_3(exclusive_concrete_methods_2, ctxk, m1, m2); | |
| 101 } | |
| 102 | |
| 103 void Dependencies::assert_has_no_finalizable_subclasses(ciKlass* ctxk) { | |
| 104 check_ctxk(ctxk); | |
| 105 assert_common_1(no_finalizable_subclasses, ctxk); | |
| 106 } | |
| 107 | |
| 108 // Helper function. If we are adding a new dep. under ctxk2, | |
| 109 // try to find an old dep. under a broader* ctxk1. If there is | |
| 110 // | |
| 111 bool Dependencies::maybe_merge_ctxk(GrowableArray<ciObject*>* deps, | |
| 112 int ctxk_i, ciKlass* ctxk2) { | |
| 113 ciKlass* ctxk1 = deps->at(ctxk_i)->as_klass(); | |
| 114 if (ctxk2->is_subtype_of(ctxk1)) { | |
| 115 return true; // success, and no need to change | |
| 116 } else if (ctxk1->is_subtype_of(ctxk2)) { | |
| 117 // new context class fully subsumes previous one | |
| 118 deps->at_put(ctxk_i, ctxk2); | |
| 119 return true; | |
| 120 } else { | |
| 121 return false; | |
| 122 } | |
| 123 } | |
| 124 | |
| 125 void Dependencies::assert_common_1(Dependencies::DepType dept, ciObject* x) { | |
| 126 assert(dep_args(dept) == 1, "sanity"); | |
| 127 log_dependency(dept, x); | |
| 128 GrowableArray<ciObject*>* deps = _deps[dept]; | |
| 129 | |
| 130 // see if the same (or a similar) dep is already recorded | |
| 131 if (note_dep_seen(dept, x)) { | |
| 132 assert(deps->find(x) >= 0, "sanity"); | |
| 133 } else { | |
| 134 deps->append(x); | |
| 135 } | |
| 136 } | |
| 137 | |
| 138 void Dependencies::assert_common_2(Dependencies::DepType dept, | |
| 139 ciKlass* ctxk, ciObject* x) { | |
| 140 assert(dep_context_arg(dept) == 0, "sanity"); | |
| 141 assert(dep_args(dept) == 2, "sanity"); | |
| 142 log_dependency(dept, ctxk, x); | |
| 143 GrowableArray<ciObject*>* deps = _deps[dept]; | |
| 144 | |
| 145 // see if the same (or a similar) dep is already recorded | |
| 146 if (note_dep_seen(dept, x)) { | |
| 147 // look in this bucket for redundant assertions | |
| 148 const int stride = 2; | |
| 149 for (int i = deps->length(); (i -= stride) >= 0; ) { | |
| 150 ciObject* x1 = deps->at(i+1); | |
| 151 if (x == x1) { // same subject; check the context | |
| 152 if (maybe_merge_ctxk(deps, i+0, ctxk)) { | |
| 153 return; | |
| 154 } | |
| 155 } | |
| 156 } | |
| 157 } | |
| 158 | |
| 159 // append the assertion in the correct bucket: | |
| 160 deps->append(ctxk); | |
| 161 deps->append(x); | |
| 162 } | |
| 163 | |
| 164 void Dependencies::assert_common_3(Dependencies::DepType dept, | |
| 165 ciKlass* ctxk, ciObject* x, ciObject* x2) { | |
| 166 assert(dep_context_arg(dept) == 0, "sanity"); | |
| 167 assert(dep_args(dept) == 3, "sanity"); | |
| 168 log_dependency(dept, ctxk, x, x2); | |
| 169 GrowableArray<ciObject*>* deps = _deps[dept]; | |
| 170 | |
| 171 // try to normalize an unordered pair: | |
| 172 bool swap = false; | |
| 173 switch (dept) { | |
| 174 case abstract_with_exclusive_concrete_subtypes_2: | |
| 175 swap = (x->ident() > x2->ident() && x != ctxk); | |
| 176 break; | |
| 177 case exclusive_concrete_methods_2: | |
| 178 swap = (x->ident() > x2->ident() && x->as_method()->holder() != ctxk); | |
| 179 break; | |
| 180 } | |
| 181 if (swap) { ciObject* t = x; x = x2; x2 = t; } | |
| 182 | |
| 183 // see if the same (or a similar) dep is already recorded | |
| 184 if (note_dep_seen(dept, x) && note_dep_seen(dept, x2)) { | |
| 185 // look in this bucket for redundant assertions | |
| 186 const int stride = 3; | |
| 187 for (int i = deps->length(); (i -= stride) >= 0; ) { | |
| 188 ciObject* y = deps->at(i+1); | |
| 189 ciObject* y2 = deps->at(i+2); | |
| 190 if (x == y && x2 == y2) { // same subjects; check the context | |
| 191 if (maybe_merge_ctxk(deps, i+0, ctxk)) { | |
| 192 return; | |
| 193 } | |
| 194 } | |
| 195 } | |
| 196 } | |
| 197 // append the assertion in the correct bucket: | |
| 198 deps->append(ctxk); | |
| 199 deps->append(x); | |
| 200 deps->append(x2); | |
| 201 } | |
| 202 | |
| 203 /// Support for encoding dependencies into an nmethod: | |
| 204 | |
| 205 void Dependencies::copy_to(nmethod* nm) { | |
| 206 address beg = nm->dependencies_begin(); | |
| 207 address end = nm->dependencies_end(); | |
| 208 guarantee(end - beg >= (ptrdiff_t) size_in_bytes(), "bad sizing"); | |
| 209 Copy::disjoint_words((HeapWord*) content_bytes(), | |
| 210 (HeapWord*) beg, | |
| 211 size_in_bytes() / sizeof(HeapWord)); | |
| 212 assert(size_in_bytes() % sizeof(HeapWord) == 0, "copy by words"); | |
| 213 } | |
| 214 | |
| 215 static int sort_dep(ciObject** p1, ciObject** p2, int narg) { | |
| 216 for (int i = 0; i < narg; i++) { | |
| 217 int diff = p1[i]->ident() - p2[i]->ident(); | |
| 218 if (diff != 0) return diff; | |
| 219 } | |
| 220 return 0; | |
| 221 } | |
| 222 static int sort_dep_arg_1(ciObject** p1, ciObject** p2) | |
| 223 { return sort_dep(p1, p2, 1); } | |
| 224 static int sort_dep_arg_2(ciObject** p1, ciObject** p2) | |
| 225 { return sort_dep(p1, p2, 2); } | |
| 226 static int sort_dep_arg_3(ciObject** p1, ciObject** p2) | |
| 227 { return sort_dep(p1, p2, 3); } | |
| 228 | |
| 229 void Dependencies::sort_all_deps() { | |
| 230 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | |
| 231 DepType dept = (DepType)deptv; | |
| 232 GrowableArray<ciObject*>* deps = _deps[dept]; | |
| 233 if (deps->length() <= 1) continue; | |
| 234 switch (dep_args(dept)) { | |
| 235 case 1: deps->sort(sort_dep_arg_1, 1); break; | |
| 236 case 2: deps->sort(sort_dep_arg_2, 2); break; | |
| 237 case 3: deps->sort(sort_dep_arg_3, 3); break; | |
| 238 default: ShouldNotReachHere(); | |
| 239 } | |
| 240 } | |
| 241 } | |
| 242 | |
| 243 size_t Dependencies::estimate_size_in_bytes() { | |
| 244 size_t est_size = 100; | |
| 245 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | |
| 246 DepType dept = (DepType)deptv; | |
| 247 GrowableArray<ciObject*>* deps = _deps[dept]; | |
| 248 est_size += deps->length()*2; // tags and argument(s) | |
| 249 } | |
| 250 return est_size; | |
| 251 } | |
| 252 | |
| 253 ciKlass* Dependencies::ctxk_encoded_as_null(DepType dept, ciObject* x) { | |
| 254 switch (dept) { | |
| 255 case abstract_with_exclusive_concrete_subtypes_2: | |
| 256 return x->as_klass(); | |
| 257 case unique_concrete_method: | |
| 258 case exclusive_concrete_methods_2: | |
| 259 return x->as_method()->holder(); | |
| 260 } | |
| 261 return NULL; // let NULL be NULL | |
| 262 } | |
| 263 | |
| 264 klassOop Dependencies::ctxk_encoded_as_null(DepType dept, oop x) { | |
| 265 assert(must_be_in_vm(), "raw oops here"); | |
| 266 switch (dept) { | |
| 267 case abstract_with_exclusive_concrete_subtypes_2: | |
| 268 assert(x->is_klass(), "sanity"); | |
| 269 return (klassOop) x; | |
| 270 case unique_concrete_method: | |
| 271 case exclusive_concrete_methods_2: | |
| 272 assert(x->is_method(), "sanity"); | |
| 273 return ((methodOop)x)->method_holder(); | |
| 274 } | |
| 275 return NULL; // let NULL be NULL | |
| 276 } | |
| 277 | |
| 278 void Dependencies::encode_content_bytes() { | |
| 279 sort_all_deps(); | |
| 280 | |
| 281 // cast is safe, no deps can overflow INT_MAX | |
| 282 CompressedWriteStream bytes((int)estimate_size_in_bytes()); | |
| 283 | |
| 284 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | |
| 285 DepType dept = (DepType)deptv; | |
| 286 GrowableArray<ciObject*>* deps = _deps[dept]; | |
| 287 if (deps->length() == 0) continue; | |
| 288 int stride = dep_args(dept); | |
| 289 int ctxkj = dep_context_arg(dept); // -1 if no context arg | |
| 290 assert(stride > 0, "sanity"); | |
| 291 for (int i = 0; i < deps->length(); i += stride) { | |
| 292 jbyte code_byte = (jbyte)dept; | |
| 293 int skipj = -1; | |
| 294 if (ctxkj >= 0 && ctxkj+1 < stride) { | |
| 295 ciKlass* ctxk = deps->at(i+ctxkj+0)->as_klass(); | |
| 296 ciObject* x = deps->at(i+ctxkj+1); // following argument | |
| 297 if (ctxk == ctxk_encoded_as_null(dept, x)) { | |
| 298 skipj = ctxkj; // we win: maybe one less oop to keep track of | |
| 299 code_byte |= default_context_type_bit; | |
| 300 } | |
| 301 } | |
| 302 bytes.write_byte(code_byte); | |
| 303 for (int j = 0; j < stride; j++) { | |
| 304 if (j == skipj) continue; | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
196
diff
changeset
|
305 bytes.write_int(_oop_recorder->find_index(deps->at(i+j)->constant_encoding())); |
| 0 | 306 } |
| 307 } | |
| 308 } | |
| 309 | |
| 310 // write a sentinel byte to mark the end | |
| 311 bytes.write_byte(end_marker); | |
| 312 | |
| 313 // round it out to a word boundary | |
| 314 while (bytes.position() % sizeof(HeapWord) != 0) { | |
| 315 bytes.write_byte(end_marker); | |
| 316 } | |
| 317 | |
| 318 // check whether the dept byte encoding really works | |
| 319 assert((jbyte)default_context_type_bit != 0, "byte overflow"); | |
| 320 | |
| 321 _content_bytes = bytes.buffer(); | |
| 322 _size_in_bytes = bytes.position(); | |
| 323 } | |
| 324 | |
| 325 | |
| 326 const char* Dependencies::_dep_name[TYPE_LIMIT] = { | |
| 327 "end_marker", | |
| 328 "evol_method", | |
| 329 "leaf_type", | |
| 330 "abstract_with_unique_concrete_subtype", | |
| 331 "abstract_with_no_concrete_subtype", | |
| 332 "concrete_with_no_concrete_subtype", | |
| 333 "unique_concrete_method", | |
| 334 "abstract_with_exclusive_concrete_subtypes_2", | |
| 335 "exclusive_concrete_methods_2", | |
| 336 "no_finalizable_subclasses" | |
| 337 }; | |
| 338 | |
| 339 int Dependencies::_dep_args[TYPE_LIMIT] = { | |
| 340 -1,// end_marker | |
| 341 1, // evol_method m | |
| 342 1, // leaf_type ctxk | |
| 343 2, // abstract_with_unique_concrete_subtype ctxk, k | |
| 344 1, // abstract_with_no_concrete_subtype ctxk | |
| 345 1, // concrete_with_no_concrete_subtype ctxk | |
| 346 2, // unique_concrete_method ctxk, m | |
| 347 3, // unique_concrete_subtypes_2 ctxk, k1, k2 | |
| 348 3, // unique_concrete_methods_2 ctxk, m1, m2 | |
| 349 1 // no_finalizable_subclasses ctxk | |
| 350 }; | |
| 351 | |
| 352 const char* Dependencies::dep_name(Dependencies::DepType dept) { | |
| 353 if (!dept_in_mask(dept, all_types)) return "?bad-dep?"; | |
| 354 return _dep_name[dept]; | |
| 355 } | |
| 356 | |
| 357 int Dependencies::dep_args(Dependencies::DepType dept) { | |
| 358 if (!dept_in_mask(dept, all_types)) return -1; | |
| 359 return _dep_args[dept]; | |
| 360 } | |
| 361 | |
| 362 // for the sake of the compiler log, print out current dependencies: | |
| 363 void Dependencies::log_all_dependencies() { | |
| 364 if (log() == NULL) return; | |
| 365 ciObject* args[max_arg_count]; | |
| 366 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | |
| 367 DepType dept = (DepType)deptv; | |
| 368 GrowableArray<ciObject*>* deps = _deps[dept]; | |
| 369 if (deps->length() == 0) continue; | |
| 370 int stride = dep_args(dept); | |
| 371 for (int i = 0; i < deps->length(); i += stride) { | |
| 372 for (int j = 0; j < stride; j++) { | |
| 373 // flush out the identities before printing | |
| 374 args[j] = deps->at(i+j); | |
| 375 } | |
| 376 write_dependency_to(log(), dept, stride, args); | |
| 377 } | |
| 378 } | |
| 379 } | |
| 380 | |
| 381 void Dependencies::write_dependency_to(CompileLog* log, | |
| 382 DepType dept, | |
| 383 int nargs, oop args[], | |
| 384 klassOop witness) { | |
| 385 if (log == NULL) { | |
| 386 return; | |
| 387 } | |
| 388 ciEnv* env = ciEnv::current(); | |
| 389 ciObject* ciargs[max_arg_count]; | |
| 390 assert(nargs <= max_arg_count, "oob"); | |
| 391 for (int j = 0; j < nargs; j++) { | |
| 392 ciargs[j] = env->get_object(args[j]); | |
| 393 } | |
| 394 Dependencies::write_dependency_to(log, dept, nargs, ciargs, witness); | |
| 395 } | |
| 396 | |
| 397 void Dependencies::write_dependency_to(CompileLog* log, | |
| 398 DepType dept, | |
| 399 int nargs, ciObject* args[], | |
| 400 klassOop witness) { | |
| 401 if (log == NULL) return; | |
| 402 assert(nargs <= max_arg_count, "oob"); | |
| 403 int argids[max_arg_count]; | |
| 404 int ctxkj = dep_context_arg(dept); // -1 if no context arg | |
| 405 int j; | |
| 406 for (j = 0; j < nargs; j++) { | |
| 407 argids[j] = log->identify(args[j]); | |
| 408 } | |
| 409 if (witness != NULL) { | |
| 410 log->begin_elem("dependency_failed"); | |
| 411 } else { | |
| 412 log->begin_elem("dependency"); | |
| 413 } | |
| 414 log->print(" type='%s'", dep_name(dept)); | |
| 415 if (ctxkj >= 0) { | |
| 416 log->print(" ctxk='%d'", argids[ctxkj]); | |
| 417 } | |
| 418 // write remaining arguments, if any. | |
| 419 for (j = 0; j < nargs; j++) { | |
| 420 if (j == ctxkj) continue; // already logged | |
| 421 if (j == 1) { | |
| 422 log->print( " x='%d'", argids[j]); | |
| 423 } else { | |
| 424 log->print(" x%d='%d'", j, argids[j]); | |
| 425 } | |
| 426 } | |
| 427 if (witness != NULL) { | |
| 428 log->object("witness", witness); | |
| 429 log->stamp(); | |
| 430 } | |
| 431 log->end_elem(); | |
| 432 } | |
| 433 | |
| 434 void Dependencies::write_dependency_to(xmlStream* xtty, | |
| 435 DepType dept, | |
| 436 int nargs, oop args[], | |
| 437 klassOop witness) { | |
| 438 if (xtty == NULL) return; | |
| 439 ttyLocker ttyl; | |
| 440 int ctxkj = dep_context_arg(dept); // -1 if no context arg | |
| 441 if (witness != NULL) { | |
| 442 xtty->begin_elem("dependency_failed"); | |
| 443 } else { | |
| 444 xtty->begin_elem("dependency"); | |
| 445 } | |
| 446 xtty->print(" type='%s'", dep_name(dept)); | |
| 447 if (ctxkj >= 0) { | |
| 448 xtty->object("ctxk", args[ctxkj]); | |
| 449 } | |
| 450 // write remaining arguments, if any. | |
| 451 for (int j = 0; j < nargs; j++) { | |
| 452 if (j == ctxkj) continue; // already logged | |
| 453 if (j == 1) { | |
| 454 xtty->object("x", args[j]); | |
| 455 } else { | |
| 456 char xn[10]; sprintf(xn, "x%d", j); | |
| 457 xtty->object(xn, args[j]); | |
| 458 } | |
| 459 } | |
| 460 if (witness != NULL) { | |
| 461 xtty->object("witness", witness); | |
| 462 xtty->stamp(); | |
| 463 } | |
| 464 xtty->end_elem(); | |
| 465 } | |
| 466 | |
| 467 void Dependencies::print_dependency(DepType dept, int nargs, oop args[], | |
| 468 klassOop witness) { | |
| 469 ResourceMark rm; | |
| 470 ttyLocker ttyl; // keep the following output all in one block | |
| 471 tty->print_cr("%s of type %s", | |
| 472 (witness == NULL)? "Dependency": "Failed dependency", | |
| 473 dep_name(dept)); | |
| 474 // print arguments | |
| 475 int ctxkj = dep_context_arg(dept); // -1 if no context arg | |
| 476 for (int j = 0; j < nargs; j++) { | |
| 477 oop arg = args[j]; | |
| 478 bool put_star = false; | |
| 479 if (arg == NULL) continue; | |
| 480 const char* what; | |
| 481 if (j == ctxkj) { | |
| 482 what = "context"; | |
| 483 put_star = !Dependencies::is_concrete_klass((klassOop)arg); | |
| 484 } else if (arg->is_method()) { | |
| 485 what = "method "; | |
| 486 put_star = !Dependencies::is_concrete_method((methodOop)arg); | |
| 487 } else if (arg->is_klass()) { | |
| 488 what = "class "; | |
| 489 } else { | |
| 490 what = "object "; | |
| 491 } | |
| 492 tty->print(" %s = %s", what, (put_star? "*": "")); | |
| 493 if (arg->is_klass()) | |
| 494 tty->print("%s", Klass::cast((klassOop)arg)->external_name()); | |
| 495 else | |
| 496 arg->print_value(); | |
| 497 tty->cr(); | |
| 498 } | |
| 499 if (witness != NULL) { | |
| 500 bool put_star = !Dependencies::is_concrete_klass(witness); | |
| 501 tty->print_cr(" witness = %s%s", | |
| 502 (put_star? "*": ""), | |
| 503 Klass::cast(witness)->external_name()); | |
| 504 } | |
| 505 } | |
| 506 | |
| 507 void Dependencies::DepStream::log_dependency(klassOop witness) { | |
| 508 if (_deps == NULL && xtty == NULL) return; // fast cutout for runtime | |
| 509 int nargs = argument_count(); | |
| 510 oop args[max_arg_count]; | |
| 511 for (int j = 0; j < nargs; j++) { | |
| 512 args[j] = argument(j); | |
| 513 } | |
| 514 if (_deps != NULL && _deps->log() != NULL) { | |
| 515 Dependencies::write_dependency_to(_deps->log(), | |
| 516 type(), nargs, args, witness); | |
| 517 } else { | |
| 518 Dependencies::write_dependency_to(xtty, | |
| 519 type(), nargs, args, witness); | |
| 520 } | |
| 521 } | |
| 522 | |
| 523 void Dependencies::DepStream::print_dependency(klassOop witness, bool verbose) { | |
| 524 int nargs = argument_count(); | |
| 525 oop args[max_arg_count]; | |
| 526 for (int j = 0; j < nargs; j++) { | |
| 527 args[j] = argument(j); | |
| 528 } | |
| 529 Dependencies::print_dependency(type(), nargs, args, witness); | |
| 530 if (verbose) { | |
| 531 if (_code != NULL) { | |
| 532 tty->print(" code: "); | |
| 533 _code->print_value_on(tty); | |
| 534 tty->cr(); | |
| 535 } | |
| 536 } | |
| 537 } | |
| 538 | |
| 539 | |
| 540 /// Dependency stream support (decodes dependencies from an nmethod): | |
| 541 | |
| 542 #ifdef ASSERT | |
| 543 void Dependencies::DepStream::initial_asserts(size_t byte_limit) { | |
| 544 assert(must_be_in_vm(), "raw oops here"); | |
| 545 _byte_limit = byte_limit; | |
| 546 _type = (DepType)(end_marker-1); // defeat "already at end" assert | |
| 547 assert((_code!=NULL) + (_deps!=NULL) == 1, "one or t'other"); | |
| 548 } | |
| 549 #endif //ASSERT | |
| 550 | |
| 551 bool Dependencies::DepStream::next() { | |
| 552 assert(_type != end_marker, "already at end"); | |
| 553 if (_bytes.position() == 0 && _code != NULL | |
| 554 && _code->dependencies_size() == 0) { | |
| 555 // Method has no dependencies at all. | |
| 556 return false; | |
| 557 } | |
| 558 int code_byte = (_bytes.read_byte() & 0xFF); | |
| 559 if (code_byte == end_marker) { | |
| 560 DEBUG_ONLY(_type = end_marker); | |
| 561 return false; | |
| 562 } else { | |
| 563 int ctxk_bit = (code_byte & Dependencies::default_context_type_bit); | |
| 564 code_byte -= ctxk_bit; | |
| 565 DepType dept = (DepType)code_byte; | |
| 566 _type = dept; | |
| 567 guarantee((dept - FIRST_TYPE) < (TYPE_LIMIT - FIRST_TYPE), | |
| 568 "bad dependency type tag"); | |
| 569 int stride = _dep_args[dept]; | |
| 570 assert(stride == dep_args(dept), "sanity"); | |
| 571 int skipj = -1; | |
| 572 if (ctxk_bit != 0) { | |
| 573 skipj = 0; // currently the only context argument is at zero | |
| 574 assert(skipj == dep_context_arg(dept), "zero arg always ctxk"); | |
| 575 } | |
| 576 for (int j = 0; j < stride; j++) { | |
| 577 _xi[j] = (j == skipj)? 0: _bytes.read_int(); | |
| 578 } | |
| 579 DEBUG_ONLY(_xi[stride] = -1); // help detect overruns | |
| 580 return true; | |
| 581 } | |
| 582 } | |
| 583 | |
| 584 inline oop Dependencies::DepStream::recorded_oop_at(int i) { | |
| 585 return (_code != NULL) | |
| 586 ? _code->oop_at(i) | |
| 587 : JNIHandles::resolve(_deps->oop_recorder()->handle_at(i)); | |
| 588 } | |
| 589 | |
| 590 oop Dependencies::DepStream::argument(int i) { | |
| 591 return recorded_oop_at(argument_index(i)); | |
| 592 } | |
| 593 | |
| 594 klassOop Dependencies::DepStream::context_type() { | |
| 595 assert(must_be_in_vm(), "raw oops here"); | |
| 596 int ctxkj = dep_context_arg(_type); // -1 if no context arg | |
| 597 if (ctxkj < 0) { | |
| 598 return NULL; // for example, evol_method | |
| 599 } else { | |
| 600 oop k = recorded_oop_at(_xi[ctxkj]); | |
| 601 if (k != NULL) { // context type was not compressed away | |
| 602 assert(k->is_klass(), "type check"); | |
| 603 return (klassOop) k; | |
| 604 } else { // recompute "default" context type | |
| 605 return ctxk_encoded_as_null(_type, recorded_oop_at(_xi[ctxkj+1])); | |
| 606 } | |
| 607 } | |
| 608 } | |
| 609 | |
| 610 /// Checking dependencies: | |
| 611 | |
| 612 // This hierarchy walker inspects subtypes of a given type, | |
| 613 // trying to find a "bad" class which breaks a dependency. | |
| 614 // Such a class is called a "witness" to the broken dependency. | |
| 615 // While searching around, we ignore "participants", which | |
| 616 // are already known to the dependency. | |
| 617 class ClassHierarchyWalker { | |
| 618 public: | |
| 619 enum { PARTICIPANT_LIMIT = 3 }; | |
| 620 | |
| 621 private: | |
| 622 // optional method descriptor to check for: | |
| 623 symbolOop _name; | |
| 624 symbolOop _signature; | |
| 625 | |
| 626 // special classes which are not allowed to be witnesses: | |
| 627 klassOop _participants[PARTICIPANT_LIMIT+1]; | |
| 628 int _num_participants; | |
| 629 | |
| 630 // cache of method lookups | |
| 631 methodOop _found_methods[PARTICIPANT_LIMIT+1]; | |
| 632 | |
| 633 // if non-zero, tells how many witnesses to convert to participants | |
| 634 int _record_witnesses; | |
| 635 | |
| 636 void initialize(klassOop participant) { | |
| 637 _record_witnesses = 0; | |
| 638 _participants[0] = participant; | |
| 639 _found_methods[0] = NULL; | |
| 640 _num_participants = 0; | |
| 641 if (participant != NULL) { | |
| 642 // Terminating NULL. | |
| 643 _participants[1] = NULL; | |
| 644 _found_methods[1] = NULL; | |
| 645 _num_participants = 1; | |
| 646 } | |
| 647 } | |
| 648 | |
| 649 void initialize_from_method(methodOop m) { | |
| 650 assert(m != NULL && m->is_method(), "sanity"); | |
| 651 _name = m->name(); | |
| 652 _signature = m->signature(); | |
| 653 } | |
| 654 | |
| 655 public: | |
| 656 // The walker is initialized to recognize certain methods and/or types | |
| 657 // as friendly participants. | |
| 658 ClassHierarchyWalker(klassOop participant, methodOop m) { | |
| 659 initialize_from_method(m); | |
| 660 initialize(participant); | |
| 661 } | |
| 662 ClassHierarchyWalker(methodOop m) { | |
| 663 initialize_from_method(m); | |
| 664 initialize(NULL); | |
| 665 } | |
| 666 ClassHierarchyWalker(klassOop participant = NULL) { | |
| 667 _name = NULL; | |
| 668 _signature = NULL; | |
| 669 initialize(participant); | |
| 670 } | |
| 671 | |
| 672 // This is common code for two searches: One for concrete subtypes, | |
| 673 // the other for concrete method implementations and overrides. | |
| 674 bool doing_subtype_search() { | |
| 675 return _name == NULL; | |
| 676 } | |
| 677 | |
| 678 int num_participants() { return _num_participants; } | |
| 679 klassOop participant(int n) { | |
| 680 assert((uint)n <= (uint)_num_participants, "oob"); | |
| 681 return _participants[n]; | |
| 682 } | |
| 683 | |
| 684 // Note: If n==num_participants, returns NULL. | |
| 685 methodOop found_method(int n) { | |
| 686 assert((uint)n <= (uint)_num_participants, "oob"); | |
| 687 methodOop fm = _found_methods[n]; | |
| 688 assert(n == _num_participants || fm != NULL, "proper usage"); | |
| 689 assert(fm == NULL || fm->method_holder() == _participants[n], "sanity"); | |
| 690 return fm; | |
| 691 } | |
| 692 | |
| 693 #ifdef ASSERT | |
| 694 // Assert that m is inherited into ctxk, without intervening overrides. | |
| 695 // (May return true even if this is not true, in corner cases where we punt.) | |
| 696 bool check_method_context(klassOop ctxk, methodOop m) { | |
| 697 if (m->method_holder() == ctxk) | |
| 698 return true; // Quick win. | |
| 699 if (m->is_private()) | |
| 700 return false; // Quick lose. Should not happen. | |
| 701 if (!(m->is_public() || m->is_protected())) | |
| 702 // The override story is complex when packages get involved. | |
| 703 return true; // Must punt the assertion to true. | |
| 704 Klass* k = Klass::cast(ctxk); | |
| 705 methodOop lm = k->lookup_method(m->name(), m->signature()); | |
| 706 if (lm == NULL && k->oop_is_instance()) { | |
| 707 // It might be an abstract interface method, devoid of mirandas. | |
| 708 lm = ((instanceKlass*)k)->lookup_method_in_all_interfaces(m->name(), | |
| 709 m->signature()); | |
| 710 } | |
| 711 if (lm == m) | |
| 712 // Method m is inherited into ctxk. | |
| 713 return true; | |
| 714 if (lm != NULL) { | |
| 715 if (!(lm->is_public() || lm->is_protected())) | |
| 716 // Method is [package-]private, so the override story is complex. | |
| 717 return true; // Must punt the assertion to true. | |
| 718 if ( !Dependencies::is_concrete_method(lm) | |
| 719 && !Dependencies::is_concrete_method(m) | |
| 720 && Klass::cast(lm->method_holder())->is_subtype_of(m->method_holder())) | |
| 721 // Method m is overridden by lm, but both are non-concrete. | |
| 722 return true; | |
| 723 } | |
| 724 ResourceMark rm; | |
| 725 tty->print_cr("Dependency method not found in the associated context:"); | |
| 726 tty->print_cr(" context = %s", Klass::cast(ctxk)->external_name()); | |
| 727 tty->print( " method = "); m->print_short_name(tty); tty->cr(); | |
| 728 if (lm != NULL) { | |
| 729 tty->print( " found = "); lm->print_short_name(tty); tty->cr(); | |
| 730 } | |
| 731 return false; | |
| 732 } | |
| 733 #endif | |
| 734 | |
| 735 void add_participant(klassOop participant) { | |
| 736 assert(_num_participants + _record_witnesses < PARTICIPANT_LIMIT, "oob"); | |
| 737 int np = _num_participants++; | |
| 738 _participants[np] = participant; | |
| 739 _participants[np+1] = NULL; | |
| 740 _found_methods[np+1] = NULL; | |
| 741 } | |
| 742 | |
| 743 void record_witnesses(int add) { | |
| 744 if (add > PARTICIPANT_LIMIT) add = PARTICIPANT_LIMIT; | |
| 745 assert(_num_participants + add < PARTICIPANT_LIMIT, "oob"); | |
| 746 _record_witnesses = add; | |
| 747 } | |
| 748 | |
| 749 bool is_witness(klassOop k) { | |
| 750 if (doing_subtype_search()) { | |
| 751 return Dependencies::is_concrete_klass(k); | |
| 752 } else { | |
| 753 methodOop m = instanceKlass::cast(k)->find_method(_name, _signature); | |
| 754 if (m == NULL || !Dependencies::is_concrete_method(m)) return false; | |
| 755 _found_methods[_num_participants] = m; | |
| 756 // Note: If add_participant(k) is called, | |
| 757 // the method m will already be memoized for it. | |
| 758 return true; | |
| 759 } | |
| 760 } | |
| 761 | |
| 762 bool is_participant(klassOop k) { | |
| 763 if (k == _participants[0]) { | |
| 764 return true; | |
| 765 } else if (_num_participants <= 1) { | |
| 766 return false; | |
| 767 } else { | |
| 768 return in_list(k, &_participants[1]); | |
| 769 } | |
| 770 } | |
| 771 bool ignore_witness(klassOop witness) { | |
| 772 if (_record_witnesses == 0) { | |
| 773 return false; | |
| 774 } else { | |
| 775 --_record_witnesses; | |
| 776 add_participant(witness); | |
| 777 return true; | |
| 778 } | |
| 779 } | |
| 780 static bool in_list(klassOop x, klassOop* list) { | |
| 781 for (int i = 0; ; i++) { | |
| 782 klassOop y = list[i]; | |
| 783 if (y == NULL) break; | |
| 784 if (y == x) return true; | |
| 785 } | |
| 786 return false; // not in list | |
| 787 } | |
| 788 | |
| 789 private: | |
| 790 // the actual search method: | |
| 791 klassOop find_witness_anywhere(klassOop context_type, | |
| 792 bool participants_hide_witnesses, | |
| 793 bool top_level_call = true); | |
| 794 // the spot-checking version: | |
| 795 klassOop find_witness_in(DepChange& changes, | |
| 796 klassOop context_type, | |
| 797 bool participants_hide_witnesses); | |
| 798 public: | |
| 799 klassOop find_witness_subtype(klassOop context_type, DepChange* changes = NULL) { | |
| 800 assert(doing_subtype_search(), "must set up a subtype search"); | |
| 801 // When looking for unexpected concrete types, | |
| 802 // do not look beneath expected ones. | |
| 803 const bool participants_hide_witnesses = true; | |
| 804 // CX > CC > C' is OK, even if C' is new. | |
| 805 // CX > { CC, C' } is not OK if C' is new, and C' is the witness. | |
| 806 if (changes != NULL) { | |
| 807 return find_witness_in(*changes, context_type, participants_hide_witnesses); | |
| 808 } else { | |
| 809 return find_witness_anywhere(context_type, participants_hide_witnesses); | |
| 810 } | |
| 811 } | |
| 812 klassOop find_witness_definer(klassOop context_type, DepChange* changes = NULL) { | |
| 813 assert(!doing_subtype_search(), "must set up a method definer search"); | |
| 814 // When looking for unexpected concrete methods, | |
| 815 // look beneath expected ones, to see if there are overrides. | |
| 816 const bool participants_hide_witnesses = true; | |
| 817 // CX.m > CC.m > C'.m is not OK, if C'.m is new, and C' is the witness. | |
| 818 if (changes != NULL) { | |
| 819 return find_witness_in(*changes, context_type, !participants_hide_witnesses); | |
| 820 } else { | |
| 821 return find_witness_anywhere(context_type, !participants_hide_witnesses); | |
| 822 } | |
| 823 } | |
| 824 }; | |
| 825 | |
| 826 #ifndef PRODUCT | |
| 827 static int deps_find_witness_calls = 0; | |
| 828 static int deps_find_witness_steps = 0; | |
| 829 static int deps_find_witness_recursions = 0; | |
| 830 static int deps_find_witness_singles = 0; | |
| 831 static int deps_find_witness_print = 0; // set to -1 to force a final print | |
| 832 static bool count_find_witness_calls() { | |
| 833 if (TraceDependencies || LogCompilation) { | |
| 834 int pcount = deps_find_witness_print + 1; | |
| 835 bool final_stats = (pcount == 0); | |
| 836 bool initial_call = (pcount == 1); | |
| 837 bool occasional_print = ((pcount & ((1<<10) - 1)) == 0); | |
| 838 if (pcount < 0) pcount = 1; // crude overflow protection | |
| 839 deps_find_witness_print = pcount; | |
| 840 if (VerifyDependencies && initial_call) { | |
| 841 tty->print_cr("Warning: TraceDependencies results may be inflated by VerifyDependencies"); | |
| 842 } | |
| 843 if (occasional_print || final_stats) { | |
| 844 // Every now and then dump a little info about dependency searching. | |
| 845 if (xtty != NULL) { | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1123
diff
changeset
|
846 ttyLocker ttyl; |
|
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1123
diff
changeset
|
847 xtty->elem("deps_find_witness calls='%d' steps='%d' recursions='%d' singles='%d'", |
| 0 | 848 deps_find_witness_calls, |
| 849 deps_find_witness_steps, | |
| 850 deps_find_witness_recursions, | |
| 851 deps_find_witness_singles); | |
| 852 } | |
| 853 if (final_stats || (TraceDependencies && WizardMode)) { | |
|
1206
87684f1a88b5
6614597: Performance variability in jvm2008 xml.validation
kvn
parents:
1123
diff
changeset
|
854 ttyLocker ttyl; |
| 0 | 855 tty->print_cr("Dependency check (find_witness) " |
| 856 "calls=%d, steps=%d (avg=%.1f), recursions=%d, singles=%d", | |
| 857 deps_find_witness_calls, | |
| 858 deps_find_witness_steps, | |
| 859 (double)deps_find_witness_steps / deps_find_witness_calls, | |
| 860 deps_find_witness_recursions, | |
| 861 deps_find_witness_singles); | |
| 862 } | |
| 863 } | |
| 864 return true; | |
| 865 } | |
| 866 return false; | |
| 867 } | |
| 868 #else | |
| 869 #define count_find_witness_calls() (0) | |
| 870 #endif //PRODUCT | |
| 871 | |
| 872 | |
| 873 klassOop ClassHierarchyWalker::find_witness_in(DepChange& changes, | |
| 874 klassOop context_type, | |
| 875 bool participants_hide_witnesses) { | |
| 876 assert(changes.involves_context(context_type), "irrelevant dependency"); | |
| 877 klassOop new_type = changes.new_type(); | |
| 878 | |
| 879 count_find_witness_calls(); | |
| 880 NOT_PRODUCT(deps_find_witness_singles++); | |
| 881 | |
| 882 // Current thread must be in VM (not native mode, as in CI): | |
| 883 assert(must_be_in_vm(), "raw oops here"); | |
| 884 // Must not move the class hierarchy during this check: | |
| 885 assert_locked_or_safepoint(Compile_lock); | |
| 886 | |
| 30 | 887 int nof_impls = instanceKlass::cast(context_type)->nof_implementors(); |
| 888 if (nof_impls > 1) { | |
| 889 // Avoid this case: *I.m > { A.m, C }; B.m > C | |
| 890 // %%% Until this is fixed more systematically, bail out. | |
| 891 // See corresponding comment in find_witness_anywhere. | |
| 892 return context_type; | |
| 893 } | |
| 894 | |
| 0 | 895 assert(!is_participant(new_type), "only old classes are participants"); |
| 896 if (participants_hide_witnesses) { | |
| 897 // If the new type is a subtype of a participant, we are done. | |
| 898 for (int i = 0; i < num_participants(); i++) { | |
| 899 klassOop part = participant(i); | |
| 900 if (part == NULL) continue; | |
| 901 assert(changes.involves_context(part) == Klass::cast(new_type)->is_subtype_of(part), | |
| 902 "correct marking of participants, b/c new_type is unique"); | |
| 903 if (changes.involves_context(part)) { | |
| 904 // new guy is protected from this check by previous participant | |
| 905 return NULL; | |
| 906 } | |
| 907 } | |
| 908 } | |
| 909 | |
| 910 if (is_witness(new_type) && | |
| 911 !ignore_witness(new_type)) { | |
| 912 return new_type; | |
| 913 } | |
| 914 | |
| 915 return NULL; | |
| 916 } | |
| 917 | |
| 918 | |
| 919 // Walk hierarchy under a context type, looking for unexpected types. | |
| 920 // Do not report participant types, and recursively walk beneath | |
| 921 // them only if participants_hide_witnesses is false. | |
| 922 // If top_level_call is false, skip testing the context type, | |
| 923 // because the caller has already considered it. | |
| 924 klassOop ClassHierarchyWalker::find_witness_anywhere(klassOop context_type, | |
| 925 bool participants_hide_witnesses, | |
| 926 bool top_level_call) { | |
| 927 // Current thread must be in VM (not native mode, as in CI): | |
| 928 assert(must_be_in_vm(), "raw oops here"); | |
| 929 // Must not move the class hierarchy during this check: | |
| 930 assert_locked_or_safepoint(Compile_lock); | |
| 931 | |
| 932 bool do_counts = count_find_witness_calls(); | |
| 933 | |
| 934 // Check the root of the sub-hierarchy first. | |
| 935 if (top_level_call) { | |
| 936 if (do_counts) { | |
| 937 NOT_PRODUCT(deps_find_witness_calls++); | |
| 938 NOT_PRODUCT(deps_find_witness_steps++); | |
| 939 } | |
| 940 if (is_participant(context_type)) { | |
| 941 if (participants_hide_witnesses) return NULL; | |
| 942 // else fall through to search loop... | |
| 943 } else if (is_witness(context_type) && !ignore_witness(context_type)) { | |
| 944 // The context is an abstract class or interface, to start with. | |
| 945 return context_type; | |
| 946 } | |
| 947 } | |
| 948 | |
| 949 // Now we must check each implementor and each subclass. | |
| 950 // Use a short worklist to avoid blowing the stack. | |
| 951 // Each worklist entry is a *chain* of subklass siblings to process. | |
| 952 const int CHAINMAX = 100; // >= 1 + instanceKlass::implementors_limit | |
| 953 Klass* chains[CHAINMAX]; | |
| 954 int chaini = 0; // index into worklist | |
| 955 Klass* chain; // scratch variable | |
| 956 #define ADD_SUBCLASS_CHAIN(k) { \ | |
| 957 assert(chaini < CHAINMAX, "oob"); \ | |
| 958 chain = instanceKlass::cast(k)->subklass(); \ | |
| 959 if (chain != NULL) chains[chaini++] = chain; } | |
| 960 | |
| 961 // Look for non-abstract subclasses. | |
| 962 // (Note: Interfaces do not have subclasses.) | |
| 963 ADD_SUBCLASS_CHAIN(context_type); | |
| 964 | |
| 965 // If it is an interface, search its direct implementors. | |
| 966 // (Their subclasses are additional indirect implementors. | |
| 967 // See instanceKlass::add_implementor.) | |
| 968 // (Note: nof_implementors is always zero for non-interfaces.) | |
| 969 int nof_impls = instanceKlass::cast(context_type)->nof_implementors(); | |
| 970 if (nof_impls > 1) { | |
| 971 // Avoid this case: *I.m > { A.m, C }; B.m > C | |
| 972 // Here, I.m has 2 concrete implementations, but m appears unique | |
| 973 // as A.m, because the search misses B.m when checking C. | |
| 974 // The inherited method B.m was getting missed by the walker | |
| 975 // when interface 'I' was the starting point. | |
| 976 // %%% Until this is fixed more systematically, bail out. | |
| 977 // (Old CHA had the same limitation.) | |
| 978 return context_type; | |
| 979 } | |
| 980 for (int i = 0; i < nof_impls; i++) { | |
| 981 klassOop impl = instanceKlass::cast(context_type)->implementor(i); | |
| 982 if (impl == NULL) { | |
| 983 // implementors array overflowed => no exact info. | |
| 984 return context_type; // report an inexact witness to this sad affair | |
| 985 } | |
| 986 if (do_counts) | |
| 987 { NOT_PRODUCT(deps_find_witness_steps++); } | |
| 988 if (is_participant(impl)) { | |
| 989 if (participants_hide_witnesses) continue; | |
| 990 // else fall through to process this guy's subclasses | |
| 991 } else if (is_witness(impl) && !ignore_witness(impl)) { | |
| 992 return impl; | |
| 993 } | |
| 994 ADD_SUBCLASS_CHAIN(impl); | |
| 995 } | |
| 996 | |
| 997 // Recursively process each non-trivial sibling chain. | |
| 998 while (chaini > 0) { | |
| 999 Klass* chain = chains[--chaini]; | |
| 1000 for (Klass* subk = chain; subk != NULL; subk = subk->next_sibling()) { | |
| 1001 klassOop sub = subk->as_klassOop(); | |
| 1002 if (do_counts) { NOT_PRODUCT(deps_find_witness_steps++); } | |
| 1003 if (is_participant(sub)) { | |
| 1004 if (participants_hide_witnesses) continue; | |
| 1005 // else fall through to process this guy's subclasses | |
| 1006 } else if (is_witness(sub) && !ignore_witness(sub)) { | |
| 1007 return sub; | |
| 1008 } | |
| 1009 if (chaini < (VerifyDependencies? 2: CHAINMAX)) { | |
| 1010 // Fast path. (Partially disabled if VerifyDependencies.) | |
| 1011 ADD_SUBCLASS_CHAIN(sub); | |
| 1012 } else { | |
| 1013 // Worklist overflow. Do a recursive call. Should be rare. | |
| 1014 // The recursive call will have its own worklist, of course. | |
| 1015 // (Note that sub has already been tested, so that there is | |
| 1016 // no need for the recursive call to re-test. That's handy, | |
| 1017 // since the recursive call sees sub as the context_type.) | |
| 1018 if (do_counts) { NOT_PRODUCT(deps_find_witness_recursions++); } | |
| 1019 klassOop witness = find_witness_anywhere(sub, | |
| 1020 participants_hide_witnesses, | |
| 1021 /*top_level_call=*/ false); | |
| 1022 if (witness != NULL) return witness; | |
| 1023 } | |
| 1024 } | |
| 1025 } | |
| 1026 | |
| 1027 // No witness found. The dependency remains unbroken. | |
| 1028 return NULL; | |
| 1029 #undef ADD_SUBCLASS_CHAIN | |
| 1030 } | |
| 1031 | |
| 1032 | |
| 1033 bool Dependencies::is_concrete_klass(klassOop k) { | |
| 1034 if (Klass::cast(k)->is_abstract()) return false; | |
| 1035 // %%% We could treat classes which are concrete but | |
| 1036 // have not yet been instantiated as virtually abstract. | |
| 1037 // This would require a deoptimization barrier on first instantiation. | |
| 1038 //if (k->is_not_instantiated()) return false; | |
| 1039 return true; | |
| 1040 } | |
| 1041 | |
| 1042 bool Dependencies::is_concrete_method(methodOop m) { | |
| 1043 if (m->is_abstract()) return false; | |
| 1044 // %%% We could treat unexecuted methods as virtually abstract also. | |
| 1045 // This would require a deoptimization barrier on first execution. | |
| 1046 return !m->is_abstract(); | |
| 1047 } | |
| 1048 | |
| 1049 | |
| 1050 Klass* Dependencies::find_finalizable_subclass(Klass* k) { | |
| 1051 if (k->is_interface()) return NULL; | |
| 1052 if (k->has_finalizer()) return k; | |
| 1053 k = k->subklass(); | |
| 1054 while (k != NULL) { | |
| 1055 Klass* result = find_finalizable_subclass(k); | |
| 1056 if (result != NULL) return result; | |
| 1057 k = k->next_sibling(); | |
| 1058 } | |
| 1059 return NULL; | |
| 1060 } | |
| 1061 | |
| 1062 | |
| 1063 bool Dependencies::is_concrete_klass(ciInstanceKlass* k) { | |
| 1064 if (k->is_abstract()) return false; | |
| 1065 // We could return also false if k does not yet appear to be | |
| 1066 // instantiated, if the VM version supports this distinction also. | |
| 1067 //if (k->is_not_instantiated()) return false; | |
| 1068 return true; | |
| 1069 } | |
| 1070 | |
| 1071 bool Dependencies::is_concrete_method(ciMethod* m) { | |
| 1072 // Statics are irrelevant to virtual call sites. | |
| 1073 if (m->is_static()) return false; | |
| 1074 | |
| 1075 // We could return also false if m does not yet appear to be | |
| 1076 // executed, if the VM version supports this distinction also. | |
| 1077 return !m->is_abstract(); | |
| 1078 } | |
| 1079 | |
| 1080 | |
| 1081 bool Dependencies::has_finalizable_subclass(ciInstanceKlass* k) { | |
| 1082 return k->has_finalizable_subclass(); | |
| 1083 } | |
| 1084 | |
| 1085 | |
| 1086 // Any use of the contents (bytecodes) of a method must be | |
| 1087 // marked by an "evol_method" dependency, if those contents | |
| 1088 // can change. (Note: A method is always dependent on itself.) | |
| 1089 klassOop Dependencies::check_evol_method(methodOop m) { | |
| 1090 assert(must_be_in_vm(), "raw oops here"); | |
| 1091 // Did somebody do a JVMTI RedefineClasses while our backs were turned? | |
| 1092 // Or is there a now a breakpoint? | |
| 1093 // (Assumes compiled code cannot handle bkpts; change if UseFastBreakpoints.) | |
| 1094 if (m->is_old() | |
| 1095 || m->number_of_breakpoints() > 0) { | |
| 1096 return m->method_holder(); | |
| 1097 } else { | |
| 1098 return NULL; | |
| 1099 } | |
| 1100 } | |
| 1101 | |
| 1102 // This is a strong assertion: It is that the given type | |
| 1103 // has no subtypes whatever. It is most useful for | |
| 1104 // optimizing checks on reflected types or on array types. | |
| 1105 // (Checks on types which are derived from real instances | |
| 1106 // can be optimized more strongly than this, because we | |
| 1107 // know that the checked type comes from a concrete type, | |
| 1108 // and therefore we can disregard abstract types.) | |
| 1109 klassOop Dependencies::check_leaf_type(klassOop ctxk) { | |
| 1110 assert(must_be_in_vm(), "raw oops here"); | |
| 1111 assert_locked_or_safepoint(Compile_lock); | |
| 1112 instanceKlass* ctx = instanceKlass::cast(ctxk); | |
| 1113 Klass* sub = ctx->subklass(); | |
| 1114 if (sub != NULL) { | |
| 1115 return sub->as_klassOop(); | |
| 1116 } else if (ctx->nof_implementors() != 0) { | |
| 1117 // if it is an interface, it must be unimplemented | |
| 1118 // (if it is not an interface, nof_implementors is always zero) | |
| 1119 klassOop impl = ctx->implementor(0); | |
| 1120 return (impl != NULL)? impl: ctxk; | |
| 1121 } else { | |
| 1122 return NULL; | |
| 1123 } | |
| 1124 } | |
| 1125 | |
| 1126 // Test the assertion that conck is the only concrete subtype* of ctxk. | |
| 1127 // The type conck itself is allowed to have have further concrete subtypes. | |
| 1128 // This allows the compiler to narrow occurrences of ctxk by conck, | |
| 1129 // when dealing with the types of actual instances. | |
| 1130 klassOop Dependencies::check_abstract_with_unique_concrete_subtype(klassOop ctxk, | |
| 1131 klassOop conck, | |
| 1132 DepChange* changes) { | |
| 1133 ClassHierarchyWalker wf(conck); | |
| 1134 return wf.find_witness_subtype(ctxk, changes); | |
| 1135 } | |
| 1136 | |
| 1137 // If a non-concrete class has no concrete subtypes, it is not (yet) | |
| 1138 // instantiatable. This can allow the compiler to make some paths go | |
| 1139 // dead, if they are gated by a test of the type. | |
| 1140 klassOop Dependencies::check_abstract_with_no_concrete_subtype(klassOop ctxk, | |
| 1141 DepChange* changes) { | |
| 1142 // Find any concrete subtype, with no participants: | |
| 1143 ClassHierarchyWalker wf; | |
| 1144 return wf.find_witness_subtype(ctxk, changes); | |
| 1145 } | |
| 1146 | |
| 1147 | |
| 1148 // If a concrete class has no concrete subtypes, it can always be | |
| 1149 // exactly typed. This allows the use of a cheaper type test. | |
| 1150 klassOop Dependencies::check_concrete_with_no_concrete_subtype(klassOop ctxk, | |
| 1151 DepChange* changes) { | |
| 1152 // Find any concrete subtype, with only the ctxk as participant: | |
| 1153 ClassHierarchyWalker wf(ctxk); | |
| 1154 return wf.find_witness_subtype(ctxk, changes); | |
| 1155 } | |
| 1156 | |
| 1157 | |
| 1158 // Find the unique concrete proper subtype of ctxk, or NULL if there | |
| 1159 // is more than one concrete proper subtype. If there are no concrete | |
| 1160 // proper subtypes, return ctxk itself, whether it is concrete or not. | |
| 1161 // The returned subtype is allowed to have have further concrete subtypes. | |
| 1162 // That is, return CC1 for CX > CC1 > CC2, but NULL for CX > { CC1, CC2 }. | |
| 1163 klassOop Dependencies::find_unique_concrete_subtype(klassOop ctxk) { | |
| 1164 ClassHierarchyWalker wf(ctxk); // Ignore ctxk when walking. | |
| 1165 wf.record_witnesses(1); // Record one other witness when walking. | |
| 1166 klassOop wit = wf.find_witness_subtype(ctxk); | |
| 1167 if (wit != NULL) return NULL; // Too many witnesses. | |
| 1168 klassOop conck = wf.participant(0); | |
| 1169 if (conck == NULL) { | |
| 1170 #ifndef PRODUCT | |
| 1171 // Make sure the dependency mechanism will pass this discovery: | |
| 1172 if (VerifyDependencies) { | |
| 1173 // Turn off dependency tracing while actually testing deps. | |
| 1174 FlagSetting fs(TraceDependencies, false); | |
| 1175 if (!Dependencies::is_concrete_klass(ctxk)) { | |
| 1176 guarantee(NULL == | |
| 1177 (void *)check_abstract_with_no_concrete_subtype(ctxk), | |
| 1178 "verify dep."); | |
| 1179 } else { | |
| 1180 guarantee(NULL == | |
| 1181 (void *)check_concrete_with_no_concrete_subtype(ctxk), | |
| 1182 "verify dep."); | |
| 1183 } | |
| 1184 } | |
| 1185 #endif //PRODUCT | |
| 1186 return ctxk; // Return ctxk as a flag for "no subtypes". | |
| 1187 } else { | |
| 1188 #ifndef PRODUCT | |
| 1189 // Make sure the dependency mechanism will pass this discovery: | |
| 1190 if (VerifyDependencies) { | |
| 1191 // Turn off dependency tracing while actually testing deps. | |
| 1192 FlagSetting fs(TraceDependencies, false); | |
| 1193 if (!Dependencies::is_concrete_klass(ctxk)) { | |
| 1194 guarantee(NULL == (void *) | |
| 1195 check_abstract_with_unique_concrete_subtype(ctxk, conck), | |
| 1196 "verify dep."); | |
| 1197 } | |
| 1198 } | |
| 1199 #endif //PRODUCT | |
| 1200 return conck; | |
| 1201 } | |
| 1202 } | |
| 1203 | |
| 1204 // Test the assertion that the k[12] are the only concrete subtypes of ctxk, | |
| 1205 // except possibly for further subtypes of k[12] themselves. | |
| 1206 // The context type must be abstract. The types k1 and k2 are themselves | |
| 1207 // allowed to have further concrete subtypes. | |
| 1208 klassOop Dependencies::check_abstract_with_exclusive_concrete_subtypes( | |
| 1209 klassOop ctxk, | |
| 1210 klassOop k1, | |
| 1211 klassOop k2, | |
| 1212 DepChange* changes) { | |
| 1213 ClassHierarchyWalker wf; | |
| 1214 wf.add_participant(k1); | |
| 1215 wf.add_participant(k2); | |
| 1216 return wf.find_witness_subtype(ctxk, changes); | |
| 1217 } | |
| 1218 | |
| 1219 // Search ctxk for concrete implementations. If there are klen or fewer, | |
| 1220 // pack them into the given array and return the number. | |
| 1221 // Otherwise, return -1, meaning the given array would overflow. | |
| 1222 // (Note that a return of 0 means there are exactly no concrete subtypes.) | |
| 1223 // In this search, if ctxk is concrete, it will be reported alone. | |
| 1224 // For any type CC reported, no proper subtypes of CC will be reported. | |
| 1225 int Dependencies::find_exclusive_concrete_subtypes(klassOop ctxk, | |
| 1226 int klen, | |
| 1227 klassOop karray[]) { | |
| 1228 ClassHierarchyWalker wf; | |
| 1229 wf.record_witnesses(klen); | |
| 1230 klassOop wit = wf.find_witness_subtype(ctxk); | |
| 1231 if (wit != NULL) return -1; // Too many witnesses. | |
| 1232 int num = wf.num_participants(); | |
| 1233 assert(num <= klen, "oob"); | |
| 1234 // Pack the result array with the good news. | |
| 1235 for (int i = 0; i < num; i++) | |
| 1236 karray[i] = wf.participant(i); | |
| 1237 #ifndef PRODUCT | |
| 1238 // Make sure the dependency mechanism will pass this discovery: | |
| 1239 if (VerifyDependencies) { | |
| 1240 // Turn off dependency tracing while actually testing deps. | |
| 1241 FlagSetting fs(TraceDependencies, false); | |
| 1242 switch (Dependencies::is_concrete_klass(ctxk)? -1: num) { | |
| 1243 case -1: // ctxk was itself concrete | |
| 1244 guarantee(num == 1 && karray[0] == ctxk, "verify dep."); | |
| 1245 break; | |
| 1246 case 0: | |
| 1247 guarantee(NULL == (void *)check_abstract_with_no_concrete_subtype(ctxk), | |
| 1248 "verify dep."); | |
| 1249 break; | |
| 1250 case 1: | |
| 1251 guarantee(NULL == (void *) | |
| 1252 check_abstract_with_unique_concrete_subtype(ctxk, karray[0]), | |
| 1253 "verify dep."); | |
| 1254 break; | |
| 1255 case 2: | |
| 1256 guarantee(NULL == (void *) | |
| 1257 check_abstract_with_exclusive_concrete_subtypes(ctxk, | |
| 1258 karray[0], | |
| 1259 karray[1]), | |
| 1260 "verify dep."); | |
| 1261 break; | |
| 1262 default: | |
| 1263 ShouldNotReachHere(); // klen > 2 yet supported | |
| 1264 } | |
| 1265 } | |
| 1266 #endif //PRODUCT | |
| 1267 return num; | |
| 1268 } | |
| 1269 | |
| 1270 // If a class (or interface) has a unique concrete method uniqm, return NULL. | |
| 1271 // Otherwise, return a class that contains an interfering method. | |
| 1272 klassOop Dependencies::check_unique_concrete_method(klassOop ctxk, methodOop uniqm, | |
| 1273 DepChange* changes) { | |
| 1274 // Here is a missing optimization: If uniqm->is_final(), | |
| 1275 // we don't really need to search beneath it for overrides. | |
| 1276 // This is probably not important, since we don't use dependencies | |
| 1277 // to track final methods. (They can't be "definalized".) | |
| 1278 ClassHierarchyWalker wf(uniqm->method_holder(), uniqm); | |
| 1279 return wf.find_witness_definer(ctxk, changes); | |
| 1280 } | |
| 1281 | |
| 1282 // Find the set of all non-abstract methods under ctxk that match m. | |
| 1283 // (The method m must be defined or inherited in ctxk.) | |
| 1284 // Include m itself in the set, unless it is abstract. | |
| 1285 // If this set has exactly one element, return that element. | |
| 1286 methodOop Dependencies::find_unique_concrete_method(klassOop ctxk, methodOop m) { | |
| 1287 ClassHierarchyWalker wf(m); | |
| 1288 assert(wf.check_method_context(ctxk, m), "proper context"); | |
| 1289 wf.record_witnesses(1); | |
| 1290 klassOop wit = wf.find_witness_definer(ctxk); | |
| 1291 if (wit != NULL) return NULL; // Too many witnesses. | |
| 1292 methodOop fm = wf.found_method(0); // Will be NULL if num_parts == 0. | |
| 1293 if (Dependencies::is_concrete_method(m)) { | |
| 1294 if (fm == NULL) { | |
| 1295 // It turns out that m was always the only implementation. | |
| 1296 fm = m; | |
| 1297 } else if (fm != m) { | |
| 1298 // Two conflicting implementations after all. | |
| 1299 // (This can happen if m is inherited into ctxk and fm overrides it.) | |
| 1300 return NULL; | |
| 1301 } | |
| 1302 } | |
| 1303 #ifndef PRODUCT | |
| 1304 // Make sure the dependency mechanism will pass this discovery: | |
| 1305 if (VerifyDependencies && fm != NULL) { | |
| 1306 guarantee(NULL == (void *)check_unique_concrete_method(ctxk, fm), | |
| 1307 "verify dep."); | |
| 1308 } | |
| 1309 #endif //PRODUCT | |
| 1310 return fm; | |
| 1311 } | |
| 1312 | |
| 1313 klassOop Dependencies::check_exclusive_concrete_methods(klassOop ctxk, | |
| 1314 methodOop m1, | |
| 1315 methodOop m2, | |
| 1316 DepChange* changes) { | |
| 1317 ClassHierarchyWalker wf(m1); | |
| 1318 wf.add_participant(m1->method_holder()); | |
| 1319 wf.add_participant(m2->method_holder()); | |
| 1320 return wf.find_witness_definer(ctxk, changes); | |
| 1321 } | |
| 1322 | |
| 1323 // Find the set of all non-abstract methods under ctxk that match m[0]. | |
| 1324 // (The method m[0] must be defined or inherited in ctxk.) | |
| 1325 // Include m itself in the set, unless it is abstract. | |
| 1326 // Fill the given array m[0..(mlen-1)] with this set, and return the length. | |
| 1327 // (The length may be zero if no concrete methods are found anywhere.) | |
| 1328 // If there are too many concrete methods to fit in marray, return -1. | |
| 1329 int Dependencies::find_exclusive_concrete_methods(klassOop ctxk, | |
| 1330 int mlen, | |
| 1331 methodOop marray[]) { | |
| 1332 methodOop m0 = marray[0]; | |
| 1333 ClassHierarchyWalker wf(m0); | |
| 1334 assert(wf.check_method_context(ctxk, m0), "proper context"); | |
| 1335 wf.record_witnesses(mlen); | |
| 1336 bool participants_hide_witnesses = true; | |
| 1337 klassOop wit = wf.find_witness_definer(ctxk); | |
| 1338 if (wit != NULL) return -1; // Too many witnesses. | |
| 1339 int num = wf.num_participants(); | |
| 1340 assert(num <= mlen, "oob"); | |
| 1341 // Keep track of whether m is also part of the result set. | |
| 1342 int mfill = 0; | |
| 1343 assert(marray[mfill] == m0, "sanity"); | |
| 1344 if (Dependencies::is_concrete_method(m0)) | |
| 1345 mfill++; // keep m0 as marray[0], the first result | |
| 1346 for (int i = 0; i < num; i++) { | |
| 1347 methodOop fm = wf.found_method(i); | |
| 1348 if (fm == m0) continue; // Already put this guy in the list. | |
| 1349 if (mfill == mlen) { | |
| 1350 return -1; // Oops. Too many methods after all! | |
| 1351 } | |
| 1352 marray[mfill++] = fm; | |
| 1353 } | |
| 1354 #ifndef PRODUCT | |
| 1355 // Make sure the dependency mechanism will pass this discovery: | |
| 1356 if (VerifyDependencies) { | |
| 1357 // Turn off dependency tracing while actually testing deps. | |
| 1358 FlagSetting fs(TraceDependencies, false); | |
| 1359 switch (mfill) { | |
| 1360 case 1: | |
| 1361 guarantee(NULL == (void *)check_unique_concrete_method(ctxk, marray[0]), | |
| 1362 "verify dep."); | |
| 1363 break; | |
| 1364 case 2: | |
| 1365 guarantee(NULL == (void *) | |
| 1366 check_exclusive_concrete_methods(ctxk, marray[0], marray[1]), | |
| 1367 "verify dep."); | |
| 1368 break; | |
| 1369 default: | |
| 1370 ShouldNotReachHere(); // mlen > 2 yet supported | |
| 1371 } | |
| 1372 } | |
| 1373 #endif //PRODUCT | |
| 1374 return mfill; | |
| 1375 } | |
| 1376 | |
| 1377 | |
| 1378 klassOop Dependencies::check_has_no_finalizable_subclasses(klassOop ctxk, DepChange* changes) { | |
| 1379 Klass* search_at = ctxk->klass_part(); | |
| 1380 if (changes != NULL) | |
| 1381 search_at = changes->new_type()->klass_part(); // just look at the new bit | |
| 1382 Klass* result = find_finalizable_subclass(search_at); | |
| 1383 if (result == NULL) { | |
| 1384 return NULL; | |
| 1385 } | |
| 1386 return result->as_klassOop(); | |
| 1387 } | |
| 1388 | |
| 1389 | |
| 1390 klassOop Dependencies::DepStream::check_dependency_impl(DepChange* changes) { | |
| 1391 assert_locked_or_safepoint(Compile_lock); | |
| 1392 | |
| 1393 klassOop witness = NULL; | |
| 1394 switch (type()) { | |
| 1395 case evol_method: | |
| 1396 witness = check_evol_method(method_argument(0)); | |
| 1397 break; | |
| 1398 case leaf_type: | |
| 1399 witness = check_leaf_type(context_type()); | |
| 1400 break; | |
| 1401 case abstract_with_unique_concrete_subtype: | |
| 1402 witness = check_abstract_with_unique_concrete_subtype(context_type(), | |
| 1403 type_argument(1), | |
| 1404 changes); | |
| 1405 break; | |
| 1406 case abstract_with_no_concrete_subtype: | |
| 1407 witness = check_abstract_with_no_concrete_subtype(context_type(), | |
| 1408 changes); | |
| 1409 break; | |
| 1410 case concrete_with_no_concrete_subtype: | |
| 1411 witness = check_concrete_with_no_concrete_subtype(context_type(), | |
| 1412 changes); | |
| 1413 break; | |
| 1414 case unique_concrete_method: | |
| 1415 witness = check_unique_concrete_method(context_type(), | |
| 1416 method_argument(1), | |
| 1417 changes); | |
| 1418 break; | |
| 1419 case abstract_with_exclusive_concrete_subtypes_2: | |
| 1420 witness = check_abstract_with_exclusive_concrete_subtypes(context_type(), | |
| 1421 type_argument(1), | |
| 1422 type_argument(2), | |
| 1423 changes); | |
| 1424 break; | |
| 1425 case exclusive_concrete_methods_2: | |
| 1426 witness = check_exclusive_concrete_methods(context_type(), | |
| 1427 method_argument(1), | |
| 1428 method_argument(2), | |
| 1429 changes); | |
| 1430 break; | |
| 1431 case no_finalizable_subclasses: | |
| 1432 witness = check_has_no_finalizable_subclasses(context_type(), | |
| 1433 changes); | |
| 1434 break; | |
| 1435 default: | |
| 1436 witness = NULL; | |
| 1437 ShouldNotReachHere(); | |
| 1438 break; | |
| 1439 } | |
| 1440 if (witness != NULL) { | |
| 1441 if (TraceDependencies) { | |
| 1442 print_dependency(witness, /*verbose=*/ true); | |
| 1443 } | |
| 1444 // The following is a no-op unless logging is enabled: | |
| 1445 log_dependency(witness); | |
| 1446 } | |
| 1447 return witness; | |
| 1448 } | |
| 1449 | |
| 1450 | |
| 1451 klassOop Dependencies::DepStream::spot_check_dependency_at(DepChange& changes) { | |
| 1452 if (!changes.involves_context(context_type())) | |
| 1453 // irrelevant dependency; skip it | |
| 1454 return NULL; | |
| 1455 | |
| 1456 return check_dependency_impl(&changes); | |
| 1457 } | |
| 1458 | |
| 1459 | |
| 1460 void DepChange::initialize() { | |
| 1461 // entire transaction must be under this lock: | |
| 1462 assert_lock_strong(Compile_lock); | |
| 1463 | |
| 1464 // Mark all dependee and all its superclasses | |
| 1465 // Mark transitive interfaces | |
| 1466 for (ContextStream str(*this); str.next(); ) { | |
| 1467 klassOop d = str.klass(); | |
| 1468 assert(!instanceKlass::cast(d)->is_marked_dependent(), "checking"); | |
| 975 | 1469 instanceKlass::cast(d)->set_is_marked_dependent(true); |
| 0 | 1470 } |
| 1471 } | |
| 1472 | |
| 1473 DepChange::~DepChange() { | |
| 1474 // Unmark all dependee and all its superclasses | |
| 1475 // Unmark transitive interfaces | |
| 1476 for (ContextStream str(*this); str.next(); ) { | |
| 1477 klassOop d = str.klass(); | |
| 975 | 1478 instanceKlass::cast(d)->set_is_marked_dependent(false); |
| 0 | 1479 } |
| 1480 } | |
| 1481 | |
| 1482 bool DepChange::involves_context(klassOop k) { | |
| 1483 if (k == NULL || !Klass::cast(k)->oop_is_instance()) { | |
| 1484 return false; | |
| 1485 } | |
| 1486 instanceKlass* ik = instanceKlass::cast(k); | |
| 1487 bool is_contained = ik->is_marked_dependent(); | |
| 1488 assert(is_contained == Klass::cast(new_type())->is_subtype_of(k), | |
| 1489 "correct marking of potential context types"); | |
| 1490 return is_contained; | |
| 1491 } | |
| 1492 | |
| 1493 bool DepChange::ContextStream::next() { | |
| 1494 switch (_change_type) { | |
| 1495 case Start_Klass: // initial state; _klass is the new type | |
| 1496 _ti_base = instanceKlass::cast(_klass)->transitive_interfaces(); | |
| 1497 _ti_index = 0; | |
| 1498 _change_type = Change_new_type; | |
| 1499 return true; | |
| 1500 case Change_new_type: | |
| 1501 // fall through: | |
| 1502 _change_type = Change_new_sub; | |
| 1503 case Change_new_sub: | |
|
54
d4a0f561287a
6598190: JPRT tests fail when run with -XX:+CheckUnhandledOops
sbohne
parents:
0
diff
changeset
|
1504 // 6598190: brackets workaround Sun Studio C++ compiler bug 6629277 |
|
d4a0f561287a
6598190: JPRT tests fail when run with -XX:+CheckUnhandledOops
sbohne
parents:
0
diff
changeset
|
1505 { |
|
d4a0f561287a
6598190: JPRT tests fail when run with -XX:+CheckUnhandledOops
sbohne
parents:
0
diff
changeset
|
1506 _klass = instanceKlass::cast(_klass)->super(); |
|
d4a0f561287a
6598190: JPRT tests fail when run with -XX:+CheckUnhandledOops
sbohne
parents:
0
diff
changeset
|
1507 if (_klass != NULL) { |
|
d4a0f561287a
6598190: JPRT tests fail when run with -XX:+CheckUnhandledOops
sbohne
parents:
0
diff
changeset
|
1508 return true; |
|
d4a0f561287a
6598190: JPRT tests fail when run with -XX:+CheckUnhandledOops
sbohne
parents:
0
diff
changeset
|
1509 } |
| 0 | 1510 } |
| 1511 // else set up _ti_limit and fall through: | |
| 1512 _ti_limit = (_ti_base == NULL) ? 0 : _ti_base->length(); | |
| 1513 _change_type = Change_new_impl; | |
| 1514 case Change_new_impl: | |
| 1515 if (_ti_index < _ti_limit) { | |
| 1516 _klass = klassOop( _ti_base->obj_at(_ti_index++) ); | |
| 1517 return true; | |
| 1518 } | |
| 1519 // fall through: | |
| 1520 _change_type = NO_CHANGE; // iterator is exhausted | |
| 1521 case NO_CHANGE: | |
| 1522 break; | |
| 1523 default: | |
| 1524 ShouldNotReachHere(); | |
| 1525 } | |
| 1526 return false; | |
| 1527 } | |
| 1528 | |
| 1529 void DepChange::print() { | |
| 1530 int nsup = 0, nint = 0; | |
| 1531 for (ContextStream str(*this); str.next(); ) { | |
| 1532 klassOop k = str.klass(); | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1533 switch (str.change_type()) { |
| 0 | 1534 case Change_new_type: |
| 1535 tty->print_cr(" dependee = %s", instanceKlass::cast(k)->external_name()); | |
| 1536 break; | |
| 1537 case Change_new_sub: | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1538 if (!WizardMode) { |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1539 ++nsup; |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1540 } else { |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1541 tty->print_cr(" context super = %s", instanceKlass::cast(k)->external_name()); |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1542 } |
| 0 | 1543 break; |
| 1544 case Change_new_impl: | |
|
1123
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1545 if (!WizardMode) { |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1546 ++nint; |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1547 } else { |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1548 tty->print_cr(" context interface = %s", instanceKlass::cast(k)->external_name()); |
|
167c2986d91b
6843629: Make current hotspot build part of jdk5 control build
phh
parents:
993
diff
changeset
|
1549 } |
| 0 | 1550 break; |
| 1551 } | |
| 1552 } | |
| 1553 if (nsup + nint != 0) { | |
| 1554 tty->print_cr(" context supers = %d, interfaces = %d", nsup, nint); | |
| 1555 } | |
| 1556 } | |
| 1557 | |
| 1558 #ifndef PRODUCT | |
| 1559 void Dependencies::print_statistics() { | |
| 1560 if (deps_find_witness_print != 0) { | |
| 1561 // Call one final time, to flush out the data. | |
| 1562 deps_find_witness_print = -1; | |
| 1563 count_find_witness_calls(); | |
| 1564 } | |
| 1565 } | |
| 1566 #endif |