Add a freestanding compile check

Author: patkenneally

.github/freestanding/smoketest.cpp

@@ -0,0 +1,58 @@
+// Translation unit for the freestanding compile check
+// (.github/scripts/check_freestanding.sh).
+//
+// It pulls in the modules the downstream flight software uses, because the
+// freestanding configuration is guarded module by module: a macro or shim that
+// is wrong for Geometry or Eigenvalues will not show up from Eigen/Core alone.
+// Nothing here needs to run -- the check is compile-only, and the bugs it exists
+// to catch (a leaked macro, a stray #pragma message) surface while the
+// preprocessor and front end walk these headers.
+
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#include <Eigen/Eigenvalues>
+#include <Eigen/SVD>
+#include <Eigen/LU>
+
+// Instantiate a little of each module so the definitions are actually walked
+// rather than just parsed. Kept to float and double, the two scalar types the
+// flight software uses.
+namespace {
+
+template <typename Scalar>
+void touchEveryModule() {
+    using Vector3 = Eigen::Matrix<Scalar, 3, 1>;
+    using Matrix3 = Eigen::Matrix<Scalar, 3, 3>;
+
+    Vector3 a = Vector3::Zero();
+    Vector3 b = Vector3::UnitZ();
+    Matrix3 m = Matrix3::Identity();
+
+    // Core
+    (void)a.dot(b);
+    (void)a.norm();
+    (void)(m * a);
+
+    // Geometry: declared in Eigen/Core, defined in Eigen/src/Geometry.
+    (void)a.cross(b);
+    (void)b.unitOrthogonal();
+
+    // LU
+    (void)m.determinant();
+
+    // Eigenvalues
+    Eigen::SelfAdjointEigenSolver<Matrix3> eig(m);
+    (void)eig.eigenvalues();
+
+    // SVD
+    Eigen::JacobiSVD<Matrix3> svd(m, Eigen::ComputeFullU | Eigen::ComputeFullV);
+    (void)svd.singularValues();
+}
+
+}  // namespace
+
+int main() {
+    touchEveryModule<float>();
+    touchEveryModule<double>();
+    return 0;
+}

.github/scripts/check_freestanding.sh

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+# check_freestanding.sh
+#
+# Compiles .github/freestanding/smoketest.cpp in both configurations this fork
+# has to support, and fails if the compiler says anything at all.
+#
+# Why "anything at all" rather than just a non-zero exit: the defects this check
+# exists to catch are not errors. When the freestanding guards were added,
+# GeneralBlockPanelKernel.h's four #undef PACKET_DECL_COND* lines ended up inside
+# an #ifndef EIGEN_FREESTANDING block, so in freestanding builds the macros
+# leaked out of Eigen/Core and one of them was redefined in
+# GeneralMatrixVector.h. Every downstream translation unit warned; nothing
+# failed. Same for the unconditional #pragma message in all_freestanding.hpp.
+# Both are invisible to a check that only looks at the exit status.
+#
+# Both configurations are checked because the two can break independently: the
+# macro leak appeared only with EIGEN_FREESTANDING defined, and a careless fix
+# could break the hosted path instead.
+#
+# Usage:  check_freestanding.sh
+# Environment:
+#   EIGEN3_DIR  Root of the Eigen checkout (the directory containing 'Eigen/').
+#               Defaults to the repository root, so it normally needs no setting.
+#   CXX         Compiler to use. Defaults to g++-13, the version the downstream
+#               flight software builds with.
+
+set -euo pipefail
+
+CXX="${CXX:-g++-13}"
+
+if ! REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)"; then
+  REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+fi
+EIGEN3_DIR="${EIGEN3_DIR:-$REPO_ROOT}"
+
+if [[ ! -d "${EIGEN3_DIR}/Eigen" ]]; then
+  echo "Eigen not found under ${EIGEN3_DIR}" >&2
+  exit 2
+fi
+if ! command -v "${CXX}" >/dev/null 2>&1; then
+  echo "Compiler '${CXX}' not found; set CXX to an available compiler." >&2
+  exit 2
+fi
+
+TU="${REPO_ROOT}/.github/freestanding/smoketest.cpp"
+if [[ ! -f "$TU" ]]; then
+  echo "Translation unit not found: $TU" >&2
+  exit 2
+fi
+
+FORCE_INCLUDE="${EIGEN3_DIR}/Eigen/src/Freestanding/all_freestanding.hpp"
+# -Wundef matters specifically: Eigen's own test suite compiles with it, and the
+# freestanding guards are the kind of thing that gets written as `!EIGEN_FREESTANDING`
+# instead of `!defined(EIGEN_FREESTANDING)`, which silently evaluates to 0 in every
+# hosted translation unit. Not -Wall/-Wextra yet: the freestanding stubs in
+# Memory.h have pre-existing unused-parameter warnings that need fixing first.
+COMMON=(-std=gnu++23 -fsyntax-only -Wundef -I"${EIGEN3_DIR}")
+
+FAILURES=0
+
+# $1 = human-readable configuration name, remaining args = extra compiler flags
+check_config() {
+  local name="$1"
+  shift
+
+  local output
+  if ! output="$("${CXX}" "${COMMON[@]}" "$@" "$TU" 2>&1)" || [[ -n "$output" ]]; then
+    echo "::error::${name} configuration is not clean"
+    echo "$output" | sed 's/^/    /'
+    FAILURES=$((FAILURES + 1))
+  else
+    echo "  ${name}: clean"
+  fi
+}
+
+echo "Checking ${TU#"$REPO_ROOT"/} with ${CXX}"
+check_config "freestanding" -DEIGEN_FREESTANDING=1 -include "${FORCE_INCLUDE}"
+check_config "hosted"
+
+# Approximates a non-x86 target on an x86 runner. EIGEN_HAS_CXX11_MATH is 1 on
+# x86 (Macros.h requires EIGEN_ARCH_i386_OR_x86_64), which short-circuits
+# MathFunctions.h:503 and hides anything the branch below it depends on. Forcing
+# it to 0 exercises that path without a cross toolchain -- it is how the
+# EIGEN_HAS_C99_MATH block was found to be trapped inside a freestanding guard.
+check_config "freestanding, non-x86 math path" \
+  -DEIGEN_FREESTANDING=1 -DEIGEN_HAS_CXX11_MATH=0 -include "${FORCE_INCLUDE}"
+
+if [[ $FAILURES -gt 0 ]]; then
+  echo ""
+  echo "${FAILURES} configuration(s) produced compiler output."
+  exit 1
+fi
+
+echo "All configurations compile silently."

.github/workflows/README.md

@@ -1,10 +1,11 @@
 # CI in this fork
 
-This is a LASP fork of Eigen 3.4. The CI here is deliberately small: it covers what
-the fork actually needs rather than upstream's full validation matrix.
+This is a LASP fork of Eigen 3.4 whose purpose is freestanding support, so the CI
+here covers that, not upstream's full validation matrix.
 
 | Workflow | What it does |
 |---|---|
+| `freestanding.yml` | Compiles `Eigen/{Core,Geometry,Eigenvalues,SVD,LU}` in three configurations — freestanding, hosted, and freestanding with `EIGEN_HAS_CXX11_MATH=0` (which approximates a non-x86 target) — and fails on *any* compiler output. Seconds to run. |
 | `smoketests.yml` | Builds and runs Eigen's smoke test subset (`cmake/EigenSmokeTestList.cmake`, 105 resolve in the CI configuration) under gcc-13 with `EIGEN_TEST_CXX11` on and off, and under clang-18 with it on. |
 
 Upstream's own CI is GitLab and lives in `.gitlab-ci.yml` plus `ci/`. It still runs

.github/workflows/freestanding.yml

@@ -0,0 +1,37 @@
+name: Freestanding
+
+# Compiles Eigen in the freestanding configuration this fork exists to provide,
+# and in the hosted configuration, failing if the compiler emits anything.
+#
+# This is the only CI here that covers the fork's actual purpose. Upstream's test
+# matrix never defines EIGEN_FREESTANDING, so it cannot catch a defect that only
+# appears in freestanding builds -- which is exactly what the leaked
+# PACKET_DECL_COND* macros were. See .github/scripts/check_freestanding.sh.
+#
+# Cheap enough (two -fsyntax-only compiles) to run on every push.
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+  push:
+    branches: [feature/freestanding]
+  workflow_dispatch:
+
+jobs:
+  freestanding:
+    name: freestanding compile check
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install compiler
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y --no-install-recommends g++-13
+
+      - name: Check freestanding and hosted configurations
+        env:
+          CXX: g++-13
+        run: ./.github/scripts/check_freestanding.sh