「交叉编译与多目标后端」

# 典型的交叉编译调用: 前缀标识目标平台
aarch64-linux-gnu-gcc -o app app.c                    # 为 ARM64 Linux 构建
arm-none-eabi-gcc -mcpu=cortex-m4 -o fw.elf fw.c      # 为裸机 Cortex-M4 构建
x86_64-w64-mingw32-gcc -o app.exe app.c               # 为 Windows 构建
clang --target=riscv64-unknown-elf -march=rv64gc app.c
rustc --target aarch64-unknown-linux-gnu -o app app.rs

// 源码里必须小心的平台差异: 类型宽度、对齐、字节序
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>

int main(void) {
    printf("long=%zu pointer=%zu\n", sizeof(long), sizeof(void *));
    printf("offset=%zu\n", offsetof(struct { char c; int i; }, i));
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    puts("little endian");
#else
    puts("big endian");
#endif
    return 0;
}

# 查看当前工具链的目标三元组
cc -dumpmachine                 # 例如 x86_64-linux-gnu
clang -print-target-triple
rustc -vV | grep host           # Rust 的 host 三元组
rustup target list --installed  # 已安装的交叉目标

# 在 Rust 中按目标条件编译
rustc --target aarch64-unknown-linux-gnu --print cfg | head

def parse_triple(triple):
    """把目标三元组拆成结构化描述, 供后端查询."""
    parts = triple.split("-")
    arch = parts[0]
    os = parts[-1]
    env = parts[-2] if len(parts) >= 4 else None
    vendor = parts[1] if len(parts) >= 3 else "unknown"
    return {"arch": arch, "vendor": vendor, "os": os, "env": env,
            "pointer_bits": 32 if arch in ("i686", "arm", "wasm32", "riscv32") else 64,
            "endian": "big" if arch.startswith(("s390", "powerpc", "sparc")) else "little"}

print(parse_triple("x86_64-pc-windows-msvc"))

// 同一个函数在不同 ABI 下的参数传递方式
struct Point { int x, y; };
int sum(struct Point p, int a, int b, int c, int d, int e, int f, int g);

# 同一个调用在两种 ABI 下的汇编差异 (x86-64)
# Linux SysV: 第 1 个参数放 rdi
    mov  $42, %edi
    call foo
# Windows: 第 1 个参数放 rcx, 且必须预留 32 字节 shadow space
    sub  $40, %rsp
    mov  $42, %ecx
    call foo
    add  $40, %rsp

# 用 ABI 描述驱动参数分配: 后端按表查询而非硬编码
SYSV64_INT = ["rdi", "rsi", "rdx", "rcx", "r8", "r9"]
WIN64_INT  = ["rcx", "rdx", "r8", "r9"]

def assign_params(arg_types, abi):
    regs = {"sysv64": SYSV64_INT, "win64": WIN64_INT}[abi]
    slots, i = [], 0
    for t in arg_types:
        if t == "int" and i < len(regs):
            slots.append(("reg", regs[i])); i += 1
        else:
            slots.append(("stack", len([s for s in slots if s[0] == "stack"])))
    return slots

print("SysV :", assign_params(["int"] * 8, "sysv64"))
print("Win64:", assign_params(["int"] * 8, "win64"))

# 使用 sysroot 交叉编译
aarch64-linux-gnu-gcc --sysroot=/opt/sysroot/aarch64 \
    -I/opt/sysroot/aarch64/usr/include \
    -L/opt/sysroot/aarch64/usr/lib \
    -o app app.c

# 查看编译器实际使用的搜索路径
aarch64-linux-gnu-gcc -print-search-dirs
aarch64-linux-gnu-gcc -print-sysroot
echo | aarch64-linux-gnu-gcc -E -Wp,-v -        # 列出头文件搜索路径

# 查看交叉编译产物的目标信息
file app
readelf -h app | grep -E 'Machine|Class|Data'

# 用 crosstool-NG / buildroot 生成完整工具链 (示意)
ct-ng aarch64-unknown-linux-gnu
ct-ng build
# 或用 buildroot 一键生成 sysroot + 工具链
make qemu_aarch64_virt_defconfig && make toolchain

def toolchain_paths(prefix, sysroot):
    """按约定推导交叉工具链的各组件路径."""
    return {
        "cc": f"{prefix}-gcc", "ld": f"{prefix}-ld", "ar": f"{prefix}-ar",
        "objdump": f"{prefix}-objdump", "sysroot": sysroot,
        "include": f"{sysroot}/usr/include", "lib": f"{sysroot}/usr/lib",
    }

class TargetDesc:
    """声明式目标描述: 后端读表决定合法化与指令选择."""
    def __init__(self, name, pointer_bits, regs, endian, call_conv):
        self.name, self.pointer_bits = name, pointer_bits
        self.regs, self.endian, self.call_conv = regs, endian, call_conv

    def legal_types(self):
        """该目标原生支持的类型宽度, 其余需要合法化."""
        return {8, 16, 32} | ({64} if self.pointer_bits == 64 else set())

    def needs_soft_float(self):
        return "fpu" not in self.regs

X86_64 = TargetDesc("x86-64", 64, {"gpr": 16, "fpu": 16, "vec": 32},
                    "little", "sysv64")
CORTEX_M4 = TargetDesc("thumbv7em", 32, {"gpr": 16}, "little", "aapcs")

for t in (X86_64, CORTEX_M4):
    print(f"{t.name:9} legal={sorted(t.legal_types())} soft_fp={t.needs_soft_float()}")

def legalize(op, ty, target):
    """类型合法化: 目标不支持的类型拆成支持的类型."""
    if ty in target.legal_types():
        return [(op, ty)]
    if ty == 64 and target.pointer_bits == 32:
        return [(f"{op}_lo", 32), (f"{op}_hi", 32)]     # 64 位运算拆两半
    if ty == 8 and 8 not in target.legal_types():
        return [(op, 16)]                              # 提升到 16 位
    return [(op, ty)]

print(legalize("add", 64, CORTEX_M4))
print(legalize("add", 64, X86_64))

# 同一段逻辑在不同架构上的汇编形态
# x86-64
    movl  $1, %eax
    addl  %esi, %eax
# ARM64
    mov   w0, #1
    add   w0, w0, w1
# RISC-V
    li    a0, 1
    add   a0, a0, a1

// 浮点行为受编译选项影响: 跨平台对比结果前必须先统一
// gcc -O2 -ffp-contract=off  vs  gcc -O2 -ffp-contract=fast
float fma_like(float a, float b, float c) {
    return a * b + c;     // 可能被融合为 fma, 结果精度不同
}

import struct

def show_bytes(value, fmt):
    """观察同一数值在不同字节序下的字节表示."""
    return struct.pack(fmt, value)

print("小端 0x0102:", show_bytes(0x0102, "<H"))
print("大端 0x0102:", show_bytes(0x0102, ">H"))
print("float 1.0 小端:", show_bytes(1.0, "<f"))

// 跨平台的结构体布局: 显式指定宽度与对齐, 不依赖编译器默认
#include <stdint.h>
struct __attribute__((packed)) Packet {
    uint32_t magic;      // 固定 4 字节
    uint16_t length;     // 固定 2 字节
    uint8_t  flags;
};
_Static_assert(sizeof(struct Packet) == 7, "layout changed");

# aarch64-toolchain.cmake: CMake 交叉编译工具链文件
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)
set(CMAKE_C_COMPILER   aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
set(CMAKE_SYSROOT /opt/sysroot/aarch64)
set(CMAKE_FIND_ROOT_PATH /opt/sysroot/aarch64)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)   # 程序在构建机上找
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)    # 库只在 sysroot 里找
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

# 使用工具链文件构建
cmake -B build-arm64 -DCMAKE_TOOLCHAIN_FILE=aarch64-toolchain.cmake
cmake --build build-arm64

# Rust 交叉编译
rustup target add aarch64-unknown-linux-gnu
cargo build --target aarch64-unknown-linux-gnu --release

# Go 交叉编译 (自带多目标, 只需环境变量)
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o app-arm64 .

# 测试策略一: QEMU 用户态模拟 (最快, 覆盖大部分逻辑)
qemu-aarch64 -L /opt/sysroot/aarch64 ./app-arm64
# 测试策略二: 容器内运行目标架构 (binfmt_misc 自动注册)
docker run --rm --platform linux/arm64 -v "$PWD:/w" -w /w alpine ./app-arm64
# 测试策略三: 真机 / 云上目标实例 (最真实, 成本最高)
ssh arm64-runner 'cd /tmp && ./app'

def check_binary(info):
    """发布前的最小校验清单: 架构、依赖、加载器三项."""
    return {"arch_ok": info["machine"] == "AArch64",
            "no_host_libs": not any("/usr/lib/x86_64" in p for p in info["needed"]),
            "loader_ok": info["interp"] in ("", "/lib/ld-linux-aarch64.so.1")}