cxxabi.cxxm

Go to the documentation of this file.

/// SPDX-License-Identifier: Apache-2.0
/// @file cxxabi.cxxm
/// @brief minimal cxxabi implementation
 
export module zxfoundation.base.cxxrtse.cxxabi;
import zxfoundation.base.types;
import zxfoundation.sys.syschk.core;
import zxfoundation.sys.printk.core;
import zxfoundation.sync.qspinlock.core;
import arch.s390x.cpu.processor;
import arch.s390x.cpu.clock;
import arch.s390x.cpu.sync;
import lib.static_vector;
import lib.error;
import std;
 
using zxfoundation::sys::printk::pinfo;
 
namespace {
 
constexpr usize CXA_ATEXIT_MAX = 256;
 
struct AtExitEntry {
    void (*destructor)(void*);
    void* obj;
    void* dso;
};
 
lib::static_vector<AtExitEntry, CXA_ATEXIT_MAX> g_atexit_table{};
 
alignas(4) zxfoundation::sync::qspinlock::qspinlock g_atexit_lock{};
auto atexit_lock()   noexcept -> void { g_atexit_lock.lock(); }
auto atexit_unlock() noexcept -> void { g_atexit_lock.unlock(); }
 
} // anonymous namespace
 
no_mangle {
 
extern void (*__init_array_start[])() __attribute__((weak));
 
extern void (*__init_array_end[])() __attribute__((weak));
 
extern void (*__fini_array_start[])() __attribute__((weak));
 
extern void (*__fini_array_end[])() __attribute__((weak));
 
extern void *__dso_handle __attribute__((weak));
 
}
 
no_mangle {
 
auto __cxa_atexit(void (*destructor)(void*), void* obj, void* dso) -> int {
    if (!destructor) return 0;
    atexit_lock();
    const bool ok = g_atexit_table.push_back({ destructor, obj, dso }).has_value();
    atexit_unlock();
    if (!ok) [[unlikely]] zxfoundation::sys::syschk::syschk_fatal(lib::kernel_error::from_generic(lib::generic_error::internal_error),
        "cxxrtse: __cxa_atexit: oom trying to handle atexit.");
    return 0;
}
 
auto __cxa_finalize(void* dso) -> void {
    atexit_lock();
    const usize snap = g_atexit_table.size();
    atexit_unlock();
 
    for (long i = static_cast<long>(snap) - 1; i >= 0; --i) {
        atexit_lock();
        AtExitEntry e = g_atexit_table[static_cast<usize>(i)];
        if (!e.destructor || (dso && e.dso != dso)) { atexit_unlock(); continue; }
        g_atexit_table[static_cast<usize>(i)].destructor = nullptr;
        atexit_unlock();
        e.destructor(e.obj);
    }
}
 
static constexpr u64 GUARD_INITIALIZED  = 1ULL << 0;
static constexpr u64 GUARD_IN_PROGRESS  = 1ULL << 1;
 
auto __cxa_guard_acquire(u64* g) -> int {
    if (__atomic_load_n(g, __ATOMIC_ACQUIRE) & GUARD_INITIALIZED) return 0;
 
    u64 expected = 0;
    if (__atomic_compare_exchange_n(g, &expected,
                                    GUARD_IN_PROGRESS,
                                    false,
                                    __ATOMIC_ACQUIRE,
                                    __ATOMIC_RELAXED)) {
        return 1; // We won — caller must initialize.
    }
 
    while (!(__atomic_load_n(g, __ATOMIC_ACQUIRE) & GUARD_INITIALIZED))
        arch::s390x::cpu::sync::cpu_relax();
    return 0;
}
 
auto __cxa_guard_release(u64* g) -> void {
    __atomic_store_n(g, GUARD_INITIALIZED, __ATOMIC_RELEASE);
}
 
auto __cxa_guard_abort(u64* g) -> void {
    __atomic_store_n(g, 0ULL, __ATOMIC_RELEASE);
}
 
[[noreturn]] auto __cxa_pure_virtual() -> void {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_pure_virtual(): call to pure virtual function. "
        "Object is being used before its derived constructor completed "
        "or the vtable is corrupt."
    );
}
 
[[noreturn]] auto __cxa_deleted_virtual() -> void {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_deleted_virtual(): call to explicitly deleted virtual function. "
        "The vtable is corrupt or an invalid base pointer was used."
    );
}
 
[[noreturn]] auto __cxa_bad_typeid() -> void {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_bad_typeid(): typeid applied to a null pointer. "
        "A pre-compiled object file likely contains RTTI usage."
    );
}
 
[[noreturn]] auto __cxa_throw(void *, void *, void (*)(void *)) -> void {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_throw(3): C++ exception thrown in a no-exception kernel context. "
        "A pre-compiled object file likely "
        "contains exception-throwing code that is incompatible with FoundationKit."
    );
}
 
[[noreturn]] auto __cxa_rethrow() -> void {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_rethrow(): rethrow attempted in a no-exception context. "
    );
}
 
auto __cxa_begin_catch(void*) -> void* {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_begin_catch(): catch block entered in a no-exception context."
    );
}
 
auto __cxa_end_catch() -> void {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_end_catch(): end-catch reached in a no-exception context."
    );
}
 
auto __cxa_allocate_exception(u64) -> void* {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_allocate_exception(): exception object allocation attempted "
        "in a no-exception context."
    );
}
 
auto __cxa_free_exception(void*) -> void* {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_generic(lib::generic_error::code::internal_error),
        "cxxabi: __cxa_free_exception(): exception object deallocation attempted "
        "in a no-exception context."
    );
}
 
/// @brief Global stack-protector guard value read by every `-fstack-protector`
///        function prologue/epilogue.
u64 __stack_chk_guard = 0x595A465353500001ULL; // "ZXFSSP" + version tag
 
[[gnu::no_stack_protector, noreturn]] auto __stack_chk_fail() -> void {
    zxfoundation::sys::syschk::syschk_fatal(
        lib::kernel_error::from_memory(lib::memory_error::ssp_check_fail),
        "cxxrtse: stack smashing detected"
    );
    __builtin_unreachable();
}
 
} // no_mangle
 
export {
 
namespace zxfoundation::base::cxxrtse::cxxabi {
 
    /// @brief Install the kernel-wide stack-protector guard entropy.
    /// @note One value is computed once on the BSP and used kernel-wide; APs do
    ///       not recompute it.  This is what makes the guard migration-safe
    ///       across CPUs (see the `__stack_chk_guard` rationale above).
    [[gnu::no_stack_protector]] void ssp_init() noexcept {
        __stack_chk_guard =
            arch::s390x::cpu::clock::stck() ^ 0xC0FFEE00FACADE42ULL;
    }
 
    /// @brief Read the active kernel-wide stack-protector guard value.
    /// @return The current `__stack_chk_guard`.
    [[nodiscard]] auto stack_guard() noexcept -> u64 {
        return __stack_chk_guard;
    }
 
    void run_global_constructor() noexcept {
        if (&__init_array_end == nullptr) [[unlikely]] {
            pinfo("cxxabi: __init_array_start or __init_array_end "
                "symbols are missing. No global constructors will be called. "
                "Check the kernel linker script.");
            return;
        }
 
        const auto count = static_cast<usize>(
            __init_array_end - __init_array_start);
 
        pinfo("cxxabi: running {} global constructors.", count);
 
        for (usize i = 0; i < count; ++i) {
            void (*fn)() = __init_array_start[i];
            if (fn == nullptr) [[unlikely]] {
                pinfo("cxxabi: null constructor pointer at index {}. "
                            "Possible linker script alignment issue. Skipping.", i);
                continue;
            }
            fn();
        }
 
        pinfo("cxxabi: all constructors completed.");
    }
 
    void run_fini_array() noexcept {
        if (!&__fini_array_end) [[unlikely]] {
            pinfo("cxxabi: __fini_array_start or __fini_array_end "
                "symbols are missing. No fini_array functions will be called.");
            return;
        }
 
        const auto count = static_cast<usize>(
            __fini_array_end - __fini_array_start);
 
        pinfo("cxxabi: running {} fini_array entries (reverse order).", count);
 
        // Reverse walk (LIFO).
        for (usize i = count; i > 0; --i) {
            void (*fn)() = __fini_array_start[i - 1];
            if (fn == nullptr) [[unlikely]] {
                pinfo("cxxabi: null fini_array pointer at index {}. Skipping.",
                            i - 1);
                continue;
            }
            fn();
        }
 
        pinfo("cxxabi: all fini_array entries completed.");
    }
 
    void run_global_destructors() noexcept {
        pinfo("cxxabi: running all registered atexit destructors.");
        __cxa_finalize(nullptr);
        run_fini_array();
        pinfo("cxxabi: all destructors completed.");
    }
 
}
 
}