261015)C without lib C - nostdlib-C (X86_64) - Part 1#

• Swindlers Inc

0:00 G'day
1:02 Simple C project
4:12 No stdlib
6:05 Our own _start
8:22 Our own write function
12:11 Syscall vs C function call
13:03 Our own syscall
15:22 compiler_flags.txt

• https://codeberg.org/Swindlers-Inc/hodgepodge
• https://youtu.be/U9nHEA6aOmI?si=15O5-posc6k_ijU3

AT&T syntax(asm/start.s)#

.section .text

.global _start
.type _start, @function

.extern main

_start:
    call main

    # exit(main_return_value)
    movl %eax, %edi
    movq $60, %rax
    syscall

    # Should never be reached.
    ud2


.global linux_syscall
.type linux_syscall, @function

# Linux x86-64 syscall ABI:
# rdi = syscall number (C ABI input)
# rsi = arg1
# rdx = arg2
# rcx = arg3
#
# Linux syscall ABI expects:
# rax = syscall number
# rdi = arg1
# rsi = arg2
# rdx = arg3

linux_syscall:
    movq %rdi, %rax
    movq %rsi, %rdi
    movq %rdx, %rsi
    movq %rcx, %rdx
    syscall
    ret


.global my_write
.type my_write, @function

# my_write(fd, buf, len) -> isize
# C ABI already passes fd/rdi, buf/rsi, len/rdx,
# which matches the Linux write(2) argument registers.
# rax = 1 (SYS_write); rcx and r11 are clobbered by syscall,
# both are caller-saved in the SysV ABI.

my_write:
    movq $1, %rax
    syscall
    ret

.section .note.GNU-stack,"",@progbits

Intel Syntax#

section .text

.global _start
.type _start, @function

.extern main

_start:
    call main

    # exit(main_return_value)
    mov edi, eax
    mov rax, 60
    syscall

    # Should never be reached.
    ud2


.global linux_syscall
.type linux_syscall, @function

# Linux x86-64 syscall ABI:
# rdi = syscall number (C ABI input)
# rsi = arg1
# rdx = arg2
# rcx = arg3
#
# Linux syscall ABI expects:
# rax = syscall number
# rdi = arg1
# rsi = arg2
# rdx = arg3

linux_syscall:
    mov rax, rdi
    mov rdi, rsi
    mov rsi, rdx
    mov rdx, rcx
    syscall
    ret


.global my_write
.type my_write, @function

# my_write(fd, buf, len) -> isize
# C ABI already passes fd/rdi, buf/rsi, len/rdx,
# which matches the Linux write(2) argument registers.
# rax = 1 (SYS_write); rcx and r11 are clobbered by syscall,
# both are caller-saved in the SysV ABI.

my_write:
    mov rax, 1
    syscall
    ret

.section .note.GNU-stack,"",@progbits

1. Project structure#

$ eza -TL2
.
├── asm
│   ├── linker.ld
│   └── start.s
├── Cargo.lock
├── Cargo.toml
├── README.md
├── rust-toolchain.toml
└── src
    └── main.rs

2. src/main.rs#

#![no_std]
#![no_main]

use core::arch::global_asm;
use core::panic::PanicInfo;

global_asm!(include_str!("start.s"));

unsafe extern "C" {
    fn my_write(
        fd: i32,
        buf: *const u8,
        len: usize,
    ) -> isize;
}

#[unsafe(no_mangle)]
pub extern "C" fn main() -> i32 {
    let message = b"Hello world!\n";

    unsafe {
        let _ = my_write(
            1,
            message.as_ptr(),
            message.len(),
        );
    }

    0
}

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {
        core::hint::spin_loop();
    }
}

Key fixes:

• #![no_std] removes the standard library; #![no_main] tells Rust not to generate the usual Rust entry point.
• unsafe extern "C" { ... } declares the assembly function using valid Rust syntax.
• *const u8 represents a pointer to the message bytes.
• isize represents the signed return value of the Linux syscall wrapper.
• #[panic_handler] supplies the panic handler required by a no_std executable.
• main returns 0, which the assembly entry point passes to exit.

3. src/start.s#

Your original syscall register mapping is appropriate for a six-argument syscall wrapper, but the Rust declaration only needs four arguments for write. We can simplify the assembly and make the ABI explicit.

.section .text

.global _start
.type _start, @function

.extern main

_start:
    call main

    # exit(main_return_value)
    movl %eax, %edi
    movq $60, %rax
    syscall

    # Should never be reached.
    ud2


.global linux_syscall
.type linux_syscall, @function

# Linux x86-64 syscall ABI:
# rdi = syscall number (C ABI input)
# rsi = arg1
# rdx = arg2
# rcx = arg3
#
# Linux syscall ABI expects:
# rax = syscall number
# rdi = arg1
# rsi = arg2
# rdx = arg3

linux_syscall:
    movq %rdi, %rax
    movq %rsi, %rdi
    movq %rdx, %rsi
    movq %rcx, %rdx
    syscall
    ret

.section .note.GNU-stack,"",@progbits

The important distinction is that the normal x86-64 System V function ABI passes the first arguments in rdi, rsi, rdx, and rcx, while the Linux syscall ABI passes them in rdi, rsi, rdx, and r10.

For write, we only need three syscall arguments, so the wrapper above does not need to handle r10, r8, r9, or stack-passed arguments.

4. Update the Rust declaration#

In main.rs, use the following declaration and call. This matches the assembly function exactly.

unsafe extern "C" {
    fn linux_syscall(
        number: u64,
        fd: u64,
        buf: *const u8,
        len: usize,
    ) -> isize;
}

Inside main, the call is:

let message = b"Hello world!\n";

let result = unsafe {
    linux_syscall(
        1, // SYS_write
        1, // stdout
        message.as_ptr(),
        message.len(),
    )
};

Use this in place of the earlier my_write declaration and call. The result is the number of bytes written on success, or a negative Linux error code on failure.

5. Cargo.toml#

[package]
name = "no_std_hello"
version = "0.1.0"
edition = "2024"

[[bin]]
name = "no_std_hello"
path = "src/main.rs"
test = false
bench = false

[profile.dev]
panic = "abort"

[profile.release]
panic = "abort"

6. Build and run on Linux x86-64#

Install the target if needed:

rustup target add x86_64-unknown-linux-gnu

Build with the custom _start entry point:

cargo rustc --release --target x86_64-unknown-linux-gnu -- \
  -C link-arg=-nostartfiles \
  -C link-arg=-Wl,-e,_start

Run:

./target/x86_64-unknown-linux-gnu/release/no_std_hello

Expected output:

Hello world!

Important: This example is specifically for Linux x86-64, not macOS or ARM Cortex-M7. The syscall numbers, registers, and entry-point conventions differ across operating systems and architectures. Also, #![no_std] means you are not using Rust’s standard library; it does not by itself guarantee a completely libc-free executable.

Here is a linker.ld for your Linux x86-64 no_std Rust executable using src/start.s and the custom _start entry point.

linker.ld

OUTPUT_FORMAT(elf64-x86-64)
OUTPUT_ARCH(i386:x86-64)
ENTRY(_start)

PHDRS
{
    text PT_LOAD FLAGS(5);  /* Read + Execute */
    data PT_LOAD FLAGS(6);  /* Read + Write */
}

SECTIONS
{
    /* Load the executable at a conventional Linux user-space address. */
    . = 0x400000;

    .text ALIGN(0x1000) :
    {
        KEEP(*(.text._start))
        *(.text .text.*)
    } :text

    .rodata ALIGN(0x1000) :
    {
        *(.rodata .rodata.*)
    } :text

    .data ALIGN(0x1000) :
    {
        *(.data .data.*)
    } :data

    .bss ALIGN(0x1000) (NOLOAD) :
    {
        *(COMMON)
        *(.bss .bss.*)
    } :data

    /DISCARD/ :
    {
        *(.eh_frame .eh_frame.*)
        *(.comment)
        *(.note.GNU-stack)
    }
}

Build using linker.ld#

Add the linker script argument to your build command:

cargo rustc --release --target x86_64-unknown-linux-gnu -- \
  -C link-arg=-nostartfiles \
  -C link-arg=-Wl,-T,linker.ld \
  -C link-arg=-Wl,-e,_start

How the linker script works#

• Important: This script is a minimal starting point, not a complete production linker script. If you use Rust’s core with compiler-generated support sections, you may need to retain additional sections. Also, -nostartfiles does not automatically disable every default linker behavior; for a fully controlled freestanding build, inspect the generated ELF with readelf -lW and readelf -SW.