link#

• x86-64 vs ARM64 comparison(RDI vs X0 등등)
  • assembly분석(x86_64)
  • arm어셈블리 분석

최적화는 안전한 러스트 코드가 젤 빠름.#

cpu 64비트 관리하는거 만들어봄.|🔝|#

• src/lib.rs

// safe rust
pub fn safe_rust_check_all_bits(value: u64) -> Vec<bool> {
    let bits: Vec<bool> = (0..64)
                        .rev()
                        .map(|i| (value & (1 << i)) != 0)
                        .collect();
    bits
}

// asm
unsafe extern "C" {
    fn check_bit(value: u64, index: u64) -> u64;
}

pub fn check_all_bits(value: u64) -> [bool; 64] {
    let mut bits = [false; 64];

    for i in 0usize..64 {
        let bit_index = (63 - i) as u64;

        let result = unsafe { check_bit(value, bit_index) };

        bits[i] = result != 0;
    }

    bits
}

• tests/safe_rust.rs

#[test]
fn safe_rust_check_all_bits_test() {
    let value: u64 = 1 << 62 | 1 << 32 | 1 << 30 | 1 << 20;

    let bits = safe_rust_check_all_bits(value);

    println!("{:?}", bits);
}

• tests/asm_rust_ffi_test.rs

#[test]
fn asm_test() {
    let values: [u64; 4] = [0, 1 << 61, 1 << 62, u64::MAX];

    for value in values {
        let bits = check_all_bits(value);

        println!("Value: {value:#066b}");
        println!("Bits:  {:?}", bits);
        println!();
    }
}

• asm/x86_64.S

.intel_syntax noprefix

#ifdef __APPLE__
#define SYMBOL(name) _##name
#else
#define SYMBOL(name) name
#endif

.text
.global SYMBOL(check_bit)

#ifndef __APPLE__
.type check_bit, @function
#endif

SYMBOL(check_bit):
    # RDI = value
    # RSI = bit index (0..63)
    # RAX = result (0 or 1)

    bt      rdi, rsi
    setc    al
    movzx   eax, al

    ret

#ifndef __APPLE__
.size check_bit, .-check_bit

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

#ifdef __APPLE__
#define SYMBOL(name) _##name
#else
#define SYMBOL(name) name
#endif

.text
.globl SYMBOL(check_bit)

#ifndef __APPLE__
.type check_bit, %function
#endif

SYMBOL(check_bit):
    // X0 = value
    // X1 = bit index (0..63)
    // Return X0 = 0 or 1

    lsr     x0, x0, x1
    and     x0, x0, #1

    ret

#ifndef __APPLE__
.size check_bit, .-check_bit
.section .note.GNU-stack,"",%progbits
#endif

• build.rs

use std::env;

fn main() {
    let arch = env::var("CARGO_CFG_TARGET_ARCH").expect("Missing target architecture");

    let asm_file = match arch.as_str() {
        "x86_64" => "asm/x86_64.S",
        "aarch64" => "asm/aarch64.S",
        other => panic!("Unsupported architecture: {other}"),
    };

    println!("cargo:rerun-if-changed={asm_file}");

    cc::Build::new().file(asm_file).compile("bitcheck_asm");
}

assembly분석(x86_64)|🔝|#

Let’s examine your x86-64 assembly code line by line, including the GNU assembler (GAS) syntax, C preprocessor directives, System V AMD64 calling convention, CPU registers, and how the BT instruction checks individual bits.

Your assembly function implements this Rust declaration:

unsafe extern "C" {
    fn check_bit(value: u64, index: u64) -> u64;
}

Its job is to check one bit of a 64-bit integer and return 0 or 1.

1. Complete assembly code#

.intel_syntax noprefix

#ifdef __APPLE__
#define SYMBOL(name) _##name
#else
#define SYMBOL(name) name
#endif

.text
.global SYMBOL(check_bit)

#ifndef __APPLE__
.type check_bit, @function
#endif

SYMBOL(check_bit):
    # RDI = value
    # RSI = bit index (0..63)
    # RAX = result (0 or 1)

    bt      rdi, rsi
    setc    al
    movzx   eax, al

    ret

#ifndef __APPLE__
.size check_bit, .-check_bit

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

2. Intel syntax#

.intel_syntax noprefix

This tells GNU assembler to use Intel assembly syntax instead of AT&T syntax.

There are two common x86 assembly syntaxes:

Intel syntax:

mov rax, rdi
add rax, 10

AT&T syntax:

movq %rdi, %rax
addq $10, %rax

The differences:

For example:

mov rax, rdi

Means:

RAX = RDI

The destination is on the left.

3. C preprocessor directives#

Your assembly file has .S as its extension.

This is important because uppercase .S tells GCC to run the C preprocessor before passing the source to the assembler.

#ifdef __APPLE__
#define SYMBOL(name) _##name
#else
#define SYMBOL(name) name
#endif

.global check_bit

check_bit:

.global _check_bit

_check_bit:

#define SYMBOL(name) _##name

SYMBOL(check_bit)

_check_bit

check_bit

4. Section and symbol declarations#

.text

.global SYMBOL(check_bit)

.global check_bit

.global _check_bit

#ifndef __APPLE__
.type check_bit, @function
#endif

.type symbol_name, @function

readelf -s target/debug/z99_asm_ffi_bits_check
nm target/debug/z99_asm_ffi_bits_check
objdump -t target/debug/z99_asm_ffi_bits_check

5. Function entry point#

SYMBOL(check_bit):

This defines the function’s entry label.

When Rust calls:

let result = unsafe {
    check_bit(value, bit_index)
};

The linker resolves the Rust external function reference to this assembly symbol.

The CPU starts executing at the address associated with this label.

6. Understanding the calling convention#

This is one of the most important concepts when combining Rust and assembly.

Your function declaration:

fn check_bit(value: u64, index: u64) -> u64;

Uses the C ABI.

On Linux x86-64, Rust follows the System V AMD64 ABI.

On macOS x86-64, the standard calling convention also passes these first two integer arguments in RDI and RSI.

Function argument registers

RDI#

First argument

value: u64

RSI#

Second argument

index: u64

RAX#

Return value

result: u64 (0 or 1)

For example, suppose Rust calls:

check_bit(0x4000000000000000, 62);

When assembly starts, the registers contain:

RDI = 0x4000000000000000
RSI = 62

Your assembly function must return the result in RAX.

7. The actual bit-checking instructions#

This is the most important part of your program.

bt rdi, rsi

bt destination, bit_index

RDI = 0100 0000 0000 0000 ...
RSI = 62

Bit position:

63 62 61 60 59 58 57 56 ... 3 2 1 0
 0  1  0  0  0  0  0  0 ... 0 0 0 0

bt rdi, 62

CF = 1

CF = 0

1#

Selected bit = 1

0#

Selected bit = 0

setc al

If CF == 1:
    AL = 1

If CF == 0:
    AL = 0

Before:

RAX = 0x0000000000000000
CF  = 1

After:

AL  = 1
RAX = 0x0000000000000001

64-bit: RAX
32-bit: EAX
16-bit: AX
 8-bit: AH | AL

movzx eax, al

RAX = 0x123456789ABCDEF0
AL  = 0x01

RAX = 0x123456789ABCDE01

movzx eax, al

EAX = 0x00000001

RAX = 0x0000000000000001

ret

8. ELF metadata and stack protection#

#ifndef __APPLE__
.size check_bit, .-check_bit
#endif

.size specifies the size of the function symbol.

The expression:

.-check_bit

Means:

Current address - check_bit address

This calculates the number of bytes occupied by the function.

Next:

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

This tells the ELF linker that this object file does not require an executable stack.

It helps avoid warnings such as:

warning: missing .note.GNU-stack section implies executable stack

This directive is excluded on macOS because it is ELF-specific.

9. Complete execution walkthrough#

Let’s trace the exact instructions using:

let value = 1u64 << 62;
let index = 62;

let result = unsafe {
    check_bit(value, index)
};

The input:

value = 0x4000000000000000

Binary:
0100000000000000000000000000000000000000000000000000000000000000

Execution:

10. Debug it with GDB#

Since you’re learning assembly through CLI tools, I recommend stepping through the actual instructions.

First, compile:

cargo build

Find the symbol:

nm -n target/debug/z99_asm_ffi_bits_check | grep check_bit

Disassemble:

objdump -d -Mintel target/debug/z99_asm_ffi_bits_check \
    | grep -A 10 '<check_bit>:'

Start GDB:

gdb target/debug/z99_asm_ffi_bits_check

Set a breakpoint:

(gdb) break check_bit
(gdb) run

Inspect registers:

(gdb) info registers rdi rsi rax eflags

Step through the instructions:

(gdb) si
(gdb) si
(gdb) si
(gdb) si

Inspect the Carry Flag:

(gdb) p $eflags & 1

If the result is 1, the Carry Flag is set.

Inspect the return value:

(gdb) p/x $rax

Expected:

$1 = 0x1

11. Important performance optimization#

Your current function:

bt      rdi, rsi
setc    al
movzx   eax, al
ret

Uses four instructions.

However, because check_all_bits() calls this function 64 times per value, you have 64 FFI calls and 64 function returns.

For your Rust program, a more efficient approach would be to process all 64 bits inside one assembly function.

For example, an alternative x86-64 implementation could use:

.intel_syntax noprefix

.text
.global check_all_bits

check_all_bits:
    # RDI = input u64
    # RSI = output bool array pointer

    xor     ecx, ecx

.loop:
    bt      rdi, 63
    setc    al
    mov     byte ptr [rsi + rcx], al

    shl     rdi, 1
    inc     ecx

    cmp     ecx, 64
    jne     .loop

    ret

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

This processes all 64 bits in one assembly function call.

It writes the results directly into the output memory.

Note that this version uses one byte per Boolean, matching the element size of Rust’s [bool; 64]. It also shifts the input left each iteration, so it visits bit 63 first.

For maximum performance, the loop can be further optimized or unrolled, and the output representation can be changed to a bitmask if individual Boolean bytes are not required.

My recommendation: First understand and debug the four-instruction check_bit function. Then compare it against the single-call check_all_bits implementation using objdump and GDB. That is a useful exercise in understanding FFI overhead, calling conventions, register allocation, and instruction-level optimization.

Arm분석#

• Let’s examine your ARM64 (AArch64) assembly code line by line, including the GNU assembler (GAS) syntax, C preprocessor directives, ARM64 registers, calling convention, bitwise instructions, and how Rust calls the assembly function through FFI.

Your assembly function implements this Rust declaration:

unsafe extern "C" {
    fn check_bit(value: u64, index: u64) -> u64;
}

Its purpose is to check one bit in a 64-bit integer and return 0 or 1.

1. Complete assembly code#

#ifdef __APPLE__
#define SYMBOL(name) _##name
#else
#define SYMBOL(name) name
#endif

.text
.globl SYMBOL(check_bit)

#ifndef __APPLE__
.type check_bit, %function
#endif

SYMBOL(check_bit):
    // X0 = value
    // X1 = bit index (0..63)
    // Return X0 = 0 or 1

    lsr     x0, x0, x1
    and     x0, x0, #1

    ret

#ifndef __APPLE__
.size check_bit, .-check_bit
.section .note.GNU-stack,"",%progbits
#endif

2. C preprocessor directives#

Your file uses the .S extension (uppercase S).

This means GCC runs the C preprocessor before passing the source code to the assembler.

These directives are not ARM CPU instructions.

#ifdef __APPLE__
#define SYMBOL(name) _##name
#else
#define SYMBOL(name) name
#endif

SYMBOL(check_bit)

_check_bit

SYMBOL(check_bit)

check_bit

#define SYMBOL(name) _##name

_##check_bit

_check_bit

3. Section and symbol declarations#

.text

.globl SYMBOL(check_bit)

unsafe extern "C" {
    fn check_bit(value: u64, index: u64) -> u64;
}

.globl check_bit

.globl _check_bit

#ifndef __APPLE__
.type check_bit, %function
#endif

.type symbol_name, %function

readelf -s target/debug/z99_asm_ffi_bits_check

nm -n target/debug/z99_asm_ffi_bits_check

4. Function entry point#

SYMBOL(check_bit):

This defines the function’s entry label.

When Rust executes:

let result = unsafe {
    check_bit(value, index)
};

The linker resolves the function reference to this assembly symbol.

The CPU begins executing instructions at this address.

5. ARM64 calling convention#

This is especially important when combining Rust and assembly.

Your Rust function declaration is:

unsafe extern "C" {
    fn check_bit(value: u64, index: u64) -> u64;
}

On Linux AArch64, the standard procedure-call convention (AAPCS64) specifies:

• X0–X7: first eight integer or pointer arguments.
• X0–X1: integer return values.
• X19–X28: callee-saved general-purpose registers.
• X30: link register (LR), containing the return address.

ARM64 function registers

X0#

First argument

value: u64

Also return register

X1#

Second argument

index: u64

X30 (LR)#

Link register

Stores the return address when called with BL.

For example, Rust calls:

check_bit(0x4000000000000000, 62);

When assembly starts:

X0 = 0x4000000000000000
X1 = 62

The assembly must return the result in X0.

6. Understanding the actual ARM64 instructions#

This is the most important part of your program.

lsr x0, x0, x1

lsr destination, source, shift_amount

Before:

X0 = 0100 0000 0000 0000 ...
X1 = 62

lsr x0, x0, x1

Original:

0100 0000 0000 0000 0000 0000 ...
 ^

After shifting right by 62:

0000 0000 0000 0000 0000 0000 ... 0001
                                      ^

value = 0b0100
index = 2

0100 >> 2 = 0001

and x0, x0, #1

and destination, source, immediate

#1 = 0000 ... 0001

X0 = 0000 ... 0001

and x0, x0, #1

X0 = 0000 ... 0001

X0 = 0000 ... 0000

X0 = 0

X0 = 1

ret

ret x30

bl check_bit

7. Complete execution walkthrough#

Let’s trace the instructions with:

let value = 1u64 << 62;
let index = 62;

let result = unsafe {
    check_bit(value, index)
};

The input value is:

Hexadecimal:

0x4000000000000000

Binary:

0100000000000000000000000000000000000000000000000000000000000000

8. ELF metadata and stack protection#

#ifndef __APPLE__
.size check_bit, .-check_bit
#endif

.-check_bit

Current address - check_bit address

check_bit:
    lsr x0, x0, x1
    and x0, x0, #1
    ret

Function size = 3 × 4 = 12 bytes

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

warning: missing .note.GNU-stack section implies executable stack

9. Debug using GDB on ARM64#

Since you’re working with assembly and Rust FFI, I recommend inspecting the real CPU registers.

First compile:

cargo build

Disassemble:

aarch64-linux-gnu-objdump \
    -d target/debug/z99_asm_ffi_bits_check

If you’re running natively on ARM64 Linux:

objdump -d target/debug/z99_asm_ffi_bits_check

Start GDB:

gdb target/debug/z99_asm_ffi_bits_check

Set a breakpoint:

(gdb) break check_bit
(gdb) run

Inspect registers:

(gdb) info registers x0 x1 x30 pc

Step through one instruction:

(gdb) si

Inspect X0:

(gdb) p/x $x0

Inspect X1:

(gdb) p/x $x1

You should see the input value and bit index before executing LSR.

After stepping through both bitwise instructions:

(gdb) p/x $x0

Expected:

$1 = 0x1

10. Performance optimization: extracting all 64 bits#

Your current implementation checks one bit per assembly call.

If you want to check all 64 bits, you can move the loop into assembly.

For example:

AArch64 implementation:

.text
.global check_all_bits

#ifndef __APPLE__
.type check_all_bits, %function
#endif

check_all_bits:
    // X0 = input value
    // X1 = output array pointer
    // X2 = loop counter

    mov     x2, #0

.loop:
    lsr     x3, x0, #63
    strb    w3, [x1, x2]

    lsl     x0, x0, #1

    add     x2, x2, #1
    cmp     x2, #64
    b.ne    .loop

    ret

#ifndef __APPLE__
.size check_all_bits, .-check_all_bits
.section .note.GNU-stack,"",%progbits
#endif

Corresponding Rust declaration:

unsafe extern "C" {
    fn check_all_bits(value: u64, output: *mut bool);
}

fn check_all(value: u64) -> [bool; 64] {
    let mut bits = [false; 64];

    unsafe {
        check_all_bits(value, bits.as_mut_ptr());
    }

    bits
}

This version:

• Makes only one FFI call.
• Processes all 64 bits inside assembly.
• Writes one byte per Boolean.
• Avoids Rust-side iteration.

Note that this is an educational implementation, not necessarily the fastest possible implementation. It uses a loop and shifts the input on each iteration.

11. x86-64 vs ARM64 comparison|🔝|#

Here is the key difference between your two assembly implementations.

x86-64

bt      rdi, rsi
setc    al
movzx   eax, al
ret

ARM64

lsr     x0, x0, x1
and     x0, x0, #1
ret

The main architectural difference:

• x86-64 has a dedicated BT instruction that transfers the selected bit into the Carry Flag.
• ARM64 extracts the bit using a logical shift and a bitwise AND.

Both produce exactly the same logical result.

One final detail: Your function assumes index is between 0 and 63. For this range, the implementation is correct. If you want to support arbitrary u64 indices, you should explicitly validate the index in Rust before calling assembly.

For your next learning step, I recommend comparing LSR + AND against ARM64’s UBFX instruction. UBFX can extract the selected bit directly:

ubfx x0, x0, x1, #1
ret

That is a particularly interesting comparison with x86-64’s BT instruction.

64-bit 패턴#

• 네, 가능합니다! 다만 63-bit를 어떤 의미로 사용하는지 구분해야 합니다.

예를 들어 다음 비트 패턴을 말하는 거라면:

0100 0000 0000 0000 0000 0000 0000

가장 왼쪽의 1이 63번째 비트(0부터 세면 bit 62인지, 1부터 세면 63번째인지)에 해당하는지 확인해야 합니다.

fn main() {
    let value: u64 = 1 << 62;

    let is_63bit = value & (1 << 62) != 0;

    let mut bits: Vec<bool> = Vec::new();
    bits.push(is_63bit);

    println!("Value: {:#066b}", value);
    println!("63rd bit: {}", is_63bit);
    println!("Vector: {:?}", bits);
}

Value: 0b0100000000000000000000000000000000000000000000000000000000000000
63rd bit: true
Vector: [true]

fn main() {
    let value: u64 = 1 << 62;

    let bits: Vec<bool> = (0..64)
        .rev()
        .map(|i| (value & (1 << i)) != 0)
        .collect();

    println!("{:?}", bits);
}