makefile

CC      := gcc
BINARY  := stdio-proxy
SRC     := stdio-proxy.c
SRCS    ?= $(SRC)

IMAGE = stdio-proxy-builder
BUILDDIR ?= ./build

PROGS := stdio-proxy

archs = amd64 arm64
arch ?= $(shell arch)

# Detect host architecture and pick the appropriate generic baseline flags.
# The intent is a binary that runs on any CPU of the same ISA family —
# no host-specific tuning, but optimised for the generic case.
#
#   x86_64  → -march=x86-64   (SSE2 baseline, aka x86-64-v1)
#   aarch64 → -march=armv8-a  (ARMv8.0 baseline)
#   others  → no -march flag  (let the compiler decide)
#
ARCH := $(shell uname -m)
ifeq ($(ARCH),x86_64)
  MARCH := -march=x86-64 -mtune=generic
else ifeq ($(ARCH),aarch64)
  MARCH := -march=armv8-a -mtune=generic
else
  MARCH :=
endif

# -O2           : solid speed/size trade-off
# -ffunction/data-sections + --gc-sections : strip dead code from the binary
# -flto         : link-time optimisation (whole-program inlining, DCE)
# -pipe         : use pipes instead of temp files between cc stages
CFLAGS  := -std=c11 \
           -O2 \
           $(MARCH) \
           -ffunction-sections \
           -fdata-sections \
           -fstack-protector-strong \
           -flto=auto \
           -pipe \
           -Wall \
           -Wextra \
           -Wpedantic

LDFLAGS := -static \
           -flto=auto \
           -Wl,--gc-sections \
           -Wl,-s

# Static linking requires the C runtime static archives.
#
# glibc (default):
#   Debian/Ubuntu : apt install libc6-dev  (usually already present)
#                   apt install libc-static  # or glibc-static on RHEL
#   RHEL/AlmaLinux: dnf install glibc-static  (from CRB repo)
#
# musl (recommended — no NSS resolver quirks at runtime):
#   Debian/Ubuntu : apt install musl-tools        → provides musl-gcc
#   RHEL/AlmaLinux: dnf install musl-libc-static  → use with CC=musl-gcc
#
#   make CC=musl-gcc
#   make static-musl          (auto-selects musl-gcc if present)

MUSL_GCC := $(shell command -v musl-gcc 2>/dev/null)

.PHONY: all static-musl test clean

all: builddir $(BINARY)

$(BINARY): $(SRC)
	$(CC) $(CFLAGS) -o $(BUILDDIR)/$@ $< $(LDFLAGS)

# Convenience target: build with musl-gcc when available.
static-musl: $(SRC)
ifdef MUSL_GCC
	$(MUSL_GCC) $(CFLAGS) -o $(BUILDDIR)/$(BINARY) $< $(LDFLAGS)
else
	$(error musl-gcc not found. Install musl-tools (Debian/Ubuntu) or musl-libc-static (RHEL))
endif

# Run Go integration tests.  The test harness (proxy_test.go) compiles the C
# source itself (non-static, -O0 -g) so that no static libc is required.
# Requires Go in PATH.  Run from the repo root or this directory.
.PHONE: test
test: go.mod
	go test -v -count=1 ./test

go.mod:
	go mod init $(BINARY)

clean:
	rm -f $(BINARY) stdio-proxy-test

distclean: clean
	rm -f $(addprefix $(BUILDDIR)/,$(PROGS)) $(addprefix $(BUILDDIR)/,$(addsuffix -static,$(PROGS)))

builddir:
	if [ ! -d $(BUILDDIR) ]; then mkdir -p $(BUILDDIR); fi

$(archs):
	mkdir -p release
	$(MAKE) build-docker arch=$@
	export COPYFILE_DISABLE=true; \
	for PROG in $(PROGS); do \
		tar -czf ./release/$$PROG-linux-$@.tgz LICENSE -C ./build $$PROG; \
	done

fmt:
	docker run --rm -v "$$PWD":/src -w /src alpine:latest sh -c "apk add --no-cache indent && indent -linux $(SRCS) && indent -linux $(SRCS)"

fmt-all:
	$(MAKE) fmt SRCS="*.c"

release-all:
	$(MAKE) release

.PHONY: release
release: $(archs)

build-image:
	docker build -t $(IMAGE):$(arch) --platform linux/$(arch) -f build.dockerfile .

build-docker: build-image
	$(MAKE) distclean
	docker run --rm -v "$$PWD":/src -w /src -e PROGS="$(PROGS)" \
	    --platform linux/$(arch) $(IMAGE):$(arch) make all

build-test-image:
	docker build -t $(IMAGE)-test:$(arch) --platform linux/$(arch) -f test.dockerfile .

test-docker: build-test-image
	docker run --rm -v "$$PWD":/test \
		--platform linux/$(arch) $(IMAGE)-test:$(arch) \
		make test