Lines Matching refs:ctxk
66 void Dependencies::assert_leaf_type(ciKlass* ctxk) {
67 if (ctxk->is_array_klass()) {
72 ciType* elemt = ctxk->as_array_klass()->base_element_type();
74 ctxk = elemt->as_instance_klass();
75 //if (ctxk->is_final()) return; // Ex: String[][]
77 check_ctxk(ctxk);
78 assert_common_1(leaf_type, ctxk);
81 void Dependencies::assert_abstract_with_unique_concrete_subtype(ciKlass* ctxk, ciKlass* conck) {
82 check_ctxk_abstract(ctxk);
83 assert_common_2(abstract_with_unique_concrete_subtype, ctxk, conck);
86 void Dependencies::assert_abstract_with_no_concrete_subtype(ciKlass* ctxk) {
87 check_ctxk_abstract(ctxk);
88 assert_common_1(abstract_with_no_concrete_subtype, ctxk);
91 void Dependencies::assert_concrete_with_no_concrete_subtype(ciKlass* ctxk) {
92 check_ctxk_concrete(ctxk);
93 assert_common_1(concrete_with_no_concrete_subtype, ctxk);
96 void Dependencies::assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm) {
97 check_ctxk(ctxk);
98 assert_common_2(unique_concrete_method, ctxk, uniqm);
101 void Dependencies::assert_abstract_with_exclusive_concrete_subtypes(ciKlass* ctxk, ciKlass* k1, ciKlass* k2) {
102 check_ctxk(ctxk);
103 assert_common_3(abstract_with_exclusive_concrete_subtypes_2, ctxk, k1, k2);
106 void Dependencies::assert_exclusive_concrete_methods(ciKlass* ctxk, ciMethod* m1, ciMethod* m2) {
107 check_ctxk(ctxk);
108 assert_common_3(exclusive_concrete_methods_2, ctxk, m1, m2);
111 void Dependencies::assert_has_no_finalizable_subclasses(ciKlass* ctxk) {
112 check_ctxk(ctxk);
113 assert_common_1(no_finalizable_subclasses, ctxk);
194 ciKlass* ctxk, ciObject* x, ciObject* x2) {
197 log_dependency(dept, ctxk, x, x2);
204 swap = (x->ident() > x2->ident() && x != ctxk);
207 swap = (x->ident() > x2->ident() && x->as_method()->holder() != ctxk);
220 if (maybe_merge_ctxk(deps, i+0, ctxk)) {
227 deps->append(ctxk);
324 ciKlass* ctxk = deps->at(i+ctxkj+0)->as_klass();
326 if (ctxk == ctxk_encoded_as_null(dept, x)) {
372 1, // leaf_type ctxk
373 2, // abstract_with_unique_concrete_subtype ctxk, k
374 1, // abstract_with_no_concrete_subtype ctxk
375 1, // concrete_with_no_concrete_subtype ctxk
376 2, // unique_concrete_method ctxk, m
377 3, // unique_concrete_subtypes_2 ctxk, k1, k2
378 3, // unique_concrete_methods_2 ctxk, m1, m2
379 1, // no_finalizable_subclasses ctxk
451 log->print(" ctxk='%d'", argids[ctxkj]);
483 xtty->object("ctxk", args[ctxkj]);
608 assert(skipj == dep_context_arg(dept), "zero arg always ctxk");
749 // Assert that m is inherited into ctxk, without intervening overrides.
751 bool check_method_context(klassOop ctxk, methodOop m) {
752 if (m->method_holder() == ctxk)
759 Klass* k = Klass::cast(ctxk);
767 // Method m is inherited into ctxk.
786 tty->print_cr(" context = %s", Klass::cast(ctxk)->external_name());
1175 klassOop Dependencies::check_leaf_type(klassOop ctxk) {
1178 instanceKlass* ctx = instanceKlass::cast(ctxk);
1193 // Test the assertion that conck is the only concrete subtype* of ctxk.
1195 // This allows the compiler to narrow occurrences of ctxk by conck,
1197 klassOop Dependencies::check_abstract_with_unique_concrete_subtype(klassOop ctxk,
1201 return wf.find_witness_subtype(ctxk, changes);
1207 klassOop Dependencies::check_abstract_with_no_concrete_subtype(klassOop ctxk,
1211 return wf.find_witness_subtype(ctxk, changes);
1217 klassOop Dependencies::check_concrete_with_no_concrete_subtype(klassOop ctxk,
1219 // Find any concrete subtype, with only the ctxk as participant:
1220 ClassHierarchyWalker wf(ctxk);
1221 return wf.find_witness_subtype(ctxk, changes);
1225 // Find the unique concrete proper subtype of ctxk, or NULL if there
1227 // proper subtypes, return ctxk itself, whether it is concrete or not.
1230 klassOop Dependencies::find_unique_concrete_subtype(klassOop ctxk) {
1231 ClassHierarchyWalker wf(ctxk); // Ignore ctxk when walking.
1233 klassOop wit = wf.find_witness_subtype(ctxk);
1242 if (!Dependencies::is_concrete_klass(ctxk)) {
1244 (void *)check_abstract_with_no_concrete_subtype(ctxk),
1248 (void *)check_concrete_with_no_concrete_subtype(ctxk),
1253 return ctxk; // Return ctxk as a flag for "no subtypes".
1260 if (!Dependencies::is_concrete_klass(ctxk)) {
1262 check_abstract_with_unique_concrete_subtype(ctxk, conck),
1271 // Test the assertion that the k[12] are the only concrete subtypes of ctxk,
1276 klassOop ctxk,
1283 return wf.find_witness_subtype(ctxk, changes);
1286 // Search ctxk for concrete implementations. If there are klen or fewer,
1290 // In this search, if ctxk is concrete, it will be reported alone.
1292 int Dependencies::find_exclusive_concrete_subtypes(klassOop ctxk,
1297 klassOop wit = wf.find_witness_subtype(ctxk);
1309 switch (Dependencies::is_concrete_klass(ctxk)? -1: num) {
1310 case -1: // ctxk was itself concrete
1311 guarantee(num == 1 && karray[0] == ctxk, "verify dep.");
1314 guarantee(NULL == (void *)check_abstract_with_no_concrete_subtype(ctxk),
1319 check_abstract_with_unique_concrete_subtype(ctxk, karray[0]),
1324 check_abstract_with_exclusive_concrete_subtypes(ctxk,
1339 klassOop Dependencies::check_unique_concrete_method(klassOop ctxk, methodOop uniqm,
1346 return wf.find_witness_definer(ctxk, changes);
1349 // Find the set of all non-abstract methods under ctxk that match m.
1350 // (The method m must be defined or inherited in ctxk.)
1353 methodOop Dependencies::find_unique_concrete_method(klassOop ctxk, methodOop m) {
1355 assert(wf.check_method_context(ctxk, m), "proper context");
1357 klassOop wit = wf.find_witness_definer(ctxk);
1366 // (This can happen if m is inherited into ctxk and fm overrides it.)
1373 guarantee(NULL == (void *)check_unique_concrete_method(ctxk, fm),
1380 klassOop Dependencies::check_exclusive_concrete_methods(klassOop ctxk,
1387 return wf.find_witness_definer(ctxk, changes);
1390 // Find the set of all non-abstract methods under ctxk that match m[0].
1391 // (The method m[0] must be defined or inherited in ctxk.)
1396 int Dependencies::find_exclusive_concrete_methods(klassOop ctxk,
1401 assert(wf.check_method_context(ctxk, m0), "proper context");
1404 klassOop wit = wf.find_witness_definer(ctxk);
1428 guarantee(NULL == (void *)check_unique_concrete_method(ctxk, marray[0]),
1433 check_exclusive_concrete_methods(ctxk, marray[0], marray[1]),
1445 klassOop Dependencies::check_has_no_finalizable_subclasses(klassOop ctxk, KlassDepChange* changes) {
1446 Klass* search_at = ctxk->klass_part();