portability: gcc sanitizer detection + POSIX strcasecmp + empty-TU sentinels

Three pre-existing portability bugs that landed in the v0.241-v0.252
cycle but didn't surface locally (clang+macOS):

* src/gc/internal.h:150 -- defined(__has_feature) &&
  __has_feature(...) doesn't short-circuit at the preprocessor
  level under gcc; split into nested #if so the right side never
  parses when the macro is absent.

* main.c -- strcasecmp is POSIX, lives in <strings.h>. Include it
  under #ifndef _WIN32; alias to _stricmp on Windows. Call sites
  use mino_strcasecmp.

* src/eval/bc/jit/{helpers,emit,patcher,patcher_x86_64,stats}.c
  -- whole-file #ifdef MINO_CPJIT_HOST wrap meant an empty TU on
  targets where the host isn't matched (e.g., mingw without the
  x86_64-windows opt-in). gcc -Werror=pedantic rejects empty TUs.
  Add a typedef sentinel after each #endif.

* src/eval/bc/jit/entry.c:680 -- non-host stub for mino_jit_invoke
  was 4 args; header declares 5 (mino_env *env added in the v0.219
  refactor). Stub now matches.

Verified: full local build + tests pass; pushed to retry CI on the
gcc / mingw paths.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: leifericf

CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## v0.255.7 — Portability: gcc Sanitizer Detection, POSIX strcasecmp, Empty TUs
+
+CI on ubuntu-24.04, ubuntu-24.04-arm, and windows-2022 went red on
+the v0.255.6 push with three pre-existing portability bugs that
+landed sometime in the v0.241-v0.252 cycle but didn't surface
+locally:
+
+* `src/gc/internal.h:150` -- `defined(__has_feature) &&
+  __has_feature(address_sanitizer)` doesn't short-circuit at the
+  preprocessor level under gcc. gcc evaluates the right side
+  syntactically and fails with "missing binary operator before
+  token '('". Split into nested `#if defined(__has_feature)` so
+  gcc never sees the `__has_feature(...)` call when the macro
+  isn't defined.
+
+* `main.c:815` -- `strcasecmp` is POSIX, declared in `<strings.h>`
+  (not `<string.h>`). Add the include under `#ifndef _WIN32`; on
+  Windows alias `mino_strcasecmp` to `_stricmp`. Call sites updated
+  to use the portable name.
+
+* `src/eval/bc/jit/{helpers,emit,patcher,patcher_x86_64,stats}.c`
+  -- empty translation unit under `-Werror=pedantic` when
+  `MINO_CPJIT_HOST` isn't defined for the build target (e.g.,
+  mingw without `MINO_CPJIT_X86_64_WINDOWS`). Added a sentinel
+  typedef after each `#endif` to keep each TU non-empty.
+
+* `src/eval/bc/jit/entry.c:680` -- `mino_jit_invoke` stub had 4
+  parameters; header declared 5 (`mino_env *env` was added
+  in the v0.219+ refactor and the stub wasn't updated). Stub
+  signature now matches the header.
+
+Verified: full local build + tests pass (1273 tests / 4555
+assertions, 0 failed). Pushed to trigger a fresh CI run.
+
 ## v0.255.6 — Fix: BC Speculative Fold Longjmps Through Active Try-Frame
 
 Surfaced by mino-tests v0.7.0's `gen_program.clj`: a `defn` whose

main.c

@@ -27,9 +27,12 @@
 
 #ifndef _WIN32
 #include <execinfo.h>
+#include <strings.h>  /* POSIX strcasecmp on Linux + macOS */
+#define mino_strcasecmp strcasecmp
 #else
 #  define WIN32_LEAN_AND_MEAN
 #  include <windows.h>
+#  define mino_strcasecmp _stricmp
 #endif
 
 #if defined(__APPLE__)
@@ -812,11 +815,11 @@ int main(int argc, char **argv)
     mino_jit_mode_t cli_jit = MINO_JIT_MODE_AUTO;
     int cli_jit_set = 0;
     if (cli_jit_mode != NULL) {
-        if (strcasecmp(cli_jit_mode, "auto") == 0) {
+        if (mino_strcasecmp(cli_jit_mode, "auto") == 0) {
             cli_jit = MINO_JIT_MODE_AUTO; cli_jit_set = 1;
-        } else if (strcasecmp(cli_jit_mode, "off") == 0) {
+        } else if (mino_strcasecmp(cli_jit_mode, "off") == 0) {
             cli_jit = MINO_JIT_MODE_OFF;  cli_jit_set = 1;
-        } else if (strcasecmp(cli_jit_mode, "on") == 0) {
+        } else if (mino_strcasecmp(cli_jit_mode, "on") == 0) {
             cli_jit = MINO_JIT_MODE_ON;   cli_jit_set = 1;
         } else {
             fprintf(stderr,
@@ -898,7 +901,7 @@ int main(int argc, char **argv)
             int explicit_on = (cli_jit_set && cli_jit == MINO_JIT_MODE_ON);
             if (!explicit_on) {
                 const char *env_jit = getenv("MINO_JIT");
-                if (env_jit != NULL && strcasecmp(env_jit, "on") == 0) {
+                if (env_jit != NULL && mino_strcasecmp(env_jit, "on") == 0) {
                     explicit_on = 1;
                 }
             }

src/eval/bc/jit/emit.c

@@ -762,3 +762,7 @@ int mino_jit_compile_inner(mino_state_t *S, mino_val_t *fn_val)
 }
 
 #endif /* MINO_CPJIT_HOST */
+
+/* Keep this TU non-empty under -Werror=pedantic when the gate above
+ * is false. */
+typedef int mino_jit_emit_tu_marker;

src/eval/bc/jit/entry.c

@@ -678,9 +678,10 @@ int mino_jit_compile(mino_state_t *S, mino_val_t *fn_val)
 }
 
 mino_val_t *mino_jit_invoke(mino_state_t *S, mino_bc_fn_t *bc,
-                            mino_val_t **regs, mino_val_t **consts)
+                            mino_val_t **regs, mino_val_t **consts,
+                            mino_env_t *env)
 {
-    (void)S; (void)bc; (void)regs; (void)consts; return NULL;
+    (void)S; (void)bc; (void)regs; (void)consts; (void)env; return NULL;
 }
 
 void mino_jit_invalidate(mino_state_t *S, mino_val_t *fn)

src/eval/bc/jit/helpers.c

@@ -778,3 +778,7 @@ mino_val_t **mino_jit_loop_int_lt_inc_slow(mino_state_t *S, mino_val_t **regs,
 }
 
 #endif /* MINO_CPJIT_HOST */
+
+/* Keep this TU non-empty under -Werror=pedantic when MINO_CPJIT_HOST
+ * isn't defined for the build target. */
+typedef int mino_jit_helpers_tu_marker;

src/eval/bc/jit/patcher.c

@@ -200,3 +200,7 @@ void mino_jit_write_trampoline(unsigned char *slot, uintptr_t target_addr)
 }
 
 #endif /* MINO_CPJIT_HOST_ARM64 */
+
+/* Keep this TU non-empty under -Werror=pedantic when the gate above
+ * is false (e.g., x86_64 builds). */
+typedef int mino_jit_patcher_arm64_tu_marker;

src/eval/bc/jit/patcher_x86_64.c

@@ -188,3 +188,7 @@ void mino_jit_write_trampoline(unsigned char *slot, uintptr_t target_addr)
 }
 
 #endif /* MINO_CPJIT_HOST_X86_64 */
+
+/* Keep this TU non-empty under -Werror=pedantic when the gate above
+ * is false (e.g., arm64 builds). */
+typedef int mino_jit_patcher_x86_64_tu_marker;

src/eval/bc/jit/stats.c

@@ -172,3 +172,7 @@ void mino_jit_stats_record(const mino_bc_fn_t *bc,
 }
 
 #endif /* MINO_CPJIT_HOST */
+
+/* Keep this TU non-empty under -Werror=pedantic when the gate above
+ * is false. */
+typedef int mino_jit_stats_tu_marker;

src/gc/internal.h

@@ -146,9 +146,20 @@ typedef struct {
  * Sanitizer builds want loud failure to flag liveness regressions;
  * release builds keep the documented soft-loss path so the
  * conservative C-stack scanner still covers values that escape
- * the pin array. */
-#if (defined(__has_feature) && __has_feature(address_sanitizer)) \
-    || defined(__SANITIZE_ADDRESS__) \
+ * the pin array. The __has_feature check is nested inside its own
+ * `defined` test because gcc evaluates the second half of an &&
+ * syntactically even when the first half is false -- splitting
+ * into nested #if keeps gcc preprocessing happy while still
+ * detecting clang's ASan / TSan / UBSan flavours. */
+#if defined(__has_feature)
+#  if __has_feature(address_sanitizer) \
+      || __has_feature(thread_sanitizer) \
+      || __has_feature(undefined_behavior_sanitizer)
+#    define MINO_GC_PIN_LOUD_ASSERT 1
+#  else
+#    define MINO_GC_PIN_LOUD_ASSERT 0
+#  endif
+#elif defined(__SANITIZE_ADDRESS__) \
     || defined(__SANITIZE_THREAD__) \
     || defined(__SANITIZE_UNDEFINED__)
 #  define MINO_GC_PIN_LOUD_ASSERT 1

src/mino.h

@@ -28,7 +28,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 255
-#define MINO_VERSION_PATCH 6
+#define MINO_VERSION_PATCH 7
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".