Hotspot JVM 底层C/C++ 源码 入门10 类方法解析 methodOop

类变量解析其实跟常量池解析没什么不同,方法也差不多

看看代码

Array<Method*>* ClassFileParser::parse_methods(bool is_interface,
                                               AccessFlags* promoted_flags,
                                               bool* has_final_method,
                                               bool* has_default_methods,
                                               TRAPS) {
  ClassFileStream* cfs = stream();
  cfs->guarantee_more(2, CHECK_NULL);  // length
  u2 length = cfs->get_u2_fast();
  if (length == 0) {
    _methods = Universe::the_empty_method_array();
  } else {
    _methods = MetadataFactory::new_array<Method*>(_loader_data, length, NULL, CHECK_NULL);

    HandleMark hm(THREAD);
    for (int index = 0; index < length; index++) {
      methodHandle method = parse_method(is_interface,
                                         promoted_flags,
                                         CHECK_NULL);

      if (method->is_final()) {
        *has_final_method = true;
      }
      if (is_interface && !(*has_default_methods)
        && !method->is_abstract() && !method->is_static()
        && !method->is_private()) {
        // default method
        *has_default_methods = true;
      }
      _methods->at_put(index, method());
    }
//...
  }
  return _methods;
}

逻辑大体跟解析常量池差不多,首先从文件流中读取方法数量,然后循环遍历每一个方法调用parse_method()解析

parse_method()函数实在太长但逻辑简单(感受一下)(十万个if-else)

methodHandle ClassFileParser::parse_method(bool is_interface,
                                           AccessFlags *promoted_flags,
                                           TRAPS) {
  ClassFileStream* cfs = stream();
  methodHandle nullHandle;
  ResourceMark rm(THREAD);
  // Parse fixed parts
  cfs->guarantee_more(8, CHECK_(nullHandle)); // access_flags, name_index, descriptor_index, attributes_count

  int flags = cfs->get_u2_fast();
  u2 name_index = cfs->get_u2_fast();
  int cp_size = _cp->length();
  //...
  AccessFlags access_flags;
  if (name == vmSymbols::class_initializer_name()) { //是否是静态初始化方法:<clinit>
    // We ignore the other access flags for a valid class initializer.
    // (JVM Spec 2nd ed., chapter 4.6)
    if (_major_version < 51) { // backward compatibility
      flags = JVM_ACC_STATIC;
    } else if ((flags & JVM_ACC_STATIC) == JVM_ACC_STATIC) {
      flags &= JVM_ACC_STATIC | JVM_ACC_STRICT;
    }
  } else {
    verify_legal_method_modifiers(flags, is_interface, name, CHECK_(nullHandle));
  }
  //...
   // Default values for code and exceptions attribute elements
  u2 max_stack = 0;
  u2 max_locals = 0;
  u4 code_length = 0;
  u1* code_start = 0;
  u2 exception_table_length = 0;
  u2* exception_table_start = NULL;
  //...
  u2 method_attributes_count = cfs->get_u2_fast();
  while (method_attributes_count--) {
    cfs->guarantee_more(6, CHECK_(nullHandle));  // method_attribute_name_index, method_attribute_length
    u2 method_attribute_name_index = cfs->get_u2_fast();
    u4 method_attribute_length = cfs->get_u4_fast();
    //...
  }
  //...
  Method* m = Method::allocate(
      _loader_data, code_length, access_flags, &sizes,
      ConstMethod::NORMAL, CHECK_(nullHandle));

  ClassLoadingService::add_class_method_size(m->size()*HeapWordSize);
  m->set_code(code_start);//复制字节码

  //...
  return m;
}

1. 读取和验证Java方法的访问标识,名称
2. 解析方法的属性
3. 创建methodOop(但是代码中使用了method*)
4. 复制字节码(set_code())(解析仅在内存中)

方法名校验由verify_legal_method_name(),还看看有没有LVT(局部变量表)

创建methodOop

完成对java方法的属性解析之后,hotspot在内存中创建一个与java方法对等的对象methodOop(java中的Method)包含方法的信息,参数返回值等.

// Create a Java array that points to metadata.
// As far as Java code is concerned, a metaData array is either an array of
// int or long depending on pointer size.  Only a few things use this, like
// stack trace elements in Throwable.  They cast Method* into this type.
// Note:can't point to symbols because there's no way to unreference count
// them when this object goes away.
typeArrayOop oopFactory::new_metaDataArray(int length, TRAPS) {
  BasicType type = LP64_ONLY(T_LONG) NOT_LP64(T_INT);
  Klass* type_asKlassOop = Universe::typeArrayKlassObj(type);
  TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop);
  typeArrayOop result = type_asArrayKlass->allocate_common(length, true, THREAD);
  return result;
}