rumpk/core/overrides.c

#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>

// ----------------------------------------------------------------------------
// Math Stubs (To avoid libcompiler_rt math.o)
// ----------------------------------------------------------------------------
double tan(double x) { return 0.0; }
double trunc(double x) { return (int64_t)x; }
float tanf(float x) { return 0.0f; }
float truncf(float x) { return (int32_t)x; }
double ceil(double x) { 
    long long i = (long long)x;
    if (x > i) return i + 1;
    return i;
}
double floor(double x) {
    long long i = (long long)x;
    if (x < i) return i - 1;
    return i;
}
double fmod(double x, double y) { return 0.0; } // Stub

/* atomic overrides commented out to prefer stubs.zig
// ----------------------------------------------------------------------------
// Atomic Overrides (To avoid libcompiler_rt atomics.o which uses medlow)
// ----------------------------------------------------------------------------
// These are called when the hardware doesn't support the size (e.g., 128-bit).
// Since we are single-threaded (or cooperative) on this core, we can cheat.
// WARNING: Not SMP safe without a global lock.

void ops_atomic_load(size_t size, void *ptr, void *ret, int model) {
    char *d = (char *)ret;
    char *s = (char *)ptr;
    for(size_t i=0; i<size; i++) d[i] = s[i];
}

void ops_atomic_store(size_t size, void *ptr, void *val, int model) {
    char *d = (char *)ptr;
    char *s = (char *)val;
    for(size_t i=0; i<size; i++) d[i] = s[i];
}

void ops_atomic_exchange(size_t size, void *ptr, void *val, void *ret, int model) {
    ops_atomic_load(size, ptr, ret, model);
    ops_atomic_store(size, ptr, val, model);
}

bool ops_atomic_compare_exchange(size_t size, void *ptr, void *expected, void *desired, bool weak, int success, int failure) {
    // memcmp
    char *p = (char *)ptr;
    char *e = (char *)expected;
    bool eq = true;
    for(size_t i=0; i<size; i++) {
        if (p[i] != e[i]) { eq = false; break; }
    }

    if (eq) {
        ops_atomic_store(size, ptr, desired, success);
        return true;
    } else {
        ops_atomic_store(size, expected, ptr, failure);
        return false;
    }
}

// 16-byte (128-bit) wrappers
void sovereign_atomic_load_16(void *ptr, void *ret, int model) {
    ops_atomic_load(16, ptr, ret, model);
}
void sovereign_atomic_store_16(void *ptr, void *val, int model) {
    ops_atomic_store(16, ptr, val, model);
}
void sovereign_atomic_exchange_16(void *ptr, void *val, void *ret, int model) {
    ops_atomic_exchange(16, ptr, val, ret, model);
}
bool sovereign_atomic_compare_exchange_16(void *ptr, void *expected, void *desired, bool weak, int success, int failure) {
    return ops_atomic_compare_exchange(16, ptr, expected, desired, weak, success, failure);
}

// Fetch Ops (Stubbed as NO-OPs or basic math if critical)
// These are rarely used on 128-bit types in standard logic.
// If needed, we implement them. For now, empty stubs to link.
// (Actually, let's just do a simple implementation for ADD/SUB to be safe)

// ===================================
// NOTE: We rely on re-symbol.txt in build.sh
// to redirect calls here.
// ===================================

#define ATOMIC_STUB(NAME) \
void sovereign_atomic_fetch_##NAME##_16(void *ptr, void *val, void *ret, int model) { \
    ops_atomic_load(16, ptr, ret, model); \
}

ATOMIC_STUB(add)
ATOMIC_STUB(sub)
ATOMIC_STUB(and)
ATOMIC_STUB(or)
ATOMIC_STUB(xor)
ATOMIC_STUB(nand)

void sovereign_atomic_fetch_umax_16(void *ptr, void *val, void *ret, int model) {
    ops_atomic_load(16, ptr, ret, model);
}
void sovereign_atomic_fetch_umin_16(void *ptr, void *val, void *ret, int model) {
    ops_atomic_load(16, ptr, ret, model);
}
void sovereign_atomic_fetch_max_16(void *ptr, void *val, void *ret, int model) {
    ops_atomic_load(16, ptr, ret, model);
}
void sovereign_atomic_fetch_min_16(void *ptr, void *val, void *ret, int model) {
    ops_atomic_load(16, ptr, ret, model);
}

// Check lock free (always true for us in kernel mode mostly, or false)
bool sovereign_atomic_is_lock_free(size_t size, void *ptr) {
    return true; // We are single core or spinlocked elsewhere
}
*/

// ===================================
// Compiler-RT Stubs (128-bit Math)
// ===================================

// 128-bit unsigned division
// We provide a simplified implementation or just broken one if rarely used.
// A full implementation is complex. We'll try a naive approach for small divisors (common case).
typedef unsigned __int128 uint128_t;
uint128_t __udivti3(uint128_t n, uint128_t d) {
    // Very dummy stub: if d fits in 64 bits and n fits in 64 bits, do it.
    // Otherwise return 0 (Dangerous, but fixes link).
    // TODO: Implement full division if this crashes.
    if ((d >> 64) == 0 && (n >> 64) == 0) {
        return (uint128_t)((uint64_t)n / (uint64_t)d);
    }
    return 0; 
}

// Float extensions
// RISC-V Q-extension emulation?
long double __extenddftf2(double a) {
    return (long double)a; // This might call itself recursively if compiled without Q?
    // If we loop, we need a hard stub.
    // return 0.0L;
}

long double __extendxftf2(long double a) {
    return a;
}