第6.4篇-计算vtable的大小
在ClassFileParser::parseClassFile()函数中会计算vtable和itable所需要的大小，因为vtable和itable是内嵌在Klass中的，parseClassFile()函数解析完Class文件后会创建instanceKlass来保存相关的信息，在创建instanceKlass时需要知道创建对象的大小，所以必须要把vtable和itable也计算出来。下面就来介绍一下vtable和itable大小的计算过程，这一篇只介绍vtable大小的计算过程，下一篇将介绍itable大小的计算过程。
在ClassFileParser::parseClassFile()函数中首先计算vtable的大小，如下：
// Size of Java vtable (in words) int vtable_size = 0; int itable_size = 0; int num_miranda_methods = 0; GrowableArray<Method*> all_mirandas(20); InstanceKlass* tmp = super_klass(); // 计算虚函数表的大小和mirandas方法的数量，这个虚函数表的值是什么时候进行填充的呢？？？ klassVtable::compute_vtable_size_and_num_mirandas( &vtable_size, &num_miranda_methods, &all_mirandas, tmp, methods, access_flags, class_loader, class_name, local_interfaces, CHECK_(nullHandle) );
调用方法时传递的methods就是调用parse_methods()方法后的返回值，数组中存储了类或接口中定义或声明的所有方法。
调用的compute_vtable_size_and_num_mirandas()方法的实现如下：
void klassVtable::compute_vtable_size_and_num_mirandas(
int* vtable_length_ret,
int* num_new_mirandas,
GrowableArray<Method*>* all_mirandas,
Klass* super,
Array<Method*>* methods,
AccessFlags class_flags,
Handle classloader,
Symbol* classname,
Array<Klass*>* local_interfaces,
TRAPS) {
// set up default result values
int vtable_length = 0;
// start off with super's vtable length
InstanceKlass* superklass = (InstanceKlass*)super;
// 获取父类 vtable 的大小，并将当前类的 vtable 的大小设置为父类 vtable 的大小
vtable_length = super == NULL ? 0 : superklass->vtable_length();
// go thru each method in the methods table to see if it needs a new entry
int len = methods->length();
for (int i = 0; i < len; i++) {
methodHandle mh(THREAD, methods->at(i));
// 循环遍历当前 Java 类的每一个方法 ，调用 needs_new_vtable_entry()函数进行判断，
// 如果判断的结果是 true ，则将 vtable 的大小增 1
if (needs_new_vtable_entry(mh, super, classloader, classname, class_flags, THREAD)) {
vtable_length += vtableEntry::size(); // we need a new entry
}
}
GrowableArray<Method*> new_mirandas(20);
// compute the number of mirandas methods that must be added to the end
get_mirandas(&new_mirandas, all_mirandas, super, methods, NULL, local_interfaces);
*num_new_mirandas = new_mirandas.length();
// Interfaces do not need interface methods in their vtables
// This includes miranda methods and during later processing, default methods
if (!class_flags.is_interface()) { // 只有类才需要处理miranda方法，接口不需要处理
// 类的vtable大小要加上miranda方法的大小
vtable_length += *num_new_mirandas * vtableEntry::size();
}
// 处理数组类时，其vtable_length应该等于Object的vtable_length，通常为5,因为Object中有5个方法需要动态绑定
if (Universe::is_bootstrapping() && vtable_length == 0) {
// array classes don't have their superclass set correctly during bootstrapping
vtable_length = Universe::base_vtable_size();
}
*vtable_length_ret = vtable_length;
}
vtable的大小通常都是由3部分计算得出：
父类vtable的大小+当前方法需要的vtable大小+mirandas需要的大小
下面会重点介绍needs_new_vtable_entry()方法和get_mirandas()方法，前一个方法对计算当前方法需要的vtable大小很重要，后一个方法是计算mirandas方法需要的大小。
1、needs_new_vtable_entry()方法
循环处理当前类中定义的方法，调用needs_new_vtable_entry()方法判断此方法是否需要新的vtable entry，因为有些方法可能不需要新的vtable entry，如重写父类方法时，当前类中的方法只需要更新拷贝自父类vtable中对应的vtable entry即可。调用的needs_new_entry()方法的实现如下：
源代码位置：hotspot/src/share/vm/oops/klassVtable.cpp
// Find out if a method "m" with superclass "super", loader "classloader" and
// name "classname" needs a new vtable entry. Let P be a class package defined
// by "classloader" and "classname".
// NOTE: The logic used here is very similar to the one used for computing
// the vtables indices for a method. We cannot directly use that function because,
// we allocate the InstanceKlass at load time, and that requires that the
// superclass has been loaded.
// However, the vtable entries are filled in at link time(在连接时才会被填充), and therefore
// the superclass' vtable may not yet have been filled in.
bool klassVtable::needs_new_vtable_entry(methodHandle target_method,
Klass* super,
Handle classloader,
Symbol* classname,
AccessFlags class_flags,
TRAPS) {
if (class_flags.is_interface()) { // 接口不需要vtable表
// Interfaces do not use vtables, so there is no point to assigning
// a vtable index to any of their methods. If we refrain（克制; 节制; 避免;） from doing this,
// we can use Method::_vtable_index to hold the itable index
return false;
}
if (target_method->is_final_method(class_flags) || // final方法不需要一个新的entry
// a final method never needs a new entry; final methods can be statically
// resolved and they have to be present in the vtable only if they override
// a super's method, in which case they re-use its entry
( target_method()->is_static() ) || // 静态方法不需要一个新的entry
// static methods don't need to be in vtable
( target_method()->name() == vmSymbols::object_initializer_name() ) // <init>不会被动态绑定
// <init> is never called dynamically-bound
){
return false;
}
// Concrete interface methods do not need new entries, they override
// abstract method entries using default inheritance rules
if (target_method()->method_holder() != NULL &&
target_method()->method_holder()->is_interface() &&
!target_method()->is_abstract() ){
return false;
}
// we need a new entry if there is no superclass
if (super == NULL) {
return true;
}
// private methods in classes always have a new entry in the vtable
// specification interpretation since classic has
// private methods not overriding
// JDK8 adds private methods in interfaces which require invokespecial
if (target_method()->is_private()) {
return true;
}
// 省略对miranda方法的判断逻辑
return true; // found no match; we need a new entry
}
所有的私有方法都需要vtable entry。还有一类特殊的miranda方法也需要实现“晚绑定”，所以也会有vtable entry。miranda方法是为了解决早期HotSpot虚拟机的一个Bug，因为早期虚拟机在遍历Java类的方法时，只会遍历类及所有父类的方法，不会遍历Java类所实现的接口里的方法，这会导致一个问题，即如果Java类没有实现接口里的方法，那么接口中的方法将不会被遍历到。为了解决这个问题，Javac等前端编译器会向Java类中添加方法，这些方法就是miranda方法。举个例子如下：
public interface IA{
void test();
}
public abstract class CA implements IA{
public CA(){
test();
}
}
CA类实现了IA接口，但是并没有实现接口中定义的test()方法，源代码并没有任何问题，如果只遍历类及父类，那么是无法查找到test()方法的，所以早期的HotSpot需要Javac等编译器会为CA类合成一个miranda方法，如下：
public interface IA{
void test();
}
public abstract class CA implements IA{
public CA(){
test();
}
// miranda
public abstract void test();
}
这样就解决了HotSpot不搜索接口的Bug。不过现在的虚拟机版本并不需要合成miranda方法（Class文件中不存在miranda方法），但是在填充类的vtable时，如果这个类实现的接口中有没有被实现的方法，那么仍然需要在vtable中新增vtable entry，其实也是起到了和之前一样的效果。
接着看needs_new_vtable_entry()方法中对miranda方法的判断逻辑，如下：
// search through the super class hierarchy to see if we need a new entry
ResourceMark rm;
Symbol* name = target_method()->name();
Symbol* signature = target_method()->signature();
Klass* k = super;
Method* super_method = NULL;
InstanceKlass *holder = NULL;
Method* recheck_method = NULL;
while (k != NULL) {
// lookup through the hierarchy for a method with matching name and sign.
super_method = InstanceKlass::cast(k)->lookup_method(name, signature);
if (super_method == NULL) {
break; // we still have to search for a matching miranda method
}
// get the class holding the matching method
// make sure you use that class for is_override
InstanceKlass* superk = super_method->method_holder();
// we want only instance method matches
// pretend private methods are not in the super vtable
// since we do override around them: e.g. a.m pub/b.m private/c.m pub,
// ignore private, c.m pub does override a.m pub
// For classes that were not javac'd together, we also do transitive overriding around
// methods that have less accessibility
if ( (!super_method->is_static()) &&
(!super_method->is_private()) ) { // super_method即不是静态也不是private的
if (superk->is_override(super_method, classloader, classname, THREAD)) {
return false;
// else keep looking for transitive overrides
}
}
// Start with lookup result and continue to search up
k = superk->super(); // haven't found an override match yet; continue to look
} // end while
// if the target method is public or protected it may have a matching
// miranda method in the super, whose entry it should re-use.
// Actually, to handle cases that javac would not generate, we need
// this check for all access permissions.
InstanceKlass *sk = InstanceKlass::cast(super);
if (sk->has_miranda_methods()) {
if (sk->lookup_method_in_all_interfaces(name, signature, false) != NULL) {
return false; // found a matching miranda; we do not need a new entry
}
}
调用lookup_method()方法搜索父类中是否有匹配name和signature的方法。如果搜索到方法，那可能是重写的情况，在重写情况下不需要新为此方法增加vtableEntry，只需要更新即可；如果搜索不到也不一定说明需要一个新的vtableEntry，因为还有miranda方法的情况，当调用lookup_method_in_all_interfaces()方法搜索到相关方法时，表示不需要新的vtableEntry，举个例子如下：
interface IA {
void test();
}
abstract class CA implements IA{ }
public abstract class MirandaTest extends CA {
public abstract void test();
}
在处理MirandaTest类的test()方法时，从CA和Object父类中无法搜索到test()类，但是在处理CA时，由于CA类没有实现IA接口中的test()方法，所以CA类的vtable中含有代表test()方法的vtableEntry，那么MirandaTest类中的test()方法此时就不需要一个新的vtableEntry了，只需要更新即可，所以方法最终返回false。
方法中的lookup_method()的实现如下：
Method* lookup_method(Symbol* name, Symbol* signature) const {
return uncached_lookup_method(name, signature);
}
// uncached_lookup_method searches both the local class methods array and all
// superclasses methods arrays, skipping any overpass methods in superclasses.
Method* InstanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
Klass* klass = const_cast<InstanceKlass*>(this);
bool dont_ignore_overpasses = true; // For the class being searched, find its overpasses.
while (klass != NULL) {
Method* method = InstanceKlass::cast(klass)->find_method(name, signature);
if ((method != NULL) && (dont_ignore_overpasses || !method->is_overpass())) {
return method;
}
klass = InstanceKlass::cast(klass)->super();
dont_ignore_overpasses = false; // Ignore overpass methods in all superclasses.
}
return NULL;
}
// find_method looks up the name/signature in the local methods array
Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const {
return InstanceKlass::find_method(methods(), name, signature);
}
// find_method looks up the name/signature in the local methods array
Method* InstanceKlass::find_method(Array<Method*>* methods, Symbol* name, Symbol* signature) {
int hit = find_method_index(methods, name, signature);
return hit >= 0 ? methods->at(hit): NULL;
}
其中的find_method_index()方法就是对methods进行二分算法来搜索名称为name和签名为signature的方法，这里不在介绍。
调用的is_override()方法的实现如下：
// Returns true iff super_method can be overridden by a method in targetclassname
// See JSL 3rd edition 8.4.6.1
// Assumes name-signature match
// "this" is InstanceKlass of super_method which must exist
// note that the InstanceKlass of the method in the targetclassname has not always been created yet
bool InstanceKlass::is_override(methodHandle super_method, Handle targetclassloader, Symbol* targetclassname, TRAPS) {
// Private methods can not be overridden
if (super_method->is_private()) {
return false;
}
// If super method is accessible, then override
if ((super_method->is_protected()) ||
(super_method->is_public())) {
return true;
}
// Package-private methods are not inherited outside of package
assert(super_method->is_package_private(), "must be package private");
return(is_same_class_package(targetclassloader(), targetclassname)); // 其中就是处理权限为default的方法
}
调用的lookup_method_in_all_interfaces()方法的实现如下：
// lookup a method in all the interfaces that this class implements
// Do NOT return private or static methods, new in JDK8 which are not externally visible
// They should only be found in the initial InterfaceMethodRef
Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name,
Symbol* signature,
bool skip_default_methods) const {
Array<Klass*>* all_ifs = transitive_interfaces();
int num_ifs = all_ifs->length();
InstanceKlass *ik = NULL;
for (int i = 0; i < num_ifs; i++) {
ik = InstanceKlass::cast(all_ifs->at(i));
Method* m = ik->lookup_method(name, signature);
if (m != NULL && m->is_public() && !m->is_static() &&
(!skip_default_methods || !m->is_default_method())) {
return m;
}
}
return NULL;
}
在函数中调用此方法时，skip_default_methods的值为false。逻辑实现比较简单，调用InstanceKlass类的lookup_method()方法查找接口中是否有名称为name、签名为signature的方法，如果查找到了public、非静态方法则直接返回，也就是说父类的vtable中已经存在了名称为name、签名为signature的方法的vtableEntry，所以当前类中并不再需要一个新的vtableEntry。
2、get_mirandas()方法
调用的get_mirandas()方法的实现如下：
void klassVtable::get_mirandas(GrowableArray<Method*>* new_mirandas,
GrowableArray<Method*>* all_mirandas,
Klass* super, Array<Method*>* class_methods,
Array<Method*>* default_methods,
Array<Klass*>* local_interfaces) {
assert((new_mirandas->length() == 0) , "current mirandas must be 0");
// iterate thru the local interfaces looking for a miranda
int num_local_ifs = local_interfaces->length();
for (int i = 0; i < num_local_ifs; i++) {
InstanceKlass *ik = InstanceKlass::cast(local_interfaces->at(i));
add_new_mirandas_to_lists(new_mirandas, all_mirandas,
ik->methods(), class_methods,
default_methods, super);
// iterate thru each local's super interfaces
Array<Klass*>* super_ifs = ik->transitive_interfaces();
int num_super_ifs = super_ifs->length();
for (int j = 0; j < num_super_ifs; j++) {
InstanceKlass *sik = InstanceKlass::cast(super_ifs->at(j));
add_new_mirandas_to_lists(new_mirandas, all_mirandas,
sik->methods(), class_methods,
default_methods, super);
}
}
}
如上方法遍历当前类实现的接口以及接口所继承的所有接口，然后调用add_new_mirandas_to_lists()方法进行处理，此方法的实现如下：
// Scans current_interface_methods for miranda methods that do not
// already appear in new_mirandas, or default methods, and are also not defined-and-non-private
// in super (superclass). These mirandas are added to all_mirandas if it is
// not null; in addition, those that are not duplicates of miranda methods
// inherited by super from its interfaces are added to new_mirandas.
// Thus, new_mirandas will be the set of mirandas that this class introduces,
// all_mirandas will be the set of all mirandas applicable to this class
// including all defined in superclasses.
void klassVtable::add_new_mirandas_to_lists(
GrowableArray<Method*>* new_mirandas,
GrowableArray<Method*>* all_mirandas,
Array<Method*>* current_interface_methods,
Array<Method*>* class_methods,
Array<Method*>* default_methods,
Klass* super
){
// iterate thru the current interface's method to see if it a miranda
int num_methods = current_interface_methods->length();
for (int i = 0; i < num_methods; i++) {
Method* im = current_interface_methods->at(i);
bool is_duplicate = false;
int num_of_current_mirandas = new_mirandas->length();
// check for duplicate mirandas in different interfaces we implement
for (int j = 0; j < num_of_current_mirandas; j++) {
Method* miranda = new_mirandas->at(j);
if ((im->name() == miranda->name()) &&
(im->signature() == miranda->signature()) ){
is_duplicate = true;
break;
}
}
if (!is_duplicate) { // we don't want duplicate miranda entries in the vtable
if (is_miranda(im, class_methods, default_methods, super)) { // is it a miranda at all?
InstanceKlass *sk = InstanceKlass::cast(super);
// check if it is a duplicate of a super's miranda
if (sk->lookup_method_in_all_interfaces(im->name(), im->signature(), false) == NULL) {
new_mirandas->append(im);
}
if (all_mirandas != NULL) {
all_mirandas->append(im);
}
}
}
} // end for
}
遍历当前类实现的接口（直接或间接）中定义的所有方法，如果这个方法还没有被判定为miranda方法（就是在new_mirandas数组中不存在），那么调用is_miranda()方法判断此方法是否为miranda()方法，如果是，那么还需要调用当前类的父类的lookup_method_in_all_interfaces()方法来进一步判断。举个例子如下：
interface IA {
void test();
}
abstract class CA implements IA{ }
在处理CA类时，由于CA实现的接口IA中的方法test()没有对应的实现，所以接口中定义的test()方法会添加到new_mirandas数组中，意思就是需要在当前CA类的vtable中添加对应的vtableEntry。再举个例子，如下：
interface IA {
void test();
}
abstract class CA implements IA{ }
interface IB {
void test();
}
public abstract class MirandaTest extends CA implements IB{
}
如果当前类为MirandaTest，那么实现的IB接口中的test()方法没有对应的实现，但是并不一定会添加到new_mirandas数组中，所以也就意味着不一定会新增加vtableEntry，还需要调用lookup_method_in_all_interfaces()方法来判断，由于当前类的父类CA中已经有名称和签名都相等的test()方法对应的vtableEntry了，所以只需要重用此vtableEntry即可。
调用的is_miranda()方法的实现如下：
// check if a method is a miranda method, given a class's methods table,
// its default_method table and its super
// Miranda methods are calculated twice:
// first: before vtable size calculation: including abstract and default
// This is seen by default method creation
// Second: recalculated during vtable initialization: only abstract
// This is seen by link resolution and selection.
// "miranda" means not static, not defined by this class.
// private methods in interfaces do not belong in the miranda list.
// the caller must make sure that the method belongs to an interface implemented by the class
// Miranda methods only include public interface instance methods
// Not private methods, not static methods, not default == concrete abstract
// Miranda methods also do not include overpass methods in interfaces
bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods,
Array<Method*>* default_methods, Klass* super) {
if (m->is_static() || m->is_private() || m->is_overpass()) {
return false;
}
Symbol* name = m->name();
Symbol* signature = m->signature();
if (InstanceKlass::find_instance_method(class_methods, name, signature) == NULL) {
// did not find it in the method table of the current class
if ((default_methods == NULL) ||
InstanceKlass::find_method(default_methods, name, signature) == NULL) {
// 当前类没有父类，那么接口中定义的方法肯定没有对应的实现，此接口中的方法是miranda方法
if (super == NULL) {
// super doesn't exist
return true;
}
// 需要从父类中找一个非静态的、名称为name、签名为signauture的方法，如果是静态方法，则
// 需要继续查找，因为静态方法不参与动态绑定，也就不需要判断是否重写与实现等特性
Method* mo = InstanceKlass::cast(super)->lookup_method(name, signature);
while (
mo != NULL &&
mo->access_flags().is_static() &&
mo->method_holder() != NULL &&
mo->method_holder()->super() != NULL
){
mo = mo->method_holder()->super()->uncached_lookup_method(name, signature);
}
// 如果找不到或找到的是私有方法实现，那么说明接口中定义的方法没有对应的实现，此接口中的方法是miranda方法
if (mo == NULL || mo->access_flags().is_private() ) {
// super class hierarchy does not implement it or protection is different
return true;
}
}
}
return false;
}
接口中的静态、私有等方法一定是非miranda方法，直接返回false。从class_methods数组中查找名称为name、签名为signature的方法，其中的class_methods就是当前分析的类中定义的所有方法，找不到说明没有实现对应的接口中定义的方法，有可能是miranda方法，需要继续进行判断。在判断miranda方法时传入的default_methods为NULL，所以需要继续从父类中判断。如果没有父类或父类中找不到对应的方法实现，那么方法会返回true，表示是miranda方法。
