Add target ACCTON_GFF4(STM32F405RGT6)

.github/scripts/extract-size-report.sh

@@ -0,0 +1,68 @@
+#!/bin/bash
+#
+# Run the size tool on every built .elf and write a small JSON report of
+# flash/RAM usage per target, consumed by ci-size-report.yml.
+#
+# Usage: extract-size-report.sh <build-dir> <output-json> [size-tool]
+#
+# flash = .text + .data (what's programmed into flash)
+# ram   = .data + .bss  (what's reserved in RAM at runtime)
+#
+# Runs inside the (unprivileged) build job on the PR's own checkout, so a
+# PR could in principle modify this script to misreport its own numbers.
+# Accepted tradeoff: this feature is informational/non-gating, and a real
+# overflow still fails the link step regardless of what this script says.
+
+set -euo pipefail
+
+BUILD_DIR=${1:?usage: extract-size-report.sh <build-dir> <output-json> [size-tool]}
+OUTPUT_JSON=${2:?usage: extract-size-report.sh <build-dir> <output-json> [size-tool]}
+SIZE_TOOL=${3:-}
+
+if [ -z "$SIZE_TOOL" ]; then
+    if command -v arm-none-eabi-size >/dev/null 2>&1; then
+        SIZE_TOOL=arm-none-eabi-size
+    else
+        # cmake/arm-none-eabi-checks.cmake downloads its own toolchain into
+        # tools/ and adds it to PATH — but only inside that cmake process
+        # via set(ENV{PATH} ...), which doesn't persist to a later CI step's
+        # shell. Fall back to the same location CMake would have used,
+        # relative to the repo root (this script must be run from there).
+        SIZE_TOOL=$(compgen -G 'tools/arm-gnu-toolchain-*/bin/arm-none-eabi-size' 2>/dev/null | head -n1 || true)
+        if [ -z "$SIZE_TOOL" ]; then
+            echo "::error::arm-none-eabi-size not found on PATH or under tools/arm-gnu-toolchain-*/bin/" >&2
+            exit 1
+        fi
+    fi
+fi
+
+# CMake's RUNTIME_OUTPUT_DIRECTORY puts built executables under
+# <build-dir>/bin/ (see cmake/main.cmake), not <build-dir> directly — search
+# instead of assuming a fixed depth, in case that ever changes.
+mapfile -t ELFS < <(find "$BUILD_DIR" -maxdepth 3 -name '*.elf' | sort)
+if [ "${#ELFS[@]}" -eq 0 ]; then
+    echo "::warning::No .elf files found under $BUILD_DIR, writing empty size report"
+    echo '{}' > "$OUTPUT_JSON"
+    exit 0
+fi
+
+JQ_ARGS=()
+for elf in "${ELFS[@]}"; do
+    target=$(basename "$elf" .elf)
+
+    # Berkeley format: "   text    data     bss     dec     hex filename"
+    read -r text data bss _dec _hex _name < <("$SIZE_TOOL" -B "$elf" | tail -n1)
+
+    flash=$((text + data))
+    ram=$((data + bss))
+
+    JQ_ARGS+=(--argjson "entry_${#JQ_ARGS[@]}" "{\"target\":\"${target}\",\"flash\":${flash},\"ram\":${ram}}")
+done
+
+# Build via jq rather than manual string concatenation, so the target name
+# (an .elf basename, not otherwise validated) is JSON-escaped properly
+# instead of relying on it never containing a special character.
+jq -n "${JQ_ARGS[@]}" 'reduce $ARGS.named[] as $e ({}; .[$e.target] = {flash: $e.flash, ram: $e.ram})' \
+    > "$OUTPUT_JSON"
+
+echo "Wrote size report for ${#ELFS[@]} target(s) to $OUTPUT_JSON"

.github/scripts/fetch-size-baseline.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+#
+# WARNING: This script is invoked from a GitHub Actions job via
+# `bash .github/scripts/...`. It MUST NEVER be called from a job that has
+# not first checked out a known branch (e.g. `- uses: actions/checkout@v4`
+# as the job's first step): the runner workspace is empty until then, so
+# the script doesn't exist and the call fails with exit 127, silently
+# reporting no baseline. Every job calling this script must check out
+# first.
+#
+# Fetch the size baseline for a PR's TRUE base commit — the merge-base of
+# the PR head and base ref — rather than the base branch's latest tip, so
+# the size-diff delta doesn't include unrelated changes merged to the base
+# after the PR forked (see the +9,788 B stale-RAM regression on PR #11785).
+#
+# Strategy, in order:
+#   1. Exact: size-baseline-<merge-base-sha> in the companion builds repo.
+#   2. Nearest ancestor: walk first-parents of the merge-base (older commits
+#      on the base branch) up to MAX_WALK steps, using the first per-commit
+#      baseline tag found. Nightly baselines exist only for commits that were
+#      actually pushed to the branch, so the walk finds the closest nightly
+#      build at-or-before the fork point.
+#   3. Otherwise report found=false (caller emits the graceful
+#      "no size baseline available" comment path).
+#
+# The base branch's LATEST-tip baseline is deliberately NOT used as a
+# fallback: comparing against it is exactly the stale-delta bug this fixes.
+#
+# Usage: fetch-size-baseline.sh <main-repo> <builds-repo> <base-ref> <merge-base-sha> <out-dir>
+#   <main-repo>      the firmware repo, e.g. iNavFlight/inav
+#   <builds-repo>    companion repo holding the baselines, e.g. iNavFlight/pr-test-builds
+#   <base-ref>       PR base branch, e.g. maintenance-10.x (validated)
+#   <merge-base-sha> full 40-hex SHA of the PR's merge-base commit (validated)
+#   <out-dir>        directory to write size-report.json into
+#
+# Env: GH_TOKEN with read access to both repos (secrets.PR_BUILDS_TOKEN in
+# the pr-comment job has it; the companion repo is private).
+#
+# Prints key=value lines to stdout for the workflow to append to
+# $GITHUB_OUTPUT: found, baseline_commit (full SHA), baseline_commit_short,
+# baseline_exact (true when the merge-base itself had a stored baseline).
+
+set -euo pipefail
+
+MAIN_REPO=${1:?usage: fetch-size-baseline.sh <main-repo> <builds-repo> <base-ref> <merge-base-sha> <out-dir>}
+BUILDS_REPO=${2:?usage: fetch-size-baseline.sh <main-repo> <builds-repo> <base-ref> <merge-base-sha> <out-dir>}
+BASE_REF=${3:?usage: fetch-size-baseline.sh <main-repo> <builds-repo> <base-ref> <merge-base-sha> <out-dir>}
+MERGE_BASE_SHA=${4:?usage: fetch-size-baseline.sh <main-repo> <builds-repo> <base-ref> <merge-base-sha> <out-dir>}
+OUT_DIR=${5:?usage: fetch-size-baseline.sh <main-repo> <builds-repo> <base-ref> <merge-base-sha> <out-dir>}
+
+MAX_WALK=30
+
+if ! [[ "$BASE_REF" =~ ^[A-Za-z0-9._/-]{1,100}$ ]]; then
+    echo "::error::Invalid base ref: $BASE_REF" >&2
+    exit 1
+fi
+if ! [[ "$MERGE_BASE_SHA" =~ ^[0-9a-f]{40}$ ]]; then
+    echo "::error::Invalid merge-base SHA: $MERGE_BASE_SHA" >&2
+    exit 1
+fi
+
+mkdir -p "$OUT_DIR"
+
+# Set of per-commit baseline SHAs currently stored in the builds repo.
+# One paginated call; tags are built by publish-size-baseline.sh and match
+# the strict 40-hex pattern by construction.
+list_baseline_shas() {
+    gh api "repos/${BUILDS_REPO}/releases?per_page=100" --paginate \
+        --jq '.[].tag_name | select(test("^size-baseline-[0-9a-f]{40}$")) | sub("^size-baseline-"; "")'
+}
+
+# publish-size-baseline replaces the asset in place (--clobber), which still
+# briefly deletes-then-uploads under the hood; a few short retries absorb
+# that window instead of misreporting "no baseline available".
+download_baseline() { # $1 = 40-hex sha
+    local tag="size-baseline-${1}"
+    for attempt in 1 2 3; do
+        if gh release download "$tag" --repo "$BUILDS_REPO" \
+            --pattern size-report.json --dir "$OUT_DIR" 2>/dev/null; then
+            return 0
+        fi
+        sleep 3
+    done
+    return 1
+}
+
+emit_found() { # $1 = 40-hex sha, $2 = true|false (exact)
+    echo "found=true"
+    echo "baseline_commit=${1}"
+    echo "baseline_commit_short=${1:0:7}"
+    echo "baseline_exact=${2}"
+}
+
+BASELINE_SHAS=$(list_baseline_shas) || true
+
+# Exact merge-base first, then nearest ancestors along the base branch's
+# first-parent chain. The loop STARTS at the merge-base itself so a
+# transient download failure on the exact commit is retried here instead
+# of silently degrading to a nearest-ancestor baseline.
+sha="$MERGE_BASE_SHA"
+first=1
+for _ in $(seq 1 $((MAX_WALK + 1))); do
+    if grep -qx "$sha" <<< "$BASELINE_SHAS" && download_baseline "$sha"; then
+        if [ "$first" = 1 ]; then
+            emit_found "$sha" true
+        else
+            emit_found "$sha" false
+        fi
+        exit 0
+    fi
+    first=0
+    parent=$(gh api "repos/${MAIN_REPO}/commits/${sha}" --jq '.parents[0].sha // empty' 2>/dev/null || true)
+    if [ -z "$parent" ] || ! [[ "$parent" =~ ^[0-9a-f]{40}$ ]]; then
+        break
+    fi
+    sha="$parent"
+done
+
+echo "found=false"

.github/scripts/merge-size-reports.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+#
+# Merge multiple per-shard size-report.json files (see extract-size-report.sh)
+# into one aggregate JSON, used by the "upload-artifacts" job in ci.yml.
+#
+# Usage: merge-size-reports.sh <output-json> <input-json>...
+
+set -euo pipefail
+
+OUTPUT_JSON=${1:?usage: merge-size-reports.sh <output-json> <input-json>...}
+shift
+
+if [ "$#" -eq 0 ]; then
+    echo '{}' > "$OUTPUT_JSON"
+    exit 0
+fi
+
+jq -s 'add' "$@" > "$OUTPUT_JSON"
+echo "Merged $# size report(s) into $OUTPUT_JSON"

.github/scripts/publish-size-baseline.sh

@@ -0,0 +1,142 @@
+#!/bin/bash
+#
+# WARNING: This script is invoked from a GitHub Actions job via
+# `bash .github/scripts/...`. It MUST NEVER be called from a job that has
+# not first checked out a known branch (e.g. `- uses: actions/checkout@v4`
+# as the job's first step): the runner workspace is empty until then, so
+# the script doesn't exist and the call fails with exit 127, silently
+# publishing nothing. Every job calling this script must check out first.
+#
+# Publish the nightly size report as release assets in the companion
+# pr-test-builds repo, keyed by BRANCH (latest-tip pointer, kept for
+# backward compatibility) AND by COMMIT SHA (primary — lets PR size-diff
+# comparisons use the PR's exact base commit instead of the branch tip),
+# then prune old per-commit baselines so the companion repo doesn't grow
+# unbounded.
+#
+# Usage: publish-size-baseline.sh <builds-repo> <branch> <commit-sha> <report-json> [--dry-run]
+#   <builds-repo>  companion repo, e.g. iNavFlight/pr-test-builds
+#   <branch>       branch the nightly was pushed to (e.g. maintenance-10.x)
+#   <commit-sha>   full 40-hex SHA of the pushed commit (workflow_run.head_sha)
+#   <report-json>  merged size-report.json artifact
+#   --dry-run      print what would be published/pruned without touching GitHub
+#
+# Env: GH_TOKEN with write access to <builds-repo> (Contents: write).
+#
+# Per-commit baseline releases carry a machine-readable `branch: <name>`
+# first line in their notes so pruning can group them per branch. Tags are
+# `size-baseline-<40-hex-sha>`; branch-tip tags are `size-baseline-<branch>`.
+#
+# Pruning policy: keep the newest KEEP_PER_BRANCH per-commit baselines per
+# branch, plus a GLOBAL_CAP safety net for orphaned baselines (deleted
+# branches, notes parse failures) so the repo can never grow unbounded.
+
+set -euo pipefail
+
+BUILDS_REPO=${1:?usage: publish-size-baseline.sh <builds-repo> <branch> <commit-sha> <report-json> [--dry-run]}
+BRANCH=${2:?usage: publish-size-baseline.sh <builds-repo> <branch> <commit-sha> <report-json> [--dry-run]}
+COMMIT_SHA=${3:?usage: publish-size-baseline.sh <builds-repo> <branch> <commit-sha> <report-json> [--dry-run]}
+REPORT_JSON=${4:?usage: publish-size-baseline.sh <builds-repo> <branch> <commit-sha> <report-json> [--dry-run]}
+DRY_RUN=${5:-}
+
+KEEP_PER_BRANCH=50
+GLOBAL_CAP=300
+
+# --- Validate inputs: never trust artifact content or context values before
+# they are used to build shell commands or release tags.
+if ! [[ "$BRANCH" =~ ^[A-Za-z0-9._/-]{1,100}$ ]]; then
+    echo "::error::Invalid branch name in artifact: $BRANCH" >&2
+    exit 1
+fi
+if ! [[ "$COMMIT_SHA" =~ ^[0-9a-f]{40}$ ]]; then
+    echo "::error::Invalid commit SHA: $COMMIT_SHA" >&2
+    exit 1
+fi
+if [ ! -f "$REPORT_JSON" ]; then
+    echo "::error::Size report not found: $REPORT_JSON" >&2
+    exit 1
+fi
+
+# publish one baseline release: create once, then only ever replace the
+# asset in place (--clobber) so the release/tag stays continuously
+# resolvable for concurrent PR comparisons.
+publish_asset() {
+    local tag="$1" title="$2" notes="$3"
+    if gh release view "$tag" --repo "$BUILDS_REPO" >/dev/null 2>&1; then
+        gh release upload "$tag" "$REPORT_JSON" --repo "$BUILDS_REPO" --clobber
+    else
+        gh release create "$tag" "$REPORT_JSON" --repo "$BUILDS_REPO" --prerelease \
+            --title "$title" --notes "$notes"
+    fi
+}
+
+BRANCH_TAG="size-baseline-${BRANCH}"
+COMMIT_TAG="size-baseline-${COMMIT_SHA}"
+
+if [ "$DRY_RUN" = "--dry-run" ]; then
+    echo "[dry-run] would publish ${BRANCH_TAG} and ${COMMIT_TAG} in ${BUILDS_REPO}"
+else
+    publish_asset "$BRANCH_TAG" "Size baseline: ${BRANCH}" \
+        "Latest per-target flash/RAM size report for ${BRANCH}. Auto-updated on every push. Not for human consumption."
+    publish_asset "$COMMIT_TAG" "Size baseline: ${COMMIT_SHA}" \
+        "branch: ${BRANCH}
+Per-commit per-target flash/RAM size report for ${COMMIT_SHA}. Consumed by PR size-diff comparisons; pruned to the newest ${KEEP_PER_BRANCH} per branch."
+fi
+
+# ---------------------------------------------------------------------------
+# Prune per-commit baselines
+# ---------------------------------------------------------------------------
+# Emit <created_at>\t<tag>\t<branch> for every per-commit baseline release,
+# newest first (GitHub release listing is newest-first). Branch comes from
+# the notes' `branch: <name>` FIRST LINE; the (?m) flag is required — the
+# notes are multi-line, and without it ^/$ anchor to the whole string so
+# the capture never matches and every baseline collapses into the '?'
+# bucket, which would make pruning treat all branches as one.
+list_per_commit_baselines() {
+    gh api "repos/${BUILDS_REPO}/releases?per_page=100" --paginate \
+        --jq '.[] | select(.tag_name | test("^size-baseline-[0-9a-f]{40}$")) |
+              [.created_at, .tag_name,
+               ((.body // "") | capture("(?m)^branch: (?<b>[A-Za-z0-9._/-]+)$") | .b // "?")] | @tsv'
+}
+
+prune() {
+    local tmp
+    tmp=$(mktemp)
+    trap 'rm -f "$tmp"' RETURN
+
+    # Pass 1 (NR==FNR): record every tag in `all`, and the per-branch
+    # keep-set — newest KEEP_PER_BRANCH tags per branch — in `keepTag`.
+    # Pass 2: apply the global cap to the kept set in input order.
+    # END: delete every tag in `all` that did not survive to keepFinal.
+    # (Explicit `all` set so pruning never depends on awk's create-on-
+    # reference semantics of reading keepTag[$2] in pass 2.)
+    list_per_commit_baselines | sort -r > "$tmp"
+
+    awk -F '\t' -v keep="$KEEP_PER_BRANCH" -v cap="$GLOBAL_CAP" '
+        NR == FNR {
+            all[$2] = 1
+            if (count[$3] < keep) { count[$3]++; keepTag[$2] = 1 }
+            next
+        }
+        {
+            if (keepTag[$2]) {
+                if (kept < cap) { kept++; keepFinal[$2] = 1 }
+            }
+        }
+        END {
+            for (t in all) if (!keepFinal[t]) print t
+        }
+    ' "$tmp" "$tmp" | while read -r tag; do
+        if [ "$DRY_RUN" = "--dry-run" ]; then
+            echo "[dry-run] would prune ${tag}"
+        else
+            gh release delete "$tag" --repo "$BUILDS_REPO" --yes --cleanup-tag \
+                || echo "::warning::failed to prune ${tag}" >&2
+        fi
+    done
+}
+
+# Pruning is housekeeping: a failure here must not fail the publish (the
+# baseline itself already landed above), or the nightly would look broken
+# for a cosmetic reason. Warn loudly instead.
+prune || echo "::warning::per-commit baseline pruning failed (see stderr)" >&2