标签:
本文转自ImportNew 专栏, 虽然不算一个成功的开始 ,但却是更新博客的一个动力。
java应用程序的启动在在/hotspot/src/share/tools/launcher/java.c的main()函数中,而在虚拟机初始化过程中,将创建并启动Java的Main线程。最后将调用JNIEnv的CallStaticVoidMethod()来执行main方法。
CallStaticVoidMethod()对应的jni函数为jni_CallStaticVoidMethod,定义在/hotspot/src/share/vm/prims/jni.cpp中,而jni_CallStaticVoidMethod()又调用了jni_invoke_static(),jni_invoke_static()通过JavaCalls的call()发起对Java方法的调用
所有来自虚拟机对Java函数的调用最终都将由JavaCalls模块来完成,JavaCalls将通过call_helper()来执行Java方法并返回调用结果,并最终调用StubRoutines::call_stub()来执行Java方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// do call { JavaCallWrapper link(method, receiver, result, CHECK); { HandleMark hm(thread); // HandleMark used by HandleMarkCleaner StubRoutines::call_stub()( (address)&link, // (intptr_t*)&(result->_value), // see NOTE above (compiler problem) result_val_address, // see NOTE above (compiler problem) result_type, method(), entry_point, args->parameters(), args->size_of_parameters(), CHECK ); result = link.result(); // circumvent MS C++ 5.0 compiler bug (result is clobbered across call) // Preserve oop return value across possible gc points if (oop_result_flag) { thread->set_vm_result((oop) result->get_jobject()); } } } |
call_stub()定义在/hotspot/src/share/vm/runtime/stubRoutines.h中,实际上返回的就 是CallStub函数指针_call_stub_entry,该指针指向call_stub的汇编实现的目标代码指令地址,即call_stub的例程 入口。
1
2
3
4
5
6
7
8
9
10
11
12
|
// Calls to Java typedef void (*CallStub)( address link, intptr_t* result, BasicType result_type, methodOopDesc* method, address entry_point, intptr_t* parameters, int size_of_parameters, TRAPS ); static CallStub call_stub() { return CAST_TO_FN_PTR(CallStub, _call_stub_entry); } |
在分析call_stub的汇编代码之前,先了解下x86寄存器和栈帧以及函数调用的相关知识。
x86-64的所有寄存器都是与 机器字长(数据总线位宽)相同,即64位的,x86-64将x86的8个32位通用寄存器扩展为64位(eax、ebx、ecx、edx、eci、 edi、ebp、esp),并且增加了8个新的64位寄存器(r8-r15),在命名方式上,也从”exx”变为”rxx”,但仍保留”exx”进行32 位操作,下表描述了各寄存器的命名和作用
此外,还有16个128位的XMM寄存器,分别为xmm0-15,x84-64的寄存器遵循调用约定(Calling Conventions):
https://msdn.microsoft.com/en-US/library/zthk2dkh(v=vs.80).aspx
1.参数传递:
(1).前4个参数的int类型分别通过rcx、rdx、r8、r9传递,多余的在栈空间上传递(从右向左依次入栈),寄存器所有的参数都是向右对齐的(低位对齐)
(2).浮点数类型的参数通过xmm0-xmm3传递,注意不同类型的参数占用的寄存器序号是根据参数的序号来决定的,比如add(int,double,float,int)就分别保存在rcx、xmm1、xmm2、r9寄存器中
(3).8/16/32/64类型的结构体或共用体和_m64类型将使用rcx、rdx、r8、r9直接传递,而其他类型将会通过指针引用的方式在这4个寄存器中传递
(4).被调用函数当需要时要把寄存器中的参数移动到栈空间中(shadow space)
2.返回值传递
(1).对于可以填充为64位的返回值(包括_m64)将使用rax进行传递
(2).对于_m128(i/d)以及浮点数类型将使用xmm0传递
(3).对于64位以上的返回值,将由调用函数在栈上为其分配空间,并将其指针保存在rcx中作为”第一个参数”,而传入参数将依次右移,最后函数调用完后,由rax返回该空间的指针
(4).用户定义的返回值类型长度必须是1、2、4、8、16、32、64
3.调用者/被调用者保存寄存器
调用者保存寄存器:rax、rcx、rdx、r8-r11都认为是易失型寄存器(volatile),这些寄存器随时可能被用到,这些寄存器将由调用者 自行维护,当调用其他函数时,被调用函数对这些寄存器的操作并不会影响调用函数(即这些寄存器的作用范围仅限于当前函数)。
被调用者保存寄 存器:rbx、rbp、rdi、rsi、r12-r15、xmm6-xmm15都是非易失型寄存器(non-volatile),调用其他函数时,这些寄 存器的值可能在调用返回时还需要用,那么被调用函数就必须将这些寄存器的值保存起来,当要返回时,恢复这些寄存器的值(即这些寄存器的作用范围是跨函数调 用的)。
以如下程序为例,分析函数调用的栈帧布局:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
double func( int param_i1, float param_f1, double param_d1, int param_i2, double param_d2) { int local_i1, local_i2; float local_f1; double local_d1; double local_d2 = 3.0 ; local_i1 = param_i1; local_i2 = param_i2; local_f1 = param_f1; local_d1 = param_d1; return local_d1 + local_f1 * (local_i2 - local_i1) - param_d2 + local_d2; } int main() { double res; res = func( 1 , 1.0 , 2.0 , 3 , 3.0 ); return 0 ; } |
main函数调用func之前的汇编代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
main: pushq %rbp //保存rbp .seh_pushreg %rbp movq %rsp, %rbp //更新栈基址 .seh_setframe %rbp, 0 subq $ 80 , %rsp .seh_stackalloc 80 //main栈需要80字节的栈空间 .seh_endprologue call __main movabsq $ 4611686018427387904 , %rdx //0x4000000000000000,即浮点数2.0 movabsq $ 4613937818241073152 , %rax //0x3000000000000000,即浮点数3.0 movq %rax, 32 (%rsp) //第5个参数3.0,即param_d2保存在栈空间上 movl $ 3 , %r9d //第4个参数3,即param_i2保存在r9d中(r9的低32位) movq %rdx, - 24 (%rbp) movsd - 24 (%rbp), %xmm2 //第3个参数2.0,即param_d1保存在xmm2中 movss .LC2(%rip), %xmm1 //第2个参数1.0(0x3f800000),保存在xmm1中 movl $ 1 , %ecx //第1个参数1,保存在ecx中(rcx的低32位) call func |
func函数返回后,main函数将从xmm0中取出返回结果
1
2
3
4
5
6
7
|
call func movq %xmm0, %rax //保存结果 movq %rax, - 8 (%rbp) movl $ 0 , %eax //清空eax,回收main栈,恢复栈顶地址 addq $ 80 , %rsp popq %rbp ret |
func函数的栈和操作数准备如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
func: pushq %rbp //保存rbp(main函数栈的基址) .seh_pushreg %rbp movq %rsp, %rbp //将main栈的栈顶指针作为被调用函数的栈基址 .seh_setframe %rbp, 0 subq $ 32 , %rsp //func栈需要32字节的栈空间 .seh_stackalloc 32 .seh_endprologue movl %ecx, 16 (%rbp) //将4个参数移动到栈底偏移16-40的空间(main栈的shadow space) movss %xmm1, 24 (%rbp) movsd %xmm2, 32 (%rbp) movl %r9d, 40 (%rbp) movabsq $ 4613937818241073152 , %rax //本地变量local_d2,即浮点数3.0 movq %rax, - 8 (%rbp) //5个局部变量 movl 16 (%rbp), %eax movl %eax, - 12 (%rbp) movl 40 (%rbp), %eax movl %eax, - 16 (%rbp) movl 24 (%rbp), %eax movl %eax, - 20 (%rbp) movq 32 (%rbp), %rax movq %rax, - 32 (%rbp) |
随后的func的运算过程如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
movl - 16 (%rbp), %eax //local_i2 - local_i1 subl - 12 (%rbp), %eax pxor %xmm0, %xmm0 //准备xmm0寄存器,按位异或,xmm0清零 cvtsi2ss %eax, %xmm0 mulss - 20 (%rbp), %xmm0 //local_f1 * (local_i2 - local_i1) cvtss2sd %xmm0, %xmm0 addsd - 32 (%rbp), %xmm0 //local_d1 + local_f1 * (local_i2 - local_i1) subsd 48 (%rbp), %xmm0 //local_d1 + local_f1 * (local_i2 - local_i1) - param_d2 addsd - 8 (%rbp), %xmm0 //local_d1 + local_f1 * (local_i2 - local_i1) - param_d2 + local_d2 addq $ 32 , %rsp //回收func栈,恢复栈顶地址 popq %rbp ret |
根据以上代码分析,大概得出该程序调用栈结构:
这里没有考虑func函数再次调用其他函数而准备操作数的栈内容的情况,但结合main函数栈,大致可以得出栈的通用结构如下:
call_stub由generate_call_stub()解释成汇编代码,有兴趣的可以继续阅读call_stub的汇编代码进行分析。
下面对call_stub的汇编部分进行分析:
先来看下call_stub的调用栈结构:(注:本文实验是在windows_64位平台上实现的)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
// Call stubs are used to call Java from C // return_from_Java 是紧跟在call *%eax后面的那条指令的地址 // [ return_from_Java ] <--- rsp // -28 [ arguments ] <-- rbp - 0xe8 // -26 [ saved xmm15 ] <-- rbp - 0xd8 // -24 [ saved xmm14 ] <-- rbp - 0xc8 // -22 [ saved xmm13 ] <-- rbp - 0xb8 // -20 [ saved xmm12 ] <-- rbp - 0xa8 // -18 [ saved xmm11 ] <-- rbp - 0x98 // -16 [ saved xmm10 ] <-- rbp - 0x88 // -14 [ saved xmm9 ] <-- rbp - 0x78 // -12 [ saved xmm8 ] <-- rbp - 0x68 // -10 [ saved xmm7 ] <-- rbp - 0x58 // -9 [ saved xmm6 ] <-- rbp - 0x48 // -7 [ saved r15 ] <-- rbp - 0x38 // -6 [ saved r14 ] <-- rbp - 0x30 // -5 [ saved r13 ] <-- rbp - 0x28 // -4 [ saved r12 ] <-- rbp - 0x20 // -3 [ saved rdi ] <-- rbp - 0x18 // -2 [ saved rsi ] <-- rbp - 0x10 // -1 [ saved rbx ] <-- rbp - 0x8 // 0 [ saved rbp ] <--- rbp, // 1 [ return address ] <--- rbp + 0x08 // 2 [ ptr. to call wrapper ] <--- rbp + 0x10 // 3 [ result ] <--- rbp + 0x18 // 4 [ result_type ] <--- rbp + 0x20 // 5 [ method ] <--- rbp + 0x28 // 6 [ entry_point ] <--- rbp + 0x30 // 7 [ parameters ] <--- rbp + 0x38 // 8 [ parameter_size ] <--- rbp + 0x40 // 9 [ thread ] <--- rbp + 0x48 |
1.根据函数调用栈的结构:
在被调函数栈帧的栈底 %rbp + 8(栈地址向下增长,堆地址向上增长,栈底的正偏移值指向调用函数栈帧内容)保存着被调函数的传入参数,这里即:
JavaCallWrapper指针、返回结果指针、返回结果类型、被调用方法的methodOop、被调用方法的解释代码的入口地址、参数地址、参数个数。
1
2
3
4
5
6
7
8
|
StubRoutines::call_stub [ 0x0000000002400567 , 0x00000000024006cb [ ( 356 bytes) //保存bp 0x0000000002400567 : push %rbp //更新栈顶地址 0x0000000002400568 : mov %rsp,%rbp //call_stub需要的栈空间大小为0xd8 0x000000000240056b : sub $ 0xd8 ,%rsp |
2.rcx、rdx、r8d、r9d分别保存着传入call_stub的前4个参数,现在需要将其复制到栈上的shadow space中
1
2
3
4
5
6
7
|
//分别使用rcx、rdx、r8、r9来保存第1、2、3、4个参数,多出来的其他参数用栈空间来传递 //使用xmm0-4来传递第1-4个浮点数参数 //这里将参数复制到栈空间,这样call_stub的所有参数就在rbp + 0x10 ~ 0x48栈空间上 0x0000000002400572 : mov %r9, 0x28 (%rbp) 0x0000000002400576 : mov %r8d, 0x20 (%rbp) 0x000000000240057a : mov %rdx, 0x18 (%rbp) 0x000000000240057e : mov %rcx, 0x10 (%rbp) |
3.将被调用者保存寄存器的值压入call_stub栈中:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
;; save registers: //依次保存rbx、rsi、rdi这三个被调用者保存的寄存器,随后保存r12-r15、XMM寄存器组xmm6-xmm15 0x0000000002400582 : mov %rbx,- 0x8 (%rbp) 0x0000000002400586 : mov %r12,- 0x20 (%rbp) 0x000000000240058a : mov %r13,- 0x28 (%rbp) 0x000000000240058e : mov %r14,- 0x30 (%rbp) 0x0000000002400592 : mov %r15,- 0x38 (%rbp) 0x0000000002400596 : vmovdqu %xmm6,- 0x48 (%rbp) 0x000000000240059b : vmovdqu %xmm7,- 0x58 (%rbp) 0x00000000024005a0 : vmovdqu %xmm8,- 0x68 (%rbp) 0x00000000024005a5 : vmovdqu %xmm9,- 0x78 (%rbp) 0x00000000024005aa : vmovdqu %xmm10,- 0x88 (%rbp) 0x00000000024005b2 : vmovdqu %xmm11,- 0x98 (%rbp) 0x00000000024005ba : vmovdqu %xmm12,- 0xa8 (%rbp) 0x00000000024005c2 : vmovdqu %xmm13,- 0xb8 (%rbp) 0x00000000024005ca : vmovdqu %xmm14,- 0xc8 (%rbp) 0x00000000024005d2 : vmovdqu %xmm15,- 0xd8 (%rbp) 0x00000000024005da : mov %rsi,- 0x10 (%rbp) 0x00000000024005de : mov %rdi,- 0x18 (%rbp) //栈底指针的0x48偏移保存着thread对象,0x6d01a2c3(%rip)为异常处理入口 0x00000000024005e2 : mov 0x48 (%rbp),%r15 0x00000000024005e6 : mov 0x6d01a2c3 (%rip),%r12 # 0x000000006f41a8b0 |
4.call_stub的参数保存着Java方法的参数,现在就需要将参数压入call_stub栈中
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
/栈底指针的 0x40 偏移保存着参数的个数 0x00000000024005ed : mov 0x40 (%rbp),%r9d //若参数个数为0,则直接跳转0x000000000240060d准备调用Java方法 0x00000000024005f1 : test %r9d,%r9d 0x00000000024005f4 : je 0x000000000240060d //若参数个数不为0,则遍历参数,将所有参数压入本地栈 //其中栈底指针的0x38偏移保存着参数的地址,edx将用作循环的迭代器 0x00000000024005fa : mov 0x38 (%rbp),%r8 0x00000000024005fe : mov %r9d,%edx ;; loop: //从第一个参数开始,将Java方法的参数压人本地栈 /* * i = parameter_size; //确保不等于0 * do{ * push(parameter[i]); * i--; * }while(i!=0); */ 0x0000000002400601 : mov (%r8),%rax 0x0000000002400604 : add $ 0x8 ,%r8 0x0000000002400608 : dec %edx 0x000000000240060a : push %rax 0x000000000240060b : jne 0x0000000002400601 |
5.调用Java方法的解释代码
1
2
3
4
5
6
7
|
;; prepare entry: //栈底指针的0x28和0x30偏移分别保存着被调用Java方法的methodOop指针和解释代码的入口地址 0x000000000240060d : mov 0x28 (%rbp),%rbx 0x0000000002400611 : mov 0x30 (%rbp),%rdx 0x0000000002400615 : mov %rsp,%r13 //保存栈顶指针 ;; jump to run Java method: 0x0000000002400618 : callq *%rdx |
6.准备保存返回结果,这里需要先根据不同的返回类型取出返回结果,然后保存到返回结果指针所指向的位置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
;; prepare to save result: //栈底指针的0x18和0x20偏移分别保存着返回结果的指针和结果类型 0x000000000240061a : mov 0x18 (%rbp),%rcx 0x000000000240061e : mov 0x20 (%rbp),%edx ;; handle result accord to different result_type: 0x0000000002400621 : cmp $ 0xc ,%edx 0x0000000002400624 : je 0x00000000024006b7 0x000000000240062a : cmp $ 0xb ,%edx 0x000000000240062d : je 0x00000000024006b7 0x0000000002400633 : cmp $ 0x6 ,%edx 0x0000000002400636 : je 0x00000000024006bc 0x000000000240063c : cmp $ 0x7 ,%edx 0x000000000240063f : je 0x00000000024006c2 ;; save result for the other result_type: 0x0000000002400645 : mov %eax,(%rcx) |
下面分别为返回结果类型为long、float、double的情况
1
2
3
4
5
6
7
8
9
|
;; long 类型返回结果保存: 0x00000000024006b7 : mov %rax,(%rcx) 0x00000000024006ba : jmp 0x0000000002400647 ;; float 类型返回结果保存: 0x00000000024006bc : vmovss %xmm0,(%rcx) 0x00000000024006c0 : jmp 0x0000000002400647 ;; double 类型返回结果保存: 0x00000000024006c2 : vmovsd %xmm0,(%rcx) 0x00000000024006c6 : jmpq 0x0000000002400647 |
7.被调用者保存寄存器的恢复,以及栈指针的复位
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
;; restore registers: 0x0000000002400647 : lea - 0xd8 (%rbp),%rsp 0x000000000240064e : vmovdqu - 0xd8 (%rbp),%xmm15 0x0000000002400656 : vmovdqu - 0xc8 (%rbp),%xmm14 0x000000000240065e : vmovdqu - 0xb8 (%rbp),%xmm13 0x0000000002400666 : vmovdqu - 0xa8 (%rbp),%xmm12 0x000000000240066e : vmovdqu - 0x98 (%rbp),%xmm11 0x0000000002400676 : vmovdqu - 0x88 (%rbp),%xmm10 0x000000000240067e : vmovdqu - 0x78 (%rbp),%xmm9 0x0000000002400683 : vmovdqu - 0x68 (%rbp),%xmm8 0x0000000002400688 : vmovdqu - 0x58 (%rbp),%xmm7 0x000000000240068d : vmovdqu - 0x48 (%rbp),%xmm6 0x0000000002400692 : mov - 0x38 (%rbp),%r15 0x0000000002400696 : mov - 0x30 (%rbp),%r14 0x000000000240069a : mov - 0x28 (%rbp),%r13 0x000000000240069e : mov - 0x20 (%rbp),%r12 0x00000000024006a2 : mov - 0x8 (%rbp),%rbx 0x00000000024006a6 : mov - 0x18 (%rbp),%rdi 0x00000000024006aa : mov - 0x10 (%rbp),%rsi ;; back to old(caller) stack frame: 0x00000000024006ae : add $ 0xd8 ,%rsp //栈顶指针复位 0x00000000024006b5 : pop %rbp //栈底指针复位 0x00000000024006b6 : retq |
归纳出call_stub栈结构如下:
8.对于不同的Java方法,虚拟机在初始化时会生成不同的方法入口例程
(method entry point)来准备栈帧,这里以较常被使用的zerolocals方法入口为例,分析Java方法的栈帧结构与调用过程,入口例程目标代码的产生在InterpreterGenerator::generate_normal_entry()中:
(1).根据之前的分析,初始的栈结构如下:
获取传入参数数量到rcx中:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
address InterpreterGenerator::generate_normal_entry(bool synchronized ) { // determine code generation flags bool inc_counter = UseCompiler || CountCompiledCalls; // ebx: methodOop // r13: sender sp address entry_point = __ pc(); const Address size_of_parameters(rbx, methodOopDesc::size_of_parameters_offset()); const Address size_of_locals(rbx, methodOopDesc::size_of_locals_offset()); const Address invocation_counter(rbx, methodOopDesc::invocation_counter_offset() + InvocationCounter::counter_offset()); const Address access_flags(rbx, methodOopDesc::access_flags_offset()); // get parameter size (always needed) __ load_unsigned_short(rcx, size_of_parameters); |
其中methodOop指针被保存在rbx中,调用Java方法的sender sp被保存在r13中,参数大小保存在rcx中
(2). 获取局部变量区的大小,保存在rdx中,并减去参数数量,将除参数以外的局部变量数量保存在rdx中(虽然参数作为局部变量是方法的一部分,但参数由调用 者提供,这些参数应有调用者栈帧而非被调用者栈帧维护,即被调用者栈帧只需要维护局部变量中除了参数的部分即可)
1
2
3
4
5
6
|
// rbx: methodOop // rcx: size of parameters // r13: sender_sp (could differ from sp+wordSize if we were called via c2i ) __ load_unsigned_short(rdx, size_of_locals); // get size of locals in words __ subl(rdx, rcx); // rdx = no. of additional locals |
(3).对栈空间大小进行检查,判断是否会发生栈溢出
1
2
|
// see if we‘ve got enough room on the stack for locals plus overhead. generate_stack_overflow_check(); |
(4).获取返回地址,保存在rax中(注意此时栈顶为调用函数call指令后下一条指令的地址)
1
2
|
// get return address __ pop(rax); |
(5).由于参数在栈中由低地址向高地址是以相反的顺序存放的,所以第一个参数的地址应该是 rsp+rcx*8-8(第一个参数地址范围为 rsp+rcx*8-8 ~ rsp+rcx*8),将其保存在r14中
1
2
|
// compute beginning of parameters (r14) __ lea(r14, Address(rsp, rcx, Address::times_8, -wordSize)) |
(6).为除参数以外的局部变量分配栈空间,若这些局部变量数量为0,那么就跳过这一部分处理,否则,将压入 maxlocals – param_size个0,以初始化这些局部变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
//该部分为一个loop循环 // rdx - # of additional locals // allocate space for locals // explicitly initialize locals { Label exit, loop; __ testl(rdx, rdx); __ jcc(Assembler::lessEqual, exit); // do nothing if rdx <= 0 __ bind(loop); __ push(( int ) NULL_WORD); // initialize local variables __ decrementl(rdx); // until everything initialized __ jcc(Assembler::greater, loop); __ bind(exit); } |
这时栈的层次如下:
(7).将方法的调用次数保存在rcx/ecx中
1
2
3
4
|
// (pre-)fetch invocation count if (inc_counter) { __ movl(rcx, invocation_counter); } |
(8).初始化当前方法的栈帧
1
2
|
// initialize fixed part of activation frame generate_fixed_frame( false ); |
generate_fixed_frame()的实现如下:
1
2
3
4
5
6
7
|
__ push(rax); // save return address __ enter(); // save old & set new rbp __ push(r13); // set sender sp __ push(( int )NULL_WORD); // leave last_sp as null __ movptr(r13, Address(rbx, methodOopDesc::const_offset())); // get constMethodOop __ lea(r13, Address(r13, constMethodOopDesc::codes_offset())); // get codebase __ push(rbx); |
保存返回地址,为被调用的Java方法准备栈帧,并将sender sp指针、last_sp(设置为0)压入栈,根据methodOop的constMethodOop成员将字节码指针保存到r13寄存器中,并将methodOop压入栈
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
} else { __ push( 0 ); //methodData } __ movptr(rdx, Address(rbx, methodOopDesc::constants_offset())); __ movptr(rdx, Address(rdx, constantPoolOopDesc::cache_offset_in_bytes())); __ push(rdx); // set constant pool cache __ push(r14); // set locals pointer if (native_call) { __ push( 0 ); // no bcp } else { __ push(r13); // set bcp } __ push( 0 ); // reserve word for pointer to expression stack bottom __ movptr(Address(rsp, 0 ), rsp); // set expression stack bottom } |
将methodData以0为初始值压入栈,根据methodOop的ConstantPoolOop成员将常量池缓冲地址压入栈,r14中保存着 局部变量区(第一个参数的地址)指针,将其压入栈,此外如果调用的是native调用,那么字节码指针部分为0,否则正常将字节码指针压入栈,最后为栈留 出一个字的表达式栈底空间,并更新rsp
最后栈的空间结构如下:
(9).增加方法的调用计数
1
2
3
4
5
6
7
8
9
10
11
12
|
// increment invocation count & check for overflow Label invocation_counter_overflow; Label profile_method; Label profile_method_continue; if (inc_counter) { generate_counter_incr(&invocation_counter_overflow, &profile_method, &profile_method_continue); if (ProfileInterpreter) { __ bind(profile_method_continue); } } |
(当调用深度过大会抛出StackOverFlow异常)
(10).同步方法的Monitor对象分配和方法的加锁(在汇编部分分析中没有该部分,如果对同步感兴趣的请自行分析)
1
2
3
|
if ( synchronized ) { // Allocate monitor and lock method lock_method(); |
(11).JVM工具接口部分
1
2
|
// jvmti support __ notify_method_entry(); |
(12).跳转到第一条字节码的本地代码处执行
1
|
__ dispatch_next(vtos); |
以上分析可能略显复杂,但重要的是明白方法的入口例程是如何为Java方法构造新的栈帧,从而为字节码的运行提供调用栈环境。
method entry point汇编代码的分析可以参考随后的一篇文章。
标签:
原文地址:http://www.cnblogs.com/leospiritlee/p/4977229.html