JVM

一、介绍

二、目录(不定时更新......)

(一)类加载模块

0.一切的开始

0.5初识字节码文件

1.字节码文件读取到内存

2.解析内存中的字节码文件

2.1解析"魔数"

2.2解析"版本号"

2.3解析"Class常量池"

2.4解析"访问权限"

2.5解析"类名 && 父类名"

2.6解析"接口"

2.7解析"字段"

2.8解析"方法"

2.9解析"属性"

3.类加载器

(二)执行引擎

1.cpu是如何执行指令的

2.cpu是如何执行方法的

3.初识JVM执行器

3.1JVM指令集

3.2参数/返回值的传递

3.3执行器概念

3.4方法执行理论示例

4.字节码解释器

4.1执行环境

4.2指令解释

4.2.1JVM指令格式 与 nop指令的实现

4.2.2getstatic指令的实现

4.2.3iconst0指令的实现

4.2.4putstatic指令的实现

4.2.5ldc指令的实现

4.2.6dup指令的实现

4.2.7aload0、aload1指令的实现

4.2.8new指令的实现

4.2.9invokevirtual指令的实现

4.2.10invokespecial指令的实现

4.2.11本地方法的调用

4.2.12return指令的实现

4.3终于完成Hello JVM 的打印

4.3.1自定义JDK的准备

4.3.2成功打印

5.模版解释器

5.1初步认识

5.2机器指令入口CallStub

5.2.1CallStub简介

5.2.2CallStub实现

5.3方法执行环境的准备entry_point

6.执行引擎完结

(三)内存池

1.Java进程总内存

2.堆区

3.方法区

(四)GC

1.标记 && 清除 && 整理

2.新生代 && 老年代

(五)即时编译

(六)扩展内容

(七)勘误

1.解析常量池时多循环了一次

2.LDC指令中因内存失效而产生的bug

三、猛男讲解

(一)类加载模块

 首先用你的IDEA,新建一个javaClass,输出 "Hello JVM",并将其运行,相信这对于聪明的你易如反掌,就犹如探囊取物。

 
public class HelloJVM {
 public static void main(String[] args) {
 System.out.println("Hello JVM");
 }
}
 

class ClassRead {
 char *data;
 int cur = 0;
public:
 //构造方法
 ClassRead(char *data);
 //根据路径读取.class文件
 static ClassRead* readByPath(string path);
 unsigned char readByOneByte();//往后读取一个字节
 unsigned short readByTwoByte();//往后读取两个字节
 unsigned int readByFourByte();//往后读取四个字节
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/e/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 printf("%X\n", classRead->readByFourByte());
 return 0;
}

class InstanceKlass {
 int magic; //魔数,CAFEBABE:用来校验是否是.class文件
 
};

class ClassFileParser {
public:
 static InstanceKlass* Parser(ClassRead *classRead);
 static void checkAndPutMagic(ClassRead *classRead, InstanceKlass *klass);
};

InstanceKlass *ClassFileParser::Parser(ClassRead *classRead) {
 InstanceKlass *klass = new InstanceKlass//创建klass对象用来存储.class文件中的信息;
 checkAndPutMagic(classRead, klass);//校验是否是class文件
 return klass;
}
void ClassFileParser::checkAndPutMagic(ClassRead *classRead, InstanceKlass *klass) {
 klass->setMagic(classRead->readByFourByte());
 if (klass->getMagic() == MAGIC) { //MAGIC : CAFEBABE
 printf("class文件校验正确\n");
 return;
 }
 printf("class文件校验错误,%X\n", klass->getMagic());
}

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/eba/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 printf("%X\n", klass->getMagic());
 return 0;
}

class InstanceKlass {
 int magic; //魔数,CAFEBABE:用来校验是否是.class文件
 short minorVersion; //JDK次版本号
 short majorVersion; //JDK主版本号
}

InstanceKlass *ClassFileParser::Parser(ClassRead *classRead) {
 InstanceKlass *klass = new InstanceKlass;
 checkAndPutMagic(classRead, klass);//校验是否是class文件
 checkAndPutVersion(classRead, klass);//校验版本号
 return klass;
}
void ClassFileParser::checkAndPutVersion(ClassRead *classRead, InstanceKlass *klass) {
 klass->setMinorVersion(classRead->readByTwoByte());//读取两个字节作为次版本号set进InstanceKlass属性
 klass->setMajorVersion(classRead->readByTwoByte());//读取两个字节作为主版本号set进InstanceKlass属性
 printf("次版本号:%d\n", klass->getMinorVersion());
 printf("主版本号:%d\n", klass->getMajorVersion());
 switch (klass->getMajorVersion()) {//校验版本号是否在允许范围内
 case 46:
 case 47:
 case 48:
 case 49:
 case 50:
 case 51:
 case 52: {
 if (klass->getMinorVersion() == 0) {
 printf("版本校验正确\n");
 return;
 }
 }
 }
 printf("版本校验错误\n");
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/e/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 return 0;
}

class ConstantPool {
public:
 char *tag;
 std::map<int, char*> data;
};

class InstanceKlass {
 int magic; 
 short minorVersion; 
 short majorVersion;
 short constantPoolCount;//常量数量(新增)
 ConstantPool *constantPool;//常量池数据(新增)
};

InstanceKlass *ClassFileParser::Parser(ClassRead *classRead) {
 InstanceKlass *klass = new InstanceKlass;
 checkAndPutMagic(classRead, klass);//校验是否是class文件
 checkAndPutVersion(classRead, klass);//校验版本号
 parserConstantPoolCount(classRead, klass);//解析出常量池数量
 parserConstantPool(classRead, klass);//解析常量池
 return klass;
}
void ClassFileParser::parserConstantPoolCount(ClassRead *classRead, InstanceKlass *klass) {
 klass->setConstantPoolCount(classRead->readByTwoByte());
};
void ClassFileParser::parserConstantPool(ClassRead *classRead, InstanceKlass *klass) {
 klass->setConstantPool(new ConstantPool);
 ConstantPool *constantPool = klass->getConstantPool();
 constantPool->tag = new char[klass->getConstantPoolCount()];
 for (int i = 1; i < klass->getConstantPoolCount(); i++) {
 unsigned char tag = classRead->readByOneByte();
 *(constantPool->tag + i) = tag;
 switch (tag) {
 }
 }
};

void ClassFileParser::parserConstantPool(ClassRead *classRead, InstanceKlass *klass) {
 klass->setConstantPool(new ConstantPool);//为常量池初始化内存空间
 ConstantPool *constantPool = klass->getConstantPool();
 constantPool->tag = new char[klass->getConstantPoolCount()];//根据常量池数量初始化常量池数据区的内存空间
 for (int i = 1; i < klass->getConstantPoolCount(); i++) {
 unsigned char tag = classRead->readByOneByte();//读取一个字节获取到类型的映射值
 *(constantPool->tag + i) = tag;//存储类型
 switch (tag) {//根据不同的类型,有不同的处理方式,主要是读取的字节数不同
 case CONSTANT_Utf8: {
 unsigned short len = classRead->readByTwoByte();//读两个字节作为utf-8的字节长度
 char *target = new char[len + 1]; //申请len+1长度的字节内存,c语言最后一位需要用'0円'填充
 classRead->readByFreeByte(len, target);//读取len个字节
 (constantPool->data[i]) = target;//存储在常量池
 printf("第%d个,类型utf-8,值%s\n", i, constantPool->data[i]);
 break;
 }
 case CONSTANT_Integer: {
 char *temp = new char;
 *temp = classRead->readByFourByte(); //读取四个字节
 constantPool->data[i] = temp;//存储在常量池
 printf("第%d个,类型Integer,值%d\n", i, *constantPool->data[i]);
 break;
 }
 case CONSTANT_Float: {
 char *temp = new char;
 *temp = classRead->readByFourByte();//读取四个字节
 constantPool->data[i] = temp;//存储在常量池
 printf("第%d个,类型Float,值%d\n", i, *constantPool->data[i]);
 break;
 }
 case CONSTANT_Long: {
 printf("暂不处理\n");
 break;
 }
 case CONSTANT_Double: {
 printf("暂不处理\n");
 break;
 }
 case CONSTANT_Class: {
 char *temp = new char;
 *temp = classRead->readByTwoByte();//读取两个字节
 constantPool->data[i] = temp;//存储在常量池
 printf("第%d个,类型Class,值%d\n", i, *constantPool->data[i]);
 break;
 }
 case CONSTANT_String: {
 char *temp = new char[3];
 *temp = classRead->readByTwoByte();//读取两个字节
 temp[2] = '0円';
 constantPool->data[i] = temp;//存储在常量池
 printf("第%d个,类型String,值%d\n", i, *constantPool->data[i]);
 break;
 }
 case CONSTANT_Fieldref:
 case CONSTANT_Methodref:
 case CONSTANT_InterfaceMethodref: {
 int *temp = new int;//申请四个字节的内存空间
 short classIndex = classRead->readByTwoByte();//读取两个字节
 short nameAndTypeIndex = classRead->readByTwoByte();//读取两个字节
 *temp = htonl(classIndex << 16 | nameAndTypeIndex);//左16位存储classIndex 右16为存储nameAndTypeIndex
 (constantPool->data[i]) = (char *) temp;//存储在常量池
 printf("第%d个,类型file、method、Interface Methodref,值%X\n", i, htonl(*(int *) constantPool->data[i]));
 break;
 }
 case CONSTANT_NameAndType: {
 int *temp = new int;
 short nameIndex = classRead->readByTwoByte();//读取两个字节
 short descriptorIndex = classRead->readByTwoByte();//读取两个字节
 *temp = htonl(nameIndex << 16 | descriptorIndex);//左16位存储classIndex 右16为存储nameAndTypeIndex
 (constantPool->data[i]) = (char *) temp;//存储在常量池
 printf("第%d个,类型NameAndType,值%X\n", i, htonl(*(int *) constantPool->data[i]));
 break;
 }
 default:
 break;
 }
 }
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/e/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 return 0;
}

class文件校验正确 	
次版本号:0 	
主版本号:52 	
版本校验正确 	
第1个,类型file、method、Interface Methodref,值60014 	
第2个,类型file、method、Interface Methodref,值150016 	
第3个,类型String,值23 	
第4个,类型file、method、Interface Methodref,值180019 	
第5个,类型Class,值26 	
第6个,类型Class,值27 	
第7个,类型utf-8,值<init> 	
第8个,类型utf-8,值()V 	
第9个,类型utf-8,值Code 	
第10个,类型utf-8,值LineNumberTable 	
第11个,类型utf-8,值LocalVariableTable 	
第12个,类型utf-8,值this 	
第13个,类型utf-8,值LHelloJVM; 	
第14个,类型utf-8,值main 	
第15个,类型utf-8,值([Ljava/lang/String;)V 	
第16个,类型utf-8,值args 	
第17个,类型utf-8,值[Ljava/lang/String; 	
第18个,类型utf-8,值SourceFile 	
第19个,类型utf-8,值HelloJVM.java 	
第20个,类型NameAndType,值70008 	
第21个,类型Class,值28 	
第22个,类型NameAndType,值1D001E 	
第23个,类型utf-8,值Hello JVM 	
第24个,类型Class,值31 	
第25个,类型NameAndType,值200021 	
第26个,类型utf-8,值HelloJVM 	
第27个,类型utf-8,值java/lang/Object 	
第28个,类型utf-8,值java/lang/System 	
第29个,类型utf-8,值out 	
第30个,类型utf-8,值Ljava/io/PrintStream; 	
第31个,类型utf-8,值java/io/PrintStream 	
第32个,类型utf-8,值println 	
第33个,类型utf-8,值(Ljava/lang/String;)V 	

class InstanceKlass {
 int magic; //魔数,CAFEBABE:用来校验是否是.class文件
 short minorVersion; //JDK次版本号
 short majorVersion; //JDK主版本号
 short constantPoolCount;//常量数量
 ConstantPool *constantPool;//常量池数据
 short accessFlags;//类的访问权限 (新增)
};

void ClassFileParser::parserAccessFlags(ClassRead *classRead, InstanceKlass *klass) {
 klass->setAccessFlags(classRead->readByTwoByte());//读取两个字节,set进InstanceKlass属性
 printf("访问权限:%d\n", klass->getAccessFlags());
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/e/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 return 0;
}

......
第4个,类型file、method、Interface Methodref,值180019
第5个,类型Class,值26
第6个,类型Class,值27
......
第26个,类型utf-8,值HelloJVM
......

class InstanceKlass {
int magic; //魔数,CAFEBABE:用来校验是否是.class文件
......
short thisClass;//类名
short superClass;//父类名
}

void ClassFileParser::parserThisClass(ClassRead *classRead, InstanceKlass *klass) {
 klass->setThisClass(classRead->readByTwoByte());//读取两个字节,set进InstanceKlass属性
 printf("类名:%X\n", klass->getThisClass());
};
void ClassFileParser::parserSuperClass(ClassRead *classRead, InstanceKlass *klass) {
 klass->setSuperClass(classRead->readByTwoByte());//读取两个字节,set进InstanceKlass属性
 printf("父类名:%X\n", klass->getSuperClass());
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/e/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 int indexClass = *(klass->getConstantPool()->data[klass->getThisClass()]);//获取常量池索引
 int indexSuperClass = *(klass->getConstantPool()->data[klass->getSuperClass()]);//获取常量池索引
 printf("类名:%s\n", klass->getConstantPool()->data[indexClass]);//再次索引获取name
 printf("父类名:%s\n", klass->getConstantPool()->data[indexSuperClass]);//再次索引获取name
 return 0;
}

class InterfacesInfo {
 short constantPoolIndex;
 string interfacesName;
};

class InstanceKlass {
 int magic; //魔数,CAFEBABE:用来校验是否是.class文件
......
 short interfacesCount;//接口数量
 InterfacesInfo *interfaces;//接口
}

void ClassFileParser::parserInterfacesCount(ClassRead *classRead, InstanceKlass *klass) {
 klass->setInterfacesCount(classRead->readByTwoByte());
 printf("接口数量:%d\n", klass->getInterfacesCount());
}
void ClassFileParser::parserInterfaces(ClassRead *classRead, InstanceKlass *klass) {
 if (klass->getInterfacesCount() == 0) {
 return;//未实现接口就不解析了
 }
 klass->setInterfaces(new InterfacesInfo[klass->getInterfacesCount()]);
 InterfacesInfo *interfaces = klass->getInterfaces();
 for (int i = 0; i < klass->getInterfacesCount(); i++) {
 unsigned short constantPoolIndex = classRead->readByTwoByte();//往后读取两个字节作为常量池索引
 int index = *(klass->getConstantPool()->data[constantPoolIndex]);//获取新的常量池索引
 string name = klass->getConstantPool()->data[index];//第二次索引取得全限定名
 printf("第%d个接口,name:%s,索引位置:%d", i + 1, name.c_str(), constantPoolIndex);
 *(interfaces + i) = *(new InterfacesInfo(constantPoolIndex, name));//将接口set进InstanceKlass属性中
 }
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/e/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 return 0;
}

public class HelloJVM {
 static int out = 9;
 public static void main(String[] args) {
 System.out.println("Hello JVM");
 }
}

class FieldsInfo {
 short accessFlag;
 short nameIndex;
 short descriptorIndex;
 short attributesCount;
};

class InstanceKlass {
 int magic; //魔数,CAFEBABE:用来校验是否是.class文件
......
 short fieldsCount;//字段数量
 FieldsInfo *fieldsInfo;//字段
}

void ClassFileParser::parserFieldsCount(ClassRead *classRead, InstanceKlass *klass) {
 klass->setFieldsCount(classRead->readByTwoByte());//往后读取两个字节set进InstanceKlass中的字段数量属性
 printf("字段数量:%d\n", klass->getFieldsCount());
}
void ClassFileParser::parserFieldsInfo(ClassRead *classRead, InstanceKlass *klass) {
 klass->setFieldsInfo(new FieldsInfo[klass->getFieldsCount()]);//按照字段数量初始化字段内存空间
 FieldsInfo *fieldsInfo = klass->getFieldsInfo();
 for (int i = 0; i < klass->getFieldsCount(); i++) {//循环字段数量count次,解析字段
 FieldsInfo *fields = (fieldsInfo + i);
 fields->setAccessFlag(classRead->readByTwoByte());//往后读取两个字节set进FieldsInfo的访问权限
 fields->setNameIndex(classRead->readByTwoByte());//往后读取两个字节set进FieldsInfo的name
 fields->setDescriptorIndex(classRead->readByTwoByte());//往后读取两个字节set进FieldsInfo的类型描述
 fields->setAttributesCount(classRead->readByTwoByte());//往后读取两个字节set进FieldsInfo的附加属性数量
 printf("field 解析:\n access:%X,\n nameIndex:%X\n descriptorIndex:%X \n attributesCount:%X\n",
 fields->getAccessFlag(), fields->getNameIndex(), fields->getDescriptorIndex(),
 fields->getAttributesCount());
 }
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/qsc/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 printf("字段访问权限:%d\n", klass->getFieldsInfo()->getAccessFlag());
 printf("字段名字:%s\n",klass->getConstantPool()->data[klass->getFieldsInfo()->getNameIndex()]);
 printf("字段类型:%s\n",klass->getConstantPool()->data[klass->getFieldsInfo()->getDescriptorIndex()]);
 printf("字段附加属性数量:%d\n", klass->getFieldsInfo()->getAttributesCount());
 return 0;
}

void ClassFileParser::parserMethodInfo(ClassRead *classRead, InstanceKlass *klass) {
 klass->setMethodInfo(new MethodInfo[klass->getMethodCount()]);//初始化InstanceKlass中的methodInfo的内存空间
 for (int i = 0; i < klass->getMethodCount(); i++) {
 MethodInfo *method = new MethodInfo;
 method->setBelongKlass(klass);//将方法与所属InstanceKlass关联
 method->setAccessFlags(classRead->readByTwoByte());//存储方法的访问权限
 method->setNameIndex(classRead->readByTwoByte());//存储方法的访问权限
 method->setMethodName((string) klass->getConstantPool()->data[method->getNameIndex()]);//存储方法的名字
 printf("解析方法%s\n", method->getMethodName().c_str());
 method->setDescriptorIndex(classRead->readByTwoByte());//存储方法的描述(包含了参数、返回值)
 method->setAttributesCount(classRead->readByTwoByte());//存储属性数量
 method->initCodeAttributeInfo();
 *(klass->getMethodInfo() + i) = *method;
 for (int j = 0; j < method->getAttributesCount(); j++) {
 CodeAttributeInfo *codeAttributeInfo = new CodeAttributeInfo;
 codeAttributeInfo->setAttrNameIndex(classRead->readByTwoByte());//存储属性名字的常量池索引
 codeAttributeInfo->setAttrLength(classRead->readByFourByte());//存储属性长度
 codeAttributeInfo->setMaxStack(classRead->readByTwoByte());//存储最大栈深度
 codeAttributeInfo->setMaxLocals(classRead->readByTwoByte());//存储局部变量表数量
 codeAttributeInfo->setCodeLength(classRead->readByFourByte());//存储指令数量
 BytecodeStream *bytecodeStream = new BytecodeStream(method, codeAttributeInfo,
 codeAttributeInfo->getCodeLength(), 0,
 new char[codeAttributeInfo->getCodeLength()]);
 classRead->readByFreeByte(codeAttributeInfo->getCodeLength(), bytecodeStream->getCodes()); //重点: 将方法的JVM指令存储在bytecodeStream
 codeAttributeInfo->setCode(bytecodeStream);
 printf("\t第%d个属性,access flag:%X name index : %X stack:%X container:%X code length:%X \n", j,
 method->getAccessFlags(), codeAttributeInfo->getAttrNameIndex(), codeAttributeInfo->getMaxStack(),
 codeAttributeInfo->getMaxLocals(), codeAttributeInfo->getCodeLength());
 codeAttributeInfo->setExceptionTableLength(classRead->readByTwoByte());//存储Exception表长度,此处暂时为0,因为我们没有任何异常需要处理
 codeAttributeInfo->setAttributesCount(classRead->readByTwoByte());//存储属性长度
 method->setAttributeInfo(codeAttributeInfo, j);
 for (int k = 0; k < codeAttributeInfo->getAttributesCount(); k++) {//循环解析属性
 int nameIndex = classRead->readByTwoByte();
 string attrName = klass->getConstantPool()->data[nameIndex];
 if ("LineNumberTable" == attrName) {//解析LineNumberTable
 parserLineNumberTable(classRead, codeAttributeInfo, attrName, nameIndex, klass);
 } else if ("LocalVariableTable" == attrName) {//解析LocalVariableTable
 parseLocalVariableTable(classRead, codeAttributeInfo, attrName, nameIndex, klass);
 }
 }
 }
 }
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/qsc/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 return 0;
}

方法数量:3
解析方法<init>
第0个属性,access flag:1 name index : B stack:1 container:1 code length:5
lineNumberTable: name index:12,attr len:6, table len:1
第0个属性,start pc : 0,line numnber:1
LocalVariableTable:第0个属性,start pc:0,length:5,name index:14,descrip:15,index:0
解析方法main
第0个属性,access flag:9 name index : B stack:2 container:1 code length:8
lineNumberTable: name index:12,attr len:10, table len:2
第0个属性,start pc : 0,line numnber:4
lineNumberTable: name index:12,attr len:10, table len:2
第1个属性,start pc : 7,line numnber:5
LocalVariableTable:第0个属性,start pc:0,length:8,name index:18,descrip:19,index:0
解析方法<clinit>
第0个属性,access flag:8 name index : B stack:1 container:0 code length:6
lineNumberTable: name index:12,attr len:6, table len:1
第0个属性,start pc : 0,line numnber:2

class InstanceKlass {
 int magic; //魔数,CAFEBABE:用来校验是否是.class文件
......
 short attributeCount;
 AttributeInfo *attributeInfo;
}

void ClassFileParser::parserAttributeCount(ClassRead *classRead, InstanceKlass *klass) {
 klass->setAttributeCount(classRead->readByTwoByte());//读取两个字节将属性数量存储在InstanceKlass中
 printf("解析属性,数量%d\n", klass->getAttributeCount());
};
void ClassFileParser::parserAttribute(ClassRead *classRead, InstanceKlass *klass) {
 for (int i = 0; i < klass->getAttributeCount(); i++) {
 short nameIndex = classRead->readByTwoByte();
 string attrName = klass->getConstantPool()->data[nameIndex];
 if ("SourceFile" == attrName) {
 printf("\tSourceFile\n");
 parseSourceFile(classRead, klass, nameIndex, i);//解析SourceFile属性
 } else {
 printf("\t无法识别的属性:%X\n", attrName.c_str());
 }
 }
};
void ClassFileParser::parseSourceFile(ClassRead *classRead, InstanceKlass *klass, short nameIndex, short index) {
 klass->setAttributeInfo(new AttributeInfo[klass->getAttributeCount()]);//初始化内存空间来存储属性
 AttributeInfo *attributeInfo= klass->getAttributeInfo();
 *(klass->getAttributeInfo() + index) = *attributeInfo;
 attributeInfo->setAttributeNameIndex(nameIndex);//存储属性name的常量池索引
 attributeInfo->setAttributeLength(classRead->readByFourByte());//存储属性长度length
 attributeInfo->initContainer();
 *(attributeInfo->getContainer()) = classRead->readByTwoByte();//存储文件名的常量池索引
 printf("\t\t第%d个属性,%s:nameIndex:%d,length:%d,data:%d,(%s)\n", index, klass->getConstantPool()->data[nameIndex],
 attributeInfo->getAttributeNameIndex(), attributeInfo->getAttributeLength(), *attributeInfo->getContainer(),
 klass->getConstantPool()->data[*attributeInfo->getContainer()]);
};

int main() {
 ClassRead *classRead = ClassRead::readByPath("/Users/e/Documents/github/JDK/out/production/JDK/HelloJVM.class");//换成你自己的path
 InstanceKlass *klass = ClassFileParser::Parser(classRead);
 int attrIndex = klass->getAttributeInfo()->getAttributeNameIndex();
 int length = klass->getAttributeInfo()->getAttributeLength();
 short fileIndex = *(short *)(klass->getAttributeInfo()->getContainer());
 printf("解析属性完成,属性名字:%s,长度:%d,文件名字:%s\n", klass->getConstantPool()->data[attrIndex],
 length,
 klass->getConstantPool()->data[fileIndex]);
 return 0;
}

class BootClassLoader {
public:
 static string prePath;//路径前缀 :项目地址
 static map<string, InstanceKlass *> allClass;//所有加载完成可以使用的Java类
 static InstanceKlass* loadKlass(string& path);//根据路径(全限定名)加载Java类
};

InstanceKlass *BootClassLoader::loadKlass(string &p) {
 string path = p.append(".class");
 string tempPath = prePath;
 InstanceKlass *klass = ClassFileParser::Parser(ClassRead::readByPath(tempPath.append(path)));
 allClass[p] = klass;
 return klass;
}

InstanceKlass *BootClassLoader::loadKlass(string &p) {
 if (allClass[p] != 0 ) {//先判断此类是否加载过
 return allClass[p];
 }
 string path = p.append(".class");
 string tempPath = prePath;
 InstanceKlass *klass = ClassFileParser::Parser(ClassRead::readByPath(tempPath.append(path)));//读取.class到内存,然后解析它
 allClass[p] = klass;//将解析完的klass存起来
 return klass;
}

int main() {
 string path = "HelloJVM";
 InstanceKlass *klass = BootClassLoader::loadKlass(path);
 int index = *klass->getConstantPool()->data[klass->getThisClass()];//获取该类的类名索引
 printf("%s\n", klass->getConstantPool()->data[index]);//取出类名
 return 0;
}

(二)执行引擎

int func(int arg, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7) {
 return arg + arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7;
}
int main() {
 func(1, 2, 3, 4, 5, 6, 7, 8);
 return 0;
}

main: 
 pushq %rbp //保存调用者栈底地址(8个字节),即将它入栈
 movq %rsp, %rbp // 将rsp寄存器存储的值 赋值 给 rbp寄存器
 subq $0x20, %rsp // 将rsp寄存器所指向的内存空间向下移动32个字节,就是分配32字节的内存
 movl $0x0, -0x4(%rbp) // 将0赋值给rbp寄存器往下4个字节的位置
 movl $0x1, %edi //将1 赋值给edi寄存器
 movl $0x2, %esi // 将 2 赋值给esi寄存器
 movl $0x3, %edx // 将 3 赋值给edx寄存器
 movl $0x4, %ecx //将 4 赋值给ecx寄存器
 movl $0x5, %r8d //将 5 赋值给r8d寄存器
 movl $0x6, %r9d //将 6 赋值给 r9d寄存器
 movl $0x7, (%rsp) // 将 7 赋值给rsp寄存器所指向的内存
 movl $0x8, 0x8(%rsp) // 将 8 赋值给rsp寄存器所指向的内存 往上8个字节的位置
 callq func // 调用 func函数
 xorl %ecx, %ecx
 movl %eax, -0x8(%rbp) // 将eax寄存器的值赋值给rbp寄存器往下8个字节的位置
 movl %ecx, %eax
 addq $0x20, %rsp //将rps寄存器所存的内存地址往上32个字节
 popq %rbp // 弹出栈中内容,赋值给rbp寄存器。并将rsp往上移动8个字节
 retq // 弹出栈中内容,赋值给ip寄存器,cpu跳转执行
func:
 pushq %rbp //保存调用者栈底地址(8个字节),即将它入栈
 movq %rsp, %rbp // 将rsp寄存器存储的值 赋值 给 rbp寄存器
 movl 0x18(%rbp), %eax // 将rbp寄存器所指向的内存 往上24个字节的位置的值 赋值给eax寄存器
 movl 0x10(%rbp), %r10d // 将rbp寄存器所指向的内存 往上16个字节的位置的值 赋值给r10d寄存器
 movl %edi, -0x4(%rbp) // 将 edi寄存器的值赋值给 rbp寄存器所指向的内存 往下4个字节的位置的值
 movl %esi, -0x8(%rbp) // 将 esi寄存器的值赋值给 rbp寄存器所指向的内存 往下8个字节的位置的值
 movl %edx, -0xc(%rbp) // 将 edx寄存器的值赋值给 rbp寄存器所指向的内存 往下12个字节的位置的值
 movl %ecx, -0x10(%rbp) // 将 ecx寄存器的值赋值给 rbp寄存器所指向的内存 往下16个字节的位置的值
 movl %r8d, -0x14(%rbp) // 将 r8d寄存器的值赋值给 rbp寄存器所指向的内存 往下20个字节的位置的值
 movl %r9d, -0x18(%rbp) // 将 r9d寄存器的值赋值给 rbp寄存器所指向的内存 往下24个字节的位置的值
 movl -0x4(%rbp), %ecx // 将rbp寄存器所指向的内存 往下4个字节的位置的值 赋值给ecx寄存器
 addl -0x8(%rbp), %ecx // 将rbp寄存器所指向的内存 往下8个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
 addl -0xc(%rbp), %ecx // 将rbp寄存器所指向的内存 往下12个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
 addl -0x10(%rbp), %ecx // 将rbp寄存器所指向的内存 往下16个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
 addl -0x14(%rbp), %ecx // 将rbp寄存器所指向的内存 往下20个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
 addl -0x18(%rbp), %ecx // 将rbp寄存器所指向的内存 往下24个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
 addl 0x10(%rbp), %ecx // 将rbp寄存器所指向的内存 往上10个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
 addl 0x18(%rbp), %ecx // 将rbp寄存器所指向的内存 往上18个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
 movl %eax, -0x1c(%rbp) // 将eax寄存器的值 赋值给 rbp寄存器所指向的内存 往下28个字节的位置的值
 movl %ecx, %eax // 将ecx寄存器中的值 赋值给 eax寄存器
 popq %rbp // 弹出栈中内容,赋值给rbp寄存器。并将rsp往上移动8个字节
 retq // 弹出栈中内容,赋值给ip寄存器,cpu跳转执行

pushq %rbp 
movq %rsp, %rbp

subq 0ドルx20, %rsp

movl 0ドルx0, -0x4(%rbp)

movl 0ドルx1, %edi //将1 赋值给edi寄存器
movl 0ドルx2, %esi // 将 2 赋值给esi寄存器
movl 0ドルx3, %edx // 将 3 赋值给edx寄存器
movl 0ドルx4, %ecx //将 4 赋值给ecx寄存器
movl 0ドルx5, %r8d //将 5 赋值给r8d寄存器
movl 0ドルx6, %r9d //将 6 赋值给 r9d寄存器

movl 0ドルx7, (%rsp) // 将 7 赋值给rsp寄存器所指向的内存
movl 0ドルx8, 0x8(%rsp) // 将 8 赋值给rsp寄存器所指向的内存 往上8个字节的位置

 callq func // 调用 func函数

pushq %rbp 
movq %rsp, %rbp

movl 0x18(%rbp), %eax // 将rbp寄存器所指向的内存 往上24个字节的位置的值 赋值给eax寄存器
movl 0x10(%rbp), %r10d // 将rbp寄存器所指向的内存 往上16个字节的位置的值 赋值给r10d寄存器

 movl %edi, -0x4(%rbp) // 将 edi寄存器的值赋值给 rbp寄存器所指向的内存 往下4个字节的位置的值
 movl %esi, -0x8(%rbp) // 将 esi寄存器的值赋值给 rbp寄存器所指向的内存 往下8个字节的位置的值
 movl %edx, -0xc(%rbp) // 将 edx寄存器的值赋值给 rbp寄存器所指向的内存 往下12个字节的位置的值
 movl %ecx, -0x10(%rbp) // 将 ecx寄存器的值赋值给 rbp寄存器所指向的内存 往下16个字节的位置的值
 movl %r8d, -0x14(%rbp) // 将 r8d寄存器的值赋值给 rbp寄存器所指向的内存 往下20个字节的位置的值
 movl %r9d, -0x18(%rbp) // 将 r9d寄存器的值赋值给 rbp寄存器所指向的内存 往下24个字节的位置的值

movl -0x4(%rbp), %ecx // 将rbp寄存器所指向的内存 往下4个字节的位置的值 赋值给ecx寄存器
addl -0x8(%rbp), %ecx // 将rbp寄存器所指向的内存 往下8个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
addl -0xc(%rbp), %ecx // 将rbp寄存器所指向的内存 往下12个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
addl -0x10(%rbp), %ecx // 将rbp寄存器所指向的内存 往下16个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
addl -0x14(%rbp), %ecx // 将rbp寄存器所指向的内存 往下20个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
addl -0x18(%rbp), %ecx // 将rbp寄存器所指向的内存 往下24个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
addl 0x10(%rbp), %ecx // 将rbp寄存器所指向的内存 往上10个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器
addl 0x18(%rbp), %ecx // 将rbp寄存器所指向的内存 往上18个字节的位置的值 与 ecx寄存器 的值相加 然后赋值回ecx寄存器

movl %eax, -0x1c(%rbp) // 将eax寄存器的值 赋值给 rbp寄存器所指向的内存 往下28个字节的位置的值
movl %ecx, %eax // 将ecx寄存器中的值 赋值给 eax寄存器

popq %rbp // 弹出栈中内容,赋值给rbp寄存器。并将rsp往上移动8个字节
retq // 弹出栈中内容,赋值给ip寄存器,cpu跳转执行

retq // 弹出栈中内容,赋值给ip寄存器,cpu跳转执行

movl %eax, -0x8(%rbp) // 将eax寄存器的值赋值给rbp寄存器往下8个字节的位置

void run() {
 stack.push(NULL);
}

pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x1694a(%rip), %rdi
leaq -0x4(%rbp), %rsi
callq push
addq $0x10, %rsp
popq %rbp
retq

public class HelloJVM {
 public static void main(String[] args) {
 TestClass t = new TestClass();
 int res = t.get(1, 2);
 }
}
public class TestClass {
 public int get(int a, int b) {
 return a + b;
 }
}

class JavaThread {
 stack<JavaVFrame*> stack; // 线程栈空间
};

class JavaVFrame {
 stack<char*> stack; // 方法的栈空间
 map<int,char*> locals; // 方法的局部变量表
};

void JavaNativeInterface::callStaticMethod(JavaThread* javaThread, MethodInfo *method) {
 printf("===============执行方法 :%s =================\n", method->getMethodName().c_str());
 JavaVFrame *javaVFrame = new JavaVFrame;//马上要执行方法了,先创建栈帧
 javaThread->stack.push(javaVFrame);//栈帧push进线程的栈空间
// BytecodeInterpreter::run(curThread, method); // 执行方法
 javaThread->stack.pop();//将执行完成的栈桢弹出栈空间
 delete javaVFrame; //释放栈桢内存空间
}

int main() {
 string name = "HelloJVM";
 InstanceKlass *klass = BootClassLoader::loadKlass(name);//加载HelloJVM类
 MethodInfo *m = JavaNativeInterface::getMethod(klass, "main", "([Ljava/lang/String;)V");//遍历klass所有的方法,找到main方法。getMethod就是一个循环,没有贴出,请去代码中查看。
 JavaThread *javaThread = new JavaThread;//模拟线程的创建
 JavaNativeInterface::callStaticMethod(javaThread,m);//执行main方法
 return 0;
}

bool BytecodeInterpreter::run(JavaThread *javaThread, MethodInfo *methodInfo) {
 //取出字节码指令
 BytecodeStream *bytecodeStream = methodInfo->getAttributeInfo()->getCode();
 int index = 0;
 while (index < bytecodeStream->getLength()) {
 unsigned char c = bytecodeStream->readByOne(index);
 printf("指令字节:%X\n", c);
 //todo 对操作码c进行解释
 }
 printf("===============执行方法结束 :%s =================\n", methodInfo->getMethodName().c_str());
 return true;
};

 while (index < bytecodeStream->getLength()) {
 unsigned char c = bytecodeStream->readByOne(index);
 printf("指令字节:%X\n", c);
 switch (c) {
 case 0:
 printf("执行nop指令\n");
 break;
 case 1:
 ......
 break;
 }
 }

CODERUN CodeRunBase::run[256];
void CodeRunBase::initCodeRun(){
 run[NOP] = funcNOP; // NOP枚举值为0
}
void CodeRunBase::funcNOP(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
//nop指令什么也不做
}

bool BytecodeInterpreter::run(JavaThread *javaThread, MethodInfo *methodInfo) {
 //取出字节码指令
 BytecodeStream *bytecodeStream = methodInfo->getAttributeInfo()->getCode();
 int index = 0;
 while (index < bytecodeStream->getLength()) {
 unsigned char c = bytecodeStream->readByOne(index);
 printf("指令字节:%X\n", c);
 CodeRunBase::run[c](javaThread, bytecodeStream, index); //解释指令
 }
 printf("===============执行方法结束 :%s =================\n", methodInfo->getMethodName().c_str());
 return true;
};

int main() {
 string name = "HelloJVM";
 InstanceKlass *klass = BootClassLoader::loadKlass(name);//加载HelloJVM类
 MethodInfo *m = JavaNativeInterface::getMethod(klass, "main", "([Ljava/lang/String;)V");//遍历klass所有的方法,找到main方法
 JavaThread *javaThread = new JavaThread;//模拟线程的创建
 JavaNativeInterface::callStaticMethod(javaThread,m);//执行main方法
 return 0;
}

 var value = getByClass(name);
 stack.push(value);

class CommonValue {
 int type ;//值的类型:int、byte、float......
 char *val;//值
};

class InstanceKlass {
 int magic; //魔数,CAFEBABE:用来校验是否是.class文件
 short minorVersion; //JDK次版本号
 ............
 map<string, CommonValue*> staticValue; //静态变量 (新增)
}

string ConstantPool::getClassNameByFieldInfo(unsigned short index){
 int i = htonl(*(int *)data[index]); //取出索引
 int classIndex = i >> 16; // 取出i的左16位
 //获取class全限定名
 int classNameIndex = *data[classIndex]; //取出类名的索引
 return (data[classNameIndex]); // 返回类名
};
string ConstantPool::getFieldName(unsigned short index){
 int i = htonl(*(int *)data[index]);//取出索引
 int ind = i & 0xFF; // 取出i的右16位
 int nameAndType = htonl(*(int *)data[ind]); // 取出nameAndType的索引
 int t = nameAndType >> 16; // 取nameAndType的索引 的左16位
 return (data[t]); // 返回变量名
};
 

void CodeRunBase::funcGETSTATIC(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
 printf(" *执行指令GETSTATIC\n");
 unsigned short opera = bytecodeStream->readByTwo(index); //取出操作数
 printf("\t\tconstantPool index is:%d\n", opera);
 string className = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getClassNameByFieldInfo(opera); // 根据操作数 从 常量池获取类名
 string fieldName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getFieldName(opera);// 根据操作数 从 常量池获取变量名
 printf("\t\tclassName:%s,fieldName:%s\n", className.c_str(), fieldName.c_str());
 InstanceKlass *klass = BootClassLoader::loadKlass(className); //根据类名取得加载完的klass对象
 CommonValue *commonValue = klass->staticValue[fieldName]; // 根据变量名取出 值
 javaThread->stack.top()->stack.push(new CommonValue(commonValue->type, commonValue->val)); //将前面取出的值推向栈顶
}

int main() {
 startVM();
 string name = "HelloJVM";
 InstanceKlass *klass = BootClassLoader::loadKlass(name);//加载HelloJVM类
 MethodInfo *m = JavaNativeInterface::getMethod(klass, "main", "([Ljava/lang/String;)V");//遍历klass所有的方法,找到main方法
 JavaThread *javaThread = new JavaThread;//模拟线程的创建
 JavaNativeInterface::callStaticMethod(javaThread,m);//执行main方法
 return 0;
}
void startVM(){
 CodeRunBase::initCodeRun();//初始化字节码解释器,把解析JVM指令的方法全部存入map,以便使用
};

 InstanceKlass *klass = BootClassLoader::loadKlass(className); //根据类名取得加载完的klass对象

void CodeRunBase::funcICONST0(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
 javaThread->stack.top()->stack.push(new CommonValue(T_INT, 0));
}

void CodeRunBase::funcPUTSTATIC(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
 printf(" **执行指令PUTSTATIC\n");
 unsigned short opera = bytecodeStream->readByTwo(index);//取出操作数
 printf("\t\tconstantPool index is:%d\n", opera);
 string className = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getClassNameByFieldInfo(opera);// 根据操作数 从 常量池获取类名
 string fieldName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getFieldName(opera);// 根据操作数 从 常量池获取变量名
 printf("\t\tclassName:%s,fieldName:%s\n", className.c_str(), fieldName.c_str());
 CommonValue* value =javaThread->stack.top()->pop(); //弹出栈顶变量
 InstanceKlass *klass = BootClassLoader::loadKlass(className);//根据类名取得加载完的klass对象
 klass->staticValue[fieldName] = value; //将从栈顶获得的静态变量写入类
}

void CodeRunBase::funcLDC(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
 printf(" **执行指令LDC\n");
 unsigned char opera = bytecodeStream->readByOne(index);//取出操作数
 unsigned char tag = *(bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->tag + opera);//从常量池的类型中取出本次ldc指令操作的数据类型
 switch (tag) {
 case CONSTANT_Float:
 break;
 case CONSTANT_String: {
 int index = *bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->data[opera]; //从常量池获取索引
 string str = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getStringFromPool(index);//从常量池获取string的内容
 javaThread->stack.top()->stack.push(new CommonValue(T_OBJECT, (char *)str.c_str()));//入栈
 break;
 }
 case CONSTANT_Class:
 break;
 default:
 printf("未知类型\n");
 }
}

void CodeRunBase::funcDUP(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
 CommonValue *cv = javaThread->stack.top()->stack.top(); //获取栈顶值
 javaThread->stack.top()->stack.push(cv); // 推向栈顶
}

void CodeRunBase::funcALOAD0(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
 printf(" **执行指令aload0\n");
 CommonValue *cv = javaThread->stack.top()->locals[0];//获取局部变量表第一个数据
 javaThread->stack.top()->stack.push(cv); // 推向栈顶
}
void CodeRunBase::funcALOAD1(JavaThread *javaThread, BytecodeStream *bytecodeStream , int& index) {
 printf(" **执行指令aload1\n");
 CommonValue *cv = javaThread->stack.top()->locals[1];//获取局部变量表第一个数据
 javaThread->stack.top()->stack.push(cv); // 推向栈顶
}

class InstanceOop {
 InstanceKlass *klass;//所属类
 map<string, char *> map;//实例化的成员属性
};

InstanceOop* InstanceKlass::allocateInstance(InstanceKlass* klass) {
 InstanceOop *oop = new InstanceOop;
 oop->klass = klass;
 return oop;
}

void CodeRunBase::funcNEW(JavaThread *javaThread, BytecodeStream *bytecodeStream, int &index) {
 printf(" **执行指令NEW\n");
 unsigned short opera = bytecodeStream->readByTwo(index);
 string classPath = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getClassPath(opera);
 InstanceKlass *klass = BootClassLoader::loadKlass(classPath);
 InstanceOop *oop = InstanceKlass::allocateInstance(klass);
 javaThread->stack.top()->stack.push(new CommonValue(T_NARROWOOP, (char *) oop));
}

void JavaNativeInterface::callVirtual(JavaThread* javaThread, MethodInfo *method,int paramCount ,char** params) {
 printf("===============执行方法开始 :%s =================\n", method->getMethodName().c_str());
 JavaVFrame *javaVFrame = new JavaVFrame;//马上要执行方法了,先创建栈帧
 for (int i = 1; i <= paramCount; ++i) { //将参数写入局部变量表
 javaVFrame->locals[i] = (CommonValue *) (*(params + i - 1));
 }
 javaVFrame->locals[0] = (CommonValue *)*(params + paramCount);//非静态方法第一个参数为this指针
 javaThread->stack.push(javaVFrame);//栈帧push进线程的栈空间
 BytecodeInterpreter::run(javaThread, method); // 执行方法
 javaThread->stack.pop();//将执行完成的栈桢弹出栈空间
 delete javaVFrame; //释放栈桢内存空间
}

void CodeRunBase::funcINVOKEVIRTUAL(JavaThread *javaThread, BytecodeStream *bytecodeStream, int &index) {
 printf(" **执行指令INVOKEVIRTUAL\n");
 unsigned short opera = bytecodeStream->readByTwo(index);
 string className = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getClassNameByMethodInfo(opera);//获取类名
 string methodName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getMethodNameByMethodInfo(opera);//获取方法名
 string descName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getDescriptorNameByMethodInfo(opera);//获取方法描述
 printf("\tclassName:%s,methodName:%s,descName:%s\n", className.c_str(), methodName.c_str(),
 descName.c_str());
 int paramCount =0 ;//初始化参数数量
 char **params = CodeRunBase::getParams(descName, javaThread->stack.top(),paramCount);//解析参数
 InstanceKlass *klass = BootClassLoader::loadKlass(className);//获取类全限定名
 MethodInfo *m = JavaNativeInterface::getMethod(klass, methodName, descName);//根据方法名字和方法描述找到要调用的方法
 JavaNativeInterface::callVirtual(javaThread, m, paramCount, params);//调用方法
}

void JavaNativeInterface::callSpecial(JavaThread* javaThread, MethodInfo *method,int paramCount ,char** params) {
 printf("===============执行方法开始 :%s =================\n", method->getMethodName().c_str());
 JavaVFrame *javaVFrame = new JavaVFrame;//马上要执行方法了,先创建栈帧
 for (int i = 1; i <= paramCount; ++i) { //将参数写入局部变量表
 javaVFrame->locals[i] = (CommonValue *) (*(params + i - 1));
 }
 javaVFrame->locals[0] = (CommonValue *)*(params + paramCount);//非静态方法第一个参数为this指针
 javaThread->stack.push(javaVFrame);//栈帧push进线程的栈空间
 BytecodeInterpreter::run(javaThread, method); // 执行方法
 javaThread->stack.pop();//将执行完成的栈桢弹出栈空间
 delete javaVFrame; //释放栈桢内存空间
}

void CodeRunBase::funcINVOKESPECIAL(JavaThread *javaThread, BytecodeStream *bytecodeStream, int &index) {
 printf(" **执行指令INVOKESPECIAL\n");
 unsigned short opera = bytecodeStream->readByTwo(index);
 string className = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getClassNameByMethodInfo(opera);//获取类名
 string methodName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getMethodNameByMethodInfo(opera);//获取方法名
 string descName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getDescriptorNameByMethodInfo(opera);//获取方法描述
 printf("\tclassName:%s,methodName:%s,descName:%s\n", className.c_str(), methodName.c_str(),
 descName.c_str());
 int paramCount =0 ;//初始化参数数量
 char **params = CodeRunBase::getParams(descName, javaThread->stack.top(),paramCount);//解析参数
 InstanceKlass *klass = BootClassLoader::loadKlass(className);//获取类全限定名
 MethodInfo *m = JavaNativeInterface::getMethod(klass, methodName, descName);//根据方法名字和方法描述找到要调用的方法
 // todo 如果是本地方法则调用本地方法
JavaNativeInterface::callSpecial(javaThread, m, paramCount, params);//调用方法
}

typedef void (*CODENATIVE)(int paramsCount, char **params);
class CodeRunNative {
public:
 static void initCodeRun();
 static map<string, CODENATIVE> map;
};

void CodeRunNative::initCodeRun() {
 map["writeBytes"] = writeBytes;
}
void CodeRunNative::writeBytes(int paramsCount, char **params) {
 //todo 本地方法的实现
};

void CodeRunBase::funcINVOKESPECIAL(JavaThread *javaThread, BytecodeStream *bytecodeStream, int &index) {
 printf(" **执行指令INVOKESPECIAL\n");
 unsigned short opera = bytecodeStream->readByTwo(index);
 string className = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getClassNameByMethodInfo(opera);//获取类名
 string methodName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getMethodNameByMethodInfo(opera);//获取方法名
 string descName = bytecodeStream->getBelongMethod()->getBelongKlass()->getConstantPool()->getDescriptorNameByMethodInfo(opera);//获取方法描述
 printf("\tclassName:%s,methodName:%s,descName:%s\n", className.c_str(), methodName.c_str(),
 descName.c_str());
 int paramCount =0 ;//初始化参数数量
 char **params = CodeRunBase::getParams(descName, javaThread->stack.top(),paramCount);//解析参数
 InstanceKlass *klass = BootClassLoader::loadKlass(className);//获取类全限定名
 MethodInfo *m = JavaNativeInterface::getMethod(klass, methodName, descName);//根据方法名字和方法描述找到要调用的方法
 if (m->getAccessFlags() & 100000000 == 0x0100) {//判断是否是本地方法
 FUNNATIVE nativeFunc = (FUNNATIVE) CodeRunNative::map[m->getMethodName()]; //取出本地方法
 nativeFunc(paramCount,params);//调用本地方法
 return;
 }
 JavaNativeInterface::callSpecial(javaThread, m, paramCount, params);//调用方法
}

void CodeRunBase::funcRETURN(JavaThread *javaThread, BytecodeStream *bytecodeStream, int &index) {
//nothing to do .
 printf(" **执行指令RETURN\n");
}

System.out.println("Hello JVM");

public final static PrintStream out = null;

public class System {
 public final static PrintStream out = new PrintStream();
}

public class PrintStream {
 public void println(String x) {
 write0(x);
 }
 private native void write0(String x);
}

void CodeRunNative::writeBytes(int paramsCount, char **params) {
 CommonValue *cv = (CommonValue*)*params; //目前只有一个参数 ,就直接取了
 printf("执行本地方法write0,以下为输出结果:\n");
 printf("%s\n",cv->val); //打印参数的值
};

............
执行本地方法write0,以下为输出结果:
HelloJVM
指令字节:B1
 **执行指令RETURN
===============执行方法结束 :println =================
指令字节:B1
 **执行指令RETURN
===============执行方法结束 :main =================

typedef int (*Incr)(int arg);//类型:函数指针
int main() {
 int code[] = {0x55,0x48,0x89,0xe5,0x89,0x7d,0xfc,0x8b,0x45,0xfc,0x83,0xc0,0x01,0x89,0x45,0xfc,0x5d,0xc3};//机器指令 功能:将参数+1后返回
 unsigned char * memory = static_cast<unsigned char *>(mmap(NULL,getpagesize(),PROT_READ | PROT_WRITE | PROT_EXEC,MAP_ANON | MAP_SHARED,0,0));//申请一块连续的内存空间
 for (int i = 0; i < 18; i++) {//将机器指令写入申请的内存空间
 *(memory + i) = code[i];
 }
 Incr incr = (Incr) memory;//声明函数指针 并将其指向写好了机器指令的内存空间
 int res = incr(1); //调用这个方法 实现 +1
 printf("%d\n", res);//输出 结果:2
 return 0;
}

BytecodeStream *bytecodeStream = methodInfo->getAttributeInfo()->getCode();//取出方法中的JVM指令

class MethodInfo { 
public:
 int code;
 string name;
};

int main() {
 MethodInfo *m = new MethodInfo;//创建对象
 m->code = 6;//code赋值为6
 m->name = "JVM"; //name赋值为JVM
 printf("%d\n", *(char *) m);
 printf("%s\n", (char *) m + 8);
 return 0;
}
输出:
6
JVM

mov rax,[rcx+8] //机器指令 :48 8b 41 08

"push rbp"
"mov rbp,rsp"

"push rcx"
"push rdi"
"push rsi"
"push rbx"

"mov rcx ,[rbp+0x10]" 将rsp寄存器往上16个字节的位置的值放入rcx寄存器中
"shl rcx,3" 将rcx中的值左移3位(*8)
"sub rsp,rcx" 分配栈空间

 "mov rcx ,[rsp+0x10]"
 "dec rcx"
 "i:test rcx rcx" 如果rcx的值为0(无入参,则跳转到o处执行)
 "je o"
 "xor rbx,rbx"
 //循环入参start
 "shl rcx,3"
 "mov [rsp+rcx],r9"
 "shr rcx,3"
 "dec rcx"
 "inc r9"
 "jne i"
 "o:mov rsp,r9"
 //循环入数end

"mov rcx ,[rsp+0x10]"
"mov rbx,rbp"
"call [r8d]"

(三)内存池

(四)GC

(六)扩展内容

(七)勘误