main:
	// 1.保存调用者栈基地址，并为main()函数分配栈空间
	pushl %ebp	// 保存调用者(操作系统)栈基地址
	movl%esp, %ebp	// 将调用者的栈基地址指向其栈顶，这2步是所有函数调用都会执行的指令
	subl$32, %esp	// 这里就是分配新栈，一共32个字节，%esp表示当前栈顶，subl表示减去，即将当前栈顶减去32字节的长度
			// 因为linux上栈是向下增长的，从内存的高地址位往低地址方向增长，因此每次调用一个新函数，需要分配栈空间都是做减法出来的
	
	// 2.初始化两个数据，一个是5，一个是3，将这两个整数保存到main()栈中
	movl$5, 20(%esp)	// 20(%esp)表示当前栈顶往上移20字节位置，数据5就被保存在这里
	movl$3, 24(%esp)	// 同理往上偏移24字节，由于在64位平台int占4位，即向上偏移6个整数的位置
	
	// 3.压栈：将5和3压入栈中
	movl24(%esp), %eax	// 将24(%esp)处的内存值传送到eax寄存器中
	movl%eax, 4(%esp)	// 又将eax寄存器中的值传到了4(%esp)这个地方，即中转后放到了4(%esp)这个位置
	movl20(%esp), %eax	// 同理，这么中转一下是因为CPU不支持数据从一个内存位置直接传送到另一个内存位置
	movl%eax, (%esp)	// 真实的物理机器，在发起函数调用之前，必定要进行压栈，压栈的目的是为了传参，这两个数据将被add()函数读取到
	
	// 4.调用add()函数
	calladd			// 调用add函数
	movl%eax, 28(%esp) 	// 得到add函数的返回结果，保存在eax寄存器中，因此从eax中拿

	// 返回
	movl$0, %eax	// 将值保存到eax寄存器中
	leave		// 执行后面这2条例行返回指令
	ret

add:
	// 1.保存调用者栈基地址
	pushl %ebp	// 栈基地址%ebp
	movl%esp, %ebp	// 栈顶%esp
	subl$16, %esp	// 往下开辟16字节栈空间
	
	// 2.获取入参
	movl12(%ebp), %eax	// ebp寄存器用于标识栈底位置，向内存地址高地址方向偏移12字节的位置取出数据，将数据传给eax寄存器
	movl8(%ebp), %edx	// 同理从add()栈底向上偏移8字节位置取出数据，传给edx寄存器
				// 随着堆栈寄存器ebp和esp所指向位置的变化，方法栈中同一个内存位置的偏移量也随之改变，
				// 对于压栈入参，既可以通过相对于调用者函数的栈顶偏移量来定位，也可以通过相对于被调用者的栈底偏移量来定位
	
	// 3.执行运算
	addl%edx, %eax		// 求和，将累加结果保存到eax寄存器中
	movl%eax, -4(%ebp)	// 把eax寄存器的值转移到栈基地址往下偏移4个字节的位置
	
	// 4.返回
	movl-4(%ebp), %eax	// 函数返回逻辑一般是，有返回值，就把返回值放到eax寄存器中
	leave			// 然后执行leave和ret指令，leave指令中其实顺带执行了mov %ebp, %esp 和 pop %eip
	ret			// add()执行完后把main()函数下一条指令地址出栈，存在eip，这样eip寄存器就又指向main()函数add指令的下一条指令了，当然之前先讲栈顶指向栈基位置

int add();
int main() {
	int c = add();
	return 0;
}

int add() {
	int z = 1 + 2;
	return z;
}

main:
	pusl %ebp
	movl%esp, %ebp
	andl$-16, %esp	// 与subl$16, %esp一样
			// 分配16字节空间是因为32位和64位机器上，堆栈内存都是按照16字节对齐的，多了不退少了一定补齐，主要为了能对内存快速定位、快速整理回收
	
	calladd			// 调用完add()函数又回到main()函数中后，物理机器会回收add()函数的堆栈空间
	movl%eax, 12(%esp)	// 同时eip和ebp这两个寄存器出栈，于是堆栈中仅剩下main()函数的内存，main()函数从eax寄存去中读取add()函数的返回值
	
	movl$0, %eax
	leave
	ret

add:
	pushl %ebp
	movl%esp, %ebp
	subl$16, %esp
	movl$3, -4(%ebp)
	movl-4(%ebp), %eax
	leave
	ret

// src/share/vm/runtime/stubRoutines.hpp
static CallStub call_stub() {
	// 宏，JVM中凡是函数名大写的基本都是宏
	return CAST_TO_FE_PTR(CallStub, _call_stub_entry);
}

// globalDefinitions.hpp
#define CAST_TO_FE_PTR(func_type, value)((func_type)castable_address(value))

// /src/share/vm/runtime/stubRoutines.hpp
typedef void (*CallStub) (
	address link,		// 连接器，所属类型是JavaCallWrapper
				// 在Java函数的调用者和被调用者之间搭建了一座桥梁，通过这座桥梁，我们可以实现堆栈追踪，可以得到整个方法的调用链路
	intptr_t* result,	// 函数返回值地址
	BasicType result_type,	// 函数返回类型
	methodOopDesc* method,	// JVM内部所表示的Java方法对象，每个Java方法在被JVM加载时，JVM都会在内部为这个Java方法建立函数模型，即保存一份Java方法的全部原始描述信息
				// 调用CallStub()函数指针时将method()传进去是为了取到Java函数编译后的字节码信息，JVM拿到后就能对字节码进行解释执行了
	address entry_point,	// 继_call_stub_entry这个JVM最核心例程之后另一个主要入口，是JVM调用Java方法的例程入口，JVM内部的每一段例程都是在JVM启动过程中预先生成好的一段机器指令
				// 要调用Java方法，都必须经过本例程，即需要先执行这段机器指令
				// 事实上JVM每次从JVM内部调用Java函数时(相当于通过字节码指令调用目标Java函数)，必定调用CallStub函数指针，而该函数指针的值就是_call_stub_entry。JVM通过_call_stub_entry所指向的函数地址，最终调用到Java函数
				// 而在JVM通过_call_stub_entry所指向的函数调用Java函数之前，必须要经过entry_point例程。在在entry_point例程里面会真正从method()对象上拿到Java函数编译后的字节码
				// JVM通过entry_point可以得到Java函数所对应的第一个字节码指令，然后开始调用Java函数
				// _call_stub_entry与entry_point这两个例程其实就是两段机器指令，JVM提前写好了很多例程，例如函数进入、函数调用、函数返回、异常处理、静态函数调用、本地函数调用等，这些例程都直接使用机器指令写成
				// 对于例程其实可以想象成工具类，只不过例程是直接用机器指令写的(严格说是C语言运行期动态生成的)，工具类是用Java语言写的
				// 那么总结一下，在JVM主函数调用下，先调用CallStub指针，就是_call_stub_entry例程，然后调用entry_point，即entry_point例程，最后调用到Java函数						
	intptr_t* parameters,	// Java方法的入参集合，在JVM真正调用Java函数的第一个字节码指令前，会在CallStub()函数中解析入参，解析后JVM为Java函数分配堆栈，并将参数逐个入栈
				// 而Java解释型语言与C/C++等编译型语言不同，不直接在物理机器上运行，运行在虚拟机上，因此不能直接使用物理机器的方法栈，必须在虚拟机层面为每一个Java函数都建立堆栈模型
				// 这种堆栈模型中的局部变量都是Java语言的变量类型，所以JVM在正式调用Java函数前需要获取到参数类型、参数对象、参数顺序等信息
				// 而且Java在内存模型上，Java类的实例对象分配在堆中，堆栈中只保存了引用，在JVM内部就是一个指针，因为堆栈空间放不下大对象
	int size_of_parameters,	// Java方法的入参数量，让JVM在为Java函数分配堆栈空间时，根据这个值计算出Java堆栈空间大小
	TRAPS			// 当前线程对象
);

static CallStub call_stub() {
	// 使用CallStub类型声明一个函数指针变量
	CallStub functionPointer;
	// 返回address类型的变量
	address returnAddress = castable_address(_call_stub_entry);
	// 转换为CallStub类型的变量
	functionPointer = (CallStub)returnAddress;
	return funcPointer;
}

// src/share/vm/runtime/javaCalls.cpp::call_helper()
void JavaCalls::call_helper(JavaValue* result, methodHandle* m, JavaCallArguments* args, TRAPS) {
	// ...

	// call_stub()调用开始
	{
		JavaCallWrapper link(method, receiver, result, CHECK);
		{
			HandleMark hm(thread);	// HandleMark used by HandleMarkClearner
			// 先声明一个CallStub类型的函数指针变量
			CallStub funcPointer;
			// 初始化函数指针变量，将其指向call_stub()函数首地址
			funcPointer = StubRoutines::call_stub();
			// 调用函数指针变量，传入8个参数
			funcPointer((address)&link,
					// (intptr_t*)&(result->_value), // see NOTE above (compiler problem)
					result_val_address,'
					result_type,
					method(),
					entry_point,
					args->parameters(),
					args->size_of_parameters(),
					CHECK);
			result = link.result();
			if(oop_result_flag) {
				thread->set_vm_result((oop)result->get_jobject());
			}			
		}
	}
	// call_stub()调用结束
	
	// ...
}

java.c: main()
	java_md.c: LoadJavaVM()
		jni.c: JNI_CreateJavaVM()
			Threads.c: create_vm()
				init.c: init_globals()
					StubRoutines.cpp: stubRoutines_init1()
						stubGenerator_x86_32.cpp: StubGenerator_generate()
							stubGenerator_x86_32.cpp: StubCodeGenerator()
								stubGenerator_x86_32.cpp: generate_initial()

StubRoutines::_call_stub_entry = 
	generate_call_stub(StubRountines::_call_stub_return_address);

// 使用C语言动态生成机器码，即直接向内存空间写入汇编代码
address generate_call_stub(address& return_address) {	
    StubCodeMark mark(this, "StubRoutines", "call_stub");
    // 汇编器会将生成的例程在内存中线性排列。所以取当前汇编器生成的上个例程最后一行汇编指令的地址，用来作为即将生成的新例程的首地址
    // 因为本函数后续流程会继续往代码空间写入call_stub()的指令，而外面只要拿到这部分指令的首地址，因此先拿到start这个当前入口首地址，最后返回出去即可
    address start = __ pc();

    // stub code parameters / addresses
    assert(frame::entry_frame_call_wrapper_offset == 2, "adjust this code");
    bool  sse_save = false;
    const Address rsp_after_call(rbp, -4 * wordSize); // same as in generate_catch_exception()!
    const int     locals_count_in_bytes  (4*wordSize);

    // 定义一些变量，用于保存一些调用方的信息，这四个参数放在被调用者堆栈中，即call_stub例程堆栈中，所以相对于call_stub例程的栈基址（rbp）为负数（栈是向下增长）
    const Address mxcsr_save    (rbp, -4 * wordSize);
    const Address saved_rbx     (rbp, -3 * wordSize);
    const Address saved_rsi     (rbp, -2 * wordSize);
    const Address saved_rdi     (rbp, -1 * wordSize);
    // 传参，放在调用方堆栈中，所以相对call_stub例程的栈基址为正数，可以理解为调用方在调用call_stub例程之前，会将传参都放在自己的堆栈中，这样call_stub例程中就可以直接基于栈基址进行偏移取用了
    const Address result        (rbp,  3 * wordSize);
    const Address result_type   (rbp,  4 * wordSize);
    const Address method        (rbp,  5 * wordSize);
    const Address entry_point   (rbp,  6 * wordSize);
    const Address parameters    (rbp,  7 * wordSize);
    const Address parameter_size(rbp,  8 * wordSize);
    const Address thread        (rbp,  9 * wordSize); // same as in     generate_catch_exception()!
    sse_save =  UseSSE > 0;
    
    // stub code
    // enter()在X86对应的方法如下，用来保存调用方栈基址，并将call_stub栈基址更新为当前栈顶地址，C语言编译器其实在调用方法前都会插入这件事，这里JVM相对于借用了这种思想。这两句代码都调动emit()，向代码空间中加入机器指令
 ---------------------------------------------
|        void MacroAssembler::enter() {       |
|            push(rbp);                       |
|            mov(rbp, rsp);                   |
|       }                                     |
 ---------------------------------------------
    __ enter();

    // 接下来计算并分配call_stub堆栈所需栈大小
    // 先将参数数量放入rcx寄存器。这里类似汇编指令的C函数并不是运行时真正调用的函数，它们只不过是往代码空间中写入相同作用的机器码
    __ movptr(rcx, parameter_size);              // parameter counter
    // shl用于左移，这里将rcx中的值左移了Interpreter::logStackElementSize位，在64位平台，logStackElementSize=3；在32位平台，logStackElementSize=2；所以在64位平台上，rcx = rcx * 8，即每个参数占用8字节;32位平台rcx = rcx *4，即每个参数占4个字节
    __ shlptr(rcx, Interpreter::logStackElementSize); // convert parameter count to bytes

    // locals_count_in_bytes 在上面有定义：const int locals_count_in_bytes  (4*wordSize);这四个字节其实就是上面用来保存调用方信息所占空间
    __ addptr(rcx, locals_count_in_bytes);       // reserve space for register saves

    // rcx现在保存了计算好的所需栈空间，将保存栈顶地址的寄存器rsp减去rcx，即向下扩展栈
    __ subptr(rsp, rcx);

    // 为了加速内存寻址和回收，物理机器在分配堆栈空间时都会进行内存对齐，JVM也借用了这个思想。JVM中是按照两个字节，即16位进行对齐的：const int StackAlignmentInBytes = (2*wordSize)
    __ andptr(rsp, -(StackAlignmentInBytes));    // Align stack

    // save rdi, rsi, & rbx, according to C calling conventions
    // 将调用方的一些信息，保存到栈中分配的地址处，最后会再次还原到寄存器中
    __ movtr(saved_rdi, rdi);
    __ movptr(saved_rsi, rsi);
    __ movptr(saved_rbx, rbx);
    // save and initialize %mxcsr
	
    //......

    // 接下来就要进行参数压栈了
    Label parameters_done;
    // 检查参数数量是否为0，为0则直接跳到标号parameters_done处
    __ movl(rcx, parameter_size);  // parameter counter
    __ testl(rcx, rcx);
    __ jcc(Assembler::zero, parameters_done);

    Label loop
    //将参数首地址放到寄存器rdx中，并将rbx置0
    __ movptr(rdx, parameters);          // parameter pointer
    __ xorptr(rbx, rbx);

    // 标号loop处
    __ BIND(loop);

    // 此处开始循环；从最后一个参数倒序往前进行参数压栈，初始时，rcx = parameter_size；要注意，这里的参数是指java方法所需的参数，而不是call_stub例程所需参数！
    // 将（rdx + rcx * stackElementScale（）- wordSize ）移到 rax 中，（rdx + rcx * stackElementScale（）- wordSize ）指向了要压栈的参数。
    __ movptr(rax, Address(rdx, rcx, Interpreter::stackElementScale(), -wordSize));
    // 再从rax中转移到（rsp + rbx * stackElementScale（）） 处，expr_offset_in_bytes（0） = 0；这里是基于栈顶地址进行偏移寻址的，最后一个参数会被压到栈顶处。第一个参数会被压到rsp + （parameter_size-1）* stackElementScale（）处。
    __ movptr(Address(rsp, rbx, Interpreter::stackElementScale(),
                Interpreter::expr_offset_in_bytes(0)), rax);          // store parameter
    // 更新rbx
    __ increment(rbx);
    // 自减rcx，当rcx不为0时，继续跳往loop处循环执行。
    __ decrement(rcx);
    __ jcc(Assembler::notZero, loop);

    // 标号parameters_done处
    __ BIND(parameters_done);

    // 接下来要开始调用Java方法了
    // 将调用java方法的entry_point例程所需的一些参数保存到寄存器中
    __ movptr(rbx, method);           // get Method*
    __ movptr(rax, entry_point);      // get entry_point
    __ mov(rsi, rsp);                 // set sender sp
    // 跳往entry_point例程执行
    __ call(rax);

    //......
	
    __ BIND(is_double);
    // interpreter uses xmm0 for return values
    if (UseSSE >= 2) {
        __ movdbl(Address(rdi, 0), xmm0);
    } else {
        __ fstp_d(Address(rdi, 0));
    }
    __ jmp(exit);
	
    return start;
}

class Address {
private:
	// 表示一个物理寄存器，寄存器的作用是标记基址，因此命令为_base
	Register _base;
	// 表示偏移量
	int _disp;
public:
	// 构造函数
	Address()
		: _base(noreg),
		_disp(0)
	{   }
}

void MacroAssembler::enter() {
	push(rbp);
	mov(rbp, rsp)
}

// 生成 movl 0x20(%ebp), %ecx   意为将ebp栈基地址向高地址偏移32字节处的数据传送到ecx寄存器中
__ movptr(rcx, parameter_size);              		// parameter counter  
// 生成shl $0x2, %ecx   意为将ecx寄存器中的值左移2位，对于二进制左移2位即乘以4，在32位平台上每个入参指针都占32位空间，即4字节
// 0x20(%ebp)处的数据是parameter_size，每一个parameter指针占用4个字节
__ shlptr(rcx, Interpreter::logStackElementSize); 	// convert parameter count to bytes   
// 这样就计算出即将被调用的Java函数入参需要的堆栈空间

// 生成 add $0x10, %ecx   主要用于保存rdi、rsi、rbx、mxcsr这4个寄存器的值，这4个寄存器各占4字节，因此需要再将ecx寄存器加上16，最终JVM为将被调用的Java函数所分配的对战空间再增加16字节大小
// 基址和变址用于Java字节码取值，一个Java函数对应若干条字节码指令，一条字节码指令转换为若干条机器指令，物理机器能自动取值，但无法对JVM字节码进行自动取值，因此JVM需要自己实现对字节码取值
__ addptr(rcx, locals_count_in_bytes);       		// reserve space for register saves
// 生成 sub %ecx, %esp 即 sub operand, %esp   进行动态分配堆栈空间，operand就表示刚才计算出来的堆栈大小
__ subptr(rsp, rcx);
// 生成  and &0xfffffff0, %esp     为了加速内存寻址和回收，物理机器在分配堆栈空间时都会进行内存对齐
__ andptr(rsp, -(StackAlignmentInBytes));    		// Align stack

// 生成 mov %edi, -0x4(%ebp)
__ movtr(saved_rdi, rdi);
// 生成 mov %esi, -0x8(%ebp)
__ movptr(saved_rsi, rsi);
// 生成 mov %ebx, -0xc(%ebp)
__ movptr(saved_rbx, rbx);

// pass parameters if any
Label parameters_done;
// mov 0x20(%ebp), %ecx   32(%ebp)处的数据是入参数量
__ movl(rcx, parameter_size);  // parameter counter
// test %ecx, %ecx		检查参数数量是否为0，为0则直接跳过参数处理，跳到标号parameters_done处
__ testl(rcx, rcx);
// je 0xb370b68b;;  该地址每次启动JVM时都不一样
__ jcc(Assembler::zero, parameters_done);

Label loop
// mov 0x1c(%ebp), %edx      将参数第一个入参指针放到寄存器rdx
__ movptr(rdx, parameters);          // parameter pointer
// xor %ebx, %ebx     将%ebx设为0
__ xorptr(rbx, rbx);

// pass parameters if any
__ BIND(loop);

// mov -0x4(%edx, %ecx, 4), %eax      edx指向paramsters首地址，ecx指向Java函数入参数量
__ movptr(rax, Address(rdx, rcx, Interpreter::stackElementScale(), -wordSize));
// mov eax, (%esp, %ebx, 4)
__ movptr(Address(rsp, rbx, Interpreter::stackElementScale(),
			Interpreter::expr_offset_in_bytes(0)), rax);          // store parameter
// inc %ebx
__ increment(rbx);
// esc %ecx   通过减入参数量，进行逆向循环，从后往前遍历参数，并将读取到的入参传到堆栈中去
__ decrement(rcx);
// jne 0xb370b686
__ jcc(Assembler::notZero, loop);

__ BIND(parameters_done);

// mov 0x14(%ebp), %ebx   将method首地址传给ebx寄存器
__ movptr(rbx, method);
// mov 0x18(%ebp), %ebx    将entry_point传给eax寄存器
__ movptr(rax, entry_point);
// mov %esp, %esi         将当前栈顶保存到esi寄存器中
__ mov(rsi, rsp);                 // set sender sp
// call *%eax           调用entry_point，跳往entry_point例程执行
__ call(rax);

// 返回result，0xc(%ebp)保存的是resultAddress
mov 0xc(%ebp), %edi
// result_type，0x10(%ebp)保存的是result_type
mov 0x10(%ebp), %esi