// SAFETY: plain pthread queries on the calling thread; `attr` is

// initialised by pthread_getattr_np and destroyed before returning.

unsafe {

let mut attr: libc::pthread_attr_t = std::mem::zeroed();

if libc::pthread_getattr_np(libc::pthread_self(), &mut attr) != 0 {

return None;

}

let mut addr: *mut libc::c_void = std::ptr::null_mut();

let mut size: libc::size_t = 0;

let rc = libc::pthread_attr_getstack(&attr, &mut addr, &mut size);

libc::pthread_attr_destroy(&mut attr);

if rc != 0 || addr.is_null() || size == 0 {

return None;

}

Some(addr as usize)

}

// SAFETY: plain pthread queries on the calling thread.

unsafe {

let me = libc::pthread_self();

// pthread_get_stackaddr_np returns the HIGH end (the stack base).

let high = libc::pthread_get_stackaddr_np(me) as usize;

let size = libc::pthread_get_stacksize_np(me);

if high == 0 || size == 0 || size > high {

return None;

}

Some(high - size)

}

#[link(name = "kernel32")]

extern "system" {

// Win8+ (the bundled Node runtime needs Win10 anyway). Reports the

// full RESERVED range; Windows commits pages on demand down to it.

fn GetCurrentThreadStackLimits(low_limit: *mut usize, high_limit: *mut usize);

}

let mut low: usize = 0;

let mut high: usize = 0;

// SAFETY: both out-pointers are valid for the duration of the call.

unsafe { GetCurrentThreadStackLimits(&mut low, &mut high) };

if low == 0 || high <= low {

return None;

}

Some(low)

OVERFLOWED.with(|o| o.set(false));

let cached = THRESHOLD.with(|t| t.get());

if cached != 0 && THRESHOLD_IS_OS.with(|f| f.get()) {

return;

}

match os_stack_low() {

Some(low) => {

THRESHOLD.with(|t| t.set(low.saturating_add(RED_ZONE)));

THRESHOLD_IS_OS.with(|f| f.set(true));

}

None => {

THRESHOLD.with(|t| t.set(current_sp().saturating_sub(FALLBACK_BUDGET).max(1)));

THRESHOLD_IS_OS.with(|f| f.set(false));

}

}

let threshold = THRESHOLD.with(|t| t.get());

if threshold == 0 {

begin();

return exhausted();

}

if current_sp() < threshold {

OVERFLOWED.with(|o| o.set(true));

true

} else {

false

}

begin();

let out = f();

if overflowed() {

return Err(

"defer: nesting too deep for the native walker — wasm recovery handles it".to_string(),

);

}

out

use super::*;

/// 1 MiB is a quarter of Node's worker default; a guard that holds here

/// holds on every real thread. Without the guard these walks SIGSEGV the

/// test process instead of failing an assertion.

const SMALL_STACK: usize = 1 << 20;

const DEPTH: usize = 30_000;

fn on_small_stack<T: Send + 'static>(f: impl FnOnce() -> T + Send + 'static) -> T {

std::thread::Builder::new()

.stack_size(SMALL_STACK)

.spawn(f)

.expect("spawn")

.join()

.expect("walker thread panicked")

}

fn nested_parens(prefix: &str, suffix: &str) -> String {

format!("{prefix}{}1{}{suffix}", "(".repeat(DEPTH), ")".repeat(DEPTH))

}

#[test]

fn os_bounds_are_sane_on_this_platform() {

// Every shipped target has an OS implementation; the fallback budget

// is only for platforms the kernel is not built for.

let low = os_stack_low().expect("OS stack bounds available");

let sp = current_sp();

assert!(low < sp, "stack low {low:#x} must be below the current sp {sp:#x}");

assert!(sp - low < 1 << 31, "implausible stack size {}", sp - low);

}

#[test]

fn small_stack_reports_its_own_bounds() {

on_small_stack(|| {

let low = os_stack_low().expect("OS stack bounds available");

let used = current_sp() - low;

// std/the OS round the requested size up a little (macOS reports

// 1,060,864 for a 1 MiB request); the point is that the bounds

// describe THIS thread's small stack, not the main thread's.

assert!(

used <= SMALL_STACK + 128 * 1024,

"used {used} is not within the {SMALL_STACK}-byte stack"

);

});

}

#[test]

fn deep_braces_c_defer_instead_of_crashing() {

let src = format!("void foo(void) {{\n{}{}\n}}\n", "{".repeat(DEPTH), "}".repeat(DEPTH));

let r = on_small_stack(move || run_guarded(|| crate::ccpp::extract("deep.c", &src, "c")));

let err = r.err().expect("deep nesting must defer");

assert!(err.starts_with("defer:"), "unexpected error: {err}");

}

type Extract = fn(&str) -> Result<crate::buffers::EmitOut, String>;

#[test]

fn deep_parens_cpp_rust_ts_python_defer_instead_of_crashing() {

let cases: [(&str, Extract, String); 4] = [

("deep.cpp", |s| crate::ccpp::extract("deep.cpp", s, "cpp"), nested_parens("int f() { return ", "; }\n")),

("deep.rs", |s| crate::rustlang::extract("deep.rs", s), nested_parens("fn f() -> i32 { ", " }\n")),

("deep.ts", |s| crate::tsjs::extract("deep.ts", s, "typescript"), nested_parens("function f() { return ", "; }\n")),

("deep.py", |s| crate::python::extract("deep.py", s), nested_parens("def f():\n return ", "\n")),

];

for (name, extract, src) in cases {

let r = on_small_stack(move || run_guarded(|| extract(&src)));

let err = r.err().unwrap_or_else(|| panic!("{name}: deep nesting must defer"));

assert!(err.starts_with("defer:"), "{name}: unexpected error: {err}");

}

}

#[test]

fn normal_files_are_untouched_by_the_guard() {

let src = "int add(int a, int b) { return a + b; }\nint main(void) { return add(1, 2); }\n";

let r = on_small_stack(move || run_guarded(|| crate::ccpp::extract("ok.c", src, "c")));

assert!(r.is_ok(), "a shallow file must not defer: {:?}", r.err());

assert!(!overflowed());

}

#[test]

fn latch_resets_between_runs() {

let deep = format!("void foo(void) {{\n{}{}\n}}\n", "{".repeat(DEPTH), "}".repeat(DEPTH));

on_small_stack(move || {

assert!(run_guarded(|| crate::ccpp::extract("deep.c", &deep, "c")).is_err());

// The latch from the deep file must not poison the next, shallow one.

let ok = run_guarded(|| crate::ccpp::extract("ok.c", "int x;\n", "c"));

assert!(ok.is_ok(), "latch leaked into the next run: {:?}", ok.err());

});

}