# call_ret_x86.s — 只演示控制转移；可汇编：clang --target=x86_64-linux-gnu -c
    .text
    .globl caller
    .type caller, @function
caller:
    subq    $8, %rsp          # 对齐到 16 字节；进入函数时 rsp % 16 == 8
    call    callee            # 返回地址压栈，rip = callee
    addq    $8, %rsp
    ret

    .globl callee
    .type callee, @function
callee:
    movl    $7, %eax
    ret                       # 弹出返回地址到 rip

// call_ret_arm64.s — 可汇编：clang --target=aarch64-linux-gnu -c
    .text
    .globl caller
    .type caller, %function
caller:
    stp     x29, x30, [sp, #-16]!   // 保存 FP/LR，并让 sp 16 字节对齐
    mov     x29, sp
    bl      callee                  // x30 = 返回地址，pc = callee
    ldp     x29, x30, [sp], #16
    ret                             // 跳到 x30

    .globl callee
    .type callee, %function
callee:
    mov     w0, #7
    ret

# call_ret_riscv64.s — 可汇编：clang --target=riscv64-linux-gnu -c
    .text
    .globl caller
    .type caller, @function
caller:
    addi    sp, sp, -16       # 保持 16 字节对齐
    sd      ra, 8(sp)         # 非叶函数必须自己保存 ra
    call    callee            # 伪指令：auipc + jalr，ra = 返回地址
    ld      ra, 8(sp)
    addi    sp, sp, 16
    ret                       # jalr x0, 0(ra)

    .globl callee
    .type callee, @function
callee:
    li      a0, 7
    ret

/* max3.c — 对照用；cc -O2 -S max3.c 可看编译器生成的版本 */
long max3(long a, long b, long c)
{
    long m = a > b ? a : b;
    return m > c ? m : c;
}

#![allow(unused)]
fn main() {
// max3.rs — rustc --edition 2021 -O --emit asm max3.rs
#[no_mangle]
pub extern "C" fn max3(a: i64, b: i64, c: i64) -> i64 {
    let m = if a > b { a } else { b };
    if m > c { m } else { c }
}
}

# max3_x86_64.s — clang --target=x86_64-linux-gnu -c max3_x86_64.s
    .text
    .globl max3
    .type max3, @function
max3:
    movq    %rdi, %rax        # rax = a
    cmpq    %rsi, %rax        # a ? b
    cmovl   %rsi, %rax        # 若 a < b，rax = b（有符号）
    cmpq    %rdx, %rax
    cmovl   %rdx, %rax        # 若 m < c，rax = c
    ret
    .size max3, . - max3

// max3_arm64.s — clang --target=aarch64-linux-gnu -c max3_arm64.s
    .text
    .globl max3
    .type max3, %function
max3:
    cmp     x0, x1            // 比较 a, b
    csel    x0, x0, x1, gt    // x0 = a > b ? a : b
    cmp     x0, x2
    csel    x0, x0, x2, gt    // x0 = m > c ? m : c
    ret
    .size max3, . - max3

# max3_riscv64.s — clang --target=riscv64-linux-gnu -c max3_riscv64.s
    .text
    .globl max3
    .type max3, @function
max3:
    blt     a0, a1, 1f        # 若 a < b，跳到 1f
    mv      a0, a1            # 否则 a0 = b
1:  blt     a0, a2, 2f
    mv      a0, a2
2:  ret
    .size max3, . - max3

/* frame.c — 取地址 + 调用 + 调用后复用参数，迫使编译器保存状态 */
#include <stdio.h>

static long add_one(long x) { return x + 1; }

long framed(long x, long y)
{
    long local = x * 2;        /* 需要地址，必须落在栈上 */
    long *p = &local;
    long r = add_one(y);       /* 非叶调用 */
    return *p + r + x;         /* 调用后还要用 x，必须跨调用保存 */
}

int main(void)
{
    printf("%ld\n", framed(10, 20));
    return 0;
}

// frame.rs — 与 C 版本等价；Rust 不保证局部变量一定在栈上，但语义相同
fn add_one(x: i64) -> i64 { x + 1 }

#[inline(never)]
fn framed(x: i64, y: i64) -> i64 {
    let local = x * 2;
    let p = &local;          // 取地址，强制 local 有内存位置
    let r = add_one(y);
    *p + r + x
}

fn main() {
    println!("{}", framed(10, 20));
}

# framed_x86_64.s — 与 C 版本对应的手写实现；可链接进 C 程序
    .text
    .globl framed
    .type framed, @function
framed:
    pushq   %rbp              # 保存调用者的帧指针
    movq    %rsp, %rbp        # 建立本帧
    pushq   %rbx              # 保存被调用者保存寄存器
    subq    $24, %rsp         # 局部变量 + 对齐：rbp 后已 16 对齐，push 8 后需补 8
    movq    %rdi, %rbx        # rbx = x，跨调用保存
    leaq    (%rdi,%rdi), %rax # local = x * 2
    movq    %rax, -32(%rbp)   # local 在栈上
    movq    %rsi, %rdi        # 第一个参数 = y
    call    add_one
    addq    -32(%rbp), %rax   # rax = add_one(y) + local
    addq    %rbx, %rax        # + x
    addq    $24, %rsp
    popq    %rbx
    popq    %rbp
    ret
    .size framed, . - framed

// framed_arm64.s — 与 C 版本对应的手写实现
    .text
    .globl framed
    .type framed, %function
framed:
    stp     x29, x30, [sp, #-32]!   // 保存 FP/LR，分配 32 字节
    mov     x29, sp
    str     x19, [sp, #16]          // 保存 x19
    mov     x19, x0                 // x19 = x，跨调用保存
    lsl     x9, x0, #1              // local = x * 2
    str     x9, [sp, #24]           // local 在栈上
    mov     x0, x1                  // 参数 = y
    bl      add_one
    ldr     x9, [sp, #24]
    add     x0, x0, x9              // r + local
    add     x0, x0, x19             // + x
    ldr     x19, [sp, #16]
    ldp     x29, x30, [sp], #32
    ret
    .size framed, . - framed

# framed_riscv64.s — 与 C 版本对应的手写实现
    .text
    .globl framed
    .type framed, @function
framed:
    addi    sp, sp, -32       # 分配栈帧
    sd      ra, 24(sp)        # 保存返回地址
    sd      s0, 16(sp)        # 保存帧指针
    sd      s1, 8(sp)         # 保存 x
    addi    s0, sp, 32        # s0 = 调用者的 sp（帧指针）
    mv      s1, a0            # s1 = x
    slli    t0, a0, 1         # local = x * 2
    sd      t0, -32(s0)       # local 放在本帧的最低槽（s0 = 旧 sp）
    mv      a0, a1            # 参数 = y
    call    add_one
    ld      t0, -32(s0)
    add     a0, a0, t0
    add     a0, a0, s1
    ld      ra, 24(sp)
    ld      s0, 16(sp)
    ld      s1, 8(sp)
    addi    sp, sp, 32
    ret
    .size framed, . - framed

/* argmix.c — 8 个整数、结构体、浮点、可变参数的完整程序
 * cc -std=c17 -D_GNU_SOURCE -Wall -Wextra -Werror -O2 argmix.c -o argmix
 */
#include <stdarg.h>
#include <stdio.h>

struct pair { long a; long b; };

static long sum8(long a, long b, long c, long d,
                 long e, long f, long g, long h)
{
    return a + b + c + d + e + f + g + h;
}

static struct pair make_pair(long a, long b)
{
    struct pair p = { .a = a, .b = b };
    return p;                    /* 16 字节，通常用两个寄存器返回 */
}

static double mix(long a, double x, long b, double y)
{
    return (double)a * x + (double)b * y;
}

static long sum_v(int n, ...)
{
    va_list ap;
    long total = 0;
    va_start(ap, n);
    for (int i = 0; i < n; i++)
        total += va_arg(ap, long);
    va_end(ap);
    return total;
}

int main(void)
{
    struct pair p = make_pair(30, 12);
    printf("sum8   = %ld\n", sum8(1, 2, 3, 4, 5, 6, 7, 8));
    printf("pair   = %ld + %ld\n", p.a, p.b);
    printf("mix    = %.1f\n", mix(2, 1.5, 3, 2.0));
    printf("sum_v  = %ld\n", sum_v(4, 10L, 20L, 30L, 40L));
    return 0;
}

// argmix.rs — 与 C 版本对应；Rust 稳定版不能定义 C 可变参数函数，
// 变参部分用固定切片代替，语义用 sum_slice 表达。
// rustc --edition 2021 -O argmix.rs
#[repr(C)]
pub struct Pair {
    a: i64,
    b: i64,
}

#[no_mangle]
pub extern "C" fn sum8(a: i64, b: i64, c: i64, d: i64,
                       e: i64, f: i64, g: i64, h: i64) -> i64 {
    a + b + c + d + e + f + g + h
}

#[no_mangle]
pub extern "C" fn make_pair(a: i64, b: i64) -> Pair {
    Pair { a, b }
}

fn mix(a: i64, x: f64, b: i64, y: f64) -> f64 {
    a as f64 * x + b as f64 * y
}

fn sum_slice(xs: &[i64]) -> i64 {
    xs.iter().copied().sum()
}

fn main() {
    let p = make_pair(30, 12);
    println!("sum8   = {}", sum8(1, 2, 3, 4, 5, 6, 7, 8));
    println!("pair   = {} + {}", p.a, p.b);
    println!("mix    = {:.1}", mix(2, 1.5, 3, 2.0));
    println!("sum_v  = {}", sum_slice(&[10, 20, 30, 40]));
}

# start_x86_64.s — 静态链接、无 libc
# clang --target=x86_64-linux-gnu -nostdlib -static -Wl,-e,_start start_x86_64.s -o start_x86_64
    .section .rodata
msg:
    .ascii "ch15 x86-64: write/exit via syscall\n"
    .set len, . - msg

    .text
    .globl _start
    .type _start, @function
_start:
    movq    $1, %rax          # SYS_write
    movq    $1, %rdi          # fd = stdout
    leaq    msg(%rip), %rsi   # buf（RIP 相对，PIE 安全）
    movq    $len, %rdx        # count
    syscall                   # 返回 rax；失败为 -errno

    movq    $60, %rax         # SYS_exit
    movq    $42, %rdi         # 退出码
    syscall                   # 不返回
    .size _start, . - _start

// start_arm64.s — 静态链接、无 libc
// clang --target=aarch64-linux-gnu -nostdlib -static -Wl,-e,_start start_arm64.s -o start_arm64
    .section .rodata
msg:
    .ascii "ch15 arm64: write/exit via syscall\n"
    .set len, . - msg

    .text
    .globl _start
    .type _start, %function
_start:
    mov     x8, #64           // SYS_write
    mov     x0, #1            // fd
    adr     x1, msg           // buf；ADR 范围 ±1 MiB
    mov     x2, #len          // count
    svc     #0                // 返回 x0；失败为 -errno

    mov     x8, #93           // SYS_exit
    mov     x0, #42
    svc     #0
    .size _start, . - _start

# start_riscv64.s — 静态链接、无 libc
# clang --target=riscv64-linux-gnu -nostdlib -static -Wl,-e,_start start_riscv64.s -o start_riscv64
    .section .rodata
msg:
    .ascii "ch15 riscv64: write/exit via syscall\n"
    .set len, . - msg

    .text
    .globl _start
    .type _start, @function
_start:
    li      a7, 64            # SYS_write（asm-generic）
    li      a0, 1             # fd
    la      a1, msg           # buf；auipc + addi
    li      a2, 37            # count；li 对符号差需要重定位，这里写常量
    ecall                     # 返回 a0；失败为 -errno

    li      a7, 93            # SYS_exit
    li      a0, 42
    ecall
    .size _start, . - _start

/* inline_all.c — 三架构内联汇编；用对应 target 的 cc 编译
 * cc -std=c17 -D_GNU_SOURCE -Wall -Wextra -Werror -O2 inline_all.c -o inline_all
 */
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>

static const char msg[] = "inline asm: syscall ok\n";

#if defined(__x86_64__)
static long sys_write(int fd, const void *buf, size_t n)
{
    long ret;
    __asm__ volatile("syscall"
                     : "=a"(ret)
                     : "a"(1L), "D"((long)fd), "S"(buf), "d"(n)
                     : "rcx", "r11", "memory");   /* syscall 破坏 rcx/r11 */
    return ret;
}
static uint64_t ticks(void)
{
    uint32_t lo, hi;
    __asm__ volatile("lfence\n\trdtsc" : "=a"(lo), "=d"(hi) :: "memory");
    return ((uint64_t)hi << 32) | lo;
}
#elif defined(__aarch64__)
static long sys_write(int fd, const void *buf, size_t n)
{
    register long x8 __asm__("x8") = 64;          /* SYS_write */
    register long x0 __asm__("x0") = fd;
    register const void *x1 __asm__("x1") = buf;
    register long x2 __asm__("x2") = (long)n;
    __asm__ volatile("svc #0" : "+r"(x0) : "r"(x8), "r"(x1), "r"(x2) : "memory");
    return x0;
}
static uint64_t ticks(void)
{
    uint64_t v;
    __asm__ volatile("isb\n\tmrs %0, cntvct_el0" : "=r"(v) :: "memory");
    return v;
}
#elif defined(__riscv)
static long sys_write(int fd, const void *buf, size_t n)
{
    register long a7 __asm__("a7") = 64;          /* SYS_write */
    register long a0 __asm__("a0") = fd;
    register const void *a1 __asm__("a1") = buf;
    register long a2 __asm__("a2") = (long)n;
    __asm__ volatile("ecall" : "+r"(a0) : "r"(a7), "r"(a1), "r"(a2) : "memory");
    return a0;
}
static uint64_t ticks(void)
{
    uint64_t v;
    __asm__ volatile("fence\n\trdcycle %0" : "=r"(v) :: "memory");
    return v;
}
#else
#error "unsupported architecture"
#endif

int main(void)
{
    uint64_t t0 = ticks();
    long n = sys_write(1, msg, sizeof msg - 1);
    uint64_t t1 = ticks();
    printf("wrote %ld bytes, %" PRIu64 " ticks\n", n, t1 - t0);
    return n == (long)(sizeof msg - 1) ? 0 : 1;
}

// inline_all.rs — rustc --edition 2021 -O inline_all.rs
use std::arch::asm;

#[allow(dead_code)]
static MSG: &[u8] = b"rust asm!: syscall ok\n";

#[allow(dead_code)]
#[cfg(target_arch = "x86_64")]
unsafe fn sys_write(fd: i32, buf: &[u8]) -> isize {
    let ret: isize;
    unsafe {
        asm!(
            "syscall",
            in("rax") 1isize,              // __NR_write
            in("rdi") fd as isize,
            in("rsi") buf.as_ptr(),
            in("rdx") buf.len(),
            lateout("rax") ret,
            lateout("rcx") _,              // syscall 破坏 rcx
            lateout("r11") _,              // 和 r11
            options(nostack),
        );
    }
    ret
}

#[allow(dead_code)]
#[cfg(target_arch = "aarch64")]
unsafe fn sys_write(fd: i32, buf: &[u8]) -> isize {
    let ret: isize;
    unsafe {
        asm!(
            "svc #0",
            in("x8") 64isize,              // __NR_write
            inout("x0") fd as isize => ret,
            in("x1") buf.as_ptr(),
            in("x2") buf.len(),
            options(nostack),
        );
    }
    ret
}

#[allow(dead_code)]
#[cfg(target_arch = "riscv64")]
unsafe fn sys_write(fd: i32, buf: &[u8]) -> isize {
    let ret: isize;
    unsafe {
        asm!(
            "ecall",
            in("a7") 64isize,              // __NR_write（asm-generic）
            inout("a0") fd as isize => ret,
            in("a1") buf.as_ptr(),
            in("a2") buf.len(),
            options(nostack),
        );
    }
    ret
}

#[cfg(target_os = "linux")]
fn main() {
    let n = unsafe { sys_write(1, MSG) };
    std::process::exit(if n == MSG.len() as isize { 0 } else { 1 });
}

#[cfg(not(target_os = "linux"))]
fn main() {
    println!("build for *-linux-gnu to run the Linux syscall path");
}