Go跨平台编译踩坑实录：3个CGO_ENABLED=0下静态链接失败的终极解法（含musl-gcc交叉编译完整链路）

第一章：Go跨平台编译的核心原理与CGO机制剖析

Go 的跨平台编译能力源于其自包含的静态链接模型和对目标平台抽象层的精细控制。编译器在构建阶段不依赖宿主机的 C 工具链（除非启用 CGO），而是通过内置的 go tool compile 和 go tool link 直接生成目标平台的机器码，所有标准库（如 net, os, syscall）均以 Go 源码形式实现，并通过 build tags 与平台特定代码（如 syscall_linux.go、syscall_darwin.go）自动匹配。

CGO 的双重角色与开关逻辑

CGO 是 Go 与 C 生态交互的桥梁，但也是跨平台编译的潜在障碍。默认情况下，CGO_ENABLED=1 且 GOOS/GOARCH 与当前宿主机一致时，Go 会调用系统 C 编译器（如 gcc 或 clang）链接 C 代码；一旦跨平台编译（如 Linux 上构建 Windows 二进制），若 CGO 启用，则必须提供对应目标平台的交叉 C 工具链——这通常不可行，因此官方推荐做法是禁用 CGO：

# 在 Linux 上构建 macOS 可执行文件（纯 Go，无 C 依赖）
CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -o app-darwin main.go

# 验证是否含 C 动态依赖（应返回空）
ldd app-darwin  # Not a dynamic executable（Linux 下此命令报错，可用 file 命令替代）
file app-darwin  # 输出含 "Mach-O 64-bit executable x86_64"

标准库中 CGO 的条件编译策略

Go 运行时对部分功能采用“纯 Go 实现优先，CGO 回退”机制。例如 DNS 解析：

CGO_ENABLED=0 时使用 net/dnsclient.go 中纯 Go 的 DNS 查询逻辑；
CGO_ENABLED=1 时调用 libc 的 getaddrinfo()，支持 /etc/nsswitch.conf 等系统配置。

可通过以下方式检查某包是否引入 CGO 依赖：

包名	CGO 依赖条件	替代方案
`net`	`CGO_ENABLED=1` 且系统有 libc	纯 Go resolver（默认启用）
`os/user`	必须 CGO（解析 `/etc/passwd`）	无，跨平台构建需禁用该包使用
`crypto/x509`	`CGO_ENABLED=1` 时使用系统根证书	`GODEBUG=x509usefallbackroots=1` 强制使用 Go 内置根

环境变量与构建行为对照表

关键环境变量直接影响编译结果：

变量	默认值	影响范围
`CGO_ENABLED`	`1`	控制是否允许 `#include` 和 `C.` 调用
`CC_FOR_TARGET`	—	指定交叉 C 编译器（仅 CGO 启用时生效）
`GODEBUG`	空	如 `cgocheck=0` 可绕过 CGO 运行时检查

第二章：CGO_ENABLED=0静态链接失败的三大典型场景与根因定位

2.1 环境变量冲突：GOOS/GOARCH与本地构建链不一致的隐式陷阱

当 GOOS 和 GOARCH 被显式设置却未同步调整构建上下文时，Go 工具链会静默切换目标平台——而本地依赖、cgo 行为、甚至 runtime.GOOS 的值仍反映宿主环境，埋下运行时崩溃或符号缺失的隐患。

典型误用场景

在 macOS 上执行 GOOS=linux GOARCH=arm64 go build 编译容器镜像二进制，却未禁用 cgo 或替换 C 交叉工具链
CI 中复用开发者本地 ~/.bashrc 导出的 GOOS=windows，导致测试阶段 os.Executable() 返回路径格式异常

构建行为对比表

场景	`GOOS/GOARCH` 设置	是否启用 cgo	实际链接行为
本地开发（未设）	`darwin/amd64`	`enabled`	链接 macOS dylib
交叉编译（设 linux/arm64）	`linux/arm64`	`enabled`（默认）	链接失败：找不到 `libc.so`
安全交叉编译	`linux/arm64`	`CGO_ENABLED=0`	静态链接成功

# ❌ 危险：cgo 启用状态下强制交叉编译
GOOS=linux GOARCH=arm64 go build -o app main.go

# ✅ 正确：显式禁用 cgo 并指定静态链接
CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o app main.go

逻辑分析：CGO_ENABLED=0 强制纯 Go 模式，绕过 C 工具链依赖；-ldflags="-s -w" 剥离调试信息并禁用 DWARF，减小体积且避免动态符号解析失败。未加此约束时，go build 仍尝试调用 gcc 交叉编译器，但宿主机无 aarch64-linux-gnu-gcc 则静默回退至失败。

graph TD
    A[执行 go build] --> B{CGO_ENABLED==1?}
    B -->|Yes| C[调用 host gcc]
    C --> D[链接目标平台 libc]
    D --> E[失败：工具链缺失]
    B -->|No| F[纯 Go 编译]
    F --> G[生成静态可执行文件]

2.2 标准库依赖泄露：net、os/user等包在禁用CGO时的动态符号残留分析

当 CGO_ENABLED=0 构建 Go 程序时，net 和 os/user 等包仍可能引入隐式动态链接符号，根源在于其 fallback 实现对系统 libc 的间接调用。

动态符号残留示例

# 编译后检查符号
$ CGO_ENABLED=0 go build -o demo main.go
$ readelf -d demo | grep NEEDED
 0x0000000000000001 (NEEDED)                     Shared library: [libc.so.6]  # 意外出现！

该残留源于 os/user.lookupGroup 在无 CGO 时回退至 user.LookupGroup 的纯 Go 实现——但部分发行版标准库（如 Debian 的 golang-go）未完全剥离 cgo-guarded 的 syscall 封装，导致链接器保留 libc 引用。

典型受影响包与行为对照

包名	禁用 CGO 下是否触发 libc 调用	触发条件
`net`	是（DNS 解析）	`/etc/resolv.conf` 存在且含 `nameserver`
`os/user`	是（`user.Current()`）	系统 `/etc/passwd` 格式非标准

根本原因流程

graph TD
    A[CGO_ENABLED=0] --> B{net.LookupHost?}
    B -->|/etc/resolv.conf 可读| C[调用 cgo-free DNS resolver]
    C --> D[内部仍通过 syscall.Syscall 调用 getaddrinfo]
    D --> E[链接器保留 libc.so.6 NEEDED]

解决方案包括：使用 GODEBUG=netdns=go 强制纯 Go DNS、或构建时指定 -tags netgo,osusergo 显式启用无 libc 模式。

2.3 构建缓存污染：go build -a与vendor/cache导致的伪静态链接假象验证

Go 工具链中 -a 标志强制重编译所有依赖，看似“彻底干净”，实则与 vendor/cache 机制产生隐式冲突。

缓存污染触发路径

go build -a 跳过已编译包检查，但仍读取 vendor/cache 中预构建的 .a 归档
若 cache 中存在旧版符号（如 github.com/foo/bar.a 含 v1.2.0 的未导出字段），而源码已升级至 v1.3.0，链接器静默复用旧归档

验证命令链

# 清理构建缓存（仅影响 $GOCACHE，不触碰 vendor/cache）
go clean -cache

# 强制全量重建 —— 但 vendor/cache 下的 .a 仍被优先加载
go build -a -v ./cmd/app

go build -a 不清理 vendor/cache；其内部通过 build.Context.PkgCache 优先查 vendor/cache/GOOS_GOARCH/，导致新版源码与旧二进制归档混合链接，形成“伪静态链接”——表象静态，实则符号不一致。

关键差异对比

行为	`go build -a`	`go build -a -mod=readonly` + `rm -rf vendor/cache`
是否重编译 vendor	✅（但跳过 cache 检查）	✅（且强制从源码构建）
是否保证符号一致性	❌（依赖 cache 命中）	✅（完全源码驱动）

graph TD
    A[go build -a] --> B{查 vendor/cache/}
    B -->|命中|.a[加载旧 .a 归档]
    B -->|未命中|C[从 vendor/ 源码编译]
    .a --> D[链接时符号版本错配]

2.4 交叉编译工具链缺失：目标平台sysroot未就绪引发的linker脚本中断

当 --sysroot 指向空目录或未包含 usr/lib/crt1.o 等启动文件时，链接器在解析 -lc 前即因找不到 ENTRY(_start) 符号而中止。

典型错误日志

arm-linux-gnueabihf-gcc -o app main.o --sysroot=/opt/sysroots/armv7a --static
# 错误：/opt/sysroots/armv7a/usr/lib/crt1.o: No such file or directory

该命令强制链接器从指定 sysroot 加载 C 运行时启动代码；若缺失，链接器无法定位 _start 入口，linker 脚本（如 armelf_linux_eabi.x）中 ENTRY(_start) 指令直接失效。

sysroot 必备组件清单

usr/lib/crt1.o, crti.o, crtn.o
usr/lib/libc.a（静态链接必需）
usr/include/ 下完整头文件树

组件	作用	缺失后果
`crt1.o`	提供 `_start` 入口点	链接器报 `undefined reference to '_start'`
`libc.a`	静态 libc 实现	`-lc` 解析失败

graph TD
    A[调用 arm-linux-gnueabihf-gcc] --> B[读取 linker script]
    B --> C{查找 --sysroot/usr/lib/crt1.o}
    C -->|不存在| D[中止并报错]
    C -->|存在| E[继续解析 ENTRY/_start]

2.5 Docker多阶段构建中CGO_ENABLED传播失效的调试实战

现象复现

在 Alpine 基础镜像的多阶段构建中，CGO_ENABLED=0 在 build 阶段生效，但 runtime 阶段却意外启用 CGO，导致 undefined symbol: SSL_CTX_set_ciphersuites 运行时错误。

根本原因

Docker 构建阶段间环境变量不自动继承，ARG 与 ENV 作用域隔离：

阶段	CGO_ENABLED 是否生效	原因
builder	✅（显式设置）	`ARG CGO_ENABLED=0` + `ENV`
final	❌（未重新声明）	`ARG` 仅限当前阶段生效

关键修复代码

# builder 阶段（正常）
FROM golang:1.22-alpine AS builder
ARG CGO_ENABLED=0
ENV CGO_ENABLED=${CGO_ENABLED}
RUN go build -a -ldflags '-extldflags "-static"' -o app .

# final 阶段（必须显式重置！）
FROM alpine:3.19
ARG CGO_ENABLED=0  # ← 必须重复声明，否则为默认空值（即 1）
ENV CGO_ENABLED=${CGO_ENABLED}
COPY --from=builder /workspace/app .
CMD ["./app"]

ARG CGO_ENABLED=0 在 final 阶段缺失时，CGO_ENABLED 展开为空字符串，Go 工具链将其视为 1；显式赋值确保跨阶段语义一致。

调试流程图

graph TD
    A[构建失败] --> B{检查 CGO_ENABLED 值}
    B -->|final 阶段 echo $CGO_ENABLED| C[输出为空]
    C --> D[添加 ARG CGO_ENABLED=0]
    D --> E[验证 LD_LIBRARY_PATH 无动态依赖]

第三章：musl-gcc交叉编译链路的可信搭建与验证

3.1 Alpine Linux容器内musl-gcc工具链的源码编译与路径标准化

在Alpine Linux轻量级容器中，musl libc是默认C运行时，但官方镜像不预装musl-gcc——它并非独立编译器，而是指向gcc的包装脚本，需手动构建并标准化路径。

构建musl-gcc包装器

# 创建标准musl-gcc包装脚本（/usr/local/bin/musl-gcc）
#!/bin/sh
exec /usr/bin/gcc -specs=/usr/lib/musl-gcc.specs "$@"

此脚本强制GCC使用musl链接规范；-specs指定链接器行为，避免glibc符号污染；exec确保PID继承，符合容器进程模型。

关键路径映射表

用途	标准路径	说明
包装器可执行文件	`/usr/local/bin/musl-gcc`	符合POSIX `PATH`优先级
specs文件	`/usr/lib/musl-gcc.specs`	由`musl-dev`包提供

编译流程依赖关系

graph TD
    A[alpine:latest] --> B[apk add build-base musl-dev]
    B --> C[生成musl-gcc包装脚本]
    C --> D[chmod +x && ln -sf]

3.2 Go标准库musl适配补丁（-tags netgo）的精准注入与效果比对

Go 默认使用 cgo 调用 glibc 的 getaddrinfo，在 Alpine（musl libc）环境中易因符号缺失或行为差异导致 DNS 解析失败。-tags netgo 强制启用纯 Go 实现的 net 包，绕过系统 libc。

编译时精准注入方式

# 禁用 cgo，强制启用纯 Go 网络栈
CGO_ENABLED=0 go build -tags netgo -o app .

# 或保留 cgo 但优先使用 netgo（需确保无 cgo 依赖的第三方库）
CGO_ENABLED=1 go build -tags "netgo osusergo" -o app .

netgo 标签触发 net/conf.go 中 init() 分支选择 dnsclient 实现；osusergo 避免调用 musl 不兼容的 user.Lookup。二者协同可实现零 libc 依赖的 DNS + 用户解析。

效果对比（Alpine 3.19）

场景	默认（cgo+glibc）	`-tags netgo`
`net.LookupIP("google.com")`	❌ panic（musl 无 getaddrinfo）	✅ 成功（Go 内置 UDP 查询）
静态二进制体积	~15MB	~9MB

graph TD
    A[go build -tags netgo] --> B{CGO_ENABLED=0?}
    B -->|Yes| C[完全静态链接<br>无 libc 依赖]
    B -->|No| D[仍链接 musl<br>但跳过 getaddrinfo]
    C & D --> E[DNS 使用 Go net/dns/client]

3.3 静态二进制体积膨胀归因分析：strip、upx与ldflags=-s的协同优化

静态链接的 Go 或 Rust 二进制常因调试符号、反射元数据和未裁剪的运行时而显著膨胀。三者并非简单叠加，而是存在依赖顺序与效果抵消风险。

优化必须遵循严格时序

go build -ldflags="-s -w"：在链接阶段剥离符号表（-s）和 DWARF 调试信息（-w），但无法移除 Go 的 runtime.typeinfo 等反射数据；
strip --strip-unneeded：二次清除 ELF 中剩余的 .symtab/.strtab，对已 -s 的二进制收益有限；
upx --lzma：最后压缩，若前置未清理，则压缩率下降 30%+（因符号表含大量重复字符串）。

典型体积变化对比（Go 1.22, x86_64）

步骤	二进制大小	说明
原始构建	12.4 MB	含完整符号与调试信息
`-ldflags="-s -w"`	9.1 MB	移除符号表，但保留类型元数据
`+ strip`	9.0 MB	收益仅 100 KB，验证冗余性
`+ upx --lzma`	3.2 MB	最终压缩比达 3.9×

# 推荐流水线（不可调换顺序！）
go build -ldflags="-s -w -buildmode=exe" -o app.bin .
strip --strip-unneeded app.bin
upx --lzma --best -o app.upx app.bin

strip 对 -s 后的 Go 二进制几乎无用，但对 C/C++ 混合链接目标仍必要；upx 必须作用于已剥离的文件，否则 LZMA 会浪费算力压缩无意义符号字符串。

第四章：生产级跨平台交付的三重保障方案

4.1 方案一：纯Go实现替代方案——使用github.com/hashicorp/go-cleanhttp重构HTTP客户端

go-cleanhttp 提供开箱即用的、生产就绪的 HTTP 客户端配置，避免手动设置超时、重试与连接复用陷阱。

核心优势对比

特性	默认 `http.DefaultClient`	`cleanhttp.DefaultClient()`
连接空闲超时	0（无限）	30s
最大空闲连接数	2	100
TLS握手超时	无	30s

初始化示例

import "github.com/hashicorp/go-cleanhttp"

client := cleanhttp.DefaultClient()
// 等价于手动配置 Transport + Timeout

该调用自动注入 &http.Transport{IdleConnTimeout: 30 * time.Second, MaxIdleConns: 100, ...}，并设置 Timeout = 30s。避免因连接泄漏或阻塞导致 goroutine 泄露。

数据同步机制

func NewSyncClient() *http.Client {
    return &http.Client{
        Transport: cleanhttp.DefaultPooledTransport(),
        Timeout:   45 * time.Second,
    }
}

DefaultPooledTransport() 启用连接池与 Keep-Alive，显著提升高频小请求吞吐；Timeout 覆盖整个请求生命周期（DNS + dial + TLS + write + read），保障服务稳定性。

4.2 方案二：自定义linker脚本+musl-stripped sysroot的最小化镜像构建

该方案通过精细控制链接时行为与运行时依赖，实现二进制体积压缩至极致。

自定义 linker 脚本核心片段

SECTIONS {
  . = 0x400000;                    /* 设置程序基址为 4MB，避开低地址保留区 */
  .text : { *(.text) }             /* 合并所有代码段，消除段间填充 */
  .rodata : { *(.rodata) }         /* 只读数据合并，便于 mmap 共享 */
  .data : { *(.data) }             /* 初始化数据段紧随其后 */
  .bss : { *(.bss) }               /* 未初始化段统一归一，零初始化高效 */
}

逻辑分析：0x400000 避免与内核/ASLR 冲突；显式段布局消除了默认 linker 脚本中冗余对齐（如 .text 默认按 64KB 对齐），减少约 12–18 KiB 无效填充。

musl-stripped sysroot 构建流程

使用 musl-gcc --sysroot=/path/to/stripped 编译
find /stripped -name "*.so*" -delete 删除动态库（仅保留 libc.a）
strip --strip-unneeded 清除符号表与调试信息

组件	原始大小	Strip 后	压缩率
libc.a	1.8 MiB	320 KiB	82%
crt1.o/crti.o	12 KiB	4.2 KiB	65%

镜像组装流程

graph TD
  A[源码] --> B[musl-gcc -static -T custom.ld]
  B --> C[静态可执行文件]
  C --> D[upx --best --lzma]
  D --> E[<512 KiB 容器 rootfs]

4.3 方案三：Bazel+rules_go构建图驱动的跨平台产物一致性校验流水线

核心设计思想

以构建图（Build Graph）为唯一真相源，将 linux_amd64、darwin_arm64、windows_x86_64 等平台产物的哈希值注入同一依赖节点，实现声明式一致性断言。

Bazel 规则定义示例

# BUILD.bazel
load("@io_bazel_rules_go//go:def.bzl", "go_binary")

go_binary(
    name = "app",
    srcs = ["main.go"],
    goarch = "{GOARCH}",  # 模板化平台变量
    goos = "{GOOS}",
)

逻辑分析：{GOOS}/{GOARCH} 占位符由 --platforms=//platforms:linux_amd64 等实际平台标签注入；rules_go 自动推导依赖闭包，确保各平台构建图拓扑等价。

一致性校验流程

graph TD
    A[Platform-A Build] --> B[SHA256 of binary]
    C[Platform-B Build] --> D[SHA256 of binary]
    B & D --> E[Compare Hashes]
    E -->|Match| F[Pass]
    E -->|Mismatch| G[Fail + diff report]

校验结果对比表

平台	二进制大小	SHA256（前8位）	构建耗时
linux_amd64	9.2 MB	`a1b2c3d4...`	4.2s
darwin_arm64	9.2 MB	`a1b2c3d4...`	5.1s

4.4 混合方案落地：CGO_ENABLED=1 + CC_musl交叉编译器的条件编译工程实践

在需调用 C 库但目标环境无 glibc 的场景（如 Alpine 容器），必须启用 CGO 并切换至 musl 工具链。

构建环境准备

# 使用 musl-gcc 作为交叉编译器，显式指定 CC
CC_musl=/usr/bin/x86_64-linux-musl-gcc \
CGO_ENABLED=1 \
GOOS=linux \
GOARCH=amd64 \
go build -ldflags="-extld=$CC_musl" -o app .

CGO_ENABLED=1 启用 cgo 支持（默认为 0 时禁用所有 C 交互）；
CC_musl 覆盖 CC 环境变量，确保 #cgo CC 指令及链接阶段均使用 musl-gcc；
-extld 强制链接器使用 musl-gcc，避免 go toolchain 自动回退到系统 gcc。

条件编译控制

通过构建标签精准隔离 musl 特化逻辑：

//go:build cgo && linux
// +build cgo,linux

package main

/*
#cgo LDFLAGS: -lcrypt
#include <crypt.h>
*/
import "C"

典型依赖兼容性对照表

C 函数	glibc 支持	musl 支持	注意事项
`crypt()`	✅	✅	需显式链接 `-lcrypt`
`getrandom()`	✅	✅	musl 1.2.3+
`memrchr()`	✅	❌	musl 中暂未实现

graph TD A[源码含#cgo指令] –> B{CGO_ENABLED=1?} B –>|是| C[调用CC_musl编译C代码] B –>|否| D[忽略#cgo，编译失败] C –> E[链接musl libc.a] E –> F[生成静态链接Linux二进制]

第五章：从踩坑到闭环：Go静态编译方法论的演进启示

在某金融级微服务网关项目中，团队曾因CGO_ENABLED=1默认开启导致容器镜像体积暴涨至327MB，且在Alpine环境运行时频繁触发libgcc_s.so.1: cannot open shared object file错误。这一问题倒逼团队系统性复盘Go静态编译实践路径，逐步形成可复用的方法论闭环。

编译参数组合的陷阱识别

早期运维同学直接套用go build -ldflags "-s -w"，却忽略-ldflags '-extldflags "-static"'缺失导致动态链接残留。实测对比显示：

CGO_ENABLED	-ldflags 参数	生成二进制大小	Alpine 运行结果
1（默认）	`-s -w`	14.2MB	❌ `libpthread.so.0 not found`
0	`-s -w -extldflags "-static"`	8.7MB	✅ 零依赖运行

跨平台交叉编译的版本断层

Kubernetes集群升级至v1.28后，某边缘节点因内核版本为4.19.0，而Go 1.20+默认启用-buildmode=pie，导致exec format error。解决方案需显式禁用PIE并锁定内核兼容性：

GOOS=linux GOARCH=amd64 CGO_ENABLED=0 \
  go build -ldflags="-s -w -buildmode=exe -extldflags '-static'" \
  -o gateway-linux-amd64 .

C标准库调用的静默降级路径

当业务代码间接引用net包（如使用http.Client），Go会自动注入getaddrinfo等glibc函数。通过readelf -d ./binary | grep NEEDED可验证动态依赖残留。终极解法是启用GODEBUG=netdns=go环境变量强制纯Go DNS解析，并在main.go头部添加：

import _ "net/http/pprof" // 触发DNS策略生效

构建流程的自动化校验闭环

在CI流水线中嵌入二进制纯净度检测脚本：

#!/bin/bash
# verify-static.sh
if ldd "$1" 2>&1 | grep -q "not a dynamic executable"; then
  echo "✅ 静态编译验证通过"
  exit 0
else
  echo "❌ 发现动态链接依赖：$(ldd "$1" 2>&1)"
  exit 1
fi

容器化部署的镜像瘦身实践

原Dockerfile采用FROM golang:1.21-alpine多阶段构建，仍存在/usr/lib/libcrypto.so.1.1等残留。优化后采用scratch基础镜像并验证符号表清理：

FROM scratch
COPY --from=builder /workspace/gateway /gateway
COPY ca-certificates.crt /etc/ssl/certs/
EXPOSE 8080
CMD ["/gateway"]

生产环境热更新的兼容性约束

某支付核心服务要求二进制支持SIGUSR2平滑重启，但静态编译后runtime.LockOSThread()与syscall.SIGUSR2信号处理产生竞态。最终通过go:linkname重绑定runtime.sigtramp并补丁src/runtime/signal_unix.go实现信号透传。

依赖管理的隐式风险扫描

使用go list -deps -f '{{if not .Standard}}{{.ImportPath}}{{end}}' ./... | xargs go mod graph发现github.com/mattn/go-sqlite3引入cgo依赖。改用github.com/ziutek/mymysql纯Go驱动后，静态编译成功率从63%提升至100%。

混合部署场景的ABI对齐

混合ARM64与AMD64节点时，发现Go 1.19编译的二进制在ARM64上出现floating point exception。根源在于-gcflags="-l"禁用内联后，浮点运算指令未对齐硬件特性。最终采用GOARM=7显式指定ARMv7指令集并保留部分内联优化。

安全合规的符号剥离深度

金融客户审计要求移除所有调试符号及字符串常量。除-ldflags "-s -w"外，还需执行：

strip --strip-all --remove-section=.comment --remove-section=.note gateway
strings gateway | grep -i "debug\|go\.mod" # 验证无敏感信息残留

构建缓存失效的根因定位

CI中go build耗时从12s突增至217s，经go tool trace分析发现GOROOT/src/runtime/proc.go被意外修改触发全量重编译。建立.gitattributes强制文本规范，并在Makefile中加入构建指纹校验：

BUILD_FINGERPRINT := $(shell sha256sum $(shell go list -f '{{.GoFiles}}' runtime) | cut -d' ' -f1)