交叉编译与 overlay：异构构建全攻略

# overlay 的签名：final = 叠加后的包集，prev = 原始包集
final: prev:
{
  # 新增包：用 prev 里的组件构建新包
  myapp = prev.callPackage ./pkgs/myapp.nix { };

  # 覆盖已有包：从 prev 取，改依赖
  hello = prev.hello.overrideAttrs (old: {
    configureFlags = old.configureFlags ++ [ "--enable-nls" ];
  });
}

# flake.nix 输出 overlays
outputs = { self, nixpkgs }:
let
  system = "x86_64-linux";
in {
  overlays.default = import ./overlays/default.nix;

  # 应用到本地 pkgs
  packages.${system}.default = (import nixpkgs {
    inherit system;
    overlays = [ self.overlays.default ];
  }).myapp;

  # 或通过 NixOS 模块注入系统全局
  nixosModules.my-overlay = { config, pkgs, lib, ... }: {
    nixpkgs.overlays = [ self.overlays.default ];
  };
};

# overlays/default.nix
final: prev: {
  myapp = prev.callPackage ./myapp.nix { };
  # 引入 stable 与 unstable 混用（需要第二个 input）
  # pythonForBuild = prev.python312;
}

# pkgsCross 预设了常见 target
pkgs.pkgsCross.aarch64-multiplatform.hello
pkgs.pkgsCross.aarch64-multiplatform.stdenv
pkgs.pkgsCross.raspberryPi4.pkgs.hello

# 查看某个 cross pkgs 的平台信息
pkgs.pkgsCross.aarch64-multiplatform.stdenv.hostPlatform.system
# => "aarch64-linux"

# flake.nix —— 多架构矩阵的核心
{
  outputs = { self, nixpkgs }:
    let
      # 定义需要支持的系统
      systems = [ "x86_64-linux" "aarch64-linux" "armv7l-linux" ];
      forSystem = system:
        let
          # 本地包集（build == host，用于本机构建）
          pkgs = nixpkgs.legacyPackages.${system};
          # 交叉包集（build 固定为本机，host 为 target）
          crossPkgs = nixpkgs.legacyPackages.x86_64-linux.pkgsCross.${crossName system};
          crossName = s: if s == "armv7l-linux" then "armv7l-hf-multiplatform" else "aarch64-multiplatform";
        in
        { packages.default = pkgs.callPackage ./pkgs/default.nix { }; };
    in
    builtins.foldl' (acc: system: acc // {
      packages.${system}.default = ...;
    }) {} systems;
}

{
  outputs = { self, nixpkgs }:
    let
      lib = nixpkgs.lib;
      systems = [ "x86_64-linux" "aarch64-linux" ];
      # 对每个系统生成 packages
      packages = lib.genAttrs systems (system:
        let pkgs = nixpkgs.legacyPackages.${system};
        in {
          default = pkgs.callPackage ./pkgs/default.nix { };
        });
    in { inherit packages; };
}

# flake.nix
{
  description = "cross-compile demo";

  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05";

  outputs = { self, nixpkgs }:
    let
      # 本机构建机平台
      buildSystem = "x86_64-linux";
      buildPkgs = nixpkgs.legacyPackages.${buildSystem};
      lib = nixpkgs.lib;

      # 目标平台列表：本地 + 交叉
      targets = [
        { name = "x86_64-linux";      crossName = null; }
        { name = "aarch64-linux";     crossName = "aarch64-multiplatform"; }
      ];
    in
    {
      packages = lib.genAttrs (map (t: t.name) targets) (target:
        let
          pkgs = if target.crossName == null
            then buildPkgs
            else buildPkgs.pkgsCross.${target.crossName};
        in {
          default = pkgs.callPackage ./pkgs/hello.nix { };
        });

      # 默认输出指向本机构建
      packages.x86_64-linux.default = buildPkgs.callPackage ./pkgs/hello.nix { };
    };
}

# pkgs/hello.nix —— 普通 derivation，无需交叉感知
{ lib, stdenv, fetchFromGitHub }:

stdenv.mkDerivation {
  pname = "hello-cross";
  version = "1.0.0";

  src = fetchFromGitHub {
    owner = "octocat";
    repo = "hello-cross";
    rev = "v1.0.0";
    sha256 = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
  };

  # 交叉编译时 stdenv 自动切换为 cross 工具链
  meta = {
    platforms = lib.platforms.linux;
    description = "Cross-compilable hello world";
  };
}

# 本机构建
nix build .#packages.x86_64-linux.default

# 交叉构建（在 x86_64 机器上产 aarch64 二进制）
nix build .#packages.aarch64-linux.default

# 检查产物架构
file ./result/bin/hello-cross
# => ELF 64-bit LSB executable, ARM aarch64

# 用 qemu 直接跑（验证行为）
nix shell nixpkgs#qemu -- qemu-aarch64 ./result/bin/hello-cross

stdenv.mkDerivation {
  pname = "myapp";
  # nativeBuildInputs 在编译机运行（cmake 本身也是 cross 工具链的）
  nativeBuildInputs = [ cmake pkg-config ];
  # buildInputs 是产物链接的宿主库（必须是 target 架构的）
  buildInputs = [ openssl zlib ];
  # autotools 自动注入 --host 参数
  configurePlatforms = [ "host" ];
  # 交叉环境跳过测试（或配置 qemu emulator）
  doCheck = false;
}

# overlays/cross.nix
final: prev: {
  myprivate = final.callPackage ./pkgs/myprivate.nix { };
}

# 构建时同时叠加 overlay 的交叉包集
let
  crossPkgs = import nixpkgs {
    inherit (buildPkgs.stdenv) system;
    crossSystem = { config = "aarch64-unknown-linux-gnu"; };
    overlays = [ self.overlays.cross ];
  };
in
crossPkgs.myprivate   # 自动使用交叉 stdenv

final: prev: {
  # 该包交叉构建会失败，强制跳过
  badpkg = prev.badpkg.overrideAttrs (old: {
    meta.platforms = lib.platforms.x86_64;  # 只允许本机构建
  });
  # 或为交叉平台换一个替代实现
  libfoo = if final.stdenv.hostPlatform.isAarch64
    then final.callPackage ./pkgs/libfoo-arm.nix { }
    else prev.libfoo;
}

# 推送交叉产物闭包
cachix push mycache ./result-aarch64
cachix push mycache ./result-x86_64

pkgs.pkgsCross.aarch64-darwin.something

# 注册 binfmt（让 docker 能跑 arm 镜像）
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

# 构建 aarch64 容器镜像（配合 dockerTools，见 nix-nix-docker）
nix build .#docker-aarch64
docker load < ./result