Rust基础语句汇编分析
LI Rui

作者正在积极寻找寒暑假实习机会,如果您能提供帮助,请通过文章底部的联系方式联系作者,不胜感激。

从开始接触Rust以来,我一直在惊叹于Rust的安全、高效,享受Rust带来的开发的愉悦。但随着开发的Rust项目越来越多,我的疑惑也逐渐增大,我们知道Rust可以很好的工作,但它是如何运作的?Rust是怎么处理每一条match语句的?是怎么传递参数的?

下面我们尝试去理解它,窥视Rust运作原理的一部分(非常小的一部分)。我们将编写一系列包含简单语句的函数,用静态分析工具分析汇编指令,搞明白程序是怎么执行的。希望这篇文章能够帮助到您,当然这篇文章可能包含部分甚至完全的错误,如果您能够在评论区指出,既能够帮助作者纠正错误,也能让其他读者免受作者之害(笑)。

本文的代码

作者的二进制水平有限,目前只能对于简单的语句进行分析,因此我们的第一篇文章就围绕下面的简单代码展开,争取搞懂每一个函数。作者事先也没有分析过Rust的二进制,希望能在写这篇文章的时候和读者一起学习。如果遇到带有疑问的地方,作者会用加粗字体标识,大家可以一起讨论。

在编译代码的时候,我们的项目名称为assembly,使用debug编译,而非release。

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#![feature(start)]

#[start]
#[no_mangle]
fn boost(argc: isize, argv: *const *const u8) -> isize {
mangled();
try_variable();
try_match();
try_match_with_arg(1);
try_so_many_arg(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
try_str_arg("wow");
0
}

fn mangled() {}

#[no_mangle]
fn try_variable() {
let foo = 1;
let bar = 2;
let mut bar = 3;
bar += 1;
let foo = 5;
}

#[no_mangle]
fn try_match() {
let mut foo = 1;
match foo {
1 => {
foo = 2;
}
_ => {
foo = 3;
}
}
}

#[no_mangle]
fn try_match_with_arg(foo: i32) -> i32 {
match foo {
1 => {
0
}
2 => {
1
}
_ => {
2
}
}
}

#[no_mangle]
fn try_so_many_arg(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32, g: i32, h: i32, i: i32, j: i32, k: i32, l: i32) {
let a = a + 1;
let b = b + 2;
}

#[no_mangle]
fn try_str_arg(s: &str) {
let _ = s.len();
}

#[no_mangle]是什么

本节对应的RFC页面:2603-rust-symbol-name-mangling-v0

在Rust中,我们程序中的符号在编译时会经过名字修饰这一过程,这是为了保证实体名字必须唯一的一种技术。比如我们的函数名为mangled,在经过名字修饰后,函数名会变为类似_ZN8assembly7mangled17hdae1ffd2c2da5f53E的一串,具体的规则可以查看RFC中的讲述。为了保证我们可以轻松找到编译后的函数,我们需要为函数加上#[no_mangle]这一属性,保证函数保留原本的名称。

#[start]是什么

相信部分读者已经注意到了,我们的函数没有main函数,而是为boost加上了start属性。Rust和C语言不一样,我们一般情况编写的main函数在编译后同样会经过上面说的名字修饰。而Rust在执行时,会经过_start -> main -> our_main的过程,我们的main函数实际上是被调用的,而不是入口!

下面我们来验证:

首先读取ELF头,得到入口点地址为0x6470。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
ELF 头:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
类别: ELF64
数据: 2 补码,小端序 (little endian)
Version: 1 (current)
OS/ABI: UNIX - System V
ABI 版本: 0
类型: DYN (共享目标文件)
系统架构: Advanced Micro Devices X86-64
版本: 0x1
入口点地址: 0x6470
程序头起点: 64 (bytes into file)
Start of section headers: 3585048 (bytes into file)
标志: 0x0
Size of this header: 64 (bytes)
Size of program headers: 56 (bytes)
Number of program headers: 14
Size of section headers: 64 (bytes)
Number of section headers: 43
Section header string table index: 42

查看Objdump的结果:

而main函数:

验证成功!

这里我们想为main设置no_mangle属性,但实际上已经有一个main了,重复的符号是不允许的,因此我们需要使用start+no_mangle来自定义我们程序的“入口”。

boost函数

源码

1
2
3
4
5
6
7
8
fn boost(argc: isize, argv: *const *const u8) -> isize {
try_variable();
try_match();
try_match_with_arg(1);
try_so_many_arg(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
try_str_arg("wow");
0
}

汇编

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
32
33
0000000000006570 <boost>:
6570: 48 83 ec 48 sub $0x48,%rsp
6574: 48 89 7c 24 38 mov %rdi,0x38(%rsp)
6579: 48 89 74 24 40 mov %rsi,0x40(%rsp)
657e: e8 7d 00 00 00 call 6600 <_ZN8assembly7mangled17hdae1ffd2c2da5f53E>
6583: e8 88 00 00 00 call 6610 <try_variable>
6588: e8 b3 00 00 00 call 6640 <try_match>
658d: bf 01 00 00 00 mov $0x1,%edi
6592: e8 c9 00 00 00 call 6660 <try_match_with_arg>
6597: 31 ff xor %edi,%edi
6599: be 01 00 00 00 mov $0x1,%esi
659e: ba 02 00 00 00 mov $0x2,%edx
65a3: b9 03 00 00 00 mov $0x3,%ecx
65a8: 41 b8 04 00 00 00 mov $0x4,%r8d
65ae: 41 b9 05 00 00 00 mov $0x5,%r9d
65b4: c7 04 24 06 00 00 00 movl $0x6,(%rsp)
65bb: c7 44 24 08 07 00 00 movl $0x7,0x8(%rsp)
65c2: 00
65c3: c7 44 24 10 08 00 00 movl $0x8,0x10(%rsp)
65ca: 00
65cb: c7 44 24 18 09 00 00 movl $0x9,0x18(%rsp)
65d2: 00
65d3: c7 44 24 20 0a 00 00 movl $0xa,0x20(%rsp)
65da: 00
65db: c7 44 24 28 0b 00 00 movl $0xb,0x28(%rsp)
65e2: 00
65e3: e8 c8 00 00 00 call 66b0 <try_so_many_arg>
65e8: 48 8d 3d 11 fa 02 00 lea 0x2fa11(%rip),%rdi # 36000 <_fini+0x3d8>
65ef: be 03 00 00 00 mov $0x3,%esi
65f4: e8 67 01 00 00 call 6760 <try_str_arg>
65f9: 31 c0 xor %eax,%eax
65fb: 48 83 c4 48 add $0x48,%rsp
65ff: c3 ret

伪代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
isize __fastcall assembly::boost(isize argc, u8 **argv)
{
_str v2; // rdi

assembly::mangled::hdae1ffd2c2da5f53();
assembly::try_variable();
assembly::try_match();
assembly::try_match_with_arg(1);
assembly::try_so_many_arg(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
v2.data_ptr = (u8 *)"wowsrc/main.rs";
v2.length = 3LL;
assembly::try_str_arg(v2);
return 0LL;
}

分析

在我们boost函数中,包含了一系列函数调用和参数传递,从中可以看出:Rust中的参数传递,前六个参数放到rdi rsi rdx rcx r8d r9d寄存器,之后的参数放入栈中。

而对于&str类型,Rust会用一个结构去存储,这个结构包含下面两个元素:

  • data_ptr:指向数据地址的指针
  • length:长度

这里我们的第一个放置了指向”wow”的地址,其保存在.rodata段中。第二个参数为3,代表&str的长度为3。如果不指定长度,&str也不像C语言会以’\0’进行截断,我们将不知道&str的值为什么。

最后的返回值部分可以看到eax用异或清零,直接返回。

try_variable函数

源码

1
2
3
4
5
6
7
fn try_variable() {
let foo = 1;
let bar = 2;
let mut bar = 3;
bar += 1;
let foo = 5;
}

汇编

1
2
3
4
5
6
7
8
9
10
11
12
13
0000000000006610 <try_variable>:
6610: 48 83 ec 10 sub $0x10,%rsp
6614: c7 44 24 04 01 00 00 movl $0x1,0x4(%rsp)
661b: 00
661c: c7 44 24 08 02 00 00 movl $0x2,0x8(%rsp)
6623: 00
6624: c7 04 24 03 00 00 00 movl $0x3,(%rsp)
662b: c7 04 24 04 00 00 00 movl $0x4,(%rsp)
6632: c7 44 24 0c 05 00 00 movl $0x5,0xc(%rsp)
6639: 00
663a: 48 83 c4 10 add $0x10,%rsp
663e: c3 ret
663f: 90 nop

分析

在Rust中i32的类型会占用4Byte内存,在函数头部我们可以看到栈顶地址被减去16Byte为局部变量开辟空间,此时栈的分布如下:

由于Rust中支持变量遮蔽,我们能够重复声明foo和bar变量并赋值,但他们都拥有各自的内存空间,而不是覆盖原有的空间。同时编译器已经为我们把加法优化为了mov指令直接赋值。

在可变性上,Rust会在编译上为我们强调mut和非mut的区别,而实际的编译结果是看不出来的。

try_match函数

源码

1
2
3
4
5
6
7
8
9
10
11
fn try_match() {
let mut foo = 1;
match foo {
1 => {
foo = 2;
}
_ => {
foo = 3;
}
}
}

汇编

1
2
3
4
5
6
7
8
0000000000006640 <try_match>:
6640: 48 83 ec 04 sub $0x4,%rsp
6644: c7 04 24 01 00 00 00 movl $0x1,(%rsp)
664b: c7 04 24 02 00 00 00 movl $0x2,(%rsp)
6652: 48 83 c4 04 add $0x4,%rsp
6656: c3 ret
6657: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
665e: 00 00

分析

我们可以看到这里编译器已经为我们优化了代码,由于match的变量可知,所以只需要包含值为1的分支即可。

这里抛出一个疑问:最后的nopw指令有何作用?

try_match_with_arg函数

源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#[no_mangle]
fn try_match_with_arg(foo: i32) -> i32 {
match foo {
1 => {
0
}
2 => {
1
}
_ => {
2
}
}
}

汇编

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
0000000000006660 <try_match_with_arg>:
6660: 48 83 ec 0c sub $0xc,%rsp
6664: 89 3c 24 mov %edi,(%rsp)
6667: 89 7c 24 08 mov %edi,0x8(%rsp)
666b: 83 ef 01 sub $0x1,%edi
666e: 74 16 je 6686 <try_match_with_arg+0x26>
6670: eb 00 jmp 6672 <try_match_with_arg+0x12>
6672: 8b 04 24 mov (%rsp),%eax
6675: 83 e8 02 sub $0x2,%eax
6678: 74 16 je 6690 <try_match_with_arg+0x30>
667a: eb 00 jmp 667c <try_match_with_arg+0x1c>
667c: c7 44 24 04 02 00 00 movl $0x2,0x4(%rsp)
6683: 00
6684: eb 12 jmp 6698 <try_match_with_arg+0x38>
6686: c7 44 24 04 00 00 00 movl $0x0,0x4(%rsp)
668d: 00
668e: eb 08 jmp 6698 <try_match_with_arg+0x38>
6690: c7 44 24 04 01 00 00 movl $0x1,0x4(%rsp)
6697: 00
6698: 8b 44 24 04 mov 0x4(%rsp),%eax
669c: 48 83 c4 0c add $0xc,%rsp
66a0: c3 ret
66a1: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1)
66a8: 00 00 00
66ab: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

分析

和上面一个函数的区别是我们这里match的是传入的参数,得到的汇编变得稍微复杂了一些。首先我们的参数在了rsp和rsp+8的内存处保存了副本。

之后保存参数的rdi与1进行比较,这里的cmp与sub、je与jz指令效果相同,在进行比较的时候,计算机会两数相减,如果等于零说明相等(即ZF标志为1)。如果我们的foo为1,则跳转到+0x26处,将rsp+4内存置为0。

如果不为1,可以看到Rust的编译结果会jmp到下一条指令处,这里并未做优化做了一次无谓的跳转。和之前的类似,只不过这里我们从rsp处取得了保存的参数值,交由eax寄存器比较是否为2,如果等于2则将rsp+4内存置为1。

如果不等于1和2,将使用默认匹配_,直接将rsp+4内存置为2。最后rsp+4内存的值交由eax寄存器作为返回值,释放局部变量空间。

看到这里有个疑问:为什么会保存两次副本,在rsp+8内存的副本并没有被使用到?

try_so_many_arg函数

源码

1
2
3
4
fn try_so_many_arg(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32, g: i32, h: i32, i: i32, j: i32, k: i32, l: i32) {
let a = a + 1;
let b = b + 2;
}

汇编

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
00000000000066b0 <try_so_many_arg>:
66b0: 48 83 ec 38 sub $0x38,%rsp
66b4: 89 74 24 10 mov %esi,0x10(%rsp)
66b8: 8b 44 24 68 mov 0x68(%rsp),%eax
66bc: 8b 44 24 60 mov 0x60(%rsp),%eax
66c0: 8b 44 24 58 mov 0x58(%rsp),%eax
66c4: 8b 44 24 50 mov 0x50(%rsp),%eax
66c8: 8b 44 24 48 mov 0x48(%rsp),%eax
66cc: 8b 44 24 40 mov 0x40(%rsp),%eax
66d0: 89 7c 24 18 mov %edi,0x18(%rsp)
66d4: 89 74 24 1c mov %esi,0x1c(%rsp)
66d8: 89 54 24 20 mov %edx,0x20(%rsp)
66dc: 89 4c 24 24 mov %ecx,0x24(%rsp)
66e0: 44 89 44 24 28 mov %r8d,0x28(%rsp)
66e5: 44 89 4c 24 2c mov %r9d,0x2c(%rsp)
66ea: ff c7 inc %edi
66ec: 89 7c 24 14 mov %edi,0x14(%rsp)
66f0: 0f 90 c0 seto %al
66f3: a8 01 test $0x1,%al
66f5: 75 1c jne 6713 <try_so_many_arg+0x63>
66f7: 8b 44 24 10 mov 0x10(%rsp),%eax
66fb: 8b 4c 24 14 mov 0x14(%rsp),%ecx
66ff: 89 4c 24 30 mov %ecx,0x30(%rsp)
6703: 83 c0 02 add $0x2,%eax
6706: 89 44 24 0c mov %eax,0xc(%rsp)
670a: 0f 90 c0 seto %al
670d: a8 01 test $0x1,%al
670f: 75 2d jne 673e <try_so_many_arg+0x8e>
6711: eb 1e jmp 6731 <try_so_many_arg+0x81>
6713: 48 8d 3d f6 f8 02 00 lea 0x2f8f6(%rip),%rdi # 36010 <str.0>
671a: 48 8d 15 a7 c3 03 00 lea 0x3c3a7(%rip),%rdx # 42ac8 <__do_global_dtors_aux_fini_array_entry+0x8>
6721: 48 8d 05 78 f5 ff ff lea -0xa88(%rip),%rax # 5ca0 <_ZN4core9panicking5panic17h50b51d19800453c0E>
6728: be 1c 00 00 00 mov $0x1c,%esi
672d: ff d0 call *%rax
672f: 0f 0b ud2
6731: 8b 44 24 0c mov 0xc(%rsp),%eax
6735: 89 44 24 34 mov %eax,0x34(%rsp)
6739: 48 83 c4 38 add $0x38,%rsp
673d: c3 ret
673e: 48 8d 3d cb f8 02 00 lea 0x2f8cb(%rip),%rdi # 36010 <str.0>
6745: 48 8d 15 94 c3 03 00 lea 0x3c394(%rip),%rdx # 42ae0 <__do_global_dtors_aux_fini_array_entry+0x20>
674c: 48 8d 05 4d f5 ff ff lea -0xab3(%rip),%rax # 5ca0 <_ZN4core9panicking5panic17h50b51d19800453c0E>
6753: be 1c 00 00 00 mov $0x1c,%esi
6758: ff d0 call *%rax
675a: 0f 0b ud2
675c: 0f 1f 40 00 nopl 0x0(%rax)

分析

看上去简单的函数没想到我们得到了这么复杂的结果!

我们前6个参数被手动保存到了rsp+0x18到rsp+0x2c处,而后6个参数在最开始的rsp+0x40到rsp+0x68处:

这里我们并未使用到后面的参数,但编译结果仍然可以看到这些参数分别被赋给了eax一次。

对于局部变量a和b的加法分别对应66ea和6703处的inc和add指令,有趣的是,可以看到这里Rust会校验加法是否溢出。即seto指令将OF标志赋给al寄存器,如果不为零就会将报错的信息、文件名作为参数调用panic函数。这保证了我们不会因为传入的参数为INT_MAX导致溢出为负数。

try_str_arg函数

源码

1
2
3
fn try_str_arg(s: &str) {
let _ = s.len();
}

汇编

1
2
3
4
5
6
7
8
9
0000000000006760 <try_str_arg>:
6760: 48 83 ec 18 sub $0x18,%rsp
6764: 48 89 7c 24 08 mov %rdi,0x8(%rsp)
6769: 48 89 74 24 10 mov %rsi,0x10(%rsp)
676e: e8 2d 00 00 00 call 67a0 <_ZN4core3str21_$LT$impl$u20$str$GT$3len17h99821c36485a7d2eE>
6773: 48 83 c4 18 add $0x18,%rsp
6777: c3 ret
6778: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
677f: 00

分析

终于来到了我们最后一步,这里我们接受了上文提到的data_ptr(str地址)和长度参数。在本地保存副本后调用core库str的len方法。由于没有使用返回值,我们可以看到这里没有处理rax而是直接返回。

release编译

以上的分析都是在debug编译下面进行的,如果我们使用release编译呢?

稍微修改一下boost函数的代码:

1
2
3
4
5
6
7
8
9
10
fn boost(argc: isize, argv: *const *const u8) -> isize {
let a = 1;
mangled();
try_variable();
try_match();
try_match_with_arg(1);
try_so_many_arg(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
try_str_arg("wow");
1
}

然后让我们来看看release编译的main函数:

1
2
3
4
5
0000000000001120 <main>:
1120: b8 01 00 00 00 mov $0x1,%eax
1125: c3 ret
1126: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1)
112d: 00 00 00

我们的函数调用都没了,也找不到try_variable等函数!这些没有必要的函数在release下面都会被删除掉,没有使用的局部变量也会直接删除。这保证了release编译下面的高效和二进制文件精简。

总结

通过这次分析,我们可以看到Rust中一些基础语句在编译后的结果。个人觉得比较有趣的是,因为传入的参数不可知,Rust会主动判断加法后是否会溢出,而不是产生溢出出现UB。而在release模式下,Rust能够发现我们写的无用的函数,直接删除。如果文章有什么错误或者您有什么建议,欢迎在评论区指出~

最后希望大家在2022年都能达成自己的目标,心想事成。:)

关于作者

北邮大二学生,开源爱好者。目前正在努力学习Linux内核、Rust中,对技术抱有热情。欢迎在飞书Rust 中文社群搜索李睿添加好友。

GitHub:https://github.com/KernelErr

个人博客:https://lirui.tech/

联系邮箱:xl00enz3k@mozmail.com(最大支持150⁩ ⁨KB的电子邮件,含附件)

  • 本文标题:Rust基础语句汇编分析
  • 本文作者:LI Rui
  • 创建时间:2021-12-21 23:17:51
  • 本文链接:https://www.lirui.tech/post/2021/79d332da0ea5.html
  • 版权声明:本博客所有文章除特别声明外,均采用 BY-SA 许可协议。转载请注明出处!