// Find all methods on this hierarchy that match this // method's erased (name, signature) bool visit() { PseudoScope* scope = PseudoScope::cast(current_data()); InstanceKlass* iklass = current_class(); Method* m = iklass->find_method(_method_name, _method_signature); // private interface methods are not candidates for default methods // invokespecial to private interface methods doesn't use default method logic // The overpasses are your supertypes' errors, we do not include them // future: take access controls into account for superclass methods if (m != NULL && !m->is_static() && !m->is_overpass() && (!iklass->is_interface() || m->is_public())) { if (_family == NULL) { _family = new StatefulMethodFamily(); } if (iklass->is_interface()) { StateRestorer* restorer = _family->record_method_and_dq_further(m); scope->add_mark(restorer); } else { // This is the rule that methods in classes "win" (bad word) over // methods in interfaces. This works because of single inheritance _family->set_target_if_empty(m); } } return true; }
void ConstantPoolCacheEntry::set_itable_call(Bytecodes::Code invoke_code, methodHandle method, int index) { assert(method->method_holder()->verify_itable_index(index), ""); assert(invoke_code == Bytecodes::_invokeinterface, ""); InstanceKlass* interf = method->method_holder(); assert(interf->is_interface(), "must be an interface"); assert(!method->is_final_method(), "interfaces do not have final methods; cannot link to one here"); set_f1(interf); set_f2(index); set_method_flags(as_TosState(method->result_type()), 0, // no option bits method()->size_of_parameters()); set_bytecode_1(Bytecodes::_invokeinterface); }
void KlassHierarchy::print_class(outputStream* st, KlassInfoEntry* cie, bool print_interfaces) { ResourceMark rm; InstanceKlass* klass = (InstanceKlass*)cie->klass(); int indent = 0; // Print indentation with proper indicators of superclass. Klass* super = klass->super(); while (super != NULL) { super = super->super(); indent++; } print_indent(st, indent); if (indent != 0) st->print("--"); // Print the class name, its unique ClassLoader identifer, and if it is an interface. print_classname(st, klass); if (klass->is_interface()) { st->print(" (intf)"); } st->print("\n"); // Print any interfaces the class has. if (print_interfaces) { Array<Klass*>* local_intfs = klass->local_interfaces(); Array<Klass*>* trans_intfs = klass->transitive_interfaces(); for (int i = 0; i < local_intfs->length(); i++) { print_interface(st, local_intfs->at(i), "declared", indent); } for (int i = 0; i < trans_intfs->length(); i++) { Klass* trans_interface = trans_intfs->at(i); // Only print transitive interfaces if they are not also declared. if (!local_intfs->contains(trans_interface)) { print_interface(st, trans_interface, "inherited", indent); } } } }
void CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) { methodHandle method = call_info->selected_method(); bool is_invoke_interface = (bytecode == Bytecodes::_invokeinterface && !call_info->has_vtable_index()); assert(CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), ""); assert(!is_optimized(), "cannot set an optimized virtual call to megamorphic"); assert(is_call_to_compiled() || is_call_to_interpreted(), "going directly to megamorphic?"); address entry; if (is_invoke_interface) { int index = klassItable::compute_itable_index(call_info->resolved_method()()); entry = VtableStubs::create_stub(false, index, method()); assert(entry != NULL, "entry not computed"); InstanceKlass* k = call_info->resolved_method()->method_holder(); assert(k->is_interface(), "sanity check"); InlineCacheBuffer::create_transition_stub(this, k, entry); } else { // Can be different than method->vtable_index(), due to package-private etc. int vtable_index = call_info->vtable_index(); entry = VtableStubs::create_stub(true, vtable_index, method()); InlineCacheBuffer::create_transition_stub(this, method(), entry); } if (TraceICs) { ResourceMark rm; tty->print_cr ("IC@" INTPTR_FORMAT ": to megamorphic %s entry: " INTPTR_FORMAT, instruction_address(), method->print_value_string(), entry); } // We can't check this anymore. With lazy deopt we could have already // cleaned this IC entry before we even return. This is possible if // we ran out of space in the inline cache buffer trying to do the // set_next and we safepointed to free up space. This is a benign // race because the IC entry was complete when we safepointed so // cleaning it immediately is harmless. // assert(is_megamorphic(), "sanity check"); }