Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.1

0.1.1 / src / engine / lanes_unary.lucb

# Generated by tools/lanes.py from its tables; edit those, not this file.
# Unary lane operations and float classifications: d = op a.

## Run a unary or classifying instruction; the lowest faulting lane, or the lane count.
func unary(w: Worker*, ins: Instruction) -> usize:
    match ins.op:
        .neg:
            match ins.kind:
                .f32: neg_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: neg_f64(w.f64s(ins.dst), w.f64s(ins.a))
                .i32: return neg_i32(w.i32s(ins.dst), w.i32s(ins.a), w.on())
                .i64: return neg_i64(w.i64s(ins.dst), w.i64s(ins.a), w.on())
                _: return w.n
        .wneg:
            match ins.kind:
                .i32: wneg_i32(w.i32s(ins.dst), w.i32s(ins.a))
                .i64: wneg_i64(w.i64s(ins.dst), w.i64s(ins.a))
                .u32: wneg_u32(w.u32s(ins.dst), w.u32s(ins.a))
                .u64: wneg_u64(w.u64s(ins.dst), w.u64s(ins.a))
                _: return w.n
        .abs:
            match ins.kind:
                .f32: abs_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: abs_f64(w.f64s(ins.dst), w.f64s(ins.a))
                .i32: return abs_i32(w.i32s(ins.dst), w.i32s(ins.a), w.on())
                .i64: return abs_i64(w.i64s(ins.dst), w.i64s(ins.a), w.on())
                _: return w.n
        .bnot:
            match ins.kind:
                .i32: bnot_i32(w.i32s(ins.dst), w.i32s(ins.a))
                .i64: bnot_i64(w.i64s(ins.dst), w.i64s(ins.a))
                .u32: bnot_u32(w.u32s(ins.dst), w.u32s(ins.a))
                .u64: bnot_u64(w.u64s(ins.dst), w.u64s(ins.a))
                .mask: bnot_mask(w.masks(ins.dst), w.masks(ins.a))
                _: return w.n
        .sqrt:
            match ins.kind:
                .f32: sqrt_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: sqrt_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .cbrt:
            match ins.kind:
                .f32: cbrt_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: cbrt_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .exp:
            match ins.kind:
                .f32: exp_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: exp_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .exp2:
            match ins.kind:
                .f32: exp2_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: exp2_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .log:
            match ins.kind:
                .f32: log_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: log_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .log2:
            match ins.kind:
                .f32: log2_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: log2_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .log10:
            match ins.kind:
                .f32: log10_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: log10_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .sin:
            match ins.kind:
                .f32: sin_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: sin_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .cos:
            match ins.kind:
                .f32: cos_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: cos_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .tan:
            match ins.kind:
                .f32: tan_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: tan_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .asin:
            match ins.kind:
                .f32: asin_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: asin_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .acos:
            match ins.kind:
                .f32: acos_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: acos_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .atan:
            match ins.kind:
                .f32: atan_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: atan_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .sinh:
            match ins.kind:
                .f32: sinh_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: sinh_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .cosh:
            match ins.kind:
                .f32: cosh_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: cosh_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .tanh:
            match ins.kind:
                .f32: tanh_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: tanh_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .floor:
            match ins.kind:
                .f32: floor_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: floor_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .ceil:
            match ins.kind:
                .f32: ceil_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: ceil_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .round:
            match ins.kind:
                .f32: round_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: round_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .trunc:
            match ins.kind:
                .f32: trunc_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: trunc_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .sign:
            match ins.kind:
                .f32: sign_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: sign_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .frac:
            match ins.kind:
                .f32: frac_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: frac_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .degrees:
            match ins.kind:
                .f32: degrees_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: degrees_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .radians:
            match ins.kind:
                .f32: radians_f32(w.f32s(ins.dst), w.f32s(ins.a))
                .f64: radians_f64(w.f64s(ins.dst), w.f64s(ins.a))
                _: return w.n
        .isnan:
            match ins.kind:
                .f32: isnan_f32(w.masks(ins.dst), w.f32s(ins.a))
                .f64: isnan_f64(w.masks(ins.dst), w.f64s(ins.a))
                _: return w.n
        .isinf:
            match ins.kind:
                .f32: isinf_f32(w.masks(ins.dst), w.f32s(ins.a))
                .f64: isinf_f64(w.masks(ins.dst), w.f64s(ins.a))
                _: return w.n
        .isfinite:
            match ins.kind:
                .f32: isfinite_f32(w.masks(ins.dst), w.f32s(ins.a))
                .f64: isfinite_f64(w.masks(ins.dst), w.f64s(ins.a))
                _: return w.n
        _: return w.n
    return w.n

func neg_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = -a[i]

func neg_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = -a[i]

func neg_i32(d: i32[], a: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] == (-2147483648):
            if on.at(i): return i
            d[i] = a[i]
        else:
            d[i] = -a[i]
    return d.length

func neg_i64(d: i64[], a: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] == (-9223372036854775808):
            if on.at(i): return i
            d[i] = a[i]
        else:
            d[i] = -a[i]
    return d.length

func wneg_i32(d: i32[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = -%a[i]

func wneg_i64(d: i64[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = -%a[i]

func wneg_u32(d: u32[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = -%a[i]

func wneg_u64(d: u64[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = -%a[i]

func abs_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.abs(a[i])

func abs_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.abs(a[i])

func abs_i32(d: i32[], a: const i32[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] == (-2147483648):
            if on.at(i): return i
            d[i] = a[i]
        else:
            d[i] = a[i] if a[i] >= 0 else -a[i]
    return d.length

func abs_i64(d: i64[], a: const i64[], on: Active) -> usize:
    for i in 0..<d.length:
        if a[i] == (-9223372036854775808):
            if on.at(i): return i
            d[i] = a[i]
        else:
            d[i] = a[i] if a[i] >= 0 else -a[i]
    return d.length

func bnot_i32(d: i32[], a: const i32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = ~a[i]

func bnot_i64(d: i64[], a: const i64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = ~a[i]

func bnot_u32(d: u32[], a: const u32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = ~a[i]

func bnot_u64(d: u64[], a: const u64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = ~a[i]

func bnot_mask(d: u8[], a: const u8[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i] ^ 1

func sqrt_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.sqrt(a[i])

func sqrt_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.sqrt(a[i])

func cbrt_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.cbrt(a[i])

func cbrt_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.cbrt(a[i])

func exp_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.exp(a[i])

func exp_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.exp(a[i])

func exp2_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.exp2(a[i])

func exp2_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.exp2(a[i])

func log_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.log(a[i])

func log_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.log(a[i])

func log2_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.log2(a[i])

func log2_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.log2(a[i])

func log10_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.log10(a[i])

func log10_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.log10(a[i])

func sin_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.sin(a[i])

func sin_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.sin(a[i])

func cos_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.cos(a[i])

func cos_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.cos(a[i])

func tan_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.tan(a[i])

func tan_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.tan(a[i])

func asin_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.asin(a[i])

func asin_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.asin(a[i])

func acos_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.acos(a[i])

func acos_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.acos(a[i])

func atan_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.atan(a[i])

func atan_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.atan(a[i])

func sinh_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.sinh(a[i])

func sinh_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.sinh(a[i])

func cosh_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.cosh(a[i])

func cosh_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.cosh(a[i])

func tanh_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.tanh(a[i])

func tanh_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.tanh(a[i])

func floor_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.floor(a[i])

func floor_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.floor(a[i])

func ceil_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.ceil(a[i])

func ceil_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.ceil(a[i])

func round_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.round(a[i])

func round_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.round(a[i])

func trunc_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.trunc(a[i])

func trunc_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.trunc(a[i])

func sign_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math32.sign(a[i])

func sign_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = math.sign(a[i])

func frac_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i] - math32.floor(a[i])

func frac_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i] - math.floor(a[i])

func degrees_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i] * (180.0 / math32.pi)

func degrees_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i] * (180.0 / math.pi)

func radians_f32(d: f32[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i] * (math32.pi / 180.0)

func radians_f64(d: f64[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = a[i] * (math.pi / 180.0)

func isnan_f32(d: u8[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)math32.is_nan(a[i])

func isnan_f64(d: u8[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)math.is_nan(a[i])

func isinf_f32(d: u8[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)math32.is_infinite(a[i])

func isinf_f64(d: u8[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)math.is_infinite(a[i])

func isfinite_f32(d: u8[], a: const f32[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)math32.is_finite(a[i])

func isfinite_f64(d: u8[], a: const f64[]):
    assert(a.length == d.length)
    for i in 0..<d.length: d[i] = (u8)math.is_finite(a[i])