feat: Tool enhancements

- Add ghc-pkg --target support
- Improve ghc-pkg UnitFlags handling
- Rename iserv to ghc-iserv
- Update tool configurations

Author: GHC GitLab CI

.gitmodules

@@ -10,7 +10,7 @@
 	path = libraries/Cabal
 	url = https://github.com/stable-haskell/cabal
 	ignore = untracked
-	branch = andrea/cross-compile
+	branch = stable-haskell/feature/cross-compile
 [submodule "libraries/containers"]
 	path = libraries/containers
 	url = https://gitlab.haskell.org/ghc/packages/containers.git

Makefile

@@ -5,6 +5,79 @@
 # The whole version replacement therapy is utterly ridiculous. It should be done
 # in the respective packages.
 
+# ┌─────────────────────────────────────────────────────────────────────────┐
+# │                        GHC Bootstrapping Stages                         │
+# ├─────────────────────────────────────────────────────────────────────────┤
+# │                                                                         │
+# │  Stage 0 (Bootstrap)                                                    │
+# │  ┌─────────┐     ┌─────────┐                                            │
+# │  │  ghc0   │     │  pkg0   │  (initial boot packages)                   │
+# │  │ (binary)│     │         │                                            │
+# │  └────┬────┘     └────┬────┘                                            │
+# │       │               │                                                 │
+# │       └───────┬───────┘                                                 │
+# │               ▼                                                         │
+# │         ┌─────────┐                                                     │
+# │         │  pkg0+  │  (augmented boot packages)                          │
+# │         └────┬────┘                                                     │
+# │              │                                                          │
+# │  ············│························································· │
+# │              ▼                                                          │
+# │  Stage 1     │                                                          │
+# │  ┌─────────┐ │                                                          │
+# │  │  ghc1   │◄┘  (built with ghc0, linked with rts0)                     │
+# │  │         │                                                            │
+# │  └────┬────┘                                                            │
+# │       │                                                                 │
+# │       │     ┌─────────┐                                                 │
+# │       └────►│  pkg1   │  (initially empty, then populated)              │
+# │       ┌─────│         │  (built with ghc1)                              │
+# │       │     └─────────┘                                                 │
+# │       │           ▲                                                     │
+# │       │           │ (mutual dependency; ghc1 needs to sees pkg1)        │
+# │       ▼           │                                                     │
+# │  ┌─────────┐      │                                                     │
+# │  │  ghc1   │──────┘                                                     │
+# │  │ (uses)  │                                                            │
+# │  └────┬────┘                                                            │
+# │       │                                                                 │
+# │  ·····│································································ │
+# │       ▼                                                                 │
+# │  Stage 2                                                                │
+# │  ┌─────────┐  ┌──────────┐  ┌─────────┐                                 │
+# │  │  ghc2   │  │ ghc-pkg2 │  │  ...    │                                 │
+# │  │         │  │          │  │         │                                 │
+# │  └─────────┘  └──────────┘  └─────────┘                                 │
+# │  (built with ghc1, linked with rts1)                                    │
+# │                                                                         │
+# │  ┌─────────────────────────────────┐                                    │
+# │  │        SHIPPED RESULT           │                                    │
+# │  │  ┌─────────┐   ┌─────────┐      │                                    │
+# │  │  │  pkg1   │ + │  ghc2   │      │                                    │
+# │  │  └─────────┘   └─────────┘      │                                    │
+# │  └─────────────────────────────────┘                                    │
+# │                                                                         │
+# │  Notes:                                                                 │
+# │  • Binaries: one stage ahead (ghc1 builds pkg1, ghc2 ships with pkg1)   │
+# │  • Libraries: one stage below (pkg1 ships with ghc2)                    │
+# │  • ghc1 and ghc2 are ABI compatible                                     |
+# |  • ghc0 and ghc1 are not guaruateed to be ABI compatible                |
+# │  • ghc1 is linked against rts0, ghc2 against rts1                       │
+# |  • augmented packages are needed because ghc1 may require newer         |
+# |    versions or even new pacakges, not shipped with the boot compiler    |
+# │                                                                         │
+# └─────────────────────────────────────────────────────────────────────────┘
+
+
+# ISSUES:
+# - [ ] Where do we get the version number from? The configure script _does_ contain
+#       one and sets it, but should it come from the last release tag this branch is
+#       contains?
+# - [ ] HADRIAN_SETTINGS needs to be removed.
+# - [ ] The hadrian folder needs to be removed.
+# - [ ] All sublibs should be SRPs in the relevant cabal.project files. No more
+#       submodules.
+
 SHELL := bash
 .SHELLFLAGS := -eu -o pipefail -O globstar -c
 
@@ -25,9 +98,10 @@ override CABAL_ARGS += \
 	--logs-dir=_build/$(STAGE)/logs
 
 override CABAL_BUILD_ARGS += \
-	-j -v -w $(GHC) --with-gcc=$(CC) \
+	-j -w $(GHC) --with-gcc=$(CC) \
 	--project-file=cabal.project.$(STAGE) \
-	--builddir=_build/$(STAGE)
+	--builddir=_build/$(STAGE) \
+	--ghc-options="-fhide-source-paths"
 
 # just some defaults
 STAGE ?= stage1
@@ -60,25 +134,6 @@ define HADRIAN_SETTINGS
 ]
 endef
 
-define run_and_log
-@set -e; \
-LOGDIR=$(@D)/../logs; \
-mkdir -p "$$LOGDIR"; \
-STDOUT_LOG="$$LOGDIR/$(notdir $@).stdout.log"; \
-STDERR_LOG="$$LOGDIR/$(notdir $@).stderr.log"; \
-echo "+ $(1)"; \
-( { $(1); } >"$$STDOUT_LOG" 2>"$$STDERR_LOG" ) || { \
-  if [ -s "$$STDERR_LOG" ]; then \
-    cat "$$STDERR_LOG"; \
-    echo "See logs: $$STDERR_LOG (stderr), $$STDOUT_LOG (stdout)"; \
-  elif [ -s "$$STDOUT_LOG" ]; then \
-    cat "$$STDOUT_LOG"; \
-    echo "See logs: $$STDERR_LOG (stderr), $$STDOUT_LOG (stdout)"; \
-  fi; \
-  exit 1; \
-}
-endef
-
 # Handle CPUS and THREADS
 CPUS_DETECT_SCRIPT := ./mk/detect-cpu-count.sh
 CPUS := $(shell if [ -x $(CPUS_DETECT_SCRIPT) ]; then $(CPUS_DETECT_SCRIPT); else echo 2; fi)
@@ -184,13 +239,13 @@ $(abspath _build/stage0/bin/cabal): _build/stage0/bin/cabal
 # This just builds cabal-install, which is used to build the rest of the project.
 
 # We need an absolute path here otherwise cabal will consider the path relative to `the project directory
-_build/stage0/bin/cabal: BUILD_ARGS=-j -w $(GHC0) --disable-tests --project-dir libraries/Cabal --builddir=$(abspath _build/stage0)
+_build/stage0/bin/cabal: BUILD_ARGS=-j -w $(GHC0) --disable-tests --project-dir libraries/Cabal --builddir=$(abspath _build/stage0) --ghc-options="-fhide-source-paths"
 _build/stage0/bin/cabal:
-	@echo ">>> Building Cabal..."
+	@echo "::group::Building Cabal..."
 	@mkdir -p _build/stage0/bin _build/logs
 	cabal build $(BUILD_ARGS) cabal-install:exe:cabal
 	cp -rfp $(shell cabal list-bin -v0 $(BUILD_ARGS) cabal-install:exe:cabal) _build/stage0/bin/cabal
-	@echo ">>> Cabal built successfully."
+	@echo "::endgroup::"
 
 # --- Stage 1 build ---
 
@@ -199,20 +254,34 @@ _build/stage1/%: private GHC=$(GHC0)
 
 .PHONY: $(addprefix _build/stage1/bin/,$(STAGE1_EXECUTABLES))
 $(addprefix _build/stage1/bin/,$(STAGE1_EXECUTABLES)) &: $(CABAL) | _build/booted
+	@echo "::group::Building stage1 executables ($(STAGE1_EXECUTABLES))..."
 	# Force cabal to replan
 	rm -rf _build/stage1/cache
-	$(call run_and_log, HADRIAN_SETTINGS='$(HADRIAN_SETTINGS)' \
-		$(CABAL_BUILD) $(STAGE1_TARGETS))
+	HADRIAN_SETTINGS='$(HADRIAN_SETTINGS)' $(CABAL_BUILD) $(STAGE1_TARGETS)
+	@echo "::endgroup::"
 
 _build/stage1/lib/settings: _build/stage1/bin/ghc-toolchain-bin
+	@echo "::group::Creating settings for $(TARGET_TRIPLE)..."
 	@mkdir -p $(@D)
-	$(call run_and_log, _build/stage1/bin/ghc-toolchain-bin --triple $(TARGET_TRIPLE) --output-settings -o $@ --cc $(CC) --cxx $(CXX))
+	_build/stage1/bin/ghc-toolchain-bin --triple $(TARGET_TRIPLE) --output-settings -o $@ --cc $(CC) --cxx $(CXX)
+	@echo "::endgroup::"
 
+# The somewhat strange thing is, we might not even need this at all now anymore. cabal seems to
+# pass all the necessary flags correctly. Thus even with an _empty_ package-db here (and it will
+# stay empty until we are done with the build), the build succeeds.
+#
+# For now, we are tying the knot here by making sure the stage1 compiler (stage1/bin/ghc) sees
+# the packages it builds (to build stage2/bin/ghc), by symlining cabal's target package-db into
+# the compilers global package-db. Another maybe even better solution might be to set the
+# Global Package DB in the settings file to the absolute path where cabal will place the
+# package db. This would elminate this rule outright.
 _build/stage1/lib/package.conf.d/package.cache: _build/stage1/bin/ghc-pkg _build/stage1/lib/settings
+	@echo "::group::Creating stage1 package cache..."
 	@mkdir -p _build/stage1/lib/package.conf.d
-	@rm -rf _build/stage1/lib/package.conf.d/*
-	cp -rfp _build/stage1/packagedb/host/*/* _build/stage1/lib/package.conf.d
-	_build/stage1/bin/ghc-pkg recache
+# 	@mkdir -p _build/stage2/packagedb/host
+# 	ln -s $(abspath ./_build/stage2/packagedb/host/ghc-9.13) _build/stage1/lib/package.conf.d
+# 	_build/stage1/bin/ghc-pkg init $(abspath ./_build/stage2/packagedb/host/ghc-9.13)
+	@echo "::endgroup::"
 
 _build/stage1/lib/template-hsc.h: utils/hsc2hs/data/template-hsc.h
 	@mkdir -p $(@D)
@@ -228,22 +297,26 @@ _build/stage2/%: private GHC=$(realpath _build/stage1/bin/ghc)
 
 .PHONY: $(addprefix _build/stage2/bin/,$(STAGE2_EXECUTABLES))
 $(addprefix _build/stage2/bin/,$(STAGE2_EXECUTABLES)) &: $(CABAL) stage1
+	@echo "::group::Building stage2 executables ($(STAGE2_EXECUTABLES))..."
 	# Force cabal to replan
 	rm -rf _build/stage2/cache
-	$(call run_and_log, HADRIAN_SETTINGS='$(HADRIAN_SETTINGS)' \
+	HADRIAN_SETTINGS='$(HADRIAN_SETTINGS)' \
 		PATH=$(PWD)/_build/stage1/bin:$(PATH) \
-		$(CABAL_BUILD) --ghc-options="-ghcversion-file=$(abspath ./rts/include/ghcversion.h)" -W $(GHC0) $(STAGE2_TARGETS) )
+		$(CABAL_BUILD) --ghc-options="-ghcversion-file=$(abspath ./rts/include/ghcversion.h)" -W $(GHC0) $(STAGE2_TARGETS)
+	@echo "::endgroup::"
 
 # Do we want to build these with the stage2 GHC or the stage1 GHC?
 # Traditionally we build them with the stage1 ghc, but we could just as well
 # build them with the stage2 ghc; seems like a better/cleaner idea to me (moritz).
 .PHONY: $(addprefix _build/stage2/bin/,$(STAGE2_UTIL_EXECUTABLES))
 $(addprefix _build/stage2/bin/,$(STAGE2_UTIL_EXECUTABLES)) &: $(CABAL) stage1
+	@echo "::group::Building stage2 utilities ($(STAGE2_UTIL_EXECUTABLES))..."
 	# Force cabal to replan
 	rm -rf _build/stage2/cache
-	$(call run_and_log, HADRIAN_SETTINGS='$(HADRIAN_SETTINGS)' \
+	HADRIAN_SETTINGS='$(HADRIAN_SETTINGS)' \
 		PATH=$(PWD)/_build/stage1/bin:$(PATH) \
-		$(CABAL_BUILD) --ghc-options="-ghcversion-file=$(abspath ./rts/include/ghcversion.h)" -W $(GHC0) $(STAGE2_UTIL_TARGETS) )
+		$(CABAL_BUILD) --ghc-options="-ghcversion-file=$(abspath ./rts/include/ghcversion.h)" -W $(GHC0) $(STAGE2_UTIL_TARGETS)
+	@echo "::endgroup::"
 
 
 # # We use PATH=... here to ensure all the build-tool-depends (deriveConstants, genapply, genprimopcode, ...) are
@@ -279,10 +352,12 @@ _build/stage2/lib/settings: _build/stage1/lib/settings
 	cp -rfp _build/stage1/lib/settings _build/stage2/lib/settings
 
 _build/stage2/lib/package.conf.d/package.cache: _build/stage2/bin/ghc-pkg _build/stage2/lib/settings
+	@echo "::group::Creating stage2 package cache..."
 	@mkdir -p _build/stage2/lib/package.conf.d
 	@rm -rf _build/stage2/lib/package.conf.d/*
 	cp -rfp _build/stage2/packagedb/host/*/* _build/stage2/lib/package.conf.d
 	_build/stage2/bin/ghc-pkg recache
+	@echo "::endgroup::"
 
 _build/stage2/lib/template-hsc.h: utils/hsc2hs/data/template-hsc.h
 	@mkdir -p $(@D)
@@ -293,7 +368,7 @@ stage2: $(addprefix _build/stage2/bin/,$(STAGE2_EXECUTABLES)) _build/stage2/lib/
 
 # Target for creating the final binary distribution directory
 _build/bindist: stage2 driver/ghc-usage.txt driver/ghci-usage.txt
-	@echo "Creating binary distribution in _build/bindist"
+	@echo "::group::Creating binary distribution in _build/bindist"
 	@mkdir -p _build/bindist/bin
 	@mkdir -p _build/bindist/lib
 	# Copy executables from stage2 bin
@@ -305,61 +380,66 @@ _build/bindist: stage2 driver/ghc-usage.txt driver/ghci-usage.txt
 	@cp -rfp driver/ghci-usage.txt _build/bindist/lib/
 	@echo "FIXME: Changing 'Support SMP' from YES to NO in settings file"
 	@sed 's/("Support SMP","YES")/("Support SMP","NO")/' -i.bck _build/bindist/lib/settings
-	@echo "Binary distribution created."
+	@echo "::endgroup::"
 
 # --- Configuration ---
 
 $(GHC1) $(GHC2): | hackage
 hackage: _build/packages/hackage.haskell.org/01-index.tar.gz
 _build/packages/hackage.haskell.org/01-index.tar.gz: | $(CABAL)
+	@echo "::group::Updating Hackage index..."
 	@mkdir -p $(@D)
 	$(CABAL) $(CABAL_ARGS) update --index-state 2025-04-22T01:25:40Z
+	@echo "::endgroup::"
 
 # booted depends on successful source preparation
 _build/booted:
-	@echo ">>> Running ./boot script..."
+	@echo "::group::Running ./boot script..."
 	@mkdir -p _build/logs
-	./boot |& tee _build/logs/boot.log
-	@echo ">>> Running ./configure script..."
-	$(call run_and_log, ./configure)
+	./boot
+	@echo "::endgroup::"
+	@echo "::group::Running ./configure script..."
+	./configure
+	@echo "::endgroup::"
 	touch $@
 
 # --- Clean Targets ---
 clean:
-	@echo ">>> Cleaning build artifacts..."
+	@echo "::group::Cleaning build artifacts..."
 	rm -rf _build
-	@echo ">>> Build artifacts cleaned."
+	@echo "::endgroup::"
 
 clean-stage1:
-	@echo ">>> Cleaning stage1 build artifacts..."
+	@echo "::group::Cleaning stage1 build artifacts..."
 	rm -rf _build/stage1
-	@echo ">>> Stage1 build artifacts cleaned."
+	@echo "::endgroup::"
 
 clean-stage2:
-	@echo ">>> Cleaning stage2 build artifacts..."
+	@echo "::group::Cleaning stage2 build artifacts..."
 	rm -rf _build/stage2
-	@echo ">>> Stage2 build artifacts cleaned."
+	@echo "::endgroup::"
 
 distclean: clean
-	@echo ">>> Cleaning all generated files (distclean)..."
+	@echo "::group::Cleaning all generated files (distclean)..."
 	rm -rf autom4te.cache
 	rm -f config.status config.log config.h configure aclocal.m4
 	rm -rf build-aux/config.guess build-aux/config.sub build-aux/install-sh build-aux/missing build-aux/compile depcomp
 	find . -name 'Makefile.in' -delete
 	rm -f $(CONFIGURED_FILES)
-	@echo ">>> All generated files cleaned."
+	@echo "::endgroup::"
 
 
 # --- Test Target ---
 test: _build/bindist
-	@echo ">>> Running tests with THREADS=${THREADS}" >&2
+	@echo "::group::Running tests with THREADS=${THREADS}" >&2
 	TEST_HC=`pwd`/_build/bindist/bin/ghc \
 	TEST_CC=$(CC) \
 	TEST_CXX=$(CXX) \
 	METRICS_FILE=`pwd`/_build/test-perf.csv \
 	SUMMARY_FILE=`pwd`/_build/test-summary.txt \
 	JUNIT_FILE=`pwd`/_build/test-junit.xml \
 	make -C testsuite/tests test THREADS=${THREADS}
+	@echo "::endgroup::" >&2
 
 # Inform Make that these are not actual files if they get deleted by other means
 .PHONY: clean distclean test all