- On x86_ Contents in practice 2.4 under 64 architecture
- Check the contents of the register through GDB and fill in the specific values in the figure in the textbook
- The C code of 2.4 is practiced again in OpenEuler, and the logic block diagram of ARM64 is drawn
- The experimental content can only get the corresponding score after oral defense
Code and assembly conversion
According to the textbook, there are differences in parameter transfer between 64 bit and 32 bit. 32-bit transfers parameters directly through the stack, while 64-bit transfers the first six parameters into rdi, rsi, rdx, rcx, r8 and r9 in turn, and then the remaining parameters are passed through the stack like 32-bit. In the 2.5 operation, a segment error occurs when calling printf function directly on 64 bit with 32-bit code. The textbook directly explains here, This difference is the cause.
Example code t.c:
#include <stdio.h> int sub(int a,int b,int c,int d,int e,int f,int g,int h) { int u,v,w; u = 9; v = 10; w = 11; return a+g+u+v; } int main() { int a,b,c,d,e,f,g,h,i; a=1; b=2; c=3; d=4; e=5; f=6; g=7; h=8; i=sub(a,b,c,d,e,f,g,h); }
In x86_ Convert openEuler of 64 to assembly code and view:
t.s:
.file "t.c" .text .globl sub .type sub, @function sub: .LFB0: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 .cfi_offset 6, -16 movq %rsp, %rbp .cfi_def_cfa_register 6 movl %edi, -20(%rbp) movl %esi, -24(%rbp) movl %edx, -28(%rbp) movl %ecx, -32(%rbp) movl %r8d, -36(%rbp) movl %r9d, -40(%rbp) movl $9, -4(%rbp) movl $10, -8(%rbp) movl $11, -12(%rbp) movl -20(%rbp), %edx movl 16(%rbp), %eax addl %eax, %edx movl -4(%rbp), %eax addl %eax, %edx movl -8(%rbp), %eax addl %edx, %eax popq %rbp .cfi_def_cfa 7, 8 ret .cfi_endproc .LFE0: .size sub, .-sub .globl main .type main, @function main: .LFB1: .cfi_startproc pushq %rbp .cfi_def_cfa_offset 16 .cfi_offset 6, -16 movq %rsp, %rbp .cfi_def_cfa_register 6 subq $48, %rsp movl $1, -4(%rbp) movl $2, -8(%rbp) movl $3, -12(%rbp) movl $4, -16(%rbp) movl $5, -20(%rbp) movl $6, -24(%rbp) movl $7, -28(%rbp) movl $8, -32(%rbp) movl -24(%rbp), %r9d movl -20(%rbp), %r8d movl -16(%rbp), %ecx movl -12(%rbp), %edx movl -8(%rbp), %esi movl -4(%rbp), %eax movl -32(%rbp), %edi pushq %rdi movl -28(%rbp), %edi pushq %rdi movl %eax, %edi call sub addq $16, %rsp movl %eax, -36(%rbp) movl $0, %eax leave .cfi_def_cfa 7, 8 ret .cfi_endproc .LFE1: .size main, .-main .ident "GCC: (GNU) 7.3.0" .section .note.GNU-stack,"",@progbits
gdb analysis
Use gcc -g t.s -o t to compile t.s. you can directly debug the assembly code through cgdb t and view it.
Use b main, r to start stepping.
Before the function is executed, it will push its rbp onto the stack.
Use s to step.
The first is the variable definition of the main function. First, esp is reduced by 48 to provide space for a~h.
View the value of the register: use i r to view the value in the corresponding memory, and use x 0x012345678abcdef
Corresponding to the value of ebp in the figure above, view the value of a~h in the stack:
Analyze the stack state after saving the value of main function:
After entering the sub function, the numbers in the six registers are stored on the stack before operation:
However, I see that the code does not restore the two extra parameters (g and h).
In operation, you need to add a, g, u and v.
Where u and v are defined in the sub function, a is passed in through the register, and h is passed through the stack. Through analysis, the value of h is 16(%rbp).
The box in the following figure is the addition part.
The following figure shows the stack analysis diagram:
After the final calculation, restore rbp and return to. The return value exists in rax.
Huawei Kunpeng server is based on Arm64 architecture.
Code and assembly conversion
t.s under arm64 architecture:
.cpu generic+fp+simd .file "t.c" .text .align 2 .global sub .type sub, %function sub: .LFB0: .cfi_startproc sub sp, sp, #48 .cfi_def_cfa_offset 48 str w0, [sp,28] str w1, [sp,24] str w2, [sp,20] str w3, [sp,16] str w4, [sp,12] str w5, [sp,8] str w6, [sp,4] str w7, [sp] mov w0, 9 str w0, [sp,44] mov w0, 10 str w0, [sp,40] mov w0, 11 str w0, [sp,36] ldr w1, [sp,28] ldr w0, [sp,4] add w1, w1, w0 ldr w0, [sp,44] add w1, w1, w0 ldr w0, [sp,40] add w0, w1, w0 add sp, sp, 48 .cfi_def_cfa_offset 0 ret .cfi_endproc .LFE0: .size sub, .-sub .align 2 .global main .type main, %function main: .LFB1: .cfi_startproc stp x29, x30, [sp, -64]! .cfi_def_cfa_offset 64 .cfi_offset 29, -64 .cfi_offset 30, -56 add x29, sp, 0 .cfi_def_cfa_register 29 mov w0, 1 str w0, [x29,60] mov w0, 2 str w0, [x29,56] mov w0, 3 str w0, [x29,52] mov w0, 4 str w0, [x29,48] mov w0, 5 str w0, [x29,44] mov w0, 6 str w0, [x29,40] mov w0, 7 str w0, [x29,36] mov w0, 8 str w0, [x29,32] ldr w0, [x29,60] ldr w1, [x29,56] ldr w2, [x29,52] ldr w3, [x29,48] ldr w4, [x29,44] ldr w5, [x29,40] ldr w6, [x29,36] ldr w7, [x29,32] bl sub str w0, [x29,28] ldp x29, x30, [sp], 64 .cfi_restore 30 .cfi_restore 29 .cfi_def_cfa 31, 0 ret .cfi_endproc .LFE1: .size main, .-main .ident "GCC: (GNU) 4.8.5 20150623 (Red Hat 4.8.5-39)" .section .note.GNU-stack,"",%progbits
Parameter transfer process analysis
In arm: str is storage and ldr is fetch.
In the above figure, save a-h to the corresponding positions of x29,60~x29,32.
Stack and flowchart after analysis:
It can be seen that the function parameter transfer in arm64 in this example is realized through w0-w7.