Mercurial > hg > truffle
comparison src/share/vm/code/dependencies.cpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | 49036505ab5f |
children | 75f33eecc1b3 |
comparison
equal
deleted
inserted
replaced
6724:36d1d483d5d6 | 6725:da91efe96a93 |
---|---|
28 #include "ci/ciKlass.hpp" | 28 #include "ci/ciKlass.hpp" |
29 #include "ci/ciMethod.hpp" | 29 #include "ci/ciMethod.hpp" |
30 #include "code/dependencies.hpp" | 30 #include "code/dependencies.hpp" |
31 #include "compiler/compileLog.hpp" | 31 #include "compiler/compileLog.hpp" |
32 #include "oops/oop.inline.hpp" | 32 #include "oops/oop.inline.hpp" |
33 #include "runtime/handles.hpp" | |
33 #include "runtime/handles.inline.hpp" | 34 #include "runtime/handles.inline.hpp" |
34 #include "utilities/copy.hpp" | 35 #include "utilities/copy.hpp" |
35 | 36 |
36 | 37 |
37 #ifdef ASSERT | 38 #ifdef ASSERT |
49 _oop_recorder = env->oop_recorder(); | 50 _oop_recorder = env->oop_recorder(); |
50 _log = env->log(); | 51 _log = env->log(); |
51 _dep_seen = new(arena) GrowableArray<int>(arena, 500, 0, 0); | 52 _dep_seen = new(arena) GrowableArray<int>(arena, 500, 0, 0); |
52 DEBUG_ONLY(_deps[end_marker] = NULL); | 53 DEBUG_ONLY(_deps[end_marker] = NULL); |
53 for (int i = (int)FIRST_TYPE; i < (int)TYPE_LIMIT; i++) { | 54 for (int i = (int)FIRST_TYPE; i < (int)TYPE_LIMIT; i++) { |
54 _deps[i] = new(arena) GrowableArray<ciObject*>(arena, 10, 0, 0); | 55 _deps[i] = new(arena) GrowableArray<ciBaseObject*>(arena, 10, 0, 0); |
55 } | 56 } |
56 _content_bytes = NULL; | 57 _content_bytes = NULL; |
57 _size_in_bytes = (size_t)-1; | 58 _size_in_bytes = (size_t)-1; |
58 | 59 |
59 assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT), "sanity"); | 60 assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT), "sanity"); |
119 } | 120 } |
120 | 121 |
121 // Helper function. If we are adding a new dep. under ctxk2, | 122 // Helper function. If we are adding a new dep. under ctxk2, |
122 // try to find an old dep. under a broader* ctxk1. If there is | 123 // try to find an old dep. under a broader* ctxk1. If there is |
123 // | 124 // |
124 bool Dependencies::maybe_merge_ctxk(GrowableArray<ciObject*>* deps, | 125 bool Dependencies::maybe_merge_ctxk(GrowableArray<ciBaseObject*>* deps, |
125 int ctxk_i, ciKlass* ctxk2) { | 126 int ctxk_i, ciKlass* ctxk2) { |
126 ciKlass* ctxk1 = deps->at(ctxk_i)->as_klass(); | 127 ciKlass* ctxk1 = deps->at(ctxk_i)->as_metadata()->as_klass(); |
127 if (ctxk2->is_subtype_of(ctxk1)) { | 128 if (ctxk2->is_subtype_of(ctxk1)) { |
128 return true; // success, and no need to change | 129 return true; // success, and no need to change |
129 } else if (ctxk1->is_subtype_of(ctxk2)) { | 130 } else if (ctxk1->is_subtype_of(ctxk2)) { |
130 // new context class fully subsumes previous one | 131 // new context class fully subsumes previous one |
131 deps->at_put(ctxk_i, ctxk2); | 132 deps->at_put(ctxk_i, ctxk2); |
133 } else { | 134 } else { |
134 return false; | 135 return false; |
135 } | 136 } |
136 } | 137 } |
137 | 138 |
138 void Dependencies::assert_common_1(DepType dept, ciObject* x) { | 139 void Dependencies::assert_common_1(DepType dept, ciBaseObject* x) { |
139 assert(dep_args(dept) == 1, "sanity"); | 140 assert(dep_args(dept) == 1, "sanity"); |
140 log_dependency(dept, x); | 141 log_dependency(dept, x); |
141 GrowableArray<ciObject*>* deps = _deps[dept]; | 142 GrowableArray<ciBaseObject*>* deps = _deps[dept]; |
142 | 143 |
143 // see if the same (or a similar) dep is already recorded | 144 // see if the same (or a similar) dep is already recorded |
144 if (note_dep_seen(dept, x)) { | 145 if (note_dep_seen(dept, x)) { |
145 assert(deps->find(x) >= 0, "sanity"); | 146 assert(deps->find(x) >= 0, "sanity"); |
146 } else { | 147 } else { |
147 deps->append(x); | 148 deps->append(x); |
148 } | 149 } |
149 } | 150 } |
150 | 151 |
151 void Dependencies::assert_common_2(DepType dept, | 152 void Dependencies::assert_common_2(DepType dept, |
152 ciObject* x0, ciObject* x1) { | 153 ciBaseObject* x0, ciBaseObject* x1) { |
153 assert(dep_args(dept) == 2, "sanity"); | 154 assert(dep_args(dept) == 2, "sanity"); |
154 log_dependency(dept, x0, x1); | 155 log_dependency(dept, x0, x1); |
155 GrowableArray<ciObject*>* deps = _deps[dept]; | 156 GrowableArray<ciBaseObject*>* deps = _deps[dept]; |
156 | 157 |
157 // see if the same (or a similar) dep is already recorded | 158 // see if the same (or a similar) dep is already recorded |
158 bool has_ctxk = has_explicit_context_arg(dept); | 159 bool has_ctxk = has_explicit_context_arg(dept); |
159 if (has_ctxk) { | 160 if (has_ctxk) { |
160 assert(dep_context_arg(dept) == 0, "sanity"); | 161 assert(dep_context_arg(dept) == 0, "sanity"); |
161 if (note_dep_seen(dept, x1)) { | 162 if (note_dep_seen(dept, x1)) { |
162 // look in this bucket for redundant assertions | 163 // look in this bucket for redundant assertions |
163 const int stride = 2; | 164 const int stride = 2; |
164 for (int i = deps->length(); (i -= stride) >= 0; ) { | 165 for (int i = deps->length(); (i -= stride) >= 0; ) { |
165 ciObject* y1 = deps->at(i+1); | 166 ciBaseObject* y1 = deps->at(i+1); |
166 if (x1 == y1) { // same subject; check the context | 167 if (x1 == y1) { // same subject; check the context |
167 if (maybe_merge_ctxk(deps, i+0, x0->as_klass())) { | 168 if (maybe_merge_ctxk(deps, i+0, x0->as_metadata()->as_klass())) { |
168 return; | 169 return; |
169 } | 170 } |
170 } | 171 } |
171 } | 172 } |
172 } | 173 } |
174 assert(dep_implicit_context_arg(dept) == 0, "sanity"); | 175 assert(dep_implicit_context_arg(dept) == 0, "sanity"); |
175 if (note_dep_seen(dept, x0) && note_dep_seen(dept, x1)) { | 176 if (note_dep_seen(dept, x0) && note_dep_seen(dept, x1)) { |
176 // look in this bucket for redundant assertions | 177 // look in this bucket for redundant assertions |
177 const int stride = 2; | 178 const int stride = 2; |
178 for (int i = deps->length(); (i -= stride) >= 0; ) { | 179 for (int i = deps->length(); (i -= stride) >= 0; ) { |
179 ciObject* y0 = deps->at(i+0); | 180 ciBaseObject* y0 = deps->at(i+0); |
180 ciObject* y1 = deps->at(i+1); | 181 ciBaseObject* y1 = deps->at(i+1); |
181 if (x0 == y0 && x1 == y1) { | 182 if (x0 == y0 && x1 == y1) { |
182 return; | 183 return; |
183 } | 184 } |
184 } | 185 } |
185 } | 186 } |
189 deps->append(x0); | 190 deps->append(x0); |
190 deps->append(x1); | 191 deps->append(x1); |
191 } | 192 } |
192 | 193 |
193 void Dependencies::assert_common_3(DepType dept, | 194 void Dependencies::assert_common_3(DepType dept, |
194 ciKlass* ctxk, ciObject* x, ciObject* x2) { | 195 ciKlass* ctxk, ciBaseObject* x, ciBaseObject* x2) { |
195 assert(dep_context_arg(dept) == 0, "sanity"); | 196 assert(dep_context_arg(dept) == 0, "sanity"); |
196 assert(dep_args(dept) == 3, "sanity"); | 197 assert(dep_args(dept) == 3, "sanity"); |
197 log_dependency(dept, ctxk, x, x2); | 198 log_dependency(dept, ctxk, x, x2); |
198 GrowableArray<ciObject*>* deps = _deps[dept]; | 199 GrowableArray<ciBaseObject*>* deps = _deps[dept]; |
199 | 200 |
200 // try to normalize an unordered pair: | 201 // try to normalize an unordered pair: |
201 bool swap = false; | 202 bool swap = false; |
202 switch (dept) { | 203 switch (dept) { |
203 case abstract_with_exclusive_concrete_subtypes_2: | 204 case abstract_with_exclusive_concrete_subtypes_2: |
204 swap = (x->ident() > x2->ident() && x != ctxk); | 205 swap = (x->ident() > x2->ident() && x->as_metadata()->as_klass() != ctxk); |
205 break; | 206 break; |
206 case exclusive_concrete_methods_2: | 207 case exclusive_concrete_methods_2: |
207 swap = (x->ident() > x2->ident() && x->as_method()->holder() != ctxk); | 208 swap = (x->ident() > x2->ident() && x->as_metadata()->as_method()->holder() != ctxk); |
208 break; | 209 break; |
209 } | 210 } |
210 if (swap) { ciObject* t = x; x = x2; x2 = t; } | 211 if (swap) { ciBaseObject* t = x; x = x2; x2 = t; } |
211 | 212 |
212 // see if the same (or a similar) dep is already recorded | 213 // see if the same (or a similar) dep is already recorded |
213 if (note_dep_seen(dept, x) && note_dep_seen(dept, x2)) { | 214 if (note_dep_seen(dept, x) && note_dep_seen(dept, x2)) { |
214 // look in this bucket for redundant assertions | 215 // look in this bucket for redundant assertions |
215 const int stride = 3; | 216 const int stride = 3; |
216 for (int i = deps->length(); (i -= stride) >= 0; ) { | 217 for (int i = deps->length(); (i -= stride) >= 0; ) { |
217 ciObject* y = deps->at(i+1); | 218 ciBaseObject* y = deps->at(i+1); |
218 ciObject* y2 = deps->at(i+2); | 219 ciBaseObject* y2 = deps->at(i+2); |
219 if (x == y && x2 == y2) { // same subjects; check the context | 220 if (x == y && x2 == y2) { // same subjects; check the context |
220 if (maybe_merge_ctxk(deps, i+0, ctxk)) { | 221 if (maybe_merge_ctxk(deps, i+0, ctxk)) { |
221 return; | 222 return; |
222 } | 223 } |
223 } | 224 } |
239 (HeapWord*) beg, | 240 (HeapWord*) beg, |
240 size_in_bytes() / sizeof(HeapWord)); | 241 size_in_bytes() / sizeof(HeapWord)); |
241 assert(size_in_bytes() % sizeof(HeapWord) == 0, "copy by words"); | 242 assert(size_in_bytes() % sizeof(HeapWord) == 0, "copy by words"); |
242 } | 243 } |
243 | 244 |
244 static int sort_dep(ciObject** p1, ciObject** p2, int narg) { | 245 static int sort_dep(ciBaseObject** p1, ciBaseObject** p2, int narg) { |
245 for (int i = 0; i < narg; i++) { | 246 for (int i = 0; i < narg; i++) { |
246 int diff = p1[i]->ident() - p2[i]->ident(); | 247 int diff = p1[i]->ident() - p2[i]->ident(); |
247 if (diff != 0) return diff; | 248 if (diff != 0) return diff; |
248 } | 249 } |
249 return 0; | 250 return 0; |
250 } | 251 } |
251 static int sort_dep_arg_1(ciObject** p1, ciObject** p2) | 252 static int sort_dep_arg_1(ciBaseObject** p1, ciBaseObject** p2) |
252 { return sort_dep(p1, p2, 1); } | 253 { return sort_dep(p1, p2, 1); } |
253 static int sort_dep_arg_2(ciObject** p1, ciObject** p2) | 254 static int sort_dep_arg_2(ciBaseObject** p1, ciBaseObject** p2) |
254 { return sort_dep(p1, p2, 2); } | 255 { return sort_dep(p1, p2, 2); } |
255 static int sort_dep_arg_3(ciObject** p1, ciObject** p2) | 256 static int sort_dep_arg_3(ciBaseObject** p1, ciBaseObject** p2) |
256 { return sort_dep(p1, p2, 3); } | 257 { return sort_dep(p1, p2, 3); } |
257 | 258 |
258 void Dependencies::sort_all_deps() { | 259 void Dependencies::sort_all_deps() { |
259 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | 260 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { |
260 DepType dept = (DepType)deptv; | 261 DepType dept = (DepType)deptv; |
261 GrowableArray<ciObject*>* deps = _deps[dept]; | 262 GrowableArray<ciBaseObject*>* deps = _deps[dept]; |
262 if (deps->length() <= 1) continue; | 263 if (deps->length() <= 1) continue; |
263 switch (dep_args(dept)) { | 264 switch (dep_args(dept)) { |
264 case 1: deps->sort(sort_dep_arg_1, 1); break; | 265 case 1: deps->sort(sort_dep_arg_1, 1); break; |
265 case 2: deps->sort(sort_dep_arg_2, 2); break; | 266 case 2: deps->sort(sort_dep_arg_2, 2); break; |
266 case 3: deps->sort(sort_dep_arg_3, 3); break; | 267 case 3: deps->sort(sort_dep_arg_3, 3); break; |
271 | 272 |
272 size_t Dependencies::estimate_size_in_bytes() { | 273 size_t Dependencies::estimate_size_in_bytes() { |
273 size_t est_size = 100; | 274 size_t est_size = 100; |
274 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | 275 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { |
275 DepType dept = (DepType)deptv; | 276 DepType dept = (DepType)deptv; |
276 GrowableArray<ciObject*>* deps = _deps[dept]; | 277 GrowableArray<ciBaseObject*>* deps = _deps[dept]; |
277 est_size += deps->length()*2; // tags and argument(s) | 278 est_size += deps->length()*2; // tags and argument(s) |
278 } | 279 } |
279 return est_size; | 280 return est_size; |
280 } | 281 } |
281 | 282 |
282 ciKlass* Dependencies::ctxk_encoded_as_null(DepType dept, ciObject* x) { | 283 ciKlass* Dependencies::ctxk_encoded_as_null(DepType dept, ciBaseObject* x) { |
283 switch (dept) { | 284 switch (dept) { |
284 case abstract_with_exclusive_concrete_subtypes_2: | 285 case abstract_with_exclusive_concrete_subtypes_2: |
285 return x->as_klass(); | 286 return x->as_metadata()->as_klass(); |
286 case unique_concrete_method: | 287 case unique_concrete_method: |
287 case exclusive_concrete_methods_2: | 288 case exclusive_concrete_methods_2: |
288 return x->as_method()->holder(); | 289 return x->as_metadata()->as_method()->holder(); |
289 } | 290 } |
290 return NULL; // let NULL be NULL | 291 return NULL; // let NULL be NULL |
291 } | 292 } |
292 | 293 |
293 klassOop Dependencies::ctxk_encoded_as_null(DepType dept, oop x) { | 294 Klass* Dependencies::ctxk_encoded_as_null(DepType dept, Metadata* x) { |
294 assert(must_be_in_vm(), "raw oops here"); | 295 assert(must_be_in_vm(), "raw oops here"); |
295 switch (dept) { | 296 switch (dept) { |
296 case abstract_with_exclusive_concrete_subtypes_2: | 297 case abstract_with_exclusive_concrete_subtypes_2: |
297 assert(x->is_klass(), "sanity"); | 298 assert(x->is_klass(), "sanity"); |
298 return (klassOop) x; | 299 return (Klass*) x; |
299 case unique_concrete_method: | 300 case unique_concrete_method: |
300 case exclusive_concrete_methods_2: | 301 case exclusive_concrete_methods_2: |
301 assert(x->is_method(), "sanity"); | 302 assert(x->is_method(), "sanity"); |
302 return ((methodOop)x)->method_holder(); | 303 return ((Method*)x)->method_holder(); |
303 } | 304 } |
304 return NULL; // let NULL be NULL | 305 return NULL; // let NULL be NULL |
305 } | 306 } |
306 | 307 |
307 void Dependencies::encode_content_bytes() { | 308 void Dependencies::encode_content_bytes() { |
310 // cast is safe, no deps can overflow INT_MAX | 311 // cast is safe, no deps can overflow INT_MAX |
311 CompressedWriteStream bytes((int)estimate_size_in_bytes()); | 312 CompressedWriteStream bytes((int)estimate_size_in_bytes()); |
312 | 313 |
313 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | 314 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { |
314 DepType dept = (DepType)deptv; | 315 DepType dept = (DepType)deptv; |
315 GrowableArray<ciObject*>* deps = _deps[dept]; | 316 GrowableArray<ciBaseObject*>* deps = _deps[dept]; |
316 if (deps->length() == 0) continue; | 317 if (deps->length() == 0) continue; |
317 int stride = dep_args(dept); | 318 int stride = dep_args(dept); |
318 int ctxkj = dep_context_arg(dept); // -1 if no context arg | 319 int ctxkj = dep_context_arg(dept); // -1 if no context arg |
319 assert(stride > 0, "sanity"); | 320 assert(stride > 0, "sanity"); |
320 for (int i = 0; i < deps->length(); i += stride) { | 321 for (int i = 0; i < deps->length(); i += stride) { |
321 jbyte code_byte = (jbyte)dept; | 322 jbyte code_byte = (jbyte)dept; |
322 int skipj = -1; | 323 int skipj = -1; |
323 if (ctxkj >= 0 && ctxkj+1 < stride) { | 324 if (ctxkj >= 0 && ctxkj+1 < stride) { |
324 ciKlass* ctxk = deps->at(i+ctxkj+0)->as_klass(); | 325 ciKlass* ctxk = deps->at(i+ctxkj+0)->as_metadata()->as_klass(); |
325 ciObject* x = deps->at(i+ctxkj+1); // following argument | 326 ciBaseObject* x = deps->at(i+ctxkj+1); // following argument |
326 if (ctxk == ctxk_encoded_as_null(dept, x)) { | 327 if (ctxk == ctxk_encoded_as_null(dept, x)) { |
327 skipj = ctxkj; // we win: maybe one less oop to keep track of | 328 skipj = ctxkj; // we win: maybe one less oop to keep track of |
328 code_byte |= default_context_type_bit; | 329 code_byte |= default_context_type_bit; |
329 } | 330 } |
330 } | 331 } |
331 bytes.write_byte(code_byte); | 332 bytes.write_byte(code_byte); |
332 for (int j = 0; j < stride; j++) { | 333 for (int j = 0; j < stride; j++) { |
333 if (j == skipj) continue; | 334 if (j == skipj) continue; |
334 bytes.write_int(_oop_recorder->find_index(deps->at(i+j)->constant_encoding())); | 335 ciBaseObject* v = deps->at(i+j); |
336 if (v->is_object()) { | |
337 bytes.write_int(_oop_recorder->find_index(v->as_object()->constant_encoding())); | |
338 } else { | |
339 ciMetadata* meta = v->as_metadata(); | |
340 bytes.write_int(_oop_recorder->find_index(meta->constant_encoding())); | |
341 } | |
335 } | 342 } |
336 } | 343 } |
337 } | 344 } |
338 | 345 |
339 // write a sentinel byte to mark the end | 346 // write a sentinel byte to mark the end |
395 } | 402 } |
396 | 403 |
397 // for the sake of the compiler log, print out current dependencies: | 404 // for the sake of the compiler log, print out current dependencies: |
398 void Dependencies::log_all_dependencies() { | 405 void Dependencies::log_all_dependencies() { |
399 if (log() == NULL) return; | 406 if (log() == NULL) return; |
400 ciObject* args[max_arg_count]; | 407 ciBaseObject* args[max_arg_count]; |
401 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { | 408 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) { |
402 DepType dept = (DepType)deptv; | 409 DepType dept = (DepType)deptv; |
403 GrowableArray<ciObject*>* deps = _deps[dept]; | 410 GrowableArray<ciBaseObject*>* deps = _deps[dept]; |
404 if (deps->length() == 0) continue; | 411 if (deps->length() == 0) continue; |
405 int stride = dep_args(dept); | 412 int stride = dep_args(dept); |
406 for (int i = 0; i < deps->length(); i += stride) { | 413 for (int i = 0; i < deps->length(); i += stride) { |
407 for (int j = 0; j < stride; j++) { | 414 for (int j = 0; j < stride; j++) { |
408 // flush out the identities before printing | 415 // flush out the identities before printing |
413 } | 420 } |
414 } | 421 } |
415 | 422 |
416 void Dependencies::write_dependency_to(CompileLog* log, | 423 void Dependencies::write_dependency_to(CompileLog* log, |
417 DepType dept, | 424 DepType dept, |
418 int nargs, oop args[], | 425 int nargs, DepArgument args[], |
419 klassOop witness) { | 426 Klass* witness) { |
420 if (log == NULL) { | 427 if (log == NULL) { |
421 return; | 428 return; |
422 } | 429 } |
423 ciEnv* env = ciEnv::current(); | 430 ciEnv* env = ciEnv::current(); |
424 ciObject* ciargs[max_arg_count]; | 431 ciBaseObject* ciargs[max_arg_count]; |
425 assert(nargs <= max_arg_count, "oob"); | 432 assert(nargs <= max_arg_count, "oob"); |
426 for (int j = 0; j < nargs; j++) { | 433 for (int j = 0; j < nargs; j++) { |
427 ciargs[j] = env->get_object(args[j]); | 434 if (args[j].is_oop()) { |
435 ciargs[j] = env->get_object(args[j].oop_value()); | |
436 } else { | |
437 ciargs[j] = env->get_metadata(args[j].metadata_value()); | |
438 } | |
428 } | 439 } |
429 Dependencies::write_dependency_to(log, dept, nargs, ciargs, witness); | 440 Dependencies::write_dependency_to(log, dept, nargs, ciargs, witness); |
430 } | 441 } |
431 | 442 |
432 void Dependencies::write_dependency_to(CompileLog* log, | 443 void Dependencies::write_dependency_to(CompileLog* log, |
433 DepType dept, | 444 DepType dept, |
434 int nargs, ciObject* args[], | 445 int nargs, ciBaseObject* args[], |
435 klassOop witness) { | 446 Klass* witness) { |
436 if (log == NULL) return; | 447 if (log == NULL) return; |
437 assert(nargs <= max_arg_count, "oob"); | 448 assert(nargs <= max_arg_count, "oob"); |
438 int argids[max_arg_count]; | 449 int argids[max_arg_count]; |
439 int ctxkj = dep_context_arg(dept); // -1 if no context arg | 450 int ctxkj = dep_context_arg(dept); // -1 if no context arg |
440 int j; | 451 int j; |
441 for (j = 0; j < nargs; j++) { | 452 for (j = 0; j < nargs; j++) { |
442 argids[j] = log->identify(args[j]); | 453 if (args[j]->is_object()) { |
454 argids[j] = log->identify(args[j]->as_object()); | |
455 } else { | |
456 argids[j] = log->identify(args[j]->as_metadata()); | |
457 } | |
443 } | 458 } |
444 if (witness != NULL) { | 459 if (witness != NULL) { |
445 log->begin_elem("dependency_failed"); | 460 log->begin_elem("dependency_failed"); |
446 } else { | 461 } else { |
447 log->begin_elem("dependency"); | 462 log->begin_elem("dependency"); |
466 log->end_elem(); | 481 log->end_elem(); |
467 } | 482 } |
468 | 483 |
469 void Dependencies::write_dependency_to(xmlStream* xtty, | 484 void Dependencies::write_dependency_to(xmlStream* xtty, |
470 DepType dept, | 485 DepType dept, |
471 int nargs, oop args[], | 486 int nargs, DepArgument args[], |
472 klassOop witness) { | 487 Klass* witness) { |
473 if (xtty == NULL) return; | 488 if (xtty == NULL) return; |
474 ttyLocker ttyl; | 489 ttyLocker ttyl; |
475 int ctxkj = dep_context_arg(dept); // -1 if no context arg | 490 int ctxkj = dep_context_arg(dept); // -1 if no context arg |
476 if (witness != NULL) { | 491 if (witness != NULL) { |
477 xtty->begin_elem("dependency_failed"); | 492 xtty->begin_elem("dependency_failed"); |
478 } else { | 493 } else { |
479 xtty->begin_elem("dependency"); | 494 xtty->begin_elem("dependency"); |
480 } | 495 } |
481 xtty->print(" type='%s'", dep_name(dept)); | 496 xtty->print(" type='%s'", dep_name(dept)); |
482 if (ctxkj >= 0) { | 497 if (ctxkj >= 0) { |
483 xtty->object("ctxk", args[ctxkj]); | 498 xtty->object("ctxk", args[ctxkj].metadata_value()); |
484 } | 499 } |
485 // write remaining arguments, if any. | 500 // write remaining arguments, if any. |
486 for (int j = 0; j < nargs; j++) { | 501 for (int j = 0; j < nargs; j++) { |
487 if (j == ctxkj) continue; // already logged | 502 if (j == ctxkj) continue; // already logged |
488 if (j == 1) { | 503 if (j == 1) { |
489 xtty->object("x", args[j]); | 504 if (args[j].is_oop()) { |
505 xtty->object("x", args[j].oop_value()); | |
506 } else { | |
507 xtty->object("x", args[j].metadata_value()); | |
508 } | |
490 } else { | 509 } else { |
491 char xn[10]; sprintf(xn, "x%d", j); | 510 char xn[10]; sprintf(xn, "x%d", j); |
492 xtty->object(xn, args[j]); | 511 if (args[j].is_oop()) { |
512 xtty->object(xn, args[j].oop_value()); | |
513 } else { | |
514 xtty->object(xn, args[j].metadata_value()); | |
515 } | |
493 } | 516 } |
494 } | 517 } |
495 if (witness != NULL) { | 518 if (witness != NULL) { |
496 xtty->object("witness", witness); | 519 xtty->object("witness", witness); |
497 xtty->stamp(); | 520 xtty->stamp(); |
498 } | 521 } |
499 xtty->end_elem(); | 522 xtty->end_elem(); |
500 } | 523 } |
501 | 524 |
502 void Dependencies::print_dependency(DepType dept, int nargs, oop args[], | 525 void Dependencies::print_dependency(DepType dept, int nargs, DepArgument args[], |
503 klassOop witness) { | 526 Klass* witness) { |
504 ResourceMark rm; | 527 ResourceMark rm; |
505 ttyLocker ttyl; // keep the following output all in one block | 528 ttyLocker ttyl; // keep the following output all in one block |
506 tty->print_cr("%s of type %s", | 529 tty->print_cr("%s of type %s", |
507 (witness == NULL)? "Dependency": "Failed dependency", | 530 (witness == NULL)? "Dependency": "Failed dependency", |
508 dep_name(dept)); | 531 dep_name(dept)); |
509 // print arguments | 532 // print arguments |
510 int ctxkj = dep_context_arg(dept); // -1 if no context arg | 533 int ctxkj = dep_context_arg(dept); // -1 if no context arg |
511 for (int j = 0; j < nargs; j++) { | 534 for (int j = 0; j < nargs; j++) { |
512 oop arg = args[j]; | 535 DepArgument arg = args[j]; |
513 bool put_star = false; | 536 bool put_star = false; |
514 if (arg == NULL) continue; | 537 if (arg.is_null()) continue; |
515 const char* what; | 538 const char* what; |
516 if (j == ctxkj) { | 539 if (j == ctxkj) { |
540 assert(arg.is_metadata(), "must be"); | |
517 what = "context"; | 541 what = "context"; |
518 put_star = !Dependencies::is_concrete_klass((klassOop)arg); | 542 put_star = !Dependencies::is_concrete_klass((Klass*)arg.metadata_value()); |
519 } else if (arg->is_method()) { | 543 } else if (arg.is_method()) { |
520 what = "method "; | 544 what = "method "; |
521 put_star = !Dependencies::is_concrete_method((methodOop)arg); | 545 put_star = !Dependencies::is_concrete_method((Method*)arg.metadata_value()); |
522 } else if (arg->is_klass()) { | 546 } else if (arg.is_klass()) { |
523 what = "class "; | 547 what = "class "; |
524 } else { | 548 } else { |
525 what = "object "; | 549 what = "object "; |
526 } | 550 } |
527 tty->print(" %s = %s", what, (put_star? "*": "")); | 551 tty->print(" %s = %s", what, (put_star? "*": "")); |
528 if (arg->is_klass()) | 552 if (arg.is_klass()) |
529 tty->print("%s", Klass::cast((klassOop)arg)->external_name()); | 553 tty->print("%s", Klass::cast((Klass*)arg.metadata_value())->external_name()); |
554 else if (arg.is_method()) | |
555 ((Method*)arg.metadata_value())->print_value(); | |
530 else | 556 else |
531 arg->print_value(); | 557 ShouldNotReachHere(); // Provide impl for this type. |
532 tty->cr(); | 558 tty->cr(); |
533 } | 559 } |
534 if (witness != NULL) { | 560 if (witness != NULL) { |
535 bool put_star = !Dependencies::is_concrete_klass(witness); | 561 bool put_star = !Dependencies::is_concrete_klass(witness); |
536 tty->print_cr(" witness = %s%s", | 562 tty->print_cr(" witness = %s%s", |
537 (put_star? "*": ""), | 563 (put_star? "*": ""), |
538 Klass::cast(witness)->external_name()); | 564 Klass::cast(witness)->external_name()); |
539 } | 565 } |
540 } | 566 } |
541 | 567 |
542 void Dependencies::DepStream::log_dependency(klassOop witness) { | 568 void Dependencies::DepStream::log_dependency(Klass* witness) { |
543 if (_deps == NULL && xtty == NULL) return; // fast cutout for runtime | 569 if (_deps == NULL && xtty == NULL) return; // fast cutout for runtime |
570 if (type() == call_site_target_value) { | |
571 os::breakpoint(); | |
572 } | |
544 int nargs = argument_count(); | 573 int nargs = argument_count(); |
545 oop args[max_arg_count]; | 574 DepArgument args[max_arg_count]; |
546 for (int j = 0; j < nargs; j++) { | 575 for (int j = 0; j < nargs; j++) { |
576 if (type() == call_site_target_value) { | |
577 args[j] = argument_oop(j); | |
578 } else { | |
547 args[j] = argument(j); | 579 args[j] = argument(j); |
580 } | |
548 } | 581 } |
549 if (_deps != NULL && _deps->log() != NULL) { | 582 if (_deps != NULL && _deps->log() != NULL) { |
550 Dependencies::write_dependency_to(_deps->log(), | 583 Dependencies::write_dependency_to(_deps->log(), |
551 type(), nargs, args, witness); | 584 type(), nargs, args, witness); |
552 } else { | 585 } else { |
553 Dependencies::write_dependency_to(xtty, | 586 Dependencies::write_dependency_to(xtty, |
554 type(), nargs, args, witness); | 587 type(), nargs, args, witness); |
555 } | 588 } |
556 } | 589 } |
557 | 590 |
558 void Dependencies::DepStream::print_dependency(klassOop witness, bool verbose) { | 591 void Dependencies::DepStream::print_dependency(Klass* witness, bool verbose) { |
559 int nargs = argument_count(); | 592 int nargs = argument_count(); |
560 oop args[max_arg_count]; | 593 DepArgument args[max_arg_count]; |
561 for (int j = 0; j < nargs; j++) { | 594 for (int j = 0; j < nargs; j++) { |
562 args[j] = argument(j); | 595 args[j] = argument(j); |
563 } | 596 } |
564 Dependencies::print_dependency(type(), nargs, args, witness); | 597 Dependencies::print_dependency(type(), nargs, args, witness); |
565 if (verbose) { | 598 if (verbose) { |
613 DEBUG_ONLY(_xi[stride] = -1); // help detect overruns | 646 DEBUG_ONLY(_xi[stride] = -1); // help detect overruns |
614 return true; | 647 return true; |
615 } | 648 } |
616 } | 649 } |
617 | 650 |
651 inline Metadata* Dependencies::DepStream::recorded_metadata_at(int i) { | |
652 Metadata* o = NULL; | |
653 if (_code != NULL) { | |
654 o = _code->metadata_at(i); | |
655 } else { | |
656 o = _deps->oop_recorder()->metadata_at(i); | |
657 } | |
658 assert(o == NULL || o->is_metadata(), | |
659 err_msg("Should be perm " PTR_FORMAT, o)); | |
660 return o; | |
661 } | |
662 | |
618 inline oop Dependencies::DepStream::recorded_oop_at(int i) { | 663 inline oop Dependencies::DepStream::recorded_oop_at(int i) { |
619 return (_code != NULL) | 664 return (_code != NULL) |
620 ? _code->oop_at(i) | 665 ? _code->oop_at(i) |
621 : JNIHandles::resolve(_deps->oop_recorder()->handle_at(i)); | 666 : JNIHandles::resolve(_deps->oop_recorder()->oop_at(i)); |
622 } | 667 } |
623 | 668 |
624 oop Dependencies::DepStream::argument(int i) { | 669 Metadata* Dependencies::DepStream::argument(int i) { |
625 return recorded_oop_at(argument_index(i)); | 670 Metadata* result = recorded_metadata_at(argument_index(i)); |
626 } | 671 assert(result == NULL || result->is_klass() || result->is_method(), "must be"); |
627 | 672 return result; |
628 klassOop Dependencies::DepStream::context_type() { | 673 } |
674 | |
675 oop Dependencies::DepStream::argument_oop(int i) { | |
676 oop result = recorded_oop_at(argument_index(i)); | |
677 assert(result == NULL || result->is_oop(), "must be"); | |
678 return result; | |
679 } | |
680 | |
681 Klass* Dependencies::DepStream::context_type() { | |
629 assert(must_be_in_vm(), "raw oops here"); | 682 assert(must_be_in_vm(), "raw oops here"); |
630 | 683 |
631 // Most dependencies have an explicit context type argument. | 684 // Most dependencies have an explicit context type argument. |
632 { | 685 { |
633 int ctxkj = dep_context_arg(_type); // -1 if no explicit context arg | 686 int ctxkj = dep_context_arg(_type); // -1 if no explicit context arg |
634 if (ctxkj >= 0) { | 687 if (ctxkj >= 0) { |
635 oop k = argument(ctxkj); | 688 Metadata* k = argument(ctxkj); |
636 if (k != NULL) { // context type was not compressed away | 689 if (k != NULL) { // context type was not compressed away |
637 assert(k->is_klass(), "type check"); | 690 assert(k->is_klass(), "type check"); |
638 return (klassOop) k; | 691 return (Klass*) k; |
639 } | 692 } |
640 // recompute "default" context type | 693 // recompute "default" context type |
641 return ctxk_encoded_as_null(_type, argument(ctxkj+1)); | 694 return ctxk_encoded_as_null(_type, argument(ctxkj+1)); |
642 } | 695 } |
643 } | 696 } |
645 // Some dependencies are using the klass of the first object | 698 // Some dependencies are using the klass of the first object |
646 // argument as implicit context type (e.g. call_site_target_value). | 699 // argument as implicit context type (e.g. call_site_target_value). |
647 { | 700 { |
648 int ctxkj = dep_implicit_context_arg(_type); | 701 int ctxkj = dep_implicit_context_arg(_type); |
649 if (ctxkj >= 0) { | 702 if (ctxkj >= 0) { |
650 oop k = argument(ctxkj)->klass(); | 703 Klass* k = argument_oop(ctxkj)->klass(); |
651 assert(k->is_klass(), "type check"); | 704 assert(k->is_klass(), "type check"); |
652 return (klassOop) k; | 705 return (Klass*) k; |
653 } | 706 } |
654 } | 707 } |
655 | 708 |
656 // And some dependencies don't have a context type at all, | 709 // And some dependencies don't have a context type at all, |
657 // e.g. evol_method. | 710 // e.g. evol_method. |
673 // optional method descriptor to check for: | 726 // optional method descriptor to check for: |
674 Symbol* _name; | 727 Symbol* _name; |
675 Symbol* _signature; | 728 Symbol* _signature; |
676 | 729 |
677 // special classes which are not allowed to be witnesses: | 730 // special classes which are not allowed to be witnesses: |
678 klassOop _participants[PARTICIPANT_LIMIT+1]; | 731 Klass* _participants[PARTICIPANT_LIMIT+1]; |
679 int _num_participants; | 732 int _num_participants; |
680 | 733 |
681 // cache of method lookups | 734 // cache of method lookups |
682 methodOop _found_methods[PARTICIPANT_LIMIT+1]; | 735 Method* _found_methods[PARTICIPANT_LIMIT+1]; |
683 | 736 |
684 // if non-zero, tells how many witnesses to convert to participants | 737 // if non-zero, tells how many witnesses to convert to participants |
685 int _record_witnesses; | 738 int _record_witnesses; |
686 | 739 |
687 void initialize(klassOop participant) { | 740 void initialize(Klass* participant) { |
688 _record_witnesses = 0; | 741 _record_witnesses = 0; |
689 _participants[0] = participant; | 742 _participants[0] = participant; |
690 _found_methods[0] = NULL; | 743 _found_methods[0] = NULL; |
691 _num_participants = 0; | 744 _num_participants = 0; |
692 if (participant != NULL) { | 745 if (participant != NULL) { |
695 _found_methods[1] = NULL; | 748 _found_methods[1] = NULL; |
696 _num_participants = 1; | 749 _num_participants = 1; |
697 } | 750 } |
698 } | 751 } |
699 | 752 |
700 void initialize_from_method(methodOop m) { | 753 void initialize_from_method(Method* m) { |
701 assert(m != NULL && m->is_method(), "sanity"); | 754 assert(m != NULL && m->is_method(), "sanity"); |
702 _name = m->name(); | 755 _name = m->name(); |
703 _signature = m->signature(); | 756 _signature = m->signature(); |
704 } | 757 } |
705 | 758 |
706 public: | 759 public: |
707 // The walker is initialized to recognize certain methods and/or types | 760 // The walker is initialized to recognize certain methods and/or types |
708 // as friendly participants. | 761 // as friendly participants. |
709 ClassHierarchyWalker(klassOop participant, methodOop m) { | 762 ClassHierarchyWalker(Klass* participant, Method* m) { |
710 initialize_from_method(m); | 763 initialize_from_method(m); |
711 initialize(participant); | 764 initialize(participant); |
712 } | 765 } |
713 ClassHierarchyWalker(methodOop m) { | 766 ClassHierarchyWalker(Method* m) { |
714 initialize_from_method(m); | 767 initialize_from_method(m); |
715 initialize(NULL); | 768 initialize(NULL); |
716 } | 769 } |
717 ClassHierarchyWalker(klassOop participant = NULL) { | 770 ClassHierarchyWalker(Klass* participant = NULL) { |
718 _name = NULL; | 771 _name = NULL; |
719 _signature = NULL; | 772 _signature = NULL; |
720 initialize(participant); | 773 initialize(participant); |
721 } | 774 } |
722 | 775 |
725 bool doing_subtype_search() { | 778 bool doing_subtype_search() { |
726 return _name == NULL; | 779 return _name == NULL; |
727 } | 780 } |
728 | 781 |
729 int num_participants() { return _num_participants; } | 782 int num_participants() { return _num_participants; } |
730 klassOop participant(int n) { | 783 Klass* participant(int n) { |
731 assert((uint)n <= (uint)_num_participants, "oob"); | 784 assert((uint)n <= (uint)_num_participants, "oob"); |
732 return _participants[n]; | 785 return _participants[n]; |
733 } | 786 } |
734 | 787 |
735 // Note: If n==num_participants, returns NULL. | 788 // Note: If n==num_participants, returns NULL. |
736 methodOop found_method(int n) { | 789 Method* found_method(int n) { |
737 assert((uint)n <= (uint)_num_participants, "oob"); | 790 assert((uint)n <= (uint)_num_participants, "oob"); |
738 methodOop fm = _found_methods[n]; | 791 Method* fm = _found_methods[n]; |
739 assert(n == _num_participants || fm != NULL, "proper usage"); | 792 assert(n == _num_participants || fm != NULL, "proper usage"); |
740 assert(fm == NULL || fm->method_holder() == _participants[n], "sanity"); | 793 assert(fm == NULL || fm->method_holder() == _participants[n], "sanity"); |
741 return fm; | 794 return fm; |
742 } | 795 } |
743 | 796 |
744 #ifdef ASSERT | 797 #ifdef ASSERT |
745 // Assert that m is inherited into ctxk, without intervening overrides. | 798 // Assert that m is inherited into ctxk, without intervening overrides. |
746 // (May return true even if this is not true, in corner cases where we punt.) | 799 // (May return true even if this is not true, in corner cases where we punt.) |
747 bool check_method_context(klassOop ctxk, methodOop m) { | 800 bool check_method_context(Klass* ctxk, Method* m) { |
748 if (m->method_holder() == ctxk) | 801 if (m->method_holder() == ctxk) |
749 return true; // Quick win. | 802 return true; // Quick win. |
750 if (m->is_private()) | 803 if (m->is_private()) |
751 return false; // Quick lose. Should not happen. | 804 return false; // Quick lose. Should not happen. |
752 if (!(m->is_public() || m->is_protected())) | 805 if (!(m->is_public() || m->is_protected())) |
753 // The override story is complex when packages get involved. | 806 // The override story is complex when packages get involved. |
754 return true; // Must punt the assertion to true. | 807 return true; // Must punt the assertion to true. |
755 Klass* k = Klass::cast(ctxk); | 808 Klass* k = Klass::cast(ctxk); |
756 methodOop lm = k->lookup_method(m->name(), m->signature()); | 809 Method* lm = k->lookup_method(m->name(), m->signature()); |
757 if (lm == NULL && k->oop_is_instance()) { | 810 if (lm == NULL && k->oop_is_instance()) { |
758 // It might be an abstract interface method, devoid of mirandas. | 811 // It might be an abstract interface method, devoid of mirandas. |
759 lm = ((instanceKlass*)k)->lookup_method_in_all_interfaces(m->name(), | 812 lm = ((InstanceKlass*)k)->lookup_method_in_all_interfaces(m->name(), |
760 m->signature()); | 813 m->signature()); |
761 } | 814 } |
762 if (lm == m) | 815 if (lm == m) |
763 // Method m is inherited into ctxk. | 816 // Method m is inherited into ctxk. |
764 return true; | 817 return true; |
786 } | 839 } |
787 return false; | 840 return false; |
788 } | 841 } |
789 #endif | 842 #endif |
790 | 843 |
791 void add_participant(klassOop participant) { | 844 void add_participant(Klass* participant) { |
792 assert(_num_participants + _record_witnesses < PARTICIPANT_LIMIT, "oob"); | 845 assert(_num_participants + _record_witnesses < PARTICIPANT_LIMIT, "oob"); |
793 int np = _num_participants++; | 846 int np = _num_participants++; |
794 _participants[np] = participant; | 847 _participants[np] = participant; |
795 _participants[np+1] = NULL; | 848 _participants[np+1] = NULL; |
796 _found_methods[np+1] = NULL; | 849 _found_methods[np+1] = NULL; |
800 if (add > PARTICIPANT_LIMIT) add = PARTICIPANT_LIMIT; | 853 if (add > PARTICIPANT_LIMIT) add = PARTICIPANT_LIMIT; |
801 assert(_num_participants + add < PARTICIPANT_LIMIT, "oob"); | 854 assert(_num_participants + add < PARTICIPANT_LIMIT, "oob"); |
802 _record_witnesses = add; | 855 _record_witnesses = add; |
803 } | 856 } |
804 | 857 |
805 bool is_witness(klassOop k) { | 858 bool is_witness(Klass* k) { |
806 if (doing_subtype_search()) { | 859 if (doing_subtype_search()) { |
807 return Dependencies::is_concrete_klass(k); | 860 return Dependencies::is_concrete_klass(k); |
808 } else { | 861 } else { |
809 methodOop m = instanceKlass::cast(k)->find_method(_name, _signature); | 862 Method* m = InstanceKlass::cast(k)->find_method(_name, _signature); |
810 if (m == NULL || !Dependencies::is_concrete_method(m)) return false; | 863 if (m == NULL || !Dependencies::is_concrete_method(m)) return false; |
811 _found_methods[_num_participants] = m; | 864 _found_methods[_num_participants] = m; |
812 // Note: If add_participant(k) is called, | 865 // Note: If add_participant(k) is called, |
813 // the method m will already be memoized for it. | 866 // the method m will already be memoized for it. |
814 return true; | 867 return true; |
815 } | 868 } |
816 } | 869 } |
817 | 870 |
818 bool is_participant(klassOop k) { | 871 bool is_participant(Klass* k) { |
819 if (k == _participants[0]) { | 872 if (k == _participants[0]) { |
820 return true; | 873 return true; |
821 } else if (_num_participants <= 1) { | 874 } else if (_num_participants <= 1) { |
822 return false; | 875 return false; |
823 } else { | 876 } else { |
824 return in_list(k, &_participants[1]); | 877 return in_list(k, &_participants[1]); |
825 } | 878 } |
826 } | 879 } |
827 bool ignore_witness(klassOop witness) { | 880 bool ignore_witness(Klass* witness) { |
828 if (_record_witnesses == 0) { | 881 if (_record_witnesses == 0) { |
829 return false; | 882 return false; |
830 } else { | 883 } else { |
831 --_record_witnesses; | 884 --_record_witnesses; |
832 add_participant(witness); | 885 add_participant(witness); |
833 return true; | 886 return true; |
834 } | 887 } |
835 } | 888 } |
836 static bool in_list(klassOop x, klassOop* list) { | 889 static bool in_list(Klass* x, Klass** list) { |
837 for (int i = 0; ; i++) { | 890 for (int i = 0; ; i++) { |
838 klassOop y = list[i]; | 891 Klass* y = list[i]; |
839 if (y == NULL) break; | 892 if (y == NULL) break; |
840 if (y == x) return true; | 893 if (y == x) return true; |
841 } | 894 } |
842 return false; // not in list | 895 return false; // not in list |
843 } | 896 } |
844 | 897 |
845 private: | 898 private: |
846 // the actual search method: | 899 // the actual search method: |
847 klassOop find_witness_anywhere(klassOop context_type, | 900 Klass* find_witness_anywhere(Klass* context_type, |
848 bool participants_hide_witnesses, | 901 bool participants_hide_witnesses, |
849 bool top_level_call = true); | 902 bool top_level_call = true); |
850 // the spot-checking version: | 903 // the spot-checking version: |
851 klassOop find_witness_in(KlassDepChange& changes, | 904 Klass* find_witness_in(KlassDepChange& changes, |
852 klassOop context_type, | 905 Klass* context_type, |
853 bool participants_hide_witnesses); | 906 bool participants_hide_witnesses); |
854 public: | 907 public: |
855 klassOop find_witness_subtype(klassOop context_type, KlassDepChange* changes = NULL) { | 908 Klass* find_witness_subtype(Klass* context_type, KlassDepChange* changes = NULL) { |
856 assert(doing_subtype_search(), "must set up a subtype search"); | 909 assert(doing_subtype_search(), "must set up a subtype search"); |
857 // When looking for unexpected concrete types, | 910 // When looking for unexpected concrete types, |
858 // do not look beneath expected ones. | 911 // do not look beneath expected ones. |
859 const bool participants_hide_witnesses = true; | 912 const bool participants_hide_witnesses = true; |
860 // CX > CC > C' is OK, even if C' is new. | 913 // CX > CC > C' is OK, even if C' is new. |
863 return find_witness_in(*changes, context_type, participants_hide_witnesses); | 916 return find_witness_in(*changes, context_type, participants_hide_witnesses); |
864 } else { | 917 } else { |
865 return find_witness_anywhere(context_type, participants_hide_witnesses); | 918 return find_witness_anywhere(context_type, participants_hide_witnesses); |
866 } | 919 } |
867 } | 920 } |
868 klassOop find_witness_definer(klassOop context_type, KlassDepChange* changes = NULL) { | 921 Klass* find_witness_definer(Klass* context_type, KlassDepChange* changes = NULL) { |
869 assert(!doing_subtype_search(), "must set up a method definer search"); | 922 assert(!doing_subtype_search(), "must set up a method definer search"); |
870 // When looking for unexpected concrete methods, | 923 // When looking for unexpected concrete methods, |
871 // look beneath expected ones, to see if there are overrides. | 924 // look beneath expected ones, to see if there are overrides. |
872 const bool participants_hide_witnesses = true; | 925 const bool participants_hide_witnesses = true; |
873 // CX.m > CC.m > C'.m is not OK, if C'.m is new, and C' is the witness. | 926 // CX.m > CC.m > C'.m is not OK, if C'.m is new, and C' is the witness. |
924 #else | 977 #else |
925 #define count_find_witness_calls() (0) | 978 #define count_find_witness_calls() (0) |
926 #endif //PRODUCT | 979 #endif //PRODUCT |
927 | 980 |
928 | 981 |
929 klassOop ClassHierarchyWalker::find_witness_in(KlassDepChange& changes, | 982 Klass* ClassHierarchyWalker::find_witness_in(KlassDepChange& changes, |
930 klassOop context_type, | 983 Klass* context_type, |
931 bool participants_hide_witnesses) { | 984 bool participants_hide_witnesses) { |
932 assert(changes.involves_context(context_type), "irrelevant dependency"); | 985 assert(changes.involves_context(context_type), "irrelevant dependency"); |
933 klassOop new_type = changes.new_type(); | 986 Klass* new_type = changes.new_type(); |
934 | 987 |
935 count_find_witness_calls(); | 988 count_find_witness_calls(); |
936 NOT_PRODUCT(deps_find_witness_singles++); | 989 NOT_PRODUCT(deps_find_witness_singles++); |
937 | 990 |
938 // Current thread must be in VM (not native mode, as in CI): | 991 // Current thread must be in VM (not native mode, as in CI): |
939 assert(must_be_in_vm(), "raw oops here"); | 992 assert(must_be_in_vm(), "raw oops here"); |
940 // Must not move the class hierarchy during this check: | 993 // Must not move the class hierarchy during this check: |
941 assert_locked_or_safepoint(Compile_lock); | 994 assert_locked_or_safepoint(Compile_lock); |
942 | 995 |
943 int nof_impls = instanceKlass::cast(context_type)->nof_implementors(); | 996 int nof_impls = InstanceKlass::cast(context_type)->nof_implementors(); |
944 if (nof_impls > 1) { | 997 if (nof_impls > 1) { |
945 // Avoid this case: *I.m > { A.m, C }; B.m > C | 998 // Avoid this case: *I.m > { A.m, C }; B.m > C |
946 // %%% Until this is fixed more systematically, bail out. | 999 // %%% Until this is fixed more systematically, bail out. |
947 // See corresponding comment in find_witness_anywhere. | 1000 // See corresponding comment in find_witness_anywhere. |
948 return context_type; | 1001 return context_type; |
950 | 1003 |
951 assert(!is_participant(new_type), "only old classes are participants"); | 1004 assert(!is_participant(new_type), "only old classes are participants"); |
952 if (participants_hide_witnesses) { | 1005 if (participants_hide_witnesses) { |
953 // If the new type is a subtype of a participant, we are done. | 1006 // If the new type is a subtype of a participant, we are done. |
954 for (int i = 0; i < num_participants(); i++) { | 1007 for (int i = 0; i < num_participants(); i++) { |
955 klassOop part = participant(i); | 1008 Klass* part = participant(i); |
956 if (part == NULL) continue; | 1009 if (part == NULL) continue; |
957 assert(changes.involves_context(part) == Klass::cast(new_type)->is_subtype_of(part), | 1010 assert(changes.involves_context(part) == Klass::cast(new_type)->is_subtype_of(part), |
958 "correct marking of participants, b/c new_type is unique"); | 1011 "correct marking of participants, b/c new_type is unique"); |
959 if (changes.involves_context(part)) { | 1012 if (changes.involves_context(part)) { |
960 // new guy is protected from this check by previous participant | 1013 // new guy is protected from this check by previous participant |
975 // Walk hierarchy under a context type, looking for unexpected types. | 1028 // Walk hierarchy under a context type, looking for unexpected types. |
976 // Do not report participant types, and recursively walk beneath | 1029 // Do not report participant types, and recursively walk beneath |
977 // them only if participants_hide_witnesses is false. | 1030 // them only if participants_hide_witnesses is false. |
978 // If top_level_call is false, skip testing the context type, | 1031 // If top_level_call is false, skip testing the context type, |
979 // because the caller has already considered it. | 1032 // because the caller has already considered it. |
980 klassOop ClassHierarchyWalker::find_witness_anywhere(klassOop context_type, | 1033 Klass* ClassHierarchyWalker::find_witness_anywhere(Klass* context_type, |
981 bool participants_hide_witnesses, | 1034 bool participants_hide_witnesses, |
982 bool top_level_call) { | 1035 bool top_level_call) { |
983 // Current thread must be in VM (not native mode, as in CI): | 1036 // Current thread must be in VM (not native mode, as in CI): |
984 assert(must_be_in_vm(), "raw oops here"); | 1037 assert(must_be_in_vm(), "raw oops here"); |
985 // Must not move the class hierarchy during this check: | 1038 // Must not move the class hierarchy during this check: |
1003 } | 1056 } |
1004 | 1057 |
1005 // Now we must check each implementor and each subclass. | 1058 // Now we must check each implementor and each subclass. |
1006 // Use a short worklist to avoid blowing the stack. | 1059 // Use a short worklist to avoid blowing the stack. |
1007 // Each worklist entry is a *chain* of subklass siblings to process. | 1060 // Each worklist entry is a *chain* of subklass siblings to process. |
1008 const int CHAINMAX = 100; // >= 1 + instanceKlass::implementors_limit | 1061 const int CHAINMAX = 100; // >= 1 + InstanceKlass::implementors_limit |
1009 Klass* chains[CHAINMAX]; | 1062 Klass* chains[CHAINMAX]; |
1010 int chaini = 0; // index into worklist | 1063 int chaini = 0; // index into worklist |
1011 Klass* chain; // scratch variable | 1064 Klass* chain; // scratch variable |
1012 #define ADD_SUBCLASS_CHAIN(k) { \ | 1065 #define ADD_SUBCLASS_CHAIN(k) { \ |
1013 assert(chaini < CHAINMAX, "oob"); \ | 1066 assert(chaini < CHAINMAX, "oob"); \ |
1014 chain = instanceKlass::cast(k)->subklass(); \ | 1067 chain = InstanceKlass::cast(k)->subklass(); \ |
1015 if (chain != NULL) chains[chaini++] = chain; } | 1068 if (chain != NULL) chains[chaini++] = chain; } |
1016 | 1069 |
1017 // Look for non-abstract subclasses. | 1070 // Look for non-abstract subclasses. |
1018 // (Note: Interfaces do not have subclasses.) | 1071 // (Note: Interfaces do not have subclasses.) |
1019 ADD_SUBCLASS_CHAIN(context_type); | 1072 ADD_SUBCLASS_CHAIN(context_type); |
1020 | 1073 |
1021 // If it is an interface, search its direct implementors. | 1074 // If it is an interface, search its direct implementors. |
1022 // (Their subclasses are additional indirect implementors. | 1075 // (Their subclasses are additional indirect implementors. |
1023 // See instanceKlass::add_implementor.) | 1076 // See InstanceKlass::add_implementor.) |
1024 // (Note: nof_implementors is always zero for non-interfaces.) | 1077 // (Note: nof_implementors is always zero for non-interfaces.) |
1025 int nof_impls = instanceKlass::cast(context_type)->nof_implementors(); | 1078 int nof_impls = InstanceKlass::cast(context_type)->nof_implementors(); |
1026 if (nof_impls > 1) { | 1079 if (nof_impls > 1) { |
1027 // Avoid this case: *I.m > { A.m, C }; B.m > C | 1080 // Avoid this case: *I.m > { A.m, C }; B.m > C |
1028 // Here, I.m has 2 concrete implementations, but m appears unique | 1081 // Here, I.m has 2 concrete implementations, but m appears unique |
1029 // as A.m, because the search misses B.m when checking C. | 1082 // as A.m, because the search misses B.m when checking C. |
1030 // The inherited method B.m was getting missed by the walker | 1083 // The inherited method B.m was getting missed by the walker |
1032 // %%% Until this is fixed more systematically, bail out. | 1085 // %%% Until this is fixed more systematically, bail out. |
1033 // (Old CHA had the same limitation.) | 1086 // (Old CHA had the same limitation.) |
1034 return context_type; | 1087 return context_type; |
1035 } | 1088 } |
1036 if (nof_impls > 0) { | 1089 if (nof_impls > 0) { |
1037 klassOop impl = instanceKlass::cast(context_type)->implementor(); | 1090 Klass* impl = InstanceKlass::cast(context_type)->implementor(); |
1038 assert(impl != NULL, "just checking"); | 1091 assert(impl != NULL, "just checking"); |
1039 // If impl is the same as the context_type, then more than one | 1092 // If impl is the same as the context_type, then more than one |
1040 // implementor has seen. No exact info in this case. | 1093 // implementor has seen. No exact info in this case. |
1041 if (impl == context_type) { | 1094 if (impl == context_type) { |
1042 return context_type; // report an inexact witness to this sad affair | 1095 return context_type; // report an inexact witness to this sad affair |
1055 } | 1108 } |
1056 | 1109 |
1057 // Recursively process each non-trivial sibling chain. | 1110 // Recursively process each non-trivial sibling chain. |
1058 while (chaini > 0) { | 1111 while (chaini > 0) { |
1059 Klass* chain = chains[--chaini]; | 1112 Klass* chain = chains[--chaini]; |
1060 for (Klass* subk = chain; subk != NULL; subk = subk->next_sibling()) { | 1113 for (Klass* sub = chain; sub != NULL; sub = sub->next_sibling()) { |
1061 klassOop sub = subk->as_klassOop(); | |
1062 if (do_counts) { NOT_PRODUCT(deps_find_witness_steps++); } | 1114 if (do_counts) { NOT_PRODUCT(deps_find_witness_steps++); } |
1063 if (is_participant(sub)) { | 1115 if (is_participant(sub)) { |
1064 if (participants_hide_witnesses) continue; | 1116 if (participants_hide_witnesses) continue; |
1065 // else fall through to process this guy's subclasses | 1117 // else fall through to process this guy's subclasses |
1066 } else if (is_witness(sub) && !ignore_witness(sub)) { | 1118 } else if (is_witness(sub) && !ignore_witness(sub)) { |
1074 // The recursive call will have its own worklist, of course. | 1126 // The recursive call will have its own worklist, of course. |
1075 // (Note that sub has already been tested, so that there is | 1127 // (Note that sub has already been tested, so that there is |
1076 // no need for the recursive call to re-test. That's handy, | 1128 // no need for the recursive call to re-test. That's handy, |
1077 // since the recursive call sees sub as the context_type.) | 1129 // since the recursive call sees sub as the context_type.) |
1078 if (do_counts) { NOT_PRODUCT(deps_find_witness_recursions++); } | 1130 if (do_counts) { NOT_PRODUCT(deps_find_witness_recursions++); } |
1079 klassOop witness = find_witness_anywhere(sub, | 1131 Klass* witness = find_witness_anywhere(sub, |
1080 participants_hide_witnesses, | 1132 participants_hide_witnesses, |
1081 /*top_level_call=*/ false); | 1133 /*top_level_call=*/ false); |
1082 if (witness != NULL) return witness; | 1134 if (witness != NULL) return witness; |
1083 } | 1135 } |
1084 } | 1136 } |
1088 return NULL; | 1140 return NULL; |
1089 #undef ADD_SUBCLASS_CHAIN | 1141 #undef ADD_SUBCLASS_CHAIN |
1090 } | 1142 } |
1091 | 1143 |
1092 | 1144 |
1093 bool Dependencies::is_concrete_klass(klassOop k) { | 1145 bool Dependencies::is_concrete_klass(Klass* k) { |
1094 if (Klass::cast(k)->is_abstract()) return false; | 1146 if (Klass::cast(k)->is_abstract()) return false; |
1095 // %%% We could treat classes which are concrete but | 1147 // %%% We could treat classes which are concrete but |
1096 // have not yet been instantiated as virtually abstract. | 1148 // have not yet been instantiated as virtually abstract. |
1097 // This would require a deoptimization barrier on first instantiation. | 1149 // This would require a deoptimization barrier on first instantiation. |
1098 //if (k->is_not_instantiated()) return false; | 1150 //if (k->is_not_instantiated()) return false; |
1099 return true; | 1151 return true; |
1100 } | 1152 } |
1101 | 1153 |
1102 bool Dependencies::is_concrete_method(methodOop m) { | 1154 bool Dependencies::is_concrete_method(Method* m) { |
1103 // Statics are irrelevant to virtual call sites. | 1155 // Statics are irrelevant to virtual call sites. |
1104 if (m->is_static()) return false; | 1156 if (m->is_static()) return false; |
1105 | 1157 |
1106 // We could also return false if m does not yet appear to be | 1158 // We could also return false if m does not yet appear to be |
1107 // executed, if the VM version supports this distinction also. | 1159 // executed, if the VM version supports this distinction also. |
1146 | 1198 |
1147 | 1199 |
1148 // Any use of the contents (bytecodes) of a method must be | 1200 // Any use of the contents (bytecodes) of a method must be |
1149 // marked by an "evol_method" dependency, if those contents | 1201 // marked by an "evol_method" dependency, if those contents |
1150 // can change. (Note: A method is always dependent on itself.) | 1202 // can change. (Note: A method is always dependent on itself.) |
1151 klassOop Dependencies::check_evol_method(methodOop m) { | 1203 Klass* Dependencies::check_evol_method(Method* m) { |
1152 assert(must_be_in_vm(), "raw oops here"); | 1204 assert(must_be_in_vm(), "raw oops here"); |
1153 // Did somebody do a JVMTI RedefineClasses while our backs were turned? | 1205 // Did somebody do a JVMTI RedefineClasses while our backs were turned? |
1154 // Or is there a now a breakpoint? | 1206 // Or is there a now a breakpoint? |
1155 // (Assumes compiled code cannot handle bkpts; change if UseFastBreakpoints.) | 1207 // (Assumes compiled code cannot handle bkpts; change if UseFastBreakpoints.) |
1156 if (m->is_old() | 1208 if (m->is_old() |
1166 // optimizing checks on reflected types or on array types. | 1218 // optimizing checks on reflected types or on array types. |
1167 // (Checks on types which are derived from real instances | 1219 // (Checks on types which are derived from real instances |
1168 // can be optimized more strongly than this, because we | 1220 // can be optimized more strongly than this, because we |
1169 // know that the checked type comes from a concrete type, | 1221 // know that the checked type comes from a concrete type, |
1170 // and therefore we can disregard abstract types.) | 1222 // and therefore we can disregard abstract types.) |
1171 klassOop Dependencies::check_leaf_type(klassOop ctxk) { | 1223 Klass* Dependencies::check_leaf_type(Klass* ctxk) { |
1172 assert(must_be_in_vm(), "raw oops here"); | 1224 assert(must_be_in_vm(), "raw oops here"); |
1173 assert_locked_or_safepoint(Compile_lock); | 1225 assert_locked_or_safepoint(Compile_lock); |
1174 instanceKlass* ctx = instanceKlass::cast(ctxk); | 1226 InstanceKlass* ctx = InstanceKlass::cast(ctxk); |
1175 Klass* sub = ctx->subklass(); | 1227 Klass* sub = ctx->subklass(); |
1176 if (sub != NULL) { | 1228 if (sub != NULL) { |
1177 return sub->as_klassOop(); | 1229 return sub; |
1178 } else if (ctx->nof_implementors() != 0) { | 1230 } else if (ctx->nof_implementors() != 0) { |
1179 // if it is an interface, it must be unimplemented | 1231 // if it is an interface, it must be unimplemented |
1180 // (if it is not an interface, nof_implementors is always zero) | 1232 // (if it is not an interface, nof_implementors is always zero) |
1181 klassOop impl = ctx->implementor(); | 1233 Klass* impl = ctx->implementor(); |
1182 assert(impl != NULL, "must be set"); | 1234 assert(impl != NULL, "must be set"); |
1183 return impl; | 1235 return impl; |
1184 } else { | 1236 } else { |
1185 return NULL; | 1237 return NULL; |
1186 } | 1238 } |
1188 | 1240 |
1189 // Test the assertion that conck is the only concrete subtype* of ctxk. | 1241 // Test the assertion that conck is the only concrete subtype* of ctxk. |
1190 // The type conck itself is allowed to have have further concrete subtypes. | 1242 // The type conck itself is allowed to have have further concrete subtypes. |
1191 // This allows the compiler to narrow occurrences of ctxk by conck, | 1243 // This allows the compiler to narrow occurrences of ctxk by conck, |
1192 // when dealing with the types of actual instances. | 1244 // when dealing with the types of actual instances. |
1193 klassOop Dependencies::check_abstract_with_unique_concrete_subtype(klassOop ctxk, | 1245 Klass* Dependencies::check_abstract_with_unique_concrete_subtype(Klass* ctxk, |
1194 klassOop conck, | 1246 Klass* conck, |
1195 KlassDepChange* changes) { | 1247 KlassDepChange* changes) { |
1196 ClassHierarchyWalker wf(conck); | 1248 ClassHierarchyWalker wf(conck); |
1197 return wf.find_witness_subtype(ctxk, changes); | 1249 return wf.find_witness_subtype(ctxk, changes); |
1198 } | 1250 } |
1199 | 1251 |
1200 // If a non-concrete class has no concrete subtypes, it is not (yet) | 1252 // If a non-concrete class has no concrete subtypes, it is not (yet) |
1201 // instantiatable. This can allow the compiler to make some paths go | 1253 // instantiatable. This can allow the compiler to make some paths go |
1202 // dead, if they are gated by a test of the type. | 1254 // dead, if they are gated by a test of the type. |
1203 klassOop Dependencies::check_abstract_with_no_concrete_subtype(klassOop ctxk, | 1255 Klass* Dependencies::check_abstract_with_no_concrete_subtype(Klass* ctxk, |
1204 KlassDepChange* changes) { | 1256 KlassDepChange* changes) { |
1205 // Find any concrete subtype, with no participants: | 1257 // Find any concrete subtype, with no participants: |
1206 ClassHierarchyWalker wf; | 1258 ClassHierarchyWalker wf; |
1207 return wf.find_witness_subtype(ctxk, changes); | 1259 return wf.find_witness_subtype(ctxk, changes); |
1208 } | 1260 } |
1209 | 1261 |
1210 | 1262 |
1211 // If a concrete class has no concrete subtypes, it can always be | 1263 // If a concrete class has no concrete subtypes, it can always be |
1212 // exactly typed. This allows the use of a cheaper type test. | 1264 // exactly typed. This allows the use of a cheaper type test. |
1213 klassOop Dependencies::check_concrete_with_no_concrete_subtype(klassOop ctxk, | 1265 Klass* Dependencies::check_concrete_with_no_concrete_subtype(Klass* ctxk, |
1214 KlassDepChange* changes) { | 1266 KlassDepChange* changes) { |
1215 // Find any concrete subtype, with only the ctxk as participant: | 1267 // Find any concrete subtype, with only the ctxk as participant: |
1216 ClassHierarchyWalker wf(ctxk); | 1268 ClassHierarchyWalker wf(ctxk); |
1217 return wf.find_witness_subtype(ctxk, changes); | 1269 return wf.find_witness_subtype(ctxk, changes); |
1218 } | 1270 } |
1221 // Find the unique concrete proper subtype of ctxk, or NULL if there | 1273 // Find the unique concrete proper subtype of ctxk, or NULL if there |
1222 // is more than one concrete proper subtype. If there are no concrete | 1274 // is more than one concrete proper subtype. If there are no concrete |
1223 // proper subtypes, return ctxk itself, whether it is concrete or not. | 1275 // proper subtypes, return ctxk itself, whether it is concrete or not. |
1224 // The returned subtype is allowed to have have further concrete subtypes. | 1276 // The returned subtype is allowed to have have further concrete subtypes. |
1225 // That is, return CC1 for CX > CC1 > CC2, but NULL for CX > { CC1, CC2 }. | 1277 // That is, return CC1 for CX > CC1 > CC2, but NULL for CX > { CC1, CC2 }. |
1226 klassOop Dependencies::find_unique_concrete_subtype(klassOop ctxk) { | 1278 Klass* Dependencies::find_unique_concrete_subtype(Klass* ctxk) { |
1227 ClassHierarchyWalker wf(ctxk); // Ignore ctxk when walking. | 1279 ClassHierarchyWalker wf(ctxk); // Ignore ctxk when walking. |
1228 wf.record_witnesses(1); // Record one other witness when walking. | 1280 wf.record_witnesses(1); // Record one other witness when walking. |
1229 klassOop wit = wf.find_witness_subtype(ctxk); | 1281 Klass* wit = wf.find_witness_subtype(ctxk); |
1230 if (wit != NULL) return NULL; // Too many witnesses. | 1282 if (wit != NULL) return NULL; // Too many witnesses. |
1231 klassOop conck = wf.participant(0); | 1283 Klass* conck = wf.participant(0); |
1232 if (conck == NULL) { | 1284 if (conck == NULL) { |
1233 #ifndef PRODUCT | 1285 #ifndef PRODUCT |
1234 // Make sure the dependency mechanism will pass this discovery: | 1286 // Make sure the dependency mechanism will pass this discovery: |
1235 if (VerifyDependencies) { | 1287 if (VerifyDependencies) { |
1236 // Turn off dependency tracing while actually testing deps. | 1288 // Turn off dependency tracing while actually testing deps. |
1266 | 1318 |
1267 // Test the assertion that the k[12] are the only concrete subtypes of ctxk, | 1319 // Test the assertion that the k[12] are the only concrete subtypes of ctxk, |
1268 // except possibly for further subtypes of k[12] themselves. | 1320 // except possibly for further subtypes of k[12] themselves. |
1269 // The context type must be abstract. The types k1 and k2 are themselves | 1321 // The context type must be abstract. The types k1 and k2 are themselves |
1270 // allowed to have further concrete subtypes. | 1322 // allowed to have further concrete subtypes. |
1271 klassOop Dependencies::check_abstract_with_exclusive_concrete_subtypes( | 1323 Klass* Dependencies::check_abstract_with_exclusive_concrete_subtypes( |
1272 klassOop ctxk, | 1324 Klass* ctxk, |
1273 klassOop k1, | 1325 Klass* k1, |
1274 klassOop k2, | 1326 Klass* k2, |
1275 KlassDepChange* changes) { | 1327 KlassDepChange* changes) { |
1276 ClassHierarchyWalker wf; | 1328 ClassHierarchyWalker wf; |
1277 wf.add_participant(k1); | 1329 wf.add_participant(k1); |
1278 wf.add_participant(k2); | 1330 wf.add_participant(k2); |
1279 return wf.find_witness_subtype(ctxk, changes); | 1331 return wf.find_witness_subtype(ctxk, changes); |
1283 // pack them into the given array and return the number. | 1335 // pack them into the given array and return the number. |
1284 // Otherwise, return -1, meaning the given array would overflow. | 1336 // Otherwise, return -1, meaning the given array would overflow. |
1285 // (Note that a return of 0 means there are exactly no concrete subtypes.) | 1337 // (Note that a return of 0 means there are exactly no concrete subtypes.) |
1286 // In this search, if ctxk is concrete, it will be reported alone. | 1338 // In this search, if ctxk is concrete, it will be reported alone. |
1287 // For any type CC reported, no proper subtypes of CC will be reported. | 1339 // For any type CC reported, no proper subtypes of CC will be reported. |
1288 int Dependencies::find_exclusive_concrete_subtypes(klassOop ctxk, | 1340 int Dependencies::find_exclusive_concrete_subtypes(Klass* ctxk, |
1289 int klen, | 1341 int klen, |
1290 klassOop karray[]) { | 1342 Klass* karray[]) { |
1291 ClassHierarchyWalker wf; | 1343 ClassHierarchyWalker wf; |
1292 wf.record_witnesses(klen); | 1344 wf.record_witnesses(klen); |
1293 klassOop wit = wf.find_witness_subtype(ctxk); | 1345 Klass* wit = wf.find_witness_subtype(ctxk); |
1294 if (wit != NULL) return -1; // Too many witnesses. | 1346 if (wit != NULL) return -1; // Too many witnesses. |
1295 int num = wf.num_participants(); | 1347 int num = wf.num_participants(); |
1296 assert(num <= klen, "oob"); | 1348 assert(num <= klen, "oob"); |
1297 // Pack the result array with the good news. | 1349 // Pack the result array with the good news. |
1298 for (int i = 0; i < num; i++) | 1350 for (int i = 0; i < num; i++) |
1330 return num; | 1382 return num; |
1331 } | 1383 } |
1332 | 1384 |
1333 // If a class (or interface) has a unique concrete method uniqm, return NULL. | 1385 // If a class (or interface) has a unique concrete method uniqm, return NULL. |
1334 // Otherwise, return a class that contains an interfering method. | 1386 // Otherwise, return a class that contains an interfering method. |
1335 klassOop Dependencies::check_unique_concrete_method(klassOop ctxk, methodOop uniqm, | 1387 Klass* Dependencies::check_unique_concrete_method(Klass* ctxk, Method* uniqm, |
1336 KlassDepChange* changes) { | 1388 KlassDepChange* changes) { |
1337 // Here is a missing optimization: If uniqm->is_final(), | 1389 // Here is a missing optimization: If uniqm->is_final(), |
1338 // we don't really need to search beneath it for overrides. | 1390 // we don't really need to search beneath it for overrides. |
1339 // This is probably not important, since we don't use dependencies | 1391 // This is probably not important, since we don't use dependencies |
1340 // to track final methods. (They can't be "definalized".) | 1392 // to track final methods. (They can't be "definalized".) |
1344 | 1396 |
1345 // Find the set of all non-abstract methods under ctxk that match m. | 1397 // Find the set of all non-abstract methods under ctxk that match m. |
1346 // (The method m must be defined or inherited in ctxk.) | 1398 // (The method m must be defined or inherited in ctxk.) |
1347 // Include m itself in the set, unless it is abstract. | 1399 // Include m itself in the set, unless it is abstract. |
1348 // If this set has exactly one element, return that element. | 1400 // If this set has exactly one element, return that element. |
1349 methodOop Dependencies::find_unique_concrete_method(klassOop ctxk, methodOop m) { | 1401 Method* Dependencies::find_unique_concrete_method(Klass* ctxk, Method* m) { |
1350 ClassHierarchyWalker wf(m); | 1402 ClassHierarchyWalker wf(m); |
1351 assert(wf.check_method_context(ctxk, m), "proper context"); | 1403 assert(wf.check_method_context(ctxk, m), "proper context"); |
1352 wf.record_witnesses(1); | 1404 wf.record_witnesses(1); |
1353 klassOop wit = wf.find_witness_definer(ctxk); | 1405 Klass* wit = wf.find_witness_definer(ctxk); |
1354 if (wit != NULL) return NULL; // Too many witnesses. | 1406 if (wit != NULL) return NULL; // Too many witnesses. |
1355 methodOop fm = wf.found_method(0); // Will be NULL if num_parts == 0. | 1407 Method* fm = wf.found_method(0); // Will be NULL if num_parts == 0. |
1356 if (Dependencies::is_concrete_method(m)) { | 1408 if (Dependencies::is_concrete_method(m)) { |
1357 if (fm == NULL) { | 1409 if (fm == NULL) { |
1358 // It turns out that m was always the only implementation. | 1410 // It turns out that m was always the only implementation. |
1359 fm = m; | 1411 fm = m; |
1360 } else if (fm != m) { | 1412 } else if (fm != m) { |
1371 } | 1423 } |
1372 #endif //PRODUCT | 1424 #endif //PRODUCT |
1373 return fm; | 1425 return fm; |
1374 } | 1426 } |
1375 | 1427 |
1376 klassOop Dependencies::check_exclusive_concrete_methods(klassOop ctxk, | 1428 Klass* Dependencies::check_exclusive_concrete_methods(Klass* ctxk, |
1377 methodOop m1, | 1429 Method* m1, |
1378 methodOop m2, | 1430 Method* m2, |
1379 KlassDepChange* changes) { | 1431 KlassDepChange* changes) { |
1380 ClassHierarchyWalker wf(m1); | 1432 ClassHierarchyWalker wf(m1); |
1381 wf.add_participant(m1->method_holder()); | 1433 wf.add_participant(m1->method_holder()); |
1382 wf.add_participant(m2->method_holder()); | 1434 wf.add_participant(m2->method_holder()); |
1383 return wf.find_witness_definer(ctxk, changes); | 1435 return wf.find_witness_definer(ctxk, changes); |
1387 // (The method m[0] must be defined or inherited in ctxk.) | 1439 // (The method m[0] must be defined or inherited in ctxk.) |
1388 // Include m itself in the set, unless it is abstract. | 1440 // Include m itself in the set, unless it is abstract. |
1389 // Fill the given array m[0..(mlen-1)] with this set, and return the length. | 1441 // Fill the given array m[0..(mlen-1)] with this set, and return the length. |
1390 // (The length may be zero if no concrete methods are found anywhere.) | 1442 // (The length may be zero if no concrete methods are found anywhere.) |
1391 // If there are too many concrete methods to fit in marray, return -1. | 1443 // If there are too many concrete methods to fit in marray, return -1. |
1392 int Dependencies::find_exclusive_concrete_methods(klassOop ctxk, | 1444 int Dependencies::find_exclusive_concrete_methods(Klass* ctxk, |
1393 int mlen, | 1445 int mlen, |
1394 methodOop marray[]) { | 1446 Method* marray[]) { |
1395 methodOop m0 = marray[0]; | 1447 Method* m0 = marray[0]; |
1396 ClassHierarchyWalker wf(m0); | 1448 ClassHierarchyWalker wf(m0); |
1397 assert(wf.check_method_context(ctxk, m0), "proper context"); | 1449 assert(wf.check_method_context(ctxk, m0), "proper context"); |
1398 wf.record_witnesses(mlen); | 1450 wf.record_witnesses(mlen); |
1399 bool participants_hide_witnesses = true; | 1451 bool participants_hide_witnesses = true; |
1400 klassOop wit = wf.find_witness_definer(ctxk); | 1452 Klass* wit = wf.find_witness_definer(ctxk); |
1401 if (wit != NULL) return -1; // Too many witnesses. | 1453 if (wit != NULL) return -1; // Too many witnesses. |
1402 int num = wf.num_participants(); | 1454 int num = wf.num_participants(); |
1403 assert(num <= mlen, "oob"); | 1455 assert(num <= mlen, "oob"); |
1404 // Keep track of whether m is also part of the result set. | 1456 // Keep track of whether m is also part of the result set. |
1405 int mfill = 0; | 1457 int mfill = 0; |
1406 assert(marray[mfill] == m0, "sanity"); | 1458 assert(marray[mfill] == m0, "sanity"); |
1407 if (Dependencies::is_concrete_method(m0)) | 1459 if (Dependencies::is_concrete_method(m0)) |
1408 mfill++; // keep m0 as marray[0], the first result | 1460 mfill++; // keep m0 as marray[0], the first result |
1409 for (int i = 0; i < num; i++) { | 1461 for (int i = 0; i < num; i++) { |
1410 methodOop fm = wf.found_method(i); | 1462 Method* fm = wf.found_method(i); |
1411 if (fm == m0) continue; // Already put this guy in the list. | 1463 if (fm == m0) continue; // Already put this guy in the list. |
1412 if (mfill == mlen) { | 1464 if (mfill == mlen) { |
1413 return -1; // Oops. Too many methods after all! | 1465 return -1; // Oops. Too many methods after all! |
1414 } | 1466 } |
1415 marray[mfill++] = fm; | 1467 marray[mfill++] = fm; |
1436 #endif //PRODUCT | 1488 #endif //PRODUCT |
1437 return mfill; | 1489 return mfill; |
1438 } | 1490 } |
1439 | 1491 |
1440 | 1492 |
1441 klassOop Dependencies::check_has_no_finalizable_subclasses(klassOop ctxk, KlassDepChange* changes) { | 1493 Klass* Dependencies::check_has_no_finalizable_subclasses(Klass* ctxk, KlassDepChange* changes) { |
1442 Klass* search_at = ctxk->klass_part(); | 1494 Klass* search_at = ctxk; |
1443 if (changes != NULL) | 1495 if (changes != NULL) |
1444 search_at = changes->new_type()->klass_part(); // just look at the new bit | 1496 search_at = changes->new_type(); // just look at the new bit |
1445 Klass* result = find_finalizable_subclass(search_at); | 1497 return find_finalizable_subclass(search_at); |
1446 if (result == NULL) { | 1498 } |
1447 return NULL; | 1499 |
1448 } | 1500 |
1449 return result->as_klassOop(); | 1501 Klass* Dependencies::check_call_site_target_value(oop call_site, oop method_handle, CallSiteDepChange* changes) { |
1450 } | |
1451 | |
1452 | |
1453 klassOop Dependencies::check_call_site_target_value(oop call_site, oop method_handle, CallSiteDepChange* changes) { | |
1454 assert(call_site ->is_a(SystemDictionary::CallSite_klass()), "sanity"); | 1502 assert(call_site ->is_a(SystemDictionary::CallSite_klass()), "sanity"); |
1455 assert(method_handle->is_a(SystemDictionary::MethodHandle_klass()), "sanity"); | 1503 assert(method_handle->is_a(SystemDictionary::MethodHandle_klass()), "sanity"); |
1456 if (changes == NULL) { | 1504 if (changes == NULL) { |
1457 // Validate all CallSites | 1505 // Validate all CallSites |
1458 if (java_lang_invoke_CallSite::target(call_site) != method_handle) | 1506 if (java_lang_invoke_CallSite::target(call_site) != method_handle) |
1466 } | 1514 } |
1467 return NULL; // assertion still valid | 1515 return NULL; // assertion still valid |
1468 } | 1516 } |
1469 | 1517 |
1470 | 1518 |
1471 void Dependencies::DepStream::trace_and_log_witness(klassOop witness) { | 1519 void Dependencies::DepStream::trace_and_log_witness(Klass* witness) { |
1472 if (witness != NULL) { | 1520 if (witness != NULL) { |
1473 if (TraceDependencies) { | 1521 if (TraceDependencies) { |
1474 print_dependency(witness, /*verbose=*/ true); | 1522 print_dependency(witness, /*verbose=*/ true); |
1475 } | 1523 } |
1476 // The following is a no-op unless logging is enabled: | 1524 // The following is a no-op unless logging is enabled: |
1477 log_dependency(witness); | 1525 log_dependency(witness); |
1478 } | 1526 } |
1479 } | 1527 } |
1480 | 1528 |
1481 | 1529 |
1482 klassOop Dependencies::DepStream::check_klass_dependency(KlassDepChange* changes) { | 1530 Klass* Dependencies::DepStream::check_klass_dependency(KlassDepChange* changes) { |
1483 assert_locked_or_safepoint(Compile_lock); | 1531 assert_locked_or_safepoint(Compile_lock); |
1484 Dependencies::check_valid_dependency_type(type()); | 1532 Dependencies::check_valid_dependency_type(type()); |
1485 | 1533 |
1486 klassOop witness = NULL; | 1534 Klass* witness = NULL; |
1487 switch (type()) { | 1535 switch (type()) { |
1488 case evol_method: | 1536 case evol_method: |
1489 witness = check_evol_method(method_argument(0)); | 1537 witness = check_evol_method(method_argument(0)); |
1490 break; | 1538 break; |
1491 case leaf_type: | 1539 case leaf_type: |
1519 trace_and_log_witness(witness); | 1567 trace_and_log_witness(witness); |
1520 return witness; | 1568 return witness; |
1521 } | 1569 } |
1522 | 1570 |
1523 | 1571 |
1524 klassOop Dependencies::DepStream::check_call_site_dependency(CallSiteDepChange* changes) { | 1572 Klass* Dependencies::DepStream::check_call_site_dependency(CallSiteDepChange* changes) { |
1525 assert_locked_or_safepoint(Compile_lock); | 1573 assert_locked_or_safepoint(Compile_lock); |
1526 Dependencies::check_valid_dependency_type(type()); | 1574 Dependencies::check_valid_dependency_type(type()); |
1527 | 1575 |
1528 klassOop witness = NULL; | 1576 Klass* witness = NULL; |
1529 switch (type()) { | 1577 switch (type()) { |
1530 case call_site_target_value: | 1578 case call_site_target_value: |
1531 witness = check_call_site_target_value(argument(0), argument(1), changes); | 1579 witness = check_call_site_target_value(argument_oop(0), argument_oop(1), changes); |
1532 break; | 1580 break; |
1533 default: | 1581 default: |
1534 witness = NULL; | 1582 witness = NULL; |
1535 break; | 1583 break; |
1536 } | 1584 } |
1537 trace_and_log_witness(witness); | 1585 trace_and_log_witness(witness); |
1538 return witness; | 1586 return witness; |
1539 } | 1587 } |
1540 | 1588 |
1541 | 1589 |
1542 klassOop Dependencies::DepStream::spot_check_dependency_at(DepChange& changes) { | 1590 Klass* Dependencies::DepStream::spot_check_dependency_at(DepChange& changes) { |
1543 // Handle klass dependency | 1591 // Handle klass dependency |
1544 if (changes.is_klass_change() && changes.as_klass_change()->involves_context(context_type())) | 1592 if (changes.is_klass_change() && changes.as_klass_change()->involves_context(context_type())) |
1545 return check_klass_dependency(changes.as_klass_change()); | 1593 return check_klass_dependency(changes.as_klass_change()); |
1546 | 1594 |
1547 // Handle CallSite dependency | 1595 // Handle CallSite dependency |
1554 | 1602 |
1555 | 1603 |
1556 void DepChange::print() { | 1604 void DepChange::print() { |
1557 int nsup = 0, nint = 0; | 1605 int nsup = 0, nint = 0; |
1558 for (ContextStream str(*this); str.next(); ) { | 1606 for (ContextStream str(*this); str.next(); ) { |
1559 klassOop k = str.klass(); | 1607 Klass* k = str.klass(); |
1560 switch (str.change_type()) { | 1608 switch (str.change_type()) { |
1561 case Change_new_type: | 1609 case Change_new_type: |
1562 tty->print_cr(" dependee = %s", instanceKlass::cast(k)->external_name()); | 1610 tty->print_cr(" dependee = %s", InstanceKlass::cast(k)->external_name()); |
1563 break; | 1611 break; |
1564 case Change_new_sub: | 1612 case Change_new_sub: |
1565 if (!WizardMode) { | 1613 if (!WizardMode) { |
1566 ++nsup; | 1614 ++nsup; |
1567 } else { | 1615 } else { |
1568 tty->print_cr(" context super = %s", instanceKlass::cast(k)->external_name()); | 1616 tty->print_cr(" context super = %s", InstanceKlass::cast(k)->external_name()); |
1569 } | 1617 } |
1570 break; | 1618 break; |
1571 case Change_new_impl: | 1619 case Change_new_impl: |
1572 if (!WizardMode) { | 1620 if (!WizardMode) { |
1573 ++nint; | 1621 ++nint; |
1574 } else { | 1622 } else { |
1575 tty->print_cr(" context interface = %s", instanceKlass::cast(k)->external_name()); | 1623 tty->print_cr(" context interface = %s", InstanceKlass::cast(k)->external_name()); |
1576 } | 1624 } |
1577 break; | 1625 break; |
1578 } | 1626 } |
1579 } | 1627 } |
1580 if (nsup + nint != 0) { | 1628 if (nsup + nint != 0) { |
1581 tty->print_cr(" context supers = %d, interfaces = %d", nsup, nint); | 1629 tty->print_cr(" context supers = %d, interfaces = %d", nsup, nint); |
1582 } | 1630 } |
1583 } | 1631 } |
1584 | 1632 |
1585 void DepChange::ContextStream::start() { | 1633 void DepChange::ContextStream::start() { |
1586 klassOop new_type = _changes.is_klass_change() ? _changes.as_klass_change()->new_type() : (klassOop) NULL; | 1634 Klass* new_type = _changes.is_klass_change() ? _changes.as_klass_change()->new_type() : (Klass*) NULL; |
1587 _change_type = (new_type == NULL ? NO_CHANGE : Start_Klass); | 1635 _change_type = (new_type == NULL ? NO_CHANGE : Start_Klass); |
1588 _klass = new_type; | 1636 _klass = new_type; |
1589 _ti_base = NULL; | 1637 _ti_base = NULL; |
1590 _ti_index = 0; | 1638 _ti_index = 0; |
1591 _ti_limit = 0; | 1639 _ti_limit = 0; |
1592 } | 1640 } |
1593 | 1641 |
1594 bool DepChange::ContextStream::next() { | 1642 bool DepChange::ContextStream::next() { |
1595 switch (_change_type) { | 1643 switch (_change_type) { |
1596 case Start_Klass: // initial state; _klass is the new type | 1644 case Start_Klass: // initial state; _klass is the new type |
1597 _ti_base = instanceKlass::cast(_klass)->transitive_interfaces(); | 1645 _ti_base = InstanceKlass::cast(_klass)->transitive_interfaces(); |
1598 _ti_index = 0; | 1646 _ti_index = 0; |
1599 _change_type = Change_new_type; | 1647 _change_type = Change_new_type; |
1600 return true; | 1648 return true; |
1601 case Change_new_type: | 1649 case Change_new_type: |
1602 // fall through: | 1650 // fall through: |
1603 _change_type = Change_new_sub; | 1651 _change_type = Change_new_sub; |
1604 case Change_new_sub: | 1652 case Change_new_sub: |
1605 // 6598190: brackets workaround Sun Studio C++ compiler bug 6629277 | 1653 // 6598190: brackets workaround Sun Studio C++ compiler bug 6629277 |
1606 { | 1654 { |
1607 _klass = instanceKlass::cast(_klass)->super(); | 1655 _klass = InstanceKlass::cast(_klass)->super(); |
1608 if (_klass != NULL) { | 1656 if (_klass != NULL) { |
1609 return true; | 1657 return true; |
1610 } | 1658 } |
1611 } | 1659 } |
1612 // else set up _ti_limit and fall through: | 1660 // else set up _ti_limit and fall through: |
1613 _ti_limit = (_ti_base == NULL) ? 0 : _ti_base->length(); | 1661 _ti_limit = (_ti_base == NULL) ? 0 : _ti_base->length(); |
1614 _change_type = Change_new_impl; | 1662 _change_type = Change_new_impl; |
1615 case Change_new_impl: | 1663 case Change_new_impl: |
1616 if (_ti_index < _ti_limit) { | 1664 if (_ti_index < _ti_limit) { |
1617 _klass = klassOop( _ti_base->obj_at(_ti_index++) ); | 1665 _klass = _ti_base->at(_ti_index++); |
1618 return true; | 1666 return true; |
1619 } | 1667 } |
1620 // fall through: | 1668 // fall through: |
1621 _change_type = NO_CHANGE; // iterator is exhausted | 1669 _change_type = NO_CHANGE; // iterator is exhausted |
1622 case NO_CHANGE: | 1670 case NO_CHANGE: |
1632 assert_lock_strong(Compile_lock); | 1680 assert_lock_strong(Compile_lock); |
1633 | 1681 |
1634 // Mark all dependee and all its superclasses | 1682 // Mark all dependee and all its superclasses |
1635 // Mark transitive interfaces | 1683 // Mark transitive interfaces |
1636 for (ContextStream str(*this); str.next(); ) { | 1684 for (ContextStream str(*this); str.next(); ) { |
1637 klassOop d = str.klass(); | 1685 Klass* d = str.klass(); |
1638 assert(!instanceKlass::cast(d)->is_marked_dependent(), "checking"); | 1686 assert(!InstanceKlass::cast(d)->is_marked_dependent(), "checking"); |
1639 instanceKlass::cast(d)->set_is_marked_dependent(true); | 1687 InstanceKlass::cast(d)->set_is_marked_dependent(true); |
1640 } | 1688 } |
1641 } | 1689 } |
1642 | 1690 |
1643 KlassDepChange::~KlassDepChange() { | 1691 KlassDepChange::~KlassDepChange() { |
1644 // Unmark all dependee and all its superclasses | 1692 // Unmark all dependee and all its superclasses |
1645 // Unmark transitive interfaces | 1693 // Unmark transitive interfaces |
1646 for (ContextStream str(*this); str.next(); ) { | 1694 for (ContextStream str(*this); str.next(); ) { |
1647 klassOop d = str.klass(); | 1695 Klass* d = str.klass(); |
1648 instanceKlass::cast(d)->set_is_marked_dependent(false); | 1696 InstanceKlass::cast(d)->set_is_marked_dependent(false); |
1649 } | 1697 } |
1650 } | 1698 } |
1651 | 1699 |
1652 bool KlassDepChange::involves_context(klassOop k) { | 1700 bool KlassDepChange::involves_context(Klass* k) { |
1653 if (k == NULL || !Klass::cast(k)->oop_is_instance()) { | 1701 if (k == NULL || !Klass::cast(k)->oop_is_instance()) { |
1654 return false; | 1702 return false; |
1655 } | 1703 } |
1656 instanceKlass* ik = instanceKlass::cast(k); | 1704 InstanceKlass* ik = InstanceKlass::cast(k); |
1657 bool is_contained = ik->is_marked_dependent(); | 1705 bool is_contained = ik->is_marked_dependent(); |
1658 assert(is_contained == Klass::cast(new_type())->is_subtype_of(k), | 1706 assert(is_contained == Klass::cast(new_type())->is_subtype_of(k), |
1659 "correct marking of potential context types"); | 1707 "correct marking of potential context types"); |
1660 return is_contained; | 1708 return is_contained; |
1661 } | 1709 } |