Cleanup pseudostack allocation paths (#72)

Consolidates the pseudostack machinery down to a single header and
brings the custom `THREADSAFE` mode in line with upstream Opus. No
functional change to decode/encode output.

## Consolidation

- Deletes the standalone `patches/stack_alloc.h` and the `unused
stack_alloc.patch`. `Silk/src` sources previously resolved this drifted
copy via -I patches; they now use the single patched
`celt/stack_alloc.h` like the celt sources already did.
- Drops the `#else` catch-all in the mode selector for an explicit
`#elif defined(NONTHREADSAFE_PSEUDOSTACK)` / `#elif
defined(THREADSAFE_PSEUDOSTACK)` chain.

## Matching upstream in the `THREADSAFE` branch

- Gates the `PUSH` overflow check behind `ENABLE_HARDENING`, the way
upstream already gates `NONTHREADSAFE`. Off by default, so it drops a
compare-and-branch from every allocation.
- Aligns with `ALIGNOF(type)` instead of `sizeof(type)` and cast via
`(type*)(void*)`, making `PUSH`/`ALIGN`/`ALIGNOF` byte-for-byte
identical to upstream's `NONTHREADSAFE` branch.
- Guards our fallback `celt_fatal` in `custom_support.h` behind
`!ENABLE_ASSERTIONS && !ENABLE_HARDENING`, since `arch.h` defines it
itself under those flags (avoids a redefinition collision under
hardening and a missing symbol without it).

## Bug fixes

- Aborts via `CELT_FATAL` when the per-thread pseudostack allocation
returns `NULL`, instead of writing through a near-`NULL` pointer (the
overflow guard degrades to a bare size check at a `NULL` base, and with
the guard now off by default there is no check at all).
- Routes `THREADSAFE` allocation through `opus_alloc_scratch()` in
`custom_support.h` rather than a second `Kconfig` mapping. The old copy
omitted `MALLOC_CAP_8BIT`, so the internal-RAM fallback could land in
IRAM and fault on the first byte/halfword store into the pseudostack.
- Size the `THREADSAFE` valgrind pseudostack to `GLOBAL_STACK_SIZE*2` to
match its redzone-doubling `PUSH`; it was allocating 1x and overrunning
past half usage. `_opus_alloc_and_register_pseudostack()` now takes the
size from `ALLOC_STACK` so the buffer and the `PUSH` advance stay in
step.

Author: kahrendt

CLAUDE.md

@@ -11,7 +11,6 @@ patches/                  # ESP32-specific patches applied at build time
   diffs/                  # .patch files applied to staged opus copy
   celt/xtensa/           # Xtensa assembly optimizations
   silk/xtensa/           # SILK Xtensa optimizations
-  stack_alloc.h          # Thread-local pseudostack implementation
   custom_support.h       # PSRAM-aware memory allocation
 cmake/                   # Build system modules
   staging.cmake          # Copies opus to build/opus-staged/ and applies patches

patches/custom_support.h

@@ -36,6 +36,7 @@
 #ifdef ESP_PLATFORM
 /* ESP-IDF build: Use PSRAM-aware allocation */
 #include "esp_heap_caps.h"
+#include "sdkconfig.h" /* CONFIG_OPUS_* macros used in the allocators below */
 
 /* Override opus_alloc to use configurable memory allocation for Opus state/tables */
 #define OVERRIDE_OPUS_ALLOC
@@ -102,10 +103,16 @@ static inline void* opus_alloc_scratch(size_t size) {
 /* Host builds use the default Opus implementations (malloc/free) from os_support.h */
 
 /* Function called on pseudostack overflow - required for pseudostack modes.
- * Called by the PUSH() macro when allocation exceeds GLOBAL_STACK_SIZE. */
+ * Called by the PUSH() macro when allocation exceeds GLOBAL_STACK_SIZE.
+ *
+ * Only provide our own celt_fatal when upstream does not. When a consumer defines
+ * ENABLE_ASSERTIONS or ENABLE_HARDENING, arch.h declares (and defines under CELT_C)
+ * celt_fatal itself; defining our static inline here as well would collide. */
+#if !defined(ENABLE_ASSERTIONS) && !defined(ENABLE_HARDENING)
 static inline void celt_fatal(const char* str, const char* file, int line) {
     printf("FATAL ERROR: %s at %s:%d\n", str, file, line);
     abort();
 }
+#endif
 
 #endif /* CUSTOM_SUPPORT_H */

patches/diffs/celt_stack_alloc.patch

@@ -23,7 +23,7 @@
  #ifdef CELT_C
  char *scratch_ptr=0;
  char *global_stack=0;
-@@ -163,6 +165,74 @@
+@@ -163,6 +165,99 @@
  #define SAVE_STACK char *_saved_stack = global_stack;
  #define ALLOC_NONE 0
 
@@ -61,7 +61,28 @@
 +extern _Thread_local char *global_stack;
 +
 +/* Allocate and register pseudostack - defined in thread_local_stack.c */
-+char* _opus_alloc_and_register_pseudostack(void);
++char* _opus_alloc_and_register_pseudostack(size_t size);
++
++/* ALIGNOF mirrors the definition in the NONTHREADSAFE branch above; each
++ * allocation-mode branch is self-contained, so it is repeated here. */
++#if __STDC_VERSION__ >= 201112L
++#  include <stdalign.h>
++#  define ALIGNOF(T) alignof(T)
++#elif defined(__GNUC__) || defined(__clang__)
++#  define ALIGNOF(T) __alignof__(T)
++#else
++# include <stddef.h>
++# ifdef __cplusplus
++template <typename T>
++struct alignment_helper {
++    char c;
++    T member;
++};
++# define ALIGNOF(T) (offsetof(alignment_helper<T>, member))
++# else
++# define ALIGNOF(T) (offsetof(struct { char c; T member; }, member))
++# endif
++#endif
 +
 +#ifdef ENABLE_VALGRIND
 +
@@ -70,22 +91,26 @@
 +static _Thread_local char *global_stack_top = NULL;
 +
 +#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1))
-+#define PUSH(stack, size, type) (VALGRIND_MAKE_MEM_NOACCESS(stack, global_stack_top-stack),ALIGN((stack),sizeof(type)/sizeof(char)),VALGRIND_MAKE_MEM_UNDEFINED(stack, ((size)*sizeof(type)/sizeof(char))),(stack)+=(2*(size)*sizeof(type)/sizeof(char)),(type*)((stack)-(2*(size)*sizeof(type)/sizeof(char))))
++#define PUSH(stack, size, type) (VALGRIND_MAKE_MEM_NOACCESS(stack, global_stack_top-stack),ALIGN((stack),ALIGNOF(type)),VALGRIND_MAKE_MEM_UNDEFINED(stack, ((size)*sizeof(type)/sizeof(char))),(stack)+=(2*(size)*sizeof(type)/sizeof(char)),(type*)((stack)-(2*(size)*sizeof(type)/sizeof(char))))
 +#define RESTORE_STACK ((global_stack = _saved_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack))
-+#define ALLOC_STACK char *_saved_stack; ((global_stack = (global_stack==0) ? ((global_stack_top=_opus_alloc_and_register_pseudostack()+(GLOBAL_STACK_SIZE))-(GLOBAL_STACK_SIZE)) : global_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack)); _saved_stack = global_stack;
++#define ALLOC_STACK char *_saved_stack; ((global_stack = (global_stack==0) ? ((global_stack_top=_opus_alloc_and_register_pseudostack(GLOBAL_STACK_SIZE*2)+(GLOBAL_STACK_SIZE*2))-(GLOBAL_STACK_SIZE*2)) : global_stack),VALGRIND_MAKE_MEM_NOACCESS(global_stack, global_stack_top-global_stack)); _saved_stack = global_stack;
 +
 +#else
 +
-+#include "arch.h"
 +#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1))
-+#define PUSH(stack, size, type) (ALIGN((stack),sizeof(type)/(sizeof(char))),(void)(((int)((size)*(sizeof(type)/(sizeof(char)))) <= (scratch_ptr)+GLOBAL_STACK_SIZE-(stack))?0:CELT_FATAL("pseudostack overflow")),(stack)+=(size)*(sizeof(type)/(sizeof(char))),(type*)((stack)-(size)*(sizeof(type)/(sizeof(char)))))
++#ifdef ENABLE_HARDENING
++#include "arch.h"
++#define PUSH(stack, size, type) (ALIGN((stack),ALIGNOF(type)),(void)(((int)((size)*(sizeof(type)/(sizeof(char)))) <= (scratch_ptr)+GLOBAL_STACK_SIZE-(stack))?0:CELT_FATAL("pseudostack overflow")),(stack)+=(size)*(sizeof(type)/(sizeof(char))),(type*)(void*)((stack)-(size)*(sizeof(type)/(sizeof(char)))))
++#else
++#define PUSH(stack, size, type) (ALIGN((stack),ALIGNOF(type)),(stack)+=(size)*(sizeof(type)/(sizeof(char))),(type*)(void*)((stack)-(size)*(sizeof(type)/(sizeof(char)))))
++#endif
 +#if 0 /* Set this to 1 to instrument pseudostack usage */
 +#define RESTORE_STACK (printf("%ld %s:%d\n", global_stack-scratch_ptr, __FILE__, __LINE__),global_stack = _saved_stack)
 +#else
 +#define RESTORE_STACK (global_stack = _saved_stack)
 +#endif
 +/* Lazy allocation: check global_stack==0, allocate if needed, same pattern as non-threadsafe */
-+#define ALLOC_STACK char *_saved_stack; (global_stack = (global_stack==0) ? (_opus_alloc_and_register_pseudostack()) : global_stack); _saved_stack = global_stack;
++#define ALLOC_STACK char *_saved_stack; (global_stack = (global_stack==0) ? (_opus_alloc_and_register_pseudostack(GLOBAL_STACK_SIZE)) : global_stack); _saved_stack = global_stack;
 +
 +#endif /* ENABLE_VALGRIND */
 +