2.HotSpot如何加载并解析class文件

向右看齐 2023-02-17 02:53 38阅读 0赞

文章目录

    • 2.1前言
    • 2.2 类如何加载
      • 第一步：双亲委派加载类，java顶层实现
      • 第二步：找到defneClass1的native方法，开始进入JVM源码
    • 常量池解析`parse_constant_pool`讲解

2.1前言

class文件在JVM整个生命周期包括了加载、验证、准备、解析、初始化、使用、卸载等7个阶段，Java层面通过ClassLoader.loadClass方法可以手动加载一个java类到虚拟机中，并返回Class类型的引用。

2.2 类如何加载

第一步：双亲委派加载类，java顶层实现

  1. protected Class<?> loadClass(String name, boolean resolve)
  2.         throws ClassNotFoundException
  3.     { 
  4.         synchronized (getClassLoadingLock(name)) { 
  5.             // First, check if the class has already been loaded
  6.               // 首先检查是否这个类已经被加载（后续会讲是如何检查的）
  7.             Class<?> c = findLoadedClass(name);
  8.             if (c == null) { 
  9.                 long t0 = System.nanoTime();
  10.                 try { 
  11.                       //如果当前的ClassLoader的parent!=null，首先让parent进行加载。
  12.                       //如果想多进行了解，可以看双亲委派机制，这样做的目的是什么？
  13.                     if (parent != null) { 
  14.                         c = parent.loadClass(name, false);
  15.                     } else { 
  16.                           //如果parent则说明当前的parent是bootstrapClassLoader(是由C++实现的，所以为null)
  17.                         c = findBootstrapClassOrNull(name);
  18.                     }
  19.                 } catch (ClassNotFoundException e) { 
  20.                     // ClassNotFoundException thrown if class not found
  21.                     // from the non-null parent class loader
  22.                 }
  23.                                         // 如果类还是为null 
  24.                 if (c == null) { 
  25.                     // If still not found, then invoke findClass in order
  26.                     // to find the class.
  27.                     long t1 = System.nanoTime();
  28.                       // 一般我们继承classLoader 不会重写loadClass方法，不会打破双亲委派机制，一般都会重写findClass方法。
  29.                     c = findClass(name);
  30.                     // this is the defining class loader; record the stats
  31.                     sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
  32.                     sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
  33.                     sun.misc.PerfCounter.getFindClasses().increment();
  34.                 }
  35.             }
  36.             if (resolve) { 
  37.                 resolveClass(c);
  38.             }
  39.             return c;
  40.         }
  41.     }

在findClass中调用了defineClass,顺着调用链去找，最终调用defineClass1的native方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aKejPEdO-1591858909752)(/Users/zhangwanyi/Library/Application Support/typora-user-images/image-20200610160840742.png)]

第二步：找到defneClass1的native方法，开始进入JVM源码

  1. NIEXPORT jclass JNICALL
  2. Java_java_lang_ClassLoader_defineClass1(JNIEnv *env,
  3.                                         jobject loader,
  4.                                         jstring name,
  5.                                         jbyteArray data,
  6.                                         jint offset,
  7.                                         jint length,
  8.                                         jobject pd,
  9.                                         jstring source){ 
  10.   //主要的方法，其余的判断赋值等省略
  11.   result = JVM_DefineClassWithSource(env, utfName, loader, body, length, pd, utfSource);
  12.     return result;
  13. }

JVM_DefineClassWithSource \JVM_DefineClass()\JVM_DefineClassWithSourceCond()统一实现方法：

jvm.cpp::jvm_define_class_common

  1. JVM_ENTRY(jclass, JVM_DefineClassWithSource(JNIEnv *env, const char *name, jobject loader, const jbyte *buf, jsize len, jobject pd, const char *source))
  2.   JVMWrapper2("JVM_DefineClassWithSource %s", name);
  3.     //调用 jvm_define_class_common方法
  4.   return jvm_define_class_common(env, name, loader, buf, len, pd, source, true, THREAD);
  5. JVM_END

`jvm.cpp::jvm_define_class_common

  1. static jclass jvm_define_class_common(JNIEnv *env,
  2.                                       const char *name , //类名
  3.                                       jobject loader, //
  4.                                       const jbyte *buf,
  5.                                       jsize len, jobject pd, const char *source,
  6.                                       jboolean verify, TRAPS) { 
  7.   if (source == NULL)  source = "__JVM_DefineClass__";
  9.   ///部分代码省略
  11.   JavaThread* jt = (JavaThread*) THREAD;
  12.   if (UsePerfData) { 
  13.     ClassLoader::perf_app_classfile_bytes_read()->inc(len);
  14.   }
  16.   // Since exceptions can be thrown, class initialization can take place
  17.   // if name is NULL no check for class name in .class stream has to be made.
  18.   // 检查name为null，则可以初始化，因此无需检查.class中的类名
  19.   TempNewSymbol class_name = NULL;
  20.   if (name != NULL) { 
  21.     const int str_len = (int)strlen(name);
  22.     // 检查str_len长度大于(1 << 16)-1 =>65535 主要是全限定名不支持大于65535，超过则 抛出NoClassDefFoundError
  23.     if (str_len > Symbol::max_length()) { 
  24.       // It's impossible to create this class; the name cannot fit
  25.       // into the constant pool.
  26.       THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
  27.     }
  28.     // 创建一个Symbol用于存储全限定名
  29.     class_name = SymbolTable::new_symbol(name, str_len, CHECK_NULL);
  30.   }
  32.   ResourceMark rm(THREAD);
  33.       //类流文件指向source地址，读取相关信息
  34.   ClassFileStream st((u1*) buf, len, (char *)source);
  35.   Handle class_loader (THREAD, JNIHandles::resolve(loader));
  36.   if (UsePerfData) { 
  37.     is_lock_held_by_thread(class_loader,
  38.                            ClassLoader::sync_JVMDefineClassLockFreeCounter(),
  39.                            THREAD);
  40.   }
  41.   Handle protection_domain (THREAD, JNIHandles::resolve(pd));
  42.       //解析类文件并验证 重点方法，并生成Kiass文件 
  43.   Klass* k = SystemDictionary::resolve_from_stream(class_name, class_loader,
  44.                                                      protection_domain, &st,
  45.                                                      verify != 0,
  46.                                                      CHECK_NULL);
  47.   return (jclass) JNIHandles::make_local(env, k->java_mirror());
  48. }

进一步进入 SystemDictionary::resolve_from_stream ，里面最后调用了ClassFileParser::parseClassFile，该方法用于解析class文件，里面代码非常长，我们重点讲解，要有耐心看完！

以下要对class类结构十分熟悉，如果不清楚，请先看文章：

https://blog.csdn.net/qq\_31430665/article/details/106281119 文章讲解《class文件解析，官方直译》

  1. instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
  2.                                                     ClassLoaderData* loader_data,
  3.                                                     Handle protection_domain,
  4.                                                     KlassHandle host_klass,
  5.                                                     GrowableArray<Handle>* cp_patches,
  6.                                                     TempNewSymbol& parsed_name,
  7.                                                     bool verify,
  8.                                                     TRAPS) {
  10.   JvmtiCachedClassFileData *cached_class_file = NULL;
  11.   Handle class_loader(THREAD, loader_data->class_loader());
  12.   bool has_default_methods = false;
  13.   bool declares_default_methods = false;
  14.   ResourceMark rm(THREAD);
  15.   ClassFileStream* cfs = stream();
  16.   JavaThread* jt = (JavaThread*) THREAD;
  18.   PerfClassTraceTime ctimer(ClassLoader::perf_class_parse_time(),
  19.                             ClassLoader::perf_class_parse_selftime(),
  20.                             NULL,
  21.                             jt->get_thread_stat()->perf_recursion_counts_addr(),
  22.                             jt->get_thread_stat()->perf_timers_addr(),
  23.                             PerfClassTraceTime::PARSE_CLASS);
  25.   init_parsed_class_attributes(loader_data);
  27.   if (JvmtiExport::should_post_class_file_load_hook()) {
  28.     // Get the cached class file bytes (if any) from the class that
  29.     // is being redefined or retransformed. We use jvmti_thread_state()
  30.     // instead of JvmtiThreadState::state_for(jt) so we don't allocate
  31.     // a JvmtiThreadState any earlier than necessary. This will help
  32.     // avoid the bug described by 7126851.
  33.     JvmtiThreadState *state = jt->jvmti_thread_state();
  34.     if (state != NULL) {
  35.       KlassHandle *h_class_being_redefined =
  36.                      state->get_class_being_redefined();
  37.       if (h_class_being_redefined != NULL) {
  38.         instanceKlassHandle ikh_class_being_redefined =
  39.           instanceKlassHandle(THREAD, (*h_class_being_redefined)());
  40.         cached_class_file = ikh_class_being_redefined->get_cached_class_file();
  41.       }
  42.     }
  44.     unsigned char* ptr = cfs->buffer();
  45.     unsigned char* end_ptr = cfs->buffer() + cfs->length();
  47.     JvmtiExport::post_class_file_load_hook(name, class_loader(), protection_domain,
  48.                                            &ptr, &end_ptr, &cached_class_file);
  50.     if (ptr != cfs->buffer()) {
  51.       // JVMTI agent has modified class file data.
  52.       // Set new class file stream using JVMTI agent modified
  53.       // class file data.
  54.       cfs = new ClassFileStream(ptr, end_ptr - ptr, cfs->source());
  56.       set_stream(cfs);
  57.     }
  58.   }
  60.   _host_klass = host_klass;
  61.   _cp_patches = cp_patches;
  63.   instanceKlassHandle nullHandle;
  65.   // Figure out whether we can skip format checking (matching classic VM behavior)
  66.   // 是否可以跳过验证，DumpSharedSpaces：共享的Metaspace空间dump到一个文件中
  67.   if (DumpSharedSpaces) {
  68.     // verify == true means it's a 'remote' class (i.e., non-boot class)
  69.     // Verification decision is based on BytecodeVerificationRemote flag
  70.     // for those classes.
  71.     // BytecodeVerificationRemote 为 true
  72.     // BytecodeVerificationLocal 为 false
  73.     _need_verify = (verify) ? BytecodeVerificationRemote :
  74.                               BytecodeVerificationLocal;
  75.   } else {
  76.     // 如果 class_loader==null 或者verify=false 的时候 则不需要验证，即_need_verify=false
  77.     _need_verify = Verifier::should_verify_for(class_loader(), verify=false 的时候 );
  78.   }
  79.   // Set the verify flag in stream
  80.   cfs->set_verify(_need_verify);
  82.   // Save the class file name for easier error message printing.
  83.   // 保存类文件名，以便更轻松地打印错误消息。
  84.   _class_name = (name != NULL) ? name : vmSymbols::unknown_class_name();
  86.   cfs->guarantee_more(8, CHECK_(nullHandle));  // magic, major, minor
  87.   // Magic value
  88.   // 获取magic 固定值：0xCAFEBABE
  89.   u4 magic = cfs->get_u4_fast();
  90.   guarantee_property(magic == JAVA_CLASSFILE_MAGIC,//0xCAFEBABE
  91.                      "Incompatible magic value %u in class file %s",
  92.                      magic, CHECK_(nullHandle));
  94.   // Version numbers
  95.   // 获取版本 minor_version=0，暂时没用到这个值
  96.   // major_version 为jdk版本，如jdk8 表示0X0034->52 jdk7->51 jdk6 ->50 jdk5->49
  97.   u2 minor_version = cfs->get_u2_fast();
  98.   u2 major_version = cfs->get_u2_fast();
  100.   if (DumpSharedSpaces && major_version < JAVA_1_5_VERSION) {
  101.     ResourceMark rm;
  102.     warning("Pre JDK 1.5 class not supported by CDS: %u.%u %s",
  103.             major_version,  minor_version, name->as_C_string());
  104.     Exceptions::fthrow(
  105.       THREAD_AND_LOCATION,
  106.       vmSymbols::java_lang_UnsupportedClassVersionError(),
  107.       "Unsupported major.minor version for dump time %u.%u",
  108.       major_version,
  109.       minor_version);
  110.   }
  112.   // Check version numbers - we check this even with verifier off
  113.   // 检查版本，
  114.   if (!is_supported_version(major_version, minor_version)) {
  115.     if (name == NULL) {
  116.       Exceptions::fthrow(
  117.         THREAD_AND_LOCATION,
  118.         vmSymbols::java_lang_UnsupportedClassVersionError(),
  119.         "Unsupported class file version %u.%u, "
  120.         "this version of the Java Runtime only recognizes class file versions up to %u.%u",
  121.         major_version,
  122.         minor_version,
  123.         JAVA_MAX_SUPPORTED_VERSION,
  124.         JAVA_MAX_SUPPORTED_MINOR_VERSION);
  125.     } else {
  126.       ResourceMark rm(THREAD);
  127.       Exceptions::fthrow(
  128.         THREAD_AND_LOCATION,
  129.         vmSymbols::java_lang_UnsupportedClassVersionError(),
  130.         "%s has been compiled by a more recent version of the Java Runtime (class file version %u.%u), "
  131.         "this version of the Java Runtime only recognizes class file versions up to %u.%u",
  132.         name->as_C_string(),
  133.         major_version,
  134.         minor_version,
  135.         JAVA_MAX_SUPPORTED_VERSION,
  136.         JAVA_MAX_SUPPORTED_MINOR_VERSION);
  137.     }
  138.     return nullHandle;
  139.   }
  141.   _major_version = major_version;
  142.   _minor_version = minor_version;
  145.   // Check if verification needs to be relaxed for this class file
  146.   // Do not restrict it to jdk1.0 or jdk1.1 to maintain backward compatibility (4982376)
  147.   // 是否放松验证？
  148.   _relax_verify = Verifier::relax_verify_for(class_loader());
  150.   // Constant pool
  151.   // 解析常量池,常量池中有14种常量，后面仔细讲解,这里分别对常量进行进行流解析，并且分配空间
  152.   constantPoolHandle cp = parse_constant_pool(CHECK_(nullHandle));
  153.     //获取常量池中的length
  154.   int cp_size = cp->length();
  156.   cfs->guarantee_more(8, CHECK_(nullHandle));  // flags, this_class, super_class, infs_len
  158.   // Access flags
  159.   AccessFlags access_flags;
  160.   // 获取到类访问修饰符，比如作用域/可变性/继承/接口类型/是否用户代码生成等
  161.   // 看代码可知 JVM_RECOGNIZED_CLASS_MODIFIERS = 二进制 0111 0110 0011 0001 16进制7631
  162.   jint flags = cfs->get_u2_fast() & JVM_RECOGNIZED_CLASS_MODIFIERS;
  163.     // 如果有JVM_ACC_INTERFACE 修饰，
  164.   // 版本小于6 并且 有 JVM_ACC_INTERFACE状态
  165.   if ((flags & JVM_ACC_INTERFACE) && _major_version < JAVA_6_VERSION) {
  166.     // Set abstract bit for old class files for backward compatibility
  167.     // 6版本以前没有INTERFACE 中都是采用 ABSTRACT 类的形式
  168.     flags |= JVM_ACC_ABSTRACT;
  169.   }
  170.   verify_legal_class_modifiers(flags, CHECK_(nullHandle));
  171.   access_flags.set_flags(flags);
  173.   // This class and superclass
  174.   // 获取 this_class_index 的index
  175.   u2 this_class_index = cfs->get_u2_fast();
  176.   check_property(
  177.     valid_cp_range(this_class_index, cp_size) &&
  178.       cp->tag_at(this_class_index).is_unresolved_klass(),
  179.     "Invalid this class index %u in constant pool in class file %s",
  180.     this_class_index, CHECK_(nullHandle));
  182.   Symbol*  class_name  = cp->unresolved_klass_at(this_class_index);
  183.   assert(class_name != NULL, "class_name can't be null");
  185.   // It's important to set parsed_name *before* resolving the super class.
  186.   // (it's used for cleanup by the caller if parsing fails)
  187.   parsed_name = class_name;
  188.   // parsed_name is returned and can be used if there's an error, so add to
  189.   // its reference count.  Caller will decrement the refcount.
  190.   // 自增引用数
  191.   parsed_name->increment_refcount();
  193.   // Update _class_name which could be null previously to be class_name
  194.   _class_name = class_name;
  196.   // Don't need to check whether this class name is legal or not.
  197.   // It has been checked when constant pool is parsed.
  198.   // However, make sure it is not an array type.
  199.   // 无需检查其他的，只要保证不是数组就可以。其他项在常量池的时候已经被解析过了
  200.   if (_need_verify) {
  201.     guarantee_property(class_name->byte_at(0) != JVM_SIGNATURE_ARRAY,
  202.                        "Bad class name in class file %s",
  203.                        CHECK_(nullHandle));
  204.   }
  206.   Klass* preserve_this_klass;   // for storing result across HandleMark
  207. -------------------------------可忽略-------------------------------
  208.   // release all handles when parsing is done
  209.   { HandleMark hm(THREAD);
  211.     // Checks if name in class file matches requested name
  212.     if (name != NULL && class_name != name) {
  213.       ResourceMark rm(THREAD);
  214.       Exceptions::fthrow(
  215.         THREAD_AND_LOCATION,
  216.         vmSymbols::java_lang_NoClassDefFoundError(),
  217.         "%s (wrong name: %s)",
  218.         name->as_C_string(),
  219.         class_name->as_C_string()
  220.       );
  221.       return nullHandle;
  222.     }
  224.     if (TraceClassLoadingPreorder) {
  225.       tty->print("[Loading %s", (name != NULL) ? name->as_klass_external_name() : "NoName");
  226.       if (cfs->source() != NULL) tty->print(" from %s", cfs->source());
  227.       tty->print_cr("]");
  228.     }
  229. #if INCLUDE_CDS
  230.     if (DumpLoadedClassList != NULL && cfs->source() != NULL && classlist_file->is_open()) {
  231.       // Only dump the classes that can be stored into CDS archive
  232.       if (SystemDictionaryShared::is_sharing_possible(loader_data)) {
  233.         if (name != NULL) {
  234.           ResourceMark rm(THREAD);
  235.           classlist_file->print_cr("%s", name->as_C_string());
  236.           classlist_file->flush();
  237.         }
  238.       }
  239.     }
  240. #endif
  241. -------------------------------可忽略-------------------------------
  242.   //获取super_class 
  243.     u2 super_class_index = cfs->get_u2_fast();
  244.    //从 JVM_CONSTANT_Class 常量池里获取
  245.     instanceKlassHandle super_klass = parse_super_class(super_class_index,
  246.                                                         CHECK_NULL);
  247.     // Interfaces count
  248.     u2 itfs_len = cfs->get_u2_fast();
  249.        // 开始解析interfaces 后面会仔细讲解
  250.     Array<Klass*>* local_interfaces =parse_interfaces(itfs_len, protection_domain, _class_name, &has_default_methods, CHECK_(nullHandle));
  252.     u2 java_fields_count = 0;
  253.     // Fields (offsets are filled in later)
  254.     FieldAllocationCount fac;
  255.        // 开始解析fields 后面会仔细讲解
  256.     Array<u2>* fields = parse_fields(class_name,
  257.                                      access_flags.is_interface(),
  258.                                      &fac, &java_fields_count,
  259.                                      CHECK_(nullHandle));
  260.     // Methods
  261.        // 进行Methods解析 后面会仔细讲解
  262.     bool has_final_method = false;
  263.     AccessFlags promoted_flags;
  264.     promoted_flags.set_flags(0);
  265.     Array<Method*>* methods = parse_methods(access_flags.is_interface(),
  266.                                             &promoted_flags,
  267.                                             &has_final_method,
  268.                                             &declares_default_methods,
  269.                                             CHECK_(nullHandle));
  270.        // 是否声明了默认的方法 (default 关键字，接口里支持)
  271.     if (declares_default_methods) {
  272.       has_default_methods = true;
  273.     }
  275.     // Additional attributes
  276.        // 属性解析 后面会仔细讲解
  277.     ClassAnnotationCollector parsed_annotations;
  278.     parse_classfile_attributes(&parsed_annotations, CHECK_(nullHandle));
  280.     // Finalize the Annotations metadata object,
  281.     // now that all annotation arrays have been created.
  282.        // 创建注解 
  283.     create_combined_annotations(CHECK_(nullHandle));
  285.     // Make sure this is the end of class file stream
  286.     guarantee_property(cfs->at_eos(), "Extra bytes at the end of class file %s", CHECK_(nullHandle));
  288.     // We check super class after class file is parsed and format is checked
  289.     if (super_class_index > 0 && super_klass.is_null()) {
  290.       Symbol*  sk  = cp->klass_name_at(super_class_index);
  291.       if (access_flags.is_interface()) {
  292.         // Before attempting to resolve the superclass, check for class format
  293.         // errors not checked yet.
  294.         guarantee_property(sk == vmSymbols::java_lang_Object(),
  295.                            "Interfaces must have java.lang.Object as superclass in class file %s",
  296.                            CHECK_(nullHandle));
  297.       }
  298.       Klass* k = SystemDictionary::resolve_super_or_fail(class_name, sk,
  299.                                                          class_loader,
  300.                                                          protection_domain,
  301.                                                          true,
  302.                                                          CHECK_(nullHandle));
  304.       KlassHandle kh (THREAD, k);
  305.       super_klass = instanceKlassHandle(THREAD, kh());
  306.     }
  307.     if (super_klass.not_null()) {
  309.       if (super_klass->has_default_methods()) {
  310.         has_default_methods = true;
  311.       }
  313.       if (super_klass->is_interface()) {
  314.         ResourceMark rm(THREAD);
  315.         Exceptions::fthrow(
  316.           THREAD_AND_LOCATION,
  317.           vmSymbols::java_lang_IncompatibleClassChangeError(),
  318.           "class %s has interface %s as super class",
  319.           class_name->as_klass_external_name(),
  320.           super_klass->external_name()
  321.         );
  322.         return nullHandle;
  323.       }
  324.       // Make sure super class is not final
  325.       if (super_klass->is_final()) {
  326.         THROW_MSG_(vmSymbols::java_lang_VerifyError(), "Cannot inherit from final class", nullHandle);
  327.       }
  328.     }
  330.     // save super klass for error handling.
  331.        // 保存super类，为了做错误处理
  332.     _super_klass = super_klass;
  334.     // Compute the transitive list of all unique interfaces implemented by this class
  335.        // 通过super_klass 和 local_interfaces接口传递的接口
  336.     _transitive_interfaces =
  337.           compute_transitive_interfaces(super_klass, local_interfaces, CHECK_(nullHandle));
  339.     // sort methods
  340.        // 对类进行排序
  341.     intArray* method_ordering = sort_methods(methods);
  343.     // promote flags from parse_methods() to the klass' flags
  344.     access_flags.add_promoted_flags(promoted_flags.as_int());
  346.     // Size of Java vtable (in words)
  347.     int vtable_size = 0;
  348.     int itable_size = 0;
  349.     int num_miranda_methods = 0;
  351.     GrowableArray<Method*> all_mirandas(20);
  353.     klassVtable::compute_vtable_size_and_num_mirandas(
  354.         &vtable_size, &num_miranda_methods, &all_mirandas, super_klass(), methods,
  355.         access_flags, class_loader, class_name, local_interfaces,
  356.                                                       CHECK_(nullHandle));
  358.     // Size of Java itable (in words)
  359.     itable_size = access_flags.is_interface() ? 0 : klassItable::compute_itable_size(_transitive_interfaces);
  361.     FieldLayoutInfo info;
  362.     layout_fields(class_loader, &fac, &parsed_annotations, &info, CHECK_NULL);
  364.     int total_oop_map_size2 =
  365.           InstanceKlass::nonstatic_oop_map_size(info.total_oop_map_count);
  367.     // Compute reference type
  368.     ReferenceType rt;
  369.     if (super_klass() == NULL) {
  370.       rt = REF_NONE;
  371.     } else {
  372.       rt = super_klass->reference_type();
  373.     }
  375.     // We can now create the basic Klass* for this klass
  376.        // 开始根据classLoader创建klass对象
  377.     _klass = InstanceKlass::allocate_instance_klass(loader_data,
  378.                                                     vtable_size,
  379.                                                     itable_size,
  380.                                                     info.static_field_size,
  381.                                                     total_oop_map_size2,
  382.                                                     rt,
  383.                                                     access_flags,
  384.                                                     name,
  385.                                                     super_klass(),
  386.                                                     !host_klass.is_null(),
  387.                                                     CHECK_(nullHandle));
  388.     instanceKlassHandle this_klass (THREAD, _klass);
  390.     assert(this_klass->static_field_size() == info.static_field_size, "sanity");
  391.     assert(this_klass->nonstatic_oop_map_count() == info.total_oop_map_count,
  392.            "sanity");
  394.     // Fill in information already parsed
  396.     this_klass->set_should_verify_class(verify);
  397.     jint lh = Klass::instance_layout_helper(info.instance_size, false);
  398.     this_klass->set_layout_helper(lh);
  399.     assert(this_klass->oop_is_instance(), "layout is correct");
  400.     assert(this_klass->size_helper() == info.instance_size, "correct size_helper");
  401.     // Not yet: supers are done below to support the new subtype-checking fields
  402.     //this_klass->set_super(super_klass());
  403.     this_klass->set_class_loader_data(loader_data);
  404.     this_klass->set_nonstatic_field_size(info.nonstatic_field_size);
  405.     this_klass->set_has_nonstatic_fields(info.has_nonstatic_fields);
  406.     this_klass->set_static_oop_field_count(fac.count[STATIC_OOP]);
  407.         //将类加载的信息赋值给元数据
  408.     /**
  409.         //cp位常量池
  410.       _cp->set_pool_holder(this_klass());
  411.       //设置klass的常量池
  412.       this_klass->set_constants(_cp);
  413.       //设置该类的field字段
  414.       this_klass->set_fields(_fields, java_fields_count);
  415.       //设置该类的方法
  416.       this_klass->set_methods(_methods);
  417.       //设置该类的内部类
  418.       this_klass->set_inner_classes(_inner_classes);
  419.       //设置该类的接口
  420.       this_klass->set_local_interfaces(_local_interfaces);
  421.       this_klass->set_transitive_interfaces(_transitive_interfaces);
  422.       //设置该类的注解
  423.       this_klass->set_annotations(_combined_annotations);
  424.       //清除_cp，_fields，_methods，_inner_classes
  425.       clear_class_metadata();
  426.     */
  427.     apply_parsed_class_metadata(this_klass, java_fields_count, CHECK_NULL);
  429.     if (has_final_method) {
  430.       this_klass->set_has_final_method();
  431.     }
  432.     this_klass->copy_method_ordering(method_ordering, CHECK_NULL);
  433.     // The InstanceKlass::_methods_jmethod_ids cache
  434.     // is managed on the assumption that the initial cache
  435.     // size is equal to the number of methods in the class. If
  436.     // that changes, then InstanceKlass::idnum_can_increment()
  437.     // has to be changed accordingly.
  438.     this_klass->set_initial_method_idnum(methods->length());
  439.     this_klass->set_name(cp->klass_name_at(this_class_index));
  440.     if (is_anonymous())  // I am well known to myself
  441.       cp->klass_at_put(this_class_index, this_klass()); // eagerly resolve
  442.         // 相关数据 赋值给klass 
  443.     this_klass->set_minor_version(minor_version);
  444.     this_klass->set_major_version(major_version);
  445.     this_klass->set_has_default_methods(has_default_methods);
  446.     this_klass->set_declares_default_methods(declares_default_methods);
  448.     if (!host_klass.is_null()) {
  449.       assert (this_klass->is_anonymous(), "should be the same");
  450.       this_klass->set_host_klass(host_klass());
  451.     }
  453.     // Set up Method*::intrinsic_id as soon as we know the names of methods.
  454.     // (We used to do this lazily, but now we query it in Rewriter,
  455.     // which is eagerly done for every method, so we might as well do it now,
  456.     // when everything is fresh in memory.)
  457.     if (Method::klass_id_for_intrinsics(this_klass()) != vmSymbols::NO_SID) {
  458.       for (int j = 0; j < methods->length(); j++) {
  459.         methods->at(j)->init_intrinsic_id();
  460.       }
  461.     }
  463.     if (cached_class_file != NULL) {
  464.       // JVMTI: we have an InstanceKlass now, tell it about the cached bytes
  465.       this_klass->set_cached_class_file(cached_class_file);
  466.     }
  468.     // Fill in field values obtained by parse_classfile_attributes
  469.     if (parsed_annotations.has_any_annotations())
  470.       parsed_annotations.apply_to(this_klass);
  471.     apply_parsed_class_attributes(this_klass);
  473.     // Miranda methods
  474.     if ((num_miranda_methods > 0) ||
  475.         // if this class introduced new miranda methods or
  476.         (super_klass.not_null() && (super_klass->has_miranda_methods()))
  477.         // super class exists and this class inherited miranda methods
  478.         ) {
  479.       this_klass->set_has_miranda_methods(); // then set a flag
  480.     }
  482.     // Fill in information needed to compute superclasses.
  483.        // 初始化super类的信息
  484.     this_klass->initialize_supers(super_klass(), CHECK_(nullHandle));
  486.     // Initialize itable offset tables
  487.     klassItable::setup_itable_offset_table(this_klass);
  489.     // Compute transitive closure of interfaces this class implements
  490.     // Do final class setup
  491.     fill_oop_maps(this_klass, info.nonstatic_oop_map_count, info.nonstatic_oop_offsets, info.nonstatic_oop_counts);
  493.     // Fill in has_finalizer, has_vanilla_constructor, and layout_helper
  494.     set_precomputed_flags(this_klass);
  496.     // reinitialize modifiers, using the InnerClasses attribute
  497.     int computed_modifiers = this_klass->compute_modifier_flags(CHECK_(nullHandle));
  498.     this_klass->set_modifier_flags(computed_modifiers);
  500.     // check if this class can access its super class
  501.        // 检查是否有super类的访问权限 
  502.     check_super_class_access(this_klass, CHECK_(nullHandle));
  504.     // check if this class can access its superinterfaces
  505.        // 检查接口是否有访问权限
  506.     check_super_interface_access(this_klass, CHECK_(nullHandle));
  508.     // check if this class overrides any final method
  509.        // 检查是否重写了super的final方法
  510.     check_final_method_override(this_klass, CHECK_(nullHandle));
  512.     // check that if this class is an interface then it doesn't have static methods
  513.        // 检查是否this_klass是接口，它不能有静态方法
  514.     if (this_klass->is_interface()) {
  515.       /* An interface in a JAVA 8 classfile can be static */
  516.       // java8之后接口可以有静态方法（方法是静态&&方法名不是<cinit>）
  517.       if (_major_version < JAVA_8_VERSION) {
  518.         check_illegal_static_method(this_klass, CHECK_(nullHandle));
  519.       }
  520.     }
  522.     // Allocate mirror and initialize static fields
  523.        // 分配初始化的static字段
  524.       // 1.必须加载Class对象实例（mirror），它用于分配空间
  525.        // 2.创建java.lang.Class instance并分配空间
  526.        // 3.建立 mirror(java.lang.Class instance)-》klass的关系(对应Metadata中的klass关系)
  527.        // 4.判断是否是数组(普通数组/object数组)
  528.        // 5.初始化mirror的field
  529.        //     5.1 获取到该类的field，找到静态的变量，并初始化
  530.     java_lang_Class::create_mirror(this_klass, class_loader, protection_domain,
  531.                                    CHECK_(nullHandle));
  533.     // Generate any default methods - default methods are interface methods
  534.     // that have a default implementation.  This is new with Lambda project.
  535.        // 对default方法进行处理，有兴趣的可以看一看
  536.     if (has_default_methods ) {
  537.       DefaultMethods::generate_default_methods(
  538.           this_klass(), &all_mirandas, CHECK_(nullHandle));
  539.     }
  541.     // Update the loader_data graph.
  542.        // 记录this_klass的类中依赖，以便后续进行GC（这块没看明白，后续仔细讲解）
  543.     record_defined_class_dependencies(this_klass, CHECK_NULL);
  545.     ClassLoadingService::notify_class_loaded(InstanceKlass::cast(this_klass()),
  546.                                              false /* not shared class */);
  548.     // preserve result across HandleMark
  549.     preserve_this_klass = this_klass();
  550.   }
  552.   // Create new handle outside HandleMark (might be needed for
  553.   // Extended Class Redefinition)
  554.   instanceKlassHandle this_klass (THREAD, preserve_this_klass);
  555.   debug_only(this_klass->verify();)
  557.   // Clear class if no error has occurred so destructor doesn't deallocate it
  558.   _klass = NULL;
  559.   return this_klass;
  560. }

常量池解析parse_constant_pool讲解

  1. constantPoolHandle ClassFileParser::parse_constant_pool(TRAPS) {
  2.   //加载文件流
  3.   ClassFileStream* cfs = stream();
  4.   constantPoolHandle nullHandle;
  6.   cfs->guarantee_more(3, CHECK_(nullHandle)); // length, first cp tag
  7.   //获取常量池长度
  8.   u2 length = cfs->get_u2_fast();
  9.   guarantee_property(
  10.     length >= 1, "Illegal constant pool size %u in class file %s",
  11.     length, CHECK_(nullHandle));
  12.   ConstantPool* constant_pool = ConstantPool::allocate(_loader_data, length,
  13.                                                    CHECK_(nullHandle));
  14.   //存储constant_pool->_cp
  15.   _cp = constant_pool; // save in case of errors
  16.   constantPoolHandle cp (THREAD, constant_pool);
  18.   // parsing constant pool entries
  19.   // 重点，解析常量池中的entity
  20.   // 主要是给_cp赋值，获取流中的数据
  21.   parse_constant_pool_entries(length, CHECK_(nullHandle));
  23.   int index = 1;  // declared outside of loops for portability
  25.   // first verification pass - validate cross references and fixup class and string constants
  26.   // 遍历_cp中的值，分别进行校验
  27.   for (index = 1; index < length; index++) {          // Index 0 is unused
  28.     jbyte tag = cp->tag_at(index).value();
  29.     switch (tag) {
  30.       case JVM_CONSTANT_Class :
  31.         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present
  32.         break;
  34.       case JVM_CONSTANT_Fieldref :
  35.         // fall through
  36.       case JVM_CONSTANT_Methodref :
  37.         // fall through
  38.         //这块表明 JVM_CONSTANT_Fieldref、JVM_CONSTANT_Methodref、JVM_CONSTANT_InterfaceMethodref都先验证 nameAndType常量池和class_index，因为他们的结构是一样的
  39.       case JVM_CONSTANT_InterfaceMethodref : {
  40.         if (!_need_verify) break;
  41.         int klass_ref_index = cp->klass_ref_index_at(index);
  42.         int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
  43.         check_property(valid_klass_reference_at(klass_ref_index),
  44.                        "Invalid constant pool index %u in class file %s",
  45.                        klass_ref_index,
  46.                        CHECK_(nullHandle));
  47.         check_property(valid_cp_range(name_and_type_ref_index, length) &&
  48.                        cp->tag_at(name_and_type_ref_index).is_name_and_type(),
  49.                        "Invalid constant pool index %u in class file %s",
  50.                        name_and_type_ref_index,
  51.                        CHECK_(nullHandle));
  52.         break;
  53.       }
  54.       case JVM_CONSTANT_String :
  55.         ShouldNotReachHere();     // Only JVM_CONSTANT_StringIndex should be present
  56.         break;
  57.       case JVM_CONSTANT_Integer :
  58.         break;
  59.       case JVM_CONSTANT_Float :
  60.         break;
  61.       case JVM_CONSTANT_Long :
  62.       case JVM_CONSTANT_Double :
  63.         index++;
  64.         // 跨过两位 index++ 因为 long和double都占用8字节，high_bytes,low_types
  65.         check_property(
  66.           (index < length && cp->tag_at(index).is_invalid()),
  67.           "Improper constant pool long/double index %u in class file %s",
  68.           index, CHECK_(nullHandle));
  69.         break;
  70.       case JVM_CONSTANT_NameAndType : {
  71.         if (!_need_verify) break;
  72.         //验证descriptor/name_index
  73.         int name_ref_index = cp->name_ref_index_at(index);
  74.         int signature_ref_index = cp->signature_ref_index_at(index);
  75.         check_property(valid_symbol_at(name_ref_index),
  76.                  "Invalid constant pool index %u in class file %s",
  77.                  name_ref_index, CHECK_(nullHandle));
  78.         check_property(valid_symbol_at(signature_ref_index),
  79.                  "Invalid constant pool index %u in class file %s",
  80.                  signature_ref_index, CHECK_(nullHandle));
  81.         break;
  82.       }
  83.       case JVM_CONSTANT_Utf8 :
  84.         break;
  85.       case JVM_CONSTANT_UnresolvedClass :         // fall-through
  86.       case JVM_CONSTANT_UnresolvedClassInError:
  87.         ShouldNotReachHere();     // Only JVM_CONSTANT_ClassIndex should be present
  88.         break;
  89.       case JVM_CONSTANT_ClassIndex :
  90.         {
  91.           int class_index = cp->klass_index_at(index);
  92.           check_property(valid_symbol_at(class_index),
  93.                  "Invalid constant pool index %u in class file %s",
  94.                  class_index, CHECK_(nullHandle));
  95.           cp->unresolved_klass_at_put(index, cp->symbol_at(class_index));
  96.         }
  97.         break;
  98.       case JVM_CONSTANT_StringIndex :
  99.         {
  100.           int string_index = cp->string_index_at(index);
  101.           check_property(valid_symbol_at(string_index),
  102.                  "Invalid constant pool index %u in class file %s",
  103.                  string_index, CHECK_(nullHandle));
  104.           Symbol* sym = cp->symbol_at(string_index);
  105.           cp->unresolved_string_at_put(index, sym);
  106.         }
  107.         break;
  108.       case JVM_CONSTANT_MethodHandle :
  109.         {
  110.           int ref_index = cp->method_handle_index_at(index);
  111.           check_property(
  112.             valid_cp_range(ref_index, length) &&
  113.                 EnableInvokeDynamic,
  114.               "Invalid constant pool index %u in class file %s",
  115.               ref_index, CHECK_(nullHandle));
  116.           constantTag tag = cp->tag_at(ref_index);
  117.           int ref_kind  = cp->method_handle_ref_kind_at(index);
  119.           //reference_kind=1||2||3||4，指向CONSTANT_Fieldref_info索引，后面就这块就不细讲了，在class类结构里有
  120.           switch (ref_kind) {
  121.           case JVM_REF_getField:
  122.           case JVM_REF_getStatic:
  123.           case JVM_REF_putField:
  124.           case JVM_REF_putStatic:
  125.             check_property(
  126.               tag.is_field(),
  127.               "Invalid constant pool index %u in class file %s (not a field)",
  128.               ref_index, CHECK_(nullHandle));
  129.             break;
  130.           case JVM_REF_invokeVirtual:
  131.           case JVM_REF_newInvokeSpecial:
  132.             check_property(
  133.               tag.is_method(),
  134.               "Invalid constant pool index %u in class file %s (not a method)",
  135.               ref_index, CHECK_(nullHandle));
  136.             break;
  137.           case JVM_REF_invokeStatic:
  138.           case JVM_REF_invokeSpecial:
  139.             check_property(tag.is_method() ||
  140.                            ((_major_version >= JAVA_8_VERSION) && tag.is_interface_method()),
  141.                "Invalid constant pool index %u in class file %s (not a method)",
  142.                ref_index, CHECK_(nullHandle));
  143.              break;
  144.           case JVM_REF_invokeInterface:
  145.             check_property(
  146.               tag.is_interface_method(),
  147.               "Invalid constant pool index %u in class file %s (not an interface method)",
  148.               ref_index, CHECK_(nullHandle));
  149.             break;
  150.           default:
  151.             classfile_parse_error(
  152.               "Bad method handle kind at constant pool index %u in class file %s",
  153.               index, CHECK_(nullHandle));
  154.           }
  155.           // Keep the ref_index unchanged.  It will be indirected at link-time.
  156.         }
  157.         break;
  158.       case JVM_CONSTANT_MethodType :
  159.         {
  160.           int ref_index = cp->method_type_index_at(index);
  161.           check_property(valid_symbol_at(ref_index) && EnableInvokeDynamic,
  162.                  "Invalid constant pool index %u in class file %s",
  163.                  ref_index, CHECK_(nullHandle));
  164.         }
  165.         break;
  166.       case JVM_CONSTANT_InvokeDynamic :
  167.         {
  168.           int name_and_type_ref_index = cp->invoke_dynamic_name_and_type_ref_index_at(index);
  169.           check_property(valid_cp_range(name_and_type_ref_index, length) &&
  170.                          cp->tag_at(name_and_type_ref_index).is_name_and_type(),
  171.                          "Invalid constant pool index %u in class file %s",
  172.                          name_and_type_ref_index,
  173.                          CHECK_(nullHandle));
  174.           // bootstrap specifier index must be checked later, when BootstrapMethods attr is available
  175.           break;
  176.         }
  177.       default:
  178.         fatal(err_msg("bad constant pool tag value %u",
  179.                       cp->tag_at(index).value()));
  180.         ShouldNotReachHere();
  181.         break;
  182.     } // end of switch
  183.   } // end of for
  185.   if (_cp_patches != NULL) {
  186.     // need to treat this_class specially...
  187.     assert(EnableInvokeDynamic, "");
  188.     int this_class_index;
  189.     {
  190.       cfs->guarantee_more(8, CHECK_(nullHandle));  // flags, this_class, super_class, infs_len
  191.       u1* mark = cfs->current();
  192.       u2 flags         = cfs->get_u2_fast();
  193.       this_class_index = cfs->get_u2_fast();
  194.       cfs->set_current(mark);  // revert to mark
  195.     }
  197.     for (index = 1; index < length; index++) {          // Index 0 is unused
  198.       if (has_cp_patch_at(index)) {
  199.         guarantee_property(index != this_class_index,
  200.                            "Illegal constant pool patch to self at %d in class file %s",
  201.                            index, CHECK_(nullHandle));
  202.         patch_constant_pool(cp, index, cp_patch_at(index), CHECK_(nullHandle));
  203.       }
  204.     }
  205.   }
  207.   if (!_need_verify) {
  208.     return cp;
  209.   }
  211.   // second verification pass - checks the strings are of the right format.
  212.   // but not yet to the other entries
  213.   // 第二步验证通过，检查string的格式
  214.   for (index = 1; index < length; index++) {
  215.     jbyte tag = cp->tag_at(index).value();
  216.     switch (tag) {
  217.       case JVM_CONSTANT_UnresolvedClass: {
  218.         Symbol*  class_name = cp->unresolved_klass_at(index);
  219.         // check the name, even if _cp_patches will overwrite it
  220.         verify_legal_class_name(class_name, CHECK_(nullHandle));
  221.         break;
  222.       }
  223.       case JVM_CONSTANT_NameAndType: {
  224.         if (_need_verify && _major_version >= JAVA_7_VERSION) {
  225.           int sig_index = cp->signature_ref_index_at(index);
  226.           int name_index = cp->name_ref_index_at(index);
  227.           Symbol*  name = cp->symbol_at(name_index);
  228.           Symbol*  sig = cp->symbol_at(sig_index);
  229.           if (sig->byte_at(0) == JVM_SIGNATURE_FUNC) {
  230.             verify_legal_method_signature(name, sig, CHECK_(nullHandle));
  231.           } else {
  232.             verify_legal_field_signature(name, sig, CHECK_(nullHandle));
  233.           }
  234.         }
  235.         break;
  236.       }
  237.       case JVM_CONSTANT_InvokeDynamic:
  238.       case JVM_CONSTANT_Fieldref:
  239.       case JVM_CONSTANT_Methodref:
  240.       case JVM_CONSTANT_InterfaceMethodref: {
  241.         int name_and_type_ref_index = cp->name_and_type_ref_index_at(index);
  242.         // already verified to be utf8
  243.         int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
  244.         // already verified to be utf8
  245.         int signature_ref_index = cp->signature_ref_index_at(name_and_type_ref_index);
  246.         Symbol*  name = cp->symbol_at(name_ref_index);
  247.         Symbol*  signature = cp->symbol_at(signature_ref_index);
  248.         if (tag == JVM_CONSTANT_Fieldref) {
  249.           verify_legal_field_name(name, CHECK_(nullHandle));
  250.           if (_need_verify && _major_version >= JAVA_7_VERSION) {
  251.             // Signature is verified above, when iterating NameAndType_info.
  252.             // Need only to be sure it's the right type.
  253.             if (signature->byte_at(0) == JVM_SIGNATURE_FUNC) {
  254.               throwIllegalSignature(
  255.                   "Field", name, signature, CHECK_(nullHandle));
  256.             }
  257.           } else {
  258.             verify_legal_field_signature(name, signature, CHECK_(nullHandle));
  259.           }
  260.         } else {
  261.           verify_legal_method_name(name, CHECK_(nullHandle));
  262.           if (_need_verify && _major_version >= JAVA_7_VERSION) {
  263.             // Signature is verified above, when iterating NameAndType_info.
  264.             // Need only to be sure it's the right type.
  265.             if (signature->byte_at(0) != JVM_SIGNATURE_FUNC) {
  266.               throwIllegalSignature(
  267.                   "Method", name, signature, CHECK_(nullHandle));
  268.             }
  269.           } else {
  270.             verify_legal_method_signature(name, signature, CHECK_(nullHandle));
  271.           }
  272.           if (tag == JVM_CONSTANT_Methodref) {
  273.             // 4509014: If a class method name begins with '<', it must be "<init>".
  274.             assert(name != NULL, "method name in constant pool is null");
  275.             unsigned int name_len = name->utf8_length();
  276.             assert(name_len > 0, "bad method name");  // already verified as legal name
  277.             if (name->byte_at(0) == '<') {
  278.               if (name != vmSymbols::object_initializer_name()) {
  279.                 classfile_parse_error(
  280.                   "Bad method name at constant pool index %u in class file %s",
  281.                   name_ref_index, CHECK_(nullHandle));
  282.               }
  283.             }
  284.           }
  285.         }
  286.         break;
  287.       }
  288.       case JVM_CONSTANT_MethodHandle: {
  289.         int ref_index = cp->method_handle_index_at(index);
  290.         int ref_kind  = cp->method_handle_ref_kind_at(index);
  291.         switch (ref_kind) {
  292.         case JVM_REF_invokeVirtual:
  293.         case JVM_REF_invokeStatic:
  294.         case JVM_REF_invokeSpecial:
  295.         case JVM_REF_newInvokeSpecial:
  296.           {
  297.             int name_and_type_ref_index = cp->name_and_type_ref_index_at(ref_index);
  298.             int name_ref_index = cp->name_ref_index_at(name_and_type_ref_index);
  299.             Symbol*  name = cp->symbol_at(name_ref_index);
  300.             if (ref_kind == JVM_REF_newInvokeSpecial) {
  301.               if (name != vmSymbols::object_initializer_name()) {
  302.                 classfile_parse_error(
  303.                   "Bad constructor name at constant pool index %u in class file %s",
  304.                   name_ref_index, CHECK_(nullHandle));
  305.               }
  306.             } else {
  307.               if (name == vmSymbols::object_initializer_name()) {
  308.                 classfile_parse_error(
  309.                   "Bad method name at constant pool index %u in class file %s",
  310.                   name_ref_index, CHECK_(nullHandle));
  311.               }
  312.             }
  313.           }
  314.           break;
  315.           // Other ref_kinds are already fully checked in previous pass.
  316.         }
  317.         break;
  318.       }
  319.       case JVM_CONSTANT_MethodType: {
  320.         Symbol* no_name = vmSymbols::type_name(); // place holder
  321.         Symbol*  signature = cp->method_type_signature_at(index);
  322.         verify_legal_method_signature(no_name, signature, CHECK_(nullHandle));
  323.         break;
  324.       }
  325.       case JVM_CONSTANT_Utf8: {
  326.         assert(cp->symbol_at(index)->refcount() != 0, "count corrupted");
  327.       }
  328.     }  // end of switch
  329.   }  // end of for
  331.   return cp;
  332. }

发表评论

表情：
评论列表 （有 0 条评论，38人围观）

还没有评论，来说两句吧...

相关阅读

    相关 JVM加载class文件的原理

    类加载的主要步骤分为以下3步: 1).装载.根据查找路径找到相对应的class文件,然后导入. 2).链接.链接又可以分为3个小的步骤,具体如下.     1.检查.检查

    迷南。迷南。/ 0 赞/ 339 阅读

    相关 class文件的加载过程

    1、在加载class文件的时候，JVM会先加载类中的所有静态成员( 方法，变量，静态代码块 )都加载到方法区class文件的所处静态区中 2、当把所有的静态成员加载完成之后，

    傷城~傷城~/ 0 赞/ 701 阅读