see syscall in assembly in hello world

[Tudyx]

Hello, I'm trying to learn x86_64 assembly and cargo-show-asm help me a lot.

I want to track the syscall doing the writing of an "hello world" to the console but I don't find it in the assembly.

I'm using the Rust auto-generated hello world project.

I know the syscall is done because strace give me this result:

write(1, "Hello, world!\n", 14Hello, world!)         = 14

I've also wrote the hello world in x86_64 assembly by hand. I expected the rust code to more or like the hand-crafted assembly code:

.global _start
.intel_syntax noprefix

_start:
    # sys_write hello world
    mov rax, 1 # sys_write number is 1
    mov rdi, 1 # fd 1 is stdout 
    lea rsi, [hello_world]
    mov rdx, 14 # We hardcode the len of hello world
    syscall
    # sys_exit error code
    mov rax, 60 # sys_exit number is 60
    mov rdi, 0 # the error code we want to give
    syscall

hello_world:
    .asciz "Hello, World!\n"

But if try to find the syscall instruction in the rust code with this

cargo asm --everything | grep syscall

I have not result. Same thing with the int instruction.

As the assembly for the Rust function is:

.section .text.foo::main,"ax",@progbits
	.p2align	4, 0x90
	.type	foo::main,@function
foo::main:

	.cfi_startproc
	sub rsp, 56
	.cfi_def_cfa_offset 64

	lea rax, [rip + .L__unnamed_2]

	mov qword ptr [rsp + 24], rax
	mov qword ptr [rsp + 32], 1
	mov qword ptr [rsp + 8], 0
	lea rax, [rip + .L__unnamed_3]

	mov qword ptr [rsp + 40], rax
	mov qword ptr [rsp + 48], 0
	lea rdi, [rsp + 8]

	call qword ptr [rip + std::io::stdio::_print@GOTPCREL]

	add rsp, 56
	.cfi_def_cfa_offset 8
	ret

I suppose the syscall happen within call qword ptr [rip + std::io::stdio::_print@GOTPCREL]. Can someone please correct me if I'm wrong and tell me why I don't see any syscall instruction even with --everything flag?

[pacak]

You are correct, syscall happens inside call qword ptr [rip + std::io::stdio::_print@GOTPCREL]. It happens inside stdlib which in case of rust comes precompiled and lets linked later.

[Tudyx]

Thanks for your answer!

I have tried to link statically the stdlib using the musl target. But then when looking at the assembly, still no syscall:

cargo asm --everything --target x86_64-unknown-linux-musl | grep syscall

I have also tried to rebuild the std for my crate using build-std feature :

cargo +nightly asm --everything -Z build-std --target x86_64-unknown-linux-musl | grep syscall

But without success also.
Do you have any idea why?

[pacak]

cargo-show-asm (at least at the moment) does not decompile the binary produced. It instead asks for rustc to emit generated assembly (or llvm, mir, etc) and works with that. Static linking with musl happens after. And even with build-std compilation of stdlib happens as a separate compilation unit - not somewhere cargo-show-asm looks.

[Tudyx]

Thank you for your time. Now it’s very clear to me why I don't see the syscall. I guess a decompiler should be the next stop.

Note: I aso tried codegen-units = 1 hopping that maybe the compilation of stdlib would happens on the same compilation unit, but without success

[pacak]

A recent version of cargo-show-asm comes with disasm feature, if you enable it on install you can pass --disasm to see the complete disassembled code, it should include syscalls too.