fix(wasi): update wasi stubs

Signed-off-by: Bailey Hayes <bailey@cosmonic.com>

Author: ricochet

absl/base/internal/low_level_alloc.cc

@@ -224,6 +224,7 @@ struct LowLevelAlloc::Arena {
 
 // ---------------------------------------------------------------
 // An async-signal-safe arena for LowLevelAlloc
+#ifndef __wasi__
 static std::atomic<base_internal::LowLevelAlloc::Arena *> g_sig_safe_arena;
 
 base_internal::LowLevelAlloc::Arena *SigSafeArena() {
@@ -247,6 +248,7 @@ void InitSigSafeArena() {
     }
   }
 }
+#endif  // __wasi__
 
 namespace {
 // Static storage space for the lazily-constructed, default global arena
@@ -535,6 +537,7 @@ static void AddToFreelist(void *v, LowLevelAlloc::Arena *arena)
 
 // Frees storage allocated by LowLevelAlloc::Alloc().
 // L < arena->mu
+#ifndef __wasi__
 void LowLevelAlloc::Free(void *v) {
   if (v != nullptr) {
     AllocList *f = reinterpret_cast<AllocList *>(reinterpret_cast<char *>(v) -
@@ -547,6 +550,7 @@ void LowLevelAlloc::Free(void *v) {
     section.Leave();
   }
 }
+#endif  // __wasi__
 
 // allocates and returns a block of size bytes, to be freed with Free()
 // L < arena->mu
@@ -643,6 +647,7 @@ static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
   return result;
 }
 
+#ifndef __wasi__
 void *LowLevelAlloc::Alloc(size_t request) {
   void *result = DoAllocWithArena(request, DefaultArena());
   return result;
@@ -653,9 +658,49 @@ void *LowLevelAlloc::AllocWithArena(size_t request, Arena *arena) {
   void *result = DoAllocWithArena(request, arena);
   return result;
 }
+#endif  // __wasi__
 
 }  // namespace base_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+
+// WASI-specific implementations
+// WASI doesn't support mmap, so we use malloc/free for LowLevelAlloc
+#ifdef __wasi__
+
+#include "absl/base/internal/low_level_alloc.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace base_internal {
+
+void *LowLevelAlloc::Alloc(size_t request) {
+  return malloc(request);
+}
+
+void LowLevelAlloc::Free(void *v) {
+  free(v);
+}
+
+void *LowLevelAlloc::AllocWithArena(size_t request, Arena* /*arena*/) {
+  // Ignore arena parameter and use malloc
+  return malloc(request);
+}
+
+// Signal-safe arena stubs for WASI
+void InitSigSafeArena() {
+  // No-op: WASI doesn't need arena initialization
+}
+
+LowLevelAlloc::Arena *SigSafeArena() {
+  // Return nullptr - arenas are ignored in WASI's AllocWithArena
+  return nullptr;
+}
+
+}  // namespace base_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // __wasi__

absl/synchronization/internal/create_thread_identity.cc

@@ -138,15 +138,39 @@ static base_internal::ThreadIdentity* NewThreadIdentity() {
 // Allocates and attaches ThreadIdentity object for the calling thread.  Returns
 // the new identity.
 // REQUIRES: CurrentThreadIdentity(false) == nullptr
+#ifndef __wasi__
 base_internal::ThreadIdentity* CreateThreadIdentity() {
   base_internal::ThreadIdentity* identity = NewThreadIdentity();
   // Associate the value with the current thread, and attach our destructor.
   base_internal::SetCurrentThreadIdentity(identity, ReclaimThreadIdentity);
   return identity;
 }
+#endif  // __wasi__
 
 }  // namespace synchronization_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+
+// WASI-specific implementation
+// WASI is single-threaded, so we use a single static ThreadIdentity
+#ifdef __wasi__
+
+#include "absl/base/internal/thread_identity.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+static base_internal::ThreadIdentity g_wasi_thread_identity = {};
+
+base_internal::ThreadIdentity* CreateThreadIdentity() {
+  return &g_wasi_thread_identity;
+}
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // __wasi__

absl/synchronization/internal/graphcycles.cc

@@ -370,6 +370,7 @@ void GraphCycles::TestOnlyAddNodes(uint32_t n) {
   }
 }
 
+#ifndef __wasi__
 GraphCycles::GraphCycles() {
   InitArenaIfNecessary();
   rep_ = new (base_internal::LowLevelAlloc::AllocWithArena(sizeof(Rep), arena))
@@ -706,9 +707,87 @@ int GraphCycles::GetStackTrace(GraphId id, void*** ptr) {
     return n->nstack;
   }
 }
+#endif  // __wasi__
 
 }  // namespace synchronization_internal
 ABSL_NAMESPACE_END
 }  // namespace absl
 
 #endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+
+// WASI-specific minimal GraphCycles implementation
+// WASI is single-threaded, so cycle detection is not necessary
+#ifdef __wasi__
+
+#include "absl/synchronization/internal/graphcycles.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace synchronization_internal {
+
+// Minimal implementation that always succeeds
+GraphCycles::GraphCycles() : rep_(nullptr) {}
+
+GraphCycles::~GraphCycles() {}
+
+GraphId GraphCycles::GetId(void* /*ptr*/) {
+  return GraphId{0};
+}
+
+void GraphCycles::RemoveNode(void* /*ptr*/) {
+  // No-op
+}
+
+void* GraphCycles::Ptr(GraphId /*id*/) {
+  return nullptr;
+}
+
+bool GraphCycles::InsertEdge(GraphId /*source_node*/, GraphId /*dest_node*/) {
+  // Always succeed - no cycles in single-threaded WASI
+  return true;
+}
+
+void GraphCycles::RemoveEdge(GraphId /*source_node*/, GraphId /*dest_node*/) {
+  // No-op
+}
+
+bool GraphCycles::HasNode(GraphId /*node*/) {
+  return false;
+}
+
+bool GraphCycles::HasEdge(GraphId /*source_node*/, GraphId /*dest_node*/) const {
+  return false;
+}
+
+bool GraphCycles::IsReachable(GraphId /*source_node*/, GraphId /*dest_node*/) const {
+  return false;
+}
+
+int GraphCycles::FindPath(GraphId /*source*/, GraphId /*dest*/, int /*max_path_len*/,
+                          GraphId /*path*/[]) const {
+  return 0;
+}
+
+void GraphCycles::UpdateStackTrace(GraphId /*id*/, int /*priority*/,
+                                   int (*/*get_stack_trace*/)(void**, int)) {
+  // No-op
+}
+
+int GraphCycles::GetStackTrace(GraphId /*id*/, void*** ptr) {
+  *ptr = nullptr;
+  return 0;
+}
+
+bool GraphCycles::CheckInvariants() const {
+  return true;
+}
+
+void GraphCycles::TestOnlyAddNodes(uint32_t /*n*/) {
+  // No-op
+}
+
+}  // namespace synchronization_internal
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // __wasi__

absl/synchronization/internal/per_thread_sem.cc

@@ -104,3 +104,40 @@ ABSL_ATTRIBUTE_WEAK bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
 }  // extern "C"
 
 #endif  // ABSL_LOW_LEVEL_ALLOC_MISSING
+
+// WASI-specific implementations
+// WASI doesn't support threading, so these are no-op implementations
+#ifdef __wasi__
+
+#include "absl/synchronization/internal/per_thread_sem.h"
+#include "absl/base/attributes.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/synchronization/internal/waiter.h"
+
+extern "C" {
+
+// Override the weak symbols with WASI-specific no-op implementations
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemInit)(
+    absl::base_internal::ThreadIdentity* /*identity*/) {
+  // No-op: WASI is single-threaded
+}
+
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(
+    absl::base_internal::ThreadIdentity* /*identity*/) {
+  // No-op: WASI is single-threaded
+}
+
+void ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPoke)(
+    absl::base_internal::ThreadIdentity* /*identity*/) {
+  // No-op: WASI is single-threaded
+}
+
+bool ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(
+    absl::synchronization_internal::KernelTimeout /*t*/) {
+  // No-op: WASI is single-threaded, always return true (no timeout)
+  return true;
+}
+
+}  // extern "C"
+
+#endif  // __wasi__

absl/synchronization/mutex.cc

@@ -1528,6 +1528,10 @@ static bool TryAcquireWithSpinning(std::atomic<intptr_t>* mu) {
 }
 
 void Mutex::lock() {
+#ifdef __wasi__
+  // No-op: WASI is single-threaded
+  return;
+#endif
   ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
   GraphId id = DebugOnlyDeadlockCheck(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -1546,6 +1550,10 @@ void Mutex::lock() {
 }
 
 void Mutex::lock_shared() {
+#ifdef __wasi__
+  // No-op: WASI is single-threaded
+  return;
+#endif
   ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
   GraphId id = DebugOnlyDeadlockCheck(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -1706,6 +1714,10 @@ ABSL_ATTRIBUTE_NOINLINE bool Mutex::ReaderTryLockSlow() {
 }
 
 void Mutex::unlock() {
+#ifdef __wasi__
+  // No-op: WASI is single-threaded
+  return;
+#endif
   ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
   DebugOnlyLockLeave(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -1776,6 +1788,10 @@ static bool ExactlyOneReader(intptr_t v) {
 }
 
 void Mutex::unlock_shared() {
+#ifdef __wasi__
+  // No-op: WASI is single-threaded
+  return;
+#endif
   ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
   DebugOnlyLockLeave(this);
   intptr_t v = mu_.load(std::memory_order_relaxed);
@@ -2493,6 +2509,10 @@ void Mutex::Fer(PerThreadSynch* w) {
 }
 
 void Mutex::AssertHeld() const {
+#ifdef __wasi__
+  // No-op: WASI is single-threaded, always held
+  return;
+#endif
   if ((mu_.load(std::memory_order_relaxed) & kMuWriter) == 0) {
     SynchEvent* e = GetSynchEvent(this);
     ABSL_RAW_LOG(FATAL, "thread should hold write lock on Mutex %p %s",