Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.3

0.1.3 / src / engine / lanes_compare.lucb

# Generated by tools/lanes.py from its tables; edit those, not this file.
# Compares (mask results) and ternary lane operations.

## Run a compare or ternary instruction; never faults.
func compare_or_ternary(w: Worker*, ins: Instruction) -> usize:
    match ins.op:
        .eq:
            match ins.kind:
                .f32: eq_f32(w.masks(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: eq_f64(w.masks(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: eq_i32(w.masks(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: eq_i64(w.masks(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: eq_u32(w.masks(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: eq_u64(w.masks(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                .mask: eq_mask(w.masks(ins.dst), w.masks(ins.a), w.masks(ins.b))
                _: return w.n
        .ne:
            match ins.kind:
                .f32: ne_f32(w.masks(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: ne_f64(w.masks(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: ne_i32(w.masks(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: ne_i64(w.masks(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: ne_u32(w.masks(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: ne_u64(w.masks(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                .mask: ne_mask(w.masks(ins.dst), w.masks(ins.a), w.masks(ins.b))
                _: return w.n
        .lt:
            match ins.kind:
                .f32: lt_f32(w.masks(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: lt_f64(w.masks(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: lt_i32(w.masks(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: lt_i64(w.masks(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: lt_u32(w.masks(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: lt_u64(w.masks(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .le:
            match ins.kind:
                .f32: le_f32(w.masks(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: le_f64(w.masks(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: le_i32(w.masks(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: le_i64(w.masks(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: le_u32(w.masks(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: le_u64(w.masks(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .gt:
            match ins.kind:
                .f32: gt_f32(w.masks(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: gt_f64(w.masks(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: gt_i32(w.masks(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: gt_i64(w.masks(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: gt_u32(w.masks(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: gt_u64(w.masks(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .ge:
            match ins.kind:
                .f32: ge_f32(w.masks(ins.dst), w.f32s(ins.a), w.f32s(ins.b))
                .f64: ge_f64(w.masks(ins.dst), w.f64s(ins.a), w.f64s(ins.b))
                .i32: ge_i32(w.masks(ins.dst), w.i32s(ins.a), w.i32s(ins.b))
                .i64: ge_i64(w.masks(ins.dst), w.i64s(ins.a), w.i64s(ins.b))
                .u32: ge_u32(w.masks(ins.dst), w.u32s(ins.a), w.u32s(ins.b))
                .u64: ge_u64(w.masks(ins.dst), w.u64s(ins.a), w.u64s(ins.b))
                _: return w.n
        .mul_add:
            match ins.kind:
                .f32: mul_add_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b), w.f32s(ins.c))
                .f64: mul_add_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b), w.f64s(ins.c))
                _: return w.n
        .lerp:
            match ins.kind:
                .f32: lerp_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b), w.f32s(ins.c))
                .f64: lerp_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b), w.f64s(ins.c))
                _: return w.n
        .clamp:
            match ins.kind:
                .f32: clamp_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b), w.f32s(ins.c))
                .f64: clamp_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b), w.f64s(ins.c))
                .i32: clamp_i32(w.i32s(ins.dst), w.i32s(ins.a), w.i32s(ins.b), w.i32s(ins.c))
                .i64: clamp_i64(w.i64s(ins.dst), w.i64s(ins.a), w.i64s(ins.b), w.i64s(ins.c))
                .u32: clamp_u32(w.u32s(ins.dst), w.u32s(ins.a), w.u32s(ins.b), w.u32s(ins.c))
                .u64: clamp_u64(w.u64s(ins.dst), w.u64s(ins.a), w.u64s(ins.b), w.u64s(ins.c))
                _: return w.n
        .smooth:
            match ins.kind:
                .f32: smooth_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b), w.f32s(ins.c))
                .f64: smooth_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b), w.f64s(ins.c))
                _: return w.n
        .fit01:
            match ins.kind:
                .f32: fit01_f32(w.f32s(ins.dst), w.f32s(ins.a), w.f32s(ins.b), w.f32s(ins.c))
                .f64: fit01_f64(w.f64s(ins.dst), w.f64s(ins.a), w.f64s(ins.b), w.f64s(ins.c))
                _: return w.n
        _: return w.n
    return w.n

func eq_f32(d: u8[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] == b[i])

func eq_f64(d: u8[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] == b[i])

func eq_i32(d: u8[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] == b[i])

func eq_i64(d: u8[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] == b[i])

func eq_u32(d: u8[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] == b[i])

func eq_u64(d: u8[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] == b[i])

func eq_mask(d: u8[], a: const u8[], b: const u8[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] == b[i])

func ne_f32(d: u8[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != b[i])

func ne_f64(d: u8[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != b[i])

func ne_i32(d: u8[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != b[i])

func ne_i64(d: u8[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != b[i])

func ne_u32(d: u8[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != b[i])

func ne_u64(d: u8[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != b[i])

func ne_mask(d: u8[], a: const u8[], b: const u8[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] != b[i])

func lt_f32(d: u8[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] < b[i])

func lt_f64(d: u8[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] < b[i])

func lt_i32(d: u8[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] < b[i])

func lt_i64(d: u8[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] < b[i])

func lt_u32(d: u8[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] < b[i])

func lt_u64(d: u8[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] < b[i])

func le_f32(d: u8[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] <= b[i])

func le_f64(d: u8[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] <= b[i])

func le_i32(d: u8[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] <= b[i])

func le_i64(d: u8[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] <= b[i])

func le_u32(d: u8[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] <= b[i])

func le_u64(d: u8[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] <= b[i])

func gt_f32(d: u8[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] > b[i])

func gt_f64(d: u8[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] > b[i])

func gt_i32(d: u8[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] > b[i])

func gt_i64(d: u8[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] > b[i])

func gt_u32(d: u8[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] > b[i])

func gt_u64(d: u8[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] > b[i])

func ge_f32(d: u8[], a: const f32[], b: const f32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] >= b[i])

func ge_f64(d: u8[], a: const f64[], b: const f64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] >= b[i])

func ge_i32(d: u8[], a: const i32[], b: const i32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] >= b[i])

func ge_i64(d: u8[], a: const i64[], b: const i64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] >= b[i])

func ge_u32(d: u8[], a: const u32[], b: const u32[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] >= b[i])

func ge_u64(d: u8[], a: const u64[], b: const u64[]):
    assert(a.length == d.length and b.length == d.length)
    for i in 0..<d.length: d[i] = (u8)(a[i] >= b[i])

func mul_add_f32(d: f32[], a: const f32[], b: const f32[], c: const f32[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = a[i].mul_add(b[i], c[i])

func mul_add_f64(d: f64[], a: const f64[], b: const f64[], c: const f64[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = a[i].mul_add(b[i], c[i])

func lerp_f32(d: f32[], a: const f32[], b: const f32[], c: const f32[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = lib.lerp(a[i], b[i], c[i])

func lerp_f64(d: f64[], a: const f64[], b: const f64[], c: const f64[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = lib.lerp64(a[i], b[i], c[i])

func clamp_f32(d: f32[], a: const f32[], b: const f32[], c: const f32[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = b[i] if a[i] < b[i] else (c[i] if a[i] > c[i] else a[i])

func clamp_f64(d: f64[], a: const f64[], b: const f64[], c: const f64[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = b[i] if a[i] < b[i] else (c[i] if a[i] > c[i] else a[i])

func clamp_i32(d: i32[], a: const i32[], b: const i32[], c: const i32[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = b[i] if a[i] < b[i] else (c[i] if a[i] > c[i] else a[i])

func clamp_i64(d: i64[], a: const i64[], b: const i64[], c: const i64[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = b[i] if a[i] < b[i] else (c[i] if a[i] > c[i] else a[i])

func clamp_u32(d: u32[], a: const u32[], b: const u32[], c: const u32[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = b[i] if a[i] < b[i] else (c[i] if a[i] > c[i] else a[i])

func clamp_u64(d: u64[], a: const u64[], b: const u64[], c: const u64[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = b[i] if a[i] < b[i] else (c[i] if a[i] > c[i] else a[i])

func smooth_f32(d: f32[], a: const f32[], b: const f32[], c: const f32[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = lib.smooth(a[i], b[i], c[i])

func smooth_f64(d: f64[], a: const f64[], b: const f64[], c: const f64[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = lib.smooth64(a[i], b[i], c[i])

func fit01_f32(d: f32[], a: const f32[], b: const f32[], c: const f32[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = lib.fit01(a[i], b[i], c[i])

func fit01_f64(d: f64[], a: const f64[], b: const f64[], c: const f64[]):
    assert(a.length == d.length and b.length == d.length and c.length == d.length)
    for i in 0..<d.length: d[i] = lib.fit01_64(a[i], b[i], c[i])