Makefile

# memDBG - Memory debugger payload for jailbroken consoles.
# Copyright (C) 2026 SeregonWar
# SPDX-License-Identifier: GPL-3.0-or-later

HOST_CC ?= cc
HOST_AR ?= ar

BUILD_DIR ?= build
HOST_TARGET ?= $(BUILD_DIR)/MemDBG-host
PS4_TARGET ?= $(BUILD_DIR)/ps4/MemDBG-ps4.elf
PS4_LIB_TARGET ?= $(BUILD_DIR)/ps4/libmemdbg.a
PS5_TARGET ?= $(BUILD_DIR)/ps5/MemDBG-ps5.elf
PS5_LIB_TARGET ?= $(BUILD_DIR)/ps5/libmemdbg.a
VERSION_FILE ?= $(CURDIR)/VERSION
MEMDBG_VERSION ?= $(shell sed -n '1{s/^[[:space:]]*//;s/[[:space:]]*$$//;s/^[vV]//;p;q;}' "$(VERSION_FILE)")
MEMDBG_VERSION_CORE := $(firstword $(subst -, ,$(MEMDBG_VERSION)))
MEMDBG_VERSION_PARTS := $(subst ., ,$(MEMDBG_VERSION_CORE))
MEMDBG_VERSION_MAJOR := $(or $(word 1,$(MEMDBG_VERSION_PARTS)),0)
MEMDBG_VERSION_MINOR := $(or $(word 2,$(MEMDBG_VERSION_PARTS)),0)
MEMDBG_VERSION_PATCH := $(or $(word 3,$(MEMDBG_VERSION_PARTS)),0)
GENERATED_INCLUDE_DIR := $(BUILD_DIR)/generated/include
GENERATED_VERSION_HEADER := $(GENERATED_INCLUDE_DIR)/memdbg/core/memdbg_version.h

PS4_PAYLOAD_SDK ?= $(CURDIR)/external/ps4-payload-sdk
PS5_PAYLOAD_SDK ?= $(CURDIR)/external/ps5-payload-sdk
PS4_HOST ?= ps4
PS4_PORT ?= 9021
PS5_HOST ?= ps5
PS5_PORT ?= 9021
LLVM_CONFIG ?= $(firstword $(wildcard /opt/homebrew/opt/llvm/bin/llvm-config /usr/local/opt/llvm/bin/llvm-config))
export LLVM_CONFIG

PS4_CC ?= $(PS4_PAYLOAD_SDK)/bin/orbis-clang
PS4_AR ?= $(PS4_PAYLOAD_SDK)/bin/orbis-ar
PS4_DEPLOY ?= $(PS4_PAYLOAD_SDK)/bin/orbis-deploy
PS5_CC ?= $(PS5_PAYLOAD_SDK)/bin/prospero-clang
PS5_AR ?= $(PS5_PAYLOAD_SDK)/bin/prospero-ar
PS5_DEPLOY ?= $(PS5_PAYLOAD_SDK)/bin/prospero-deploy

# Zydis x86-64 disassembler (cross-compiled for PS5 payload)
ZYDIS_DIR := $(CURDIR)/external/zydis
ZYCORE_DIR := $(ZYDIS_DIR)/dependencies/zycore
ZYDIS_SOURCES := $(wildcard $(ZYDIS_DIR)/src/*.c)
ZYCORE_SOURCES := $(wildcard $(ZYCORE_DIR)/src/*.c)
PS5_ZYDIS_OBJECTS := $(patsubst $(ZYDIS_DIR)/src/%.c,$(BUILD_DIR)/ps5-zydis/%.o,$(ZYDIS_SOURCES))
PS5_ZYCORE_OBJECTS := $(patsubst $(ZYCORE_DIR)/src/%.c,$(BUILD_DIR)/ps5-zycore/%.o,$(ZYCORE_SOURCES))
ZYDIS_PS5_CFLAGS := -I$(ZYDIS_DIR)/include -I$(ZYDIS_DIR)/src \
	-I$(ZYCORE_DIR)/include -I$(ZYCORE_DIR)/src \
	-DZYDIS_STATIC_BUILD -DZYCORE_STATIC_BUILD \
	-DZYDIS_DISABLE_FORMATTER -DZYDIS_DISABLE_ENCODER \
	-std=c11 -O2

# Keystone x86-64 assembler (pre-compiled for PS5).
# The pre-built libkeystone.a is large (~4 MiB) and not committed;
# the build degrades gracefully to MEMDBG_HAS_KEYSTONE=0 when absent.
KEYSTONE_DIR := $(CURDIR)/external/keystone
KEYSTONE_LIB := $(KEYSTONE_DIR)/lib/libkeystone.a
KEYSTONE_AVAILABLE := $(shell test -f '$(KEYSTONE_LIB)' && echo 1 || echo 0)
ifeq ($(KEYSTONE_AVAILABLE),1)
PS5_KEYSTONE_CPPFLAGS := -I$(KEYSTONE_DIR)/include -DMEMDBG_HAS_KEYSTONE=1
PS5_KEYSTONE_LDLIBS := $(KEYSTONE_LIB)
else
PS5_KEYSTONE_CPPFLAGS := -DMEMDBG_HAS_KEYSTONE=0
PS5_KEYSTONE_LDLIBS :=
endif

COMMON_CPPFLAGS := -I$(GENERATED_INCLUDE_DIR) -Iinclude -Isrc/core/daemon
COMMON_CFLAGS := -std=c11 -Wall -Wextra -Wpedantic -fstack-protector-strong -O2
HOST_CPPFLAGS := $(COMMON_CPPFLAGS) -D_DARWIN_C_SOURCE -D_POSIX_C_SOURCE=200809L -D_FORTIFY_SOURCE=2 -D_GLIBCXX_ASSERTIONS
# Keep cached CI objects and release binaries portable across host CPUs.
# Local benchmark builds may opt in with HOST_ARCH_FLAGS=-march=native.
HOST_ARCH_FLAGS ?=
HOST_CFLAGS := $(COMMON_CFLAGS) -Werror -Wconversion -Wshadow -Wformat=2 -flto $(HOST_ARCH_FLAGS)
# Console (PS4/PS5) builds share the host's strictness where the SDK allows.
# CONSOLE_WERROR defaults to 1 (treat warnings as errors). Set to 0 to
# allow warnings from console SDK headers outside MemDBG's control.
CONSOLE_WERROR ?= 1
CONSOLE_CFLAGS := $(COMMON_CFLAGS) -Wconversion -Wshadow -Wformat=2
ifeq ($(CONSOLE_WERROR),1)
CONSOLE_WERROR_FLAG := -Werror
else
CONSOLE_WERROR_FLAG :=
endif

UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S),Linux)
HOST_LDFLAGS := -Wl,-z,relro -Wl,-z,now -flto
else ifeq ($(UNAME_S),Darwin)
HOST_LDFLAGS := -Wl,-bind_at_load -flto
else
HOST_LDFLAGS :=
endif

HOST_LDLIBS := -lpthread

SOURCES := $(shell find src -name '*.c' | sort)
LIB_SOURCES := $(filter-out src/core/main.c,$(SOURCES))
HOST_OBJECTS := $(patsubst src/%.c,$(BUILD_DIR)/host/%.o,$(SOURCES))
PS4_OBJECTS := $(patsubst src/%.c,$(BUILD_DIR)/ps4/%.o,$(SOURCES))
PS4_LIB_OBJECTS := $(patsubst src/%.c,$(BUILD_DIR)/ps4-lib/%.o,$(LIB_SOURCES))
PS5_OBJECTS := $(patsubst src/%.c,$(BUILD_DIR)/ps5/%.o,$(SOURCES))
PS5_LIB_OBJECTS := $(patsubst src/%.c,$(BUILD_DIR)/ps5-lib/%.o,$(LIB_SOURCES))
ALL_DEPFILES := $(HOST_OBJECTS:.o=.d) $(PS4_OBJECTS:.o=.d) \
	$(PS4_LIB_OBJECTS:.o=.d) $(PS5_OBJECTS:.o=.d) \
	$(PS5_LIB_OBJECTS:.o=.d)

# Header dependency files are essential here: PAL structs cross translation
# unit boundaries. Without them an incremental payload build can link objects
# compiled against different layouts and trip the stack protector at runtime.
-include $(ALL_DEPFILES)

.PHONY: all clean host payload-ps4 payload-ps4-lib payload-ps5 payload-ps5-lib deploy-ps4 deploy-ps5 frontend gdb-bridge test-gdb-bridge test-debugger-disassembly x64dbg-plugin verify test test-aob-boundary test-process-aob-e2e test-debugger test-memory test-pal-ebadf test-pal-memory-console test-pal-memory-console-ps4 test-pal-wait-backend-ps4 test-privilege-ps4 test-ps4-debug-gate test-process-map-metadata test-process-map-cache test-lz4 test-scan-partition test-scan-protocol test-tracer-daemon test-new-features test-sjson test-legacy-scanner-e2e test-legacy-process-e2e test-reconnect-state-machine test-protocol-abi test-daemon-config-file check-locales check-headers tracer-tool fuzz-protocol-header fuzz-lz4 fuzz-sjson fuzz-process-maps fuzz-corpus FORCE

all: host

host: $(HOST_TARGET)

SCANNER_OBJECTS := $(BUILD_DIR)/host/scanner/scan/api.o \
	$(BUILD_DIR)/host/scanner/scan/alias.o \
	$(BUILD_DIR)/host/scanner/scan/builder.o \
	$(BUILD_DIR)/host/scanner/scan/match.o \
	$(BUILD_DIR)/host/scanner/scan/parallel.o \
	$(BUILD_DIR)/host/scanner/scan/partition.o \
	$(BUILD_DIR)/host/scanner/scan/request.o \
	$(BUILD_DIR)/host/scanner/scan/simd.o \
	$(BUILD_DIR)/host/scanner/scan/walker.o

test-aob-boundary: $(SCANNER_OBJECTS) tests/test_aob_boundary.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_aob_boundary.c $(SCANNER_OBJECTS) $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_aob_boundary
	@echo "--- Running AOB boundary test ---"
	$(BUILD_DIR)/test_aob_boundary

test-process-aob-e2e: host tests/test_process_aob_e2e.c tests/e2e_utils.c tests/e2e_utils.h
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_process_aob_e2e.c tests/e2e_utils.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_process_aob_e2e
	@echo "--- Running process AOB E2E test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e.XXXXXX); \
	port=19120; \
	$(HOST_TARGET) --bind=127.0.0.1 --debug-port=$$port --udp-port=19123 --data-root=$$tmpdir --no-udp-log --no-replace-existing >$$tmpdir/payload.log 2>&1 & \
	pid=$$!; \
	trap 'kill -TERM $$pid 2>/dev/null || true; sleep 0.8; kill -KILL $$pid 2>/dev/null || true; wait $$pid 2>/dev/null || true; rm -rf $$tmpdir' EXIT; \
	sleep 0.6; \
	$(BUILD_DIR)/test_process_aob_e2e 127.0.0.1 $$port

DEBUGGER_SESSION_OBJECTS := $(BUILD_DIR)/host/debug/session/debugger.o \
	$(BUILD_DIR)/host/debug/session/breakpoints.o \
	$(BUILD_DIR)/host/debug/session/regs.o

test-debugger: $(DEBUGGER_SESSION_OBJECTS) tests/test_debugger.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_debugger.c $(DEBUGGER_SESSION_OBJECTS) $(HOST_LDFLAGS) -lpthread -o $(BUILD_DIR)/test_debugger
	@echo "--- Running Debugger test ---"
	$(BUILD_DIR)/test_debugger

test-memory: $(BUILD_DIR)/host/debug/memory/memdbg_memory.o tests/test_memory.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_memory.c $< $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_memory
	@echo "--- Running Memory primitive test ---"
	$(BUILD_DIR)/test_memory

test-pal-ebadf: tests/test_pal_memory_ebadf.c $(GENERATED_VERSION_HEADER)
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) -D__linux__ tests/test_pal_memory_ebadf.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_pal_memory_ebadf
	@echo "--- Running PAL EBADF retry test ---"
	$(BUILD_DIR)/test_pal_memory_ebadf

test-pal-memory-console: tests/test_pal_memory_console.c tests/include/ps5/kernel.h tests/include/ps5/mdbg.h $(GENERATED_VERSION_HEADER)
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Itests/include $(HOST_CFLAGS) -DMEMDBG_PAL_CONSOLE=1 -DMEMDBG_PAL_PS5=1 tests/test_pal_memory_console.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_pal_memory_console
	@echo "--- Running PAL memory console fallback test (PS5) ---"
	$(BUILD_DIR)/test_pal_memory_console

test-pal-memory-console-ps4: tests/test_pal_memory_console_ps4.c tests/include/ps4/mdbg.h $(GENERATED_VERSION_HEADER)
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Itests/include $(HOST_CFLAGS) -DMEMDBG_PAL_CONSOLE=1 -DMEMDBG_PAL_PS4=1 tests/test_pal_memory_console_ps4.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_pal_memory_console_ps4
	@echo "--- Running PAL memory console test (PS4) ---"
	$(BUILD_DIR)/test_pal_memory_console_ps4

test-privilege-ps4: tests/test_privilege_ps4.c tests/include/ps4/authid.h tests/include/ps4/kernel.h $(GENERATED_VERSION_HEADER)
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Itests/include $(HOST_CFLAGS) -DPLATFORM_PS4=1 tests/test_privilege_ps4.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_privilege_ps4
	@echo "--- Running PS4 loader credential test ---"
	$(BUILD_DIR)/test_privilege_ps4

test-ps4-debug-gate: tests/test_ps4_debug_gate.c tests/include/ps4/kernel.h $(GENERATED_VERSION_HEADER)
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Itests/include $(HOST_CFLAGS) -DPLATFORM_PS4=1 tests/test_ps4_debug_gate.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_ps4_debug_gate
	@echo "--- Running PS4 debug gate arming test ---"
	$(BUILD_DIR)/test_ps4_debug_gate

test-process-map-metadata: $(BUILD_DIR)/host/pal/pal_process.o tests/test_process_map_metadata.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_process_map_metadata.c $< $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_process_map_metadata
	@echo "--- Running process map metadata test ---"
	$(BUILD_DIR)/test_process_map_metadata

test-process-map-cache: $(BUILD_DIR)/host/debug/process/memdbg_process.o tests/test_process_map_cache.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_process_map_cache.c $< $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_process_map_cache
	@echo "--- Running process map cache test ---"
	$(BUILD_DIR)/test_process_map_cache

test-debugger-e2e: host tests/test_debugger_e2e.c tests/e2e_utils.c tests/e2e_utils.h
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_debugger_e2e.c tests/e2e_utils.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_debugger_e2e
	@echo "--- Running Debugger E2E test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-dbg.XXXXXX); \
	port=19121; \
	$(HOST_TARGET) --bind=127.0.0.1 --debug-port=$$port --udp-port=19124 --data-root=$$tmpdir --no-udp-log --no-replace-existing >$$tmpdir/payload.log 2>&1 & \
	pid=$$!; \
	trap 'kill -TERM $$pid 2>/dev/null || true; sleep 0.8; kill -KILL $$pid 2>/dev/null || true; wait $$pid 2>/dev/null || true; rm -rf $$tmpdir' EXIT; \
	sleep 0.6; \
	$(BUILD_DIR)/test_debugger_e2e 127.0.0.1 $$port

test-debugger-protocol: tests/test_debugger_protocol.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_debugger_protocol.c \
		src/core/daemon/handlers/debug.c src/core/daemon/handlers/process.c \
		$(HOST_LDFLAGS) -o $(BUILD_DIR)/test_debugger_protocol
	@echo "--- Running Debugger Protocol test ---"
	$(BUILD_DIR)/test_debugger_protocol

test-lz4: src/util/lz4.c include/memdbg/pal/lz4.h tests/test_lz4.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_lz4.c src/util/lz4.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_lz4
	@echo "--- Running LZ4 test ---"
	$(BUILD_DIR)/test_lz4

test-benchmarks: src/scanner/scan/simd.c src/scanner/scan/partition.c src/util/lz4.c tests/test_benchmarks.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Isrc -Isrc/scanner $(HOST_CFLAGS) tests/test_benchmarks.c src/scanner/scan/simd.c src/scanner/scan/partition.c src/util/lz4.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_benchmarks
	@echo "--- Running Benchmarks ---"
	$(BUILD_DIR)/test_benchmarks

test-zero-copy: src/util/lz4.c tests/test_zero_copy.c tests/bench_utils.h
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Isrc $(HOST_CFLAGS) tests/test_zero_copy.c src/util/lz4.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_zero_copy
	@echo "--- Running Zero-Copy Benchmarks ---"
	$(BUILD_DIR)/test_zero_copy

test-thread-pool: tests/test_thread_pool.c $(GENERATED_VERSION_HEADER)
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_thread_pool.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_thread_pool
	@echo "--- Running thread pool implementation test ---"
	$(BUILD_DIR)/test_thread_pool

test-max-connections-e2e: host tests/test_max_connections_e2e.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_max_connections_e2e.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_max_connections_e2e
	@echo "--- Running E2E max_connections cap test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-maxconn.XXXXXX); \
	port=19128; \
	$(HOST_TARGET) --bind=127.0.0.1 --debug-port=$$port --udp-port=19135 --data-root=$$tmpdir --no-udp-log --no-replace-existing --max-connections=4 >$$tmpdir/payload.log 2>&1 & \
	pid=$$!; \
	trap 'kill -TERM $$pid 2>/dev/null || true; sleep 0.8; kill -KILL $$pid 2>/dev/null || true; wait $$pid 2>/dev/null || true; rm -rf $$tmpdir' EXIT; \
	sleep 0.6; \
	rc=0; $(BUILD_DIR)/test_max_connections_e2e 127.0.0.1 $$port 4 || rc=$$?; \
	notify_count=$$(grep -c 'notify: MemDBG .* connected' $$tmpdir/payload.log || true); \
	echo "  session notifications = $$notify_count (expected 1)"; \
	if [ "$$notify_count" -ne 1 ]; then rc=1; fi; \
	exit $$rc

test-idle-timeout-unit: tests/test_idle_timeout_unit.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_idle_timeout_unit.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_idle_timeout_unit
	@echo "--- Running Idle Timeout unit test ---"
	$(BUILD_DIR)/test_idle_timeout_unit

test-kqueue-timeout: $(BUILD_DIR)/host/pal/pal_wait.o tests/test_kqueue_timeout.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_kqueue_timeout.c $(BUILD_DIR)/host/pal/pal_wait.o $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_kqueue_timeout
	@echo "--- Running kqueue timeout precision test ---"
	$(BUILD_DIR)/test_kqueue_timeout

test-pal-wait-backend-ps4: tests/test_pal_wait_backend_ps4.c src/pal/pal_wait.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) -DPLATFORM_PS4=1 $^ $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_pal_wait_backend_ps4
	@echo "--- Running PS4 wait backend selection test ---"
	$(BUILD_DIR)/test_pal_wait_backend_ps4

test-connection-throughput: host tests/test_connection_throughput.c tests/bench_utils.h
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Isrc $(HOST_CFLAGS) tests/test_connection_throughput.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_connection_throughput
	@echo "--- Running Connection Throughput Benchmarks ---"
	$(BUILD_DIR)/test_connection_throughput

test-idle-timeout-e2e: host tests/test_idle_timeout_e2e.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_idle_timeout_e2e.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_idle_timeout_e2e
	@echo "--- Running E2E idle timeout test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-idle.XXXXXX); \
	port=19136; \
	$(HOST_TARGET) --bind=127.0.0.1 --debug-port=$$port --udp-port=19137 --data-root=$$tmpdir --no-udp-log --no-replace-existing --idle-timeout=3000 >$$tmpdir/payload.log 2>&1 & \
	pid=$$!; \
	trap 'kill -TERM $$pid 2>/dev/null || true; sleep 0.8; kill -KILL $$pid 2>/dev/null || true; wait $$pid 2>/dev/null || true; rm -rf $$tmpdir' EXIT; \
	sleep 0.6; \
	$(BUILD_DIR)/test_idle_timeout_e2e 127.0.0.1 $$port 3000

test-reconnect-e2e: host tests/test_reconnect_e2e.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_reconnect_e2e.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_reconnect_e2e
	@echo "--- Running E2E reconnect resilience test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-reconnect.XXXXXX); \
	port=19140; \
	$(BUILD_DIR)/test_reconnect_e2e 127.0.0.1 $$port \
		$(HOST_TARGET) --bind=127.0.0.1 --debug-port=$$port --data-root=$$tmpdir --no-udp-log --no-replace-existing; \
	rc=$$?; \
	rm -rf $$tmpdir; \
	exit $$rc

test-reconnect-state-machine: host tests/test_reconnect_state_machine.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_reconnect_state_machine.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_reconnect_state_machine
	@echo "--- Running Reconnect State Machine test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-sm.XXXXXX); \
	port=19142; \
	$(BUILD_DIR)/test_reconnect_state_machine 127.0.0.1 $$port \
		$(HOST_TARGET) --bind=127.0.0.1 --debug-port=$$port --data-root=$$tmpdir --no-udp-log --no-replace-existing; \
	rc=$$?; \
	rm -rf $$tmpdir; \
	exit $$rc

test-reconnect-50-restarts: host tests/test_reconnect_50_restarts.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_reconnect_50_restarts.c $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_reconnect_50_restarts
	@echo "--- Running Reconnect 50-Restart Stress Test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-50r.XXXXXX); \
	port=19144; \
	$(BUILD_DIR)/test_reconnect_50_restarts 127.0.0.1 $$port \
		$(HOST_TARGET) --bind=127.0.0.1 --debug-port=$$port --data-root=$$tmpdir --no-udp-log --no-replace-existing; \
	rc=$$?; \
	rm -rf $$tmpdir; \
	exit $$rc

test-memdbg-instance: $(filter-out $(BUILD_DIR)/host/core/main.o,$(HOST_OBJECTS)) tests/test_memdbg_instance.c tests/fixture_memdbg_instance.c tests/fixture_memdbg_instance.h
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_memdbg_instance.c tests/fixture_memdbg_instance.c $(filter-out $(BUILD_DIR)/host/core/main.o,$(HOST_OBJECTS)) $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $(BUILD_DIR)/test_memdbg_instance
	@echo "--- Running memdbg_instance unit tests ---"
	$(BUILD_DIR)/test_memdbg_instance

test-scan-partition: $(BUILD_DIR)/host/scanner/scan/partition.o tests/test_scan_partition.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Isrc $(HOST_CFLAGS) tests/test_scan_partition.c $(BUILD_DIR)/host/scanner/scan/partition.o $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_scan_partition
	@echo "--- Running Scan Partition test ---"
	$(BUILD_DIR)/test_scan_partition

test-scan-protocol: tests/test_scan_protocol.c src/scanner/scan/request.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_scan_protocol.c \
		src/scanner/scan/request.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_scan_protocol
	@echo "--- Running Scan Protocol test ---"
	$(BUILD_DIR)/test_scan_protocol

test-tracer-daemon: src/tracer/memdbg_tracer_daemon.c tests/test_tracer_daemon.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_tracer_daemon.c src/tracer/memdbg_tracer_daemon.c $(HOST_LDFLAGS) -lpthread -o $(BUILD_DIR)/test_tracer_daemon
	@echo "--- Running Tracer daemon lifecycle test ---"
	$(BUILD_DIR)/test_tracer_daemon

test-protocol-abi: tests/test_protocol_abi.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_protocol_abi.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_protocol_abi
	@echo "--- Running Protocol ABI consistency tests ---"
	$(BUILD_DIR)/test_protocol_abi

test-daemon-config-file: tests/test_daemon_config_file.c src/core/daemon/daemon_config_file.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_daemon_config_file.c \
		src/core/daemon/daemon_config_file.c $(HOST_LDFLAGS) $(HOST_LDLIBS) \
		-o $(BUILD_DIR)/test_daemon_config_file
	@echo "--- Running daemon.conf unit tests ---"
	$(BUILD_DIR)/test_daemon_config_file

test-sjson: tests/test_sjson.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_sjson.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_sjson
	@echo "--- Running sJson unit tests ---"
	$(BUILD_DIR)/test_sjson

test-new-features: tests/test_new_features.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) -Isrc/scanner $(HOST_CFLAGS) tests/test_new_features.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_new_features
	@echo "--- Running New Features test ---"
	$(BUILD_DIR)/test_new_features

test-legacy-scanner-e2e: host tests/test_legacy_scanner_e2e.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_legacy_scanner_e2e.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_legacy_scanner_e2e
	@echo "--- Running Legacy Scanner E2E test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-scan.XXXXXX); \
	legacy_port=19130; \
	$(HOST_TARGET) --bind=127.0.0.1 --debug-port=19129 --legacy-compat --legacy-port=$$legacy_port --udp-port=19131 --data-root=$$tmpdir --no-udp-log --no-replace-existing >$$tmpdir/payload.log 2>&1 & \
	pid=$$!; \
	trap 'kill -TERM $$pid 2>/dev/null || true; sleep 0.8; kill -KILL $$pid 2>/dev/null || true; wait $$pid 2>/dev/null || true; rm -rf $$tmpdir' EXIT; \
	sleep 0.6; \
	$(BUILD_DIR)/test_legacy_scanner_e2e 127.0.0.1 $$legacy_port

test-legacy-process-e2e: host tests/test_legacy_process_e2e.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/test_legacy_process_e2e.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/test_legacy_process_e2e
	@echo "--- Running Legacy Process/Memory E2E test ---"
	@tmpdir=$$(mktemp -d /tmp/memdbg-e2e-proc.XXXXXX); \
	legacy_port=19132; \
	$(HOST_TARGET) --bind=127.0.0.1 --debug-port=19133 --legacy-compat --legacy-port=$$legacy_port --udp-port=19134 --data-root=$$tmpdir --no-udp-log --no-replace-existing >$$tmpdir/payload.log 2>&1 & \
	pid=$$!; \
	trap 'kill -TERM $$pid 2>/dev/null || true; sleep 0.8; kill -KILL $$pid 2>/dev/null || true; wait $$pid 2>/dev/null || true; rm -rf $$tmpdir' EXIT; \
	sleep 0.6; \
	$(BUILD_DIR)/test_legacy_process_e2e 127.0.0.1 $$legacy_port

test: test-aob-boundary test-process-aob-e2e test-debugger test-memory test-pal-ebadf test-pal-memory-console test-pal-memory-console-ps4 test-pal-wait-backend-ps4 test-privilege-ps4 test-ps4-debug-gate test-process-map-metadata test-process-map-cache test-debugger-e2e test-debugger-protocol test-lz4 test-scan-partition test-scan-protocol test-tracer-daemon test-new-features test-sjson test-protocol-abi test-daemon-config-file test-legacy-scanner-e2e test-legacy-process-e2e test-thread-pool test-max-connections-e2e test-idle-timeout-e2e test-idle-timeout-unit test-kqueue-timeout test-reconnect-e2e test-reconnect-state-machine test-reconnect-50-restarts test-memdbg-instance fuzz-corpus

# ---- Fuzz harnesses (pure, socket‑free parsers) ----

fuzz-protocol-header: tests/fuzz_protocol_header.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/fuzz_protocol_header.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/fuzz_protocol_header
	@echo "--- Built fuzz_protocol_header ---"

fuzz-lz4: src/util/lz4.c tests/fuzz_lz4.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/fuzz_lz4.c src/util/lz4.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/fuzz_lz4
	@echo "--- Built fuzz_lz4 ---"

fuzz-sjson: tests/fuzz_sjson.c include/memdbg/sjson.h
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/fuzz_sjson.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/fuzz_sjson
	@echo "--- Built fuzz_sjson ---"

fuzz-process-maps: tests/fuzz_process_maps.c
	@mkdir -p $(BUILD_DIR)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) tests/fuzz_process_maps.c $(HOST_LDFLAGS) -o $(BUILD_DIR)/fuzz_process_maps
	@echo "--- Built fuzz_process_maps ---"

# Run initial corpus through all fuzz targets
fuzz-corpus: fuzz-protocol-header fuzz-lz4 fuzz-sjson fuzz-process-maps
	@echo "--- Running initial fuzz corpus ---"
	@for fuzzer in fuzz_protocol_header fuzz_lz4 fuzz_sjson fuzz_process_maps; do \
	  echo "  [$$fuzzer] corpus..."; \
	  for corpus in tests/corpus/*; do \
	    if [ -f "$$corpus" ]; then \
	      $(BUILD_DIR)/$$fuzzer "$$corpus" 2>&1 || { echo "  FAIL: $$fuzzer on $$corpus"; exit 1; }; \
	    fi; \
	  done; \
	done;
	@echo "--- All fuzz corpus tests PASSED ---"
	@echo ""
	@echo "Fuzz targets built. Run manually:"
	@echo "  # Single file:"
	@echo "    ./build/fuzz_protocol_header <file>"
	@echo "    ./build/fuzz_lz4 <file>"
	@echo "    ./build/fuzz_sjson <file>"
	@echo "    ./build/fuzz_process_maps <file>"
	@echo ""
	@echo "  # Via stdin:"
	@echo "    cat <file> | ./build/fuzz_protocol_header"
	@echo ""
	@echo "  # With AFL/libFuzzer (after clang -fsanitize=fuzzer):"
	@echo "    afl-fuzz -i tests/corpus -o findings -- ./build/fuzz_protocol_header @@"

payload-ps4: $(PS4_TARGET)
payload-ps5: $(PS5_TARGET)

payload-ps4-lib: $(PS4_LIB_TARGET)
payload-ps5-lib: $(PS5_LIB_TARGET)

deploy-ps4: $(PS4_TARGET)
	$(PS4_DEPLOY) -h $(PS4_HOST) -p $(PS4_PORT) $<

deploy-ps5: $(PS5_TARGET)
	$(PS5_DEPLOY) -h $(PS5_HOST) -p $(PS5_PORT) $<

TRACER_TOOL := $(BUILD_DIR)/tracer
TRACER_SOURCES := src/tracer/memdbg_tracer.c src/tracer/syscall_names.c src/pal/debug/debug.c

.PHONY: tracer-tool
tracer-tool: $(TRACER_TOOL)

$(TRACER_TOOL): tools/tracer/main.c $(TRACER_SOURCES) $(GENERATED_VERSION_HEADER)
	@mkdir -p $(dir $@)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) \
	  tools/tracer/main.c $(TRACER_SOURCES) $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $@

frontend:
	cmake -S frontend -B $(BUILD_DIR)/frontend -DCMAKE_BUILD_TYPE=Release -DMEMDBG_RELEASE_VERSION="$(MEMDBG_VERSION)"
	cmake --build $(BUILD_DIR)/frontend -j4

test-debugger-disassembly: frontend
	@if [ -x "$(BUILD_DIR)/frontend/bin/Release/memdbg_debugger_disassembly_test.exe" ]; then \
	  "$(BUILD_DIR)/frontend/bin/Release/memdbg_debugger_disassembly_test.exe"; \
	elif [ -x "$(BUILD_DIR)/frontend/bin/memdbg_debugger_disassembly_test.exe" ]; then \
	  "$(BUILD_DIR)/frontend/bin/memdbg_debugger_disassembly_test.exe"; \
	elif [ -x "$(BUILD_DIR)/frontend/bin/Release/memdbg_debugger_disassembly_test" ]; then \
	  "$(BUILD_DIR)/frontend/bin/Release/memdbg_debugger_disassembly_test"; \
	else \
	  "$(BUILD_DIR)/frontend/bin/memdbg_debugger_disassembly_test"; \
	fi

# Standalone host GDB RSP bridge (does not pull ImGui/GLFW FetchContent).
gdb-bridge:
	cmake -S tools/gdb_bridge -B $(BUILD_DIR)/gdb_bridge
	cmake --build $(BUILD_DIR)/gdb_bridge --config Release -j4 --target memdbg_gdb_bridge memdbg_gdb_bridge_test

test-gdb-bridge: gdb-bridge
	@if [ -x "$(BUILD_DIR)/gdb_bridge/Release/memdbg_gdb_bridge_test.exe" ]; then \
	  "$(BUILD_DIR)/gdb_bridge/Release/memdbg_gdb_bridge_test.exe"; \
	elif [ -x "$(BUILD_DIR)/gdb_bridge/Release/memdbg_gdb_bridge_test" ]; then \
	  "$(BUILD_DIR)/gdb_bridge/Release/memdbg_gdb_bridge_test"; \
	else \
	  "$(BUILD_DIR)/gdb_bridge/memdbg_gdb_bridge_test"; \
	fi

# Optional x64dbg plugin (Windows). Fetches official x64dbg-pluginsdk-cmake.zip.
x64dbg-plugin:
	cmake -S tools/x64dbg_plugin -B $(BUILD_DIR)/x64dbg_plugin -A x64 $(if $(MEMDBG_X64DBG_SDK),-DMEMDBG_X64DBG_SDK="$(MEMDBG_X64DBG_SDK)",)
	cmake --build $(BUILD_DIR)/x64dbg_plugin --config Release -j4 --target memdbg_x64dbg_plugin

test-x64dbg-plugin-util:
	cmake -S tools/x64dbg_plugin -B $(BUILD_DIR)/x64dbg_plugin -A x64 $(if $(MEMDBG_X64DBG_SDK),-DMEMDBG_X64DBG_SDK="$(MEMDBG_X64DBG_SDK)",)
	cmake --build $(BUILD_DIR)/x64dbg_plugin --config Release -j4 --target memdbg_x64dbg_plugin_util_test
	@if [ -x "$(BUILD_DIR)/x64dbg_plugin/Release/memdbg_x64dbg_plugin_util_test.exe" ]; then \
	  "$(BUILD_DIR)/x64dbg_plugin/Release/memdbg_x64dbg_plugin_util_test.exe"; \
	elif [ -x "$(BUILD_DIR)/x64dbg_plugin/Release/memdbg_x64dbg_plugin_util_test" ]; then \
	  "$(BUILD_DIR)/x64dbg_plugin/Release/memdbg_x64dbg_plugin_util_test"; \
	else \
	  "$(BUILD_DIR)/x64dbg_plugin/memdbg_x64dbg_plugin_util_test"; \
	fi

check-locales:
	python3 tools/check_locales.py

check-headers:
	python3 tools/check_headers.py

verify:
	$(MAKE) clean
	$(MAKE) host
	$(MAKE) payload-ps4
	$(MAKE) payload-ps5

# ---- Sanitizer targets (use system clang, not HOST_CC) ----
SAN_CPPFLAGS := -I$(GENERATED_INCLUDE_DIR) -Iinclude -Isrc/core/daemon -D_DARWIN_C_SOURCE -D_POSIX_C_SOURCE=200809L

host-asan:
	$(MAKE) clean
	$(MAKE) host HOST_CC=clang \
		HOST_CPPFLAGS="$(SAN_CPPFLAGS)" \
		HOST_CFLAGS="-std=c11 -Wall -Wextra -Wpedantic -O1 -g -fsanitize=address -fno-omit-frame-pointer" \
		HOST_LDFLAGS="-fsanitize=address"
	@echo "Built with AddressSanitizer. Run with: ASAN_OPTIONS=detect_leaks=1 ./build/MemDBG-host"

host-ubsan:
	$(MAKE) clean
	$(MAKE) host HOST_CC=clang \
		HOST_CPPFLAGS="$(SAN_CPPFLAGS)" \
		HOST_CFLAGS="-std=c11 -Wall -Wextra -Wpedantic -O1 -g -fsanitize=undefined -fno-sanitize-recover=all" \
		HOST_LDFLAGS="-fsanitize=undefined"
	@echo "Built with UBSan. Run with: UBSAN_OPTIONS=halt_on_error=1 ./build/MemDBG-host"

host-tsan:
	$(MAKE) clean
	$(MAKE) host HOST_CC=clang \
		HOST_CPPFLAGS="$(SAN_CPPFLAGS)" \
		HOST_CFLAGS="-std=c11 -Wall -Wextra -Wpedantic -O1 -g -fsanitize=thread" \
		HOST_LDFLAGS="-fsanitize=thread"
	@echo "Built with ThreadSanitizer. Run with: TSAN_OPTIONS=history_size=7 ./build/MemDBG-host"

$(HOST_TARGET): $(HOST_OBJECTS)
	@mkdir -p $(dir $@)
	$(HOST_CC) $^ $(HOST_LDFLAGS) $(HOST_LDLIBS) -o $@

$(GENERATED_VERSION_HEADER): $(VERSION_FILE) FORCE
	@mkdir -p $(dir $@)
	@tmp="$@.tmp"; \
	{ \
	  printf '/*\n'; \
	  printf ' * memDBG - Generated project version header.\n'; \
	  printf ' * Copyright (C) 2026 SeregonWar\n'; \
	  printf ' * SPDX-License-Identifier: GPL-3.0-or-later\n'; \
	  printf ' */\n\n'; \
	  printf '#ifndef MEMDBG_CORE_MEMDBG_VERSION_H\n'; \
	  printf '#define MEMDBG_CORE_MEMDBG_VERSION_H\n\n'; \
	  printf '#define MEMDBG_VERSION_MAJOR %sU\n' "$(MEMDBG_VERSION_MAJOR)"; \
	  printf '#define MEMDBG_VERSION_MINOR %sU\n' "$(MEMDBG_VERSION_MINOR)"; \
	  printf '#define MEMDBG_VERSION_PATCH %sU\n' "$(MEMDBG_VERSION_PATCH)"; \
	  printf '#define MEMDBG_VERSION_STRING "%s"\n\n' "$(MEMDBG_VERSION)"; \
	  printf '#endif /* MEMDBG_CORE_MEMDBG_VERSION_H */\n'; \
	} > "$$tmp"; \
	if [ -f "$@" ] && cmp -s "$$tmp" "$@"; then rm "$$tmp"; else mv "$$tmp" "$@"; fi

$(BUILD_DIR)/host/%.o: src/%.c $(GENERATED_VERSION_HEADER)
	@mkdir -p $(dir $@)
	$(HOST_CC) $(HOST_CPPFLAGS) $(HOST_CFLAGS) -MMD -MP -MF $(@:.o=.d) -c $< -o $@

$(PS4_TARGET): $(PS4_OBJECTS)
	@mkdir -p $(dir $@)
	$(PS4_CC) $^ -lpthread -o $@

$(PS4_LIB_TARGET): $(PS4_LIB_OBJECTS)
	@mkdir -p $(dir $@)
	$(PS4_AR) rcs $@ $^

$(PS5_TARGET): $(PS5_OBJECTS) $(PS5_ZYDIS_OBJECTS) $(PS5_ZYCORE_OBJECTS)
	@mkdir -p $(dir $@)
	$(PS5_CC) $^ $(PS5_KEYSTONE_LDLIBS) -lpthread -lunwind -lc++ -lc++abi -o $@

$(PS5_LIB_TARGET): $(PS5_LIB_OBJECTS)
	@mkdir -p $(dir $@)
	$(PS5_AR) rcs $@ $^

$(BUILD_DIR)/ps4/%.o: src/%.c $(GENERATED_VERSION_HEADER)
	@mkdir -p $(dir $@)
	$(PS4_CC) $(COMMON_CPPFLAGS) -DPLATFORM_PS4=1 $(CONSOLE_WERROR_FLAG) $(CONSOLE_CFLAGS) -MMD -MP -MF $(@:.o=.d) -c $< -o $@

$(BUILD_DIR)/ps4-lib/%.o: src/%.c $(GENERATED_VERSION_HEADER)
	@mkdir -p $(dir $@)
	$(PS4_CC) $(COMMON_CPPFLAGS) -DPLATFORM_PS4=1 -DMEMDBG_NO_MAIN=1 $(CONSOLE_WERROR_FLAG) $(CONSOLE_CFLAGS) -MMD -MP -MF $(@:.o=.d) -c $< -o $@

$(BUILD_DIR)/ps5/%.o: src/%.c $(GENERATED_VERSION_HEADER)
	@mkdir -p $(dir $@)
	$(PS5_CC) $(COMMON_CPPFLAGS) -I$(ZYDIS_DIR)/include -I$(ZYCORE_DIR)/include $(PS5_KEYSTONE_CPPFLAGS) -DPLATFORM_PS5=1 -DMEMDBG_HAS_ZYDIS=1 -mavx2 $(CONSOLE_WERROR_FLAG) $(CONSOLE_CFLAGS) -MMD -MP -MF $(@:.o=.d) -c $< -o $@

$(BUILD_DIR)/ps5-lib/%.o: src/%.c $(GENERATED_VERSION_HEADER)
	@mkdir -p $(dir $@)
	$(PS5_CC) $(COMMON_CPPFLAGS) -I$(ZYDIS_DIR)/include -I$(ZYCORE_DIR)/include $(PS5_KEYSTONE_CPPFLAGS) -DPLATFORM_PS5=1 -DMEMDBG_NO_MAIN=1 -DMEMDBG_HAS_ZYDIS=1 -mavx2 $(CONSOLE_WERROR_FLAG) $(CONSOLE_CFLAGS) -MMD -MP -MF $(@:.o=.d) -c $< -o $@

# Zydis disassembler objects (cross-compiled for PS5)
$(BUILD_DIR)/ps5-zydis/%.o: $(ZYDIS_DIR)/src/%.c
	@mkdir -p $(dir $@)
	$(PS5_CC) $(ZYDIS_PS5_CFLAGS) -c $< -o $@

$(BUILD_DIR)/ps5-zycore/%.o: $(ZYCORE_DIR)/src/%.c
	@mkdir -p $(dir $@)
	$(PS5_CC) $(ZYDIS_PS5_CFLAGS) -c $< -o $@

clean:
	rm -rf $(BUILD_DIR)