Assembly 如何读取这张锈码的组装码？_Assembly_Rust_X86 64_Reverse Engineering

Assembly 如何读取这张锈码的组装码？

assembly rust

Assembly 如何读取这张锈码的组装码？,assembly,rust,x86-64,reverse-engineering,Assembly,Rust,X86 64,Reverse Engineering,我试图阅读一段锈迹斑斑的汇编代码，但实际上，它比C/C++编译器生成的ASM代码更难阅读。那么，如何分析下面这段防锈代码的ASM代码呢 fn main() { let closure = |x| println!("{}", x); let x: fn(x: i32) -> () = closure; println!("{}", x as i32); } 下面是相应的汇编代码，带有一些注释（我只粘贴了主要部分，对于完整

我试图阅读一段锈迹斑斑的汇编代码，但实际上，它比C/C++编译器生成的ASM代码更难阅读。那么，如何分析下面这段防锈代码的ASM代码呢

fn main() { 
    let closure = |x| println!("{}", x);
    let x: fn(x: i32) -> () = closure; 
    println!("{}", x as i32);
}

下面是相应的汇编代码，带有一些注释（我只粘贴了主要部分，对于完整版本，请使用这个Permalink:）：

playway:：main:#@playway:：main
#%bb.0：
subq$72，%rsp
leaq core:：ops:：function:：FnOnce:：call_once（%rip），%rax
移动百分比eax，4（%rsp）
leaq 4（%rsp），%rax
movq%rax，8%（rsp）
movq核心：：fmt：：num：：imp：：：fmt@GOTPCREL（%rip），%rax
movq%rax，16%（rsp）
leaq.L_uunnamed_2（%rip），%rax#rdx的内容来自.L_uunnamed_2（%rip），如何评估此部分？
movq%rax，24%（rsp）#rdi的内容来自rax。
movq$2,32（%rsp）
movq$0，40%（rsp）
leaq 8（%rsp），%rax
movq%rax，56%（rsp）
movq$164（%rsp）
leaq 24（%rsp），%rdi#rdi应该是保存传递给println！的值的寄存器！。
callq*std:：io:：stdio:：_print@GOTPCREL（%rip）
addq$72，%rsp
retq
#--结束功能
main:#@main
#%bb.0：
subq$8，%rsp
movq%rsi，%rcx
movslq%edi，%rdx
leaq游乐场：：主（%rip），%rax
movq%rax，（%rsp）
leaq.L_u未命名_u1（%rip），%rsi
movq%rsp，%rdi
callq*std:：rt:：lang\u start_internal@GOTPCREL（%rip）
#杀死：def$eax杀死$eax杀死$rax
popq%rcx
retq
#--结束功能
.L__未命名_1：
.四核：：ptr：：将_放置到位
.quad 8#0x8
.quad 8#0x8
.quad std:：rt:：lang_start:{{closure}
.quad std:：rt:：lang_start:{{closure}
.quad-core:：ops:：function:：FnOnce:：call_once{{{vtable.shim}
.L__未命名_3：
.L__未命名_4：
.字节10
.L__未命名_2：
.quad.L__未命名_3
零八
.quad.L__未命名_4
.asciz“\001\000\000\000\000\000\000\000”

并且，我试图找出Rust编译器是如何处理闭包函数指针和普通函数的。因此，这里我尝试使用闭包作为示例，但似乎找不到任何与变量“x”的使用相对应的有效汇编代码。

没有对闭包的实际调用，因此没有生成调用代码，但是x变量的使用实际上是在一个函数中，而这个函数没有包含在您的帖子中，它在ASM输出中有一个误导性的名称

core:：ops:：function:：FnOnce:：call_once

，但在同一示例的LLVM输出中，名称更为混乱的是

@zn4core3ops8function6fnoce9call\u once17hefa1aa47132c4122E

。这是闭包的实际内容（println！（“{}”，x））

core:：ops:：function:：FnOnce:：call#u once:35;@core:：ops:：function:：FnOnce:：call#u once
#%bb.0：
#为变量和打印参数分配一堆堆栈空间
subq$72，%rsp
#%edi将x的值传递给闭包，我们将其存储在新的堆栈分配变量中
移动%edi，4（%rsp）
#然后我们将该变量的地址加载到另一个变量中
leaq 4（%rsp），%rax
movq%rax，8%（rsp）
#下面主要是填充传递给print的std:：fmt:：Arguments结构
movq核心：：fmt：：num：：imp：：：fmt@GOTPCREL（%rip），%rax
movq%rax，16%（rsp）
leaq.L_uu未命名_u2（%rip），%rax
movq%rax，24%（rsp）
movq$2,32（%rsp）
movq$0，40%（rsp）
#x地址的地址在此处加载到arguments结构中
leaq 8（%rsp），%rax
movq%rax，56%（rsp）
#完成填充参数，然后调用print
movq$164（%rsp）
leaq 24（%rsp），%rdi
callq*std:：io:：stdio:：_print@GOTPCREL（%rip）
addq$72，%rsp
retq

主函数是创建闭包的地方，但它实际上没有被调用，并且与上面的函数一样，主要填充复杂的std:：fmt:：Arguments结构

playway:：main:#@playway:：main
#%bb.0：
subq$72，%rsp
#这将通过存储指向闭包函数的指针来创建闭包
leaq core:：ops:：function:：FnOnce:：call_once（%rip），%rax
移动百分比eax，4（%rsp）
#这将闭包存储在main的'x'变量中（示例的第3行）
leaq 4（%rsp），%rax
movq%rax，8%（rsp）
#填充std:：fmt:：Arguments结构
movq核心：：fmt：：num：：imp：：：fmt@GOTPCREL（%rip），%rax
movq%rax，16%（rsp）
leaq.L_uunnamed_2（%rip），%rax#rdx的内容来自.L_uunnamed_2（%rip），如何评估此部分？
movq%rax，24%（rsp）#rdi的内容来自rax。
movq$2,32（%rsp）
movq$0，40%（rsp）
#将闭包（存储在`x`）存储在std:：fmt:：Arguments结构中
leaq 8（%rsp），%rax
movq%rax，56%（rsp）
#完成填充并调用print
movq$164（%rsp）
leaq 24（%rsp），%rdi#rdi应该是保存传递给println！的值的寄存器！。
callq*std:：io:：stdio:：_print@GOTPCREL（%rip）
addq$72，%rsp
retq

从LLVM输出中，std:：fmt:：Arguments被定义为

%“std:：fmt:：Arguments”=type{[0 x i64]、{[0 x{[0 x i8]*、i64}]*、i64}、[0 x i64]、{0 x i64*、i64}、{[0 x{i8*、i64*、i64}、[0 x i64]}、[0 x i64]}

，我不理解太多的内部细节，因此我不确定它引用静态内存区域的确切原因。L_uunnamed_2但深入研究可能会提供更多线索

没有实际调用闭包，因此没有生成调用代码，但是，x变量的使用实际上是在一个函数中，该函数没有包含在您的帖子中，它在ASM输出中具有误导性的名称

core:：ops:：function:：FnOnce:：call_once

，但其名称更为混乱，即

@ZN4core3ops8function6FnOnce9call_once17hefa1aa47132c412
playground::main: # @playground::main
# %bb.0:
    subq    $72, %rsp
    leaq    core::ops::function::FnOnce::call_once(%rip), %rax
    movl    %eax, 4(%rsp)
    leaq    4(%rsp), %rax
    movq    %rax, 8(%rsp)
    movq    core::fmt::num::imp::<impl core::fmt::Display for i32>::fmt@GOTPCREL(%rip), %rax
    movq    %rax, 16(%rsp)
    leaq    .L__unnamed_2(%rip), %rax  # the contents of rdx come from .L__unnamed_2(%rip), how to evaluate this part?
    movq    %rax, 24(%rsp)  # the contents of rdi come from rax.
    movq    $2, 32(%rsp)
    movq    $0, 40(%rsp)
    leaq    8(%rsp), %rax
    movq    %rax, 56(%rsp)
    movq    $1, 64(%rsp)
    leaq    24(%rsp), %rdi  # rdi should be the register holding the value passed to println!.
    callq   *std::io::stdio::_print@GOTPCREL(%rip)
    addq    $72, %rsp
    retq
                                        # -- End function

main:                                   # @main
# %bb.0:
    subq    $8, %rsp
    movq    %rsi, %rcx
    movslq  %edi, %rdx
    leaq    playground::main(%rip), %rax
    movq    %rax, (%rsp)
    leaq    .L__unnamed_1(%rip), %rsi
    movq    %rsp, %rdi
    callq   *std::rt::lang_start_internal@GOTPCREL(%rip)
                                        # kill: def $eax killed $eax killed $rax
    popq    %rcx
    retq
                                        # -- End function

.L__unnamed_1:
    .quad   core::ptr::drop_in_place<std::rt::lang_start<()>::{{closure}}>
    .quad   8                               # 0x8
    .quad   8                               # 0x8
    .quad   std::rt::lang_start::{{closure}}
    .quad   std::rt::lang_start::{{closure}}
    .quad   core::ops::function::FnOnce::call_once{{vtable.shim}}

.L__unnamed_3:

.L__unnamed_4:
    .byte   10

.L__unnamed_2:
    .quad   .L__unnamed_3
    .zero   8
    .quad   .L__unnamed_4
    .asciz  "\001\000\000\000\000\000\000"