Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.3

0.1.3 / src / lower / expressions.lucb

# Expressions: literals, names, API members, operators, indexing, conversions, the
# conditional and array literals. Arithmetic is lane-wise over vectors, a scalar
# operand standing for every lane, and computes in the operands' own width.

extend Lowerer:
    ## Instructions from here on came from `node`'s line and column of the snippet module.
    func position(node: ast.Node*):
        let m = self.c.modules.get(self.snippet)
        let (file, line, column) = m.src.located(self.snippet_node(node).start)
        _ = file
        self.b.at(line, column)

    func expression(e: ast.Node*) -> Value!:
        self.position(e)
        match e.kind:
            .literal: return try self.literal(e)
            .name: return try self.name(e)
            .member: return try self.member(e)
            .index: return try self.index(e)
            .unary: return try self.unary(e)
            .binary: return try self.binary(e)
            .call: return try self.call(e)
            .cast: return try self.cast(e)
            .conditional: return try self.conditional(e)
            .array_lit: return try self.array(e)
            .group:
                let inner = e.left else return try self.fail_value(e, "an empty group")
                return try self.expression(inner)
            .self_:
                if self.receivers.length() == 0: return try self.fail_value(e, "`self` outside a method")
                return self.receivers.at(self.receivers.length() - 1)
            .formatted: return try self.not_available(e, "formatted text")
            _: return try self.fail_value(e, "this expression is not available in a kernel")

    # mark: Literals and names ================================================================

    func literal(e: ast.Node*) -> Value!:
        if e.text == "true" or e.text == "false":
            return self.scalar(.mask, self.b.constant_mask(e.text == "true"), true, types.bool_id)
        let (kind, width) = try self.shape_or_fail(e, e.type_id)
        _ = width
        let bits = self.literal_bits(e, kind, false) else return try self.fail_value(e, "a literal a kernel cannot read")
        return self.scalar(kind, self.b.constant(kind, bits), true, e.type_id)

    ## The bits of a literal (negated when `negative`) as `kind`; none for text.
    func literal_bits(e: ast.Node*, kind: Kind, negative: bool) -> u64?:
        let first = e.text.bytes[0] if e.text.length > 0 else 0
        if first == '"' or first == '\'' or first == 'b' or first == 'r' or first == 'f':
            return none
        if kind.is_float():
            var digits: u8[128]
            var used: usize = 0
            for byte in e.text.bytes:
                if byte == '_': continue
                if byte == 'f': break
                if used < 127:
                    digits[used] = byte
                    used += 1
            let text = (str)digits[..<used]
            if kind == .f32:
                let value = strings.parse_f32(text) catch failure: return none
                return (u64)(-value if negative else value).bits()
            let value = strings.parse_f64(text) catch failure: return none
            return (-value if negative else value).bits()
        let width: u64 = 64 if kind.size() == 8 else 32
        let value = self.c.exact_integer(e, width, kind.is_signed()) else return none
        let signed = -%value if negative else value
        return (u64)signed if width == 64 else (u64)(u32)signed

    func name(e: ast.Node*) -> Value!:
        let decl = e.resolved else return try self.fail_value(e, "a name the checker did not resolve")
        if let at = self.find_local(decl):
            return self.local_value(at)
        if decl.kind == ast.Kind.constant:
            let initial = decl.left else return try self.fail_value(e, "a constant without a value")
            return try self.converted(try self.expression(initial), decl.type_id, initial)
        if decl.kind == ast.Kind.param and self.is_element_number(decl):
            let (kind, width) = try self.shape_or_fail(e, decl.type_id)
            _ = width
            return self.scalar(kind, self.b.index(kind), false, decl.type_id)
        if self.api_type(e.type_id) != none:
            # The running element (`p`) or the kernel (`k`) passed on to a helper: the
            # helper reads them through their members, so the name carries no value.
            if decl.kind == ast.Kind.param:
                return self.nothing()
            return try self.fail_value(e, "an API value is used through its members, not as a value")
        return try self.not_available(e, "this name")

    ## `p.P`, `p.ptnum`, `k.time`, `math32.pi`.
    func member(e: ast.Node*) -> Value!:
        if let binding = self.binding_of(e.left, e.text):
            match binding.role:
                .field:
                    let at = try self.column_index(e, binding.column)
                    let use = self.columns.at(at)
                    var value = use.value
                    value.borrowed = use.pinned
                    return value
                .element:
                    let (kind, width) = try self.shape_or_fail(e, e.type_id)
                    _ = width
                    return self.scalar(kind, self.b.index(kind), false, e.type_id)
                .uniform:
                    return try self.uniform_value(e, binding.column, e.type_id, none)
                _:
                    return try self.fail_value(e, "this member is a method; call it")
        if let owner = e.left:
            if self.record(owner.type_id) != none:
                return try self.record_field(e, owner)
        let decl = e.resolved else return try self.not_available(e, "this member")
        if decl.kind == ast.Kind.constant:
            if let value = self.math_constant(decl):
                return value
            let initial = decl.left else return try self.fail_value(e, "a constant without a value")
            return try self.converted(try self.expression(initial), decl.type_id, initial)
        return try self.not_available(e, "this member")

    ## A field of a record value (`hit.prim`, `bounds.size`): its lanes of the record's.
    func record_field(e: ast.Node*, owner: ast.Node*) -> Value!:
        let whole = try self.expression(owner)
        let found = self.field_of(owner.type_id, e.text) else return try self.not_available(e, "this field")
        let (offset, kind, width, type_id) = found
        if offset + width > whole.width:
            return try self.fail_value(e, "internal: a field past its record")
        var value = self.scalar(kind, whole.lanes[offset], whole.uniform, type_id)
        value.width = width
        value.borrowed = whole.borrowed
        for k in 0..<width: value.lanes[k] = whole.lanes[offset + k]
        return value

    ## `math.pi` and its siblings, built from bits where luce-std computes them.
    func math_constant(decl: ast.Node*) -> Value?:
        let wide = decl.type_id == types.f64_id
        if not wide and decl.type_id != types.f32_id:
            return none
        var value: f64 = 0.0
        if decl.text == "pi": value = 3.141592653589793
        elif decl.text == "tau": value = 6.283185307179586
        elif decl.text == "e": value = 2.718281828459045
        elif decl.text == "infinity": value = f64.bits(0x7FF0000000000000)
        elif decl.text == "nan": value = f64.bits(0x7FF8000000000000)
        else: return none
        if wide:
            return self.scalar(.f64, self.b.constant_f64(value), true, decl.type_id)
        return self.scalar(.f32, self.b.constant_f32((f32)value), true, decl.type_id)

    ## Uniform `name` of `type_id`, a vector's lanes named `name[k]`, with the default a
    ## literal (or, for a vector, an array literal of them) gives.
    func uniform_value(e: ast.Node*, name: str, type_id: u32, default: ast.Node*?, lanes: usize = 32) -> Value!:
        let (kind, width) = try self.shape_or_fail(e, type_id)
        var defaults: u64[32]
        if let given = default:
            if given.kind == ast.Kind.array_lit:
                var cursor = given.body
                var at: usize = 0
                while let element = cursor:
                    if at < 32: defaults[at] = try self.default_bits(element, kind)
                    at += 1
                    cursor = element.next
            else:
                let bits = try self.default_bits(given, kind)
                for k in 0..<width: defaults[k] = bits
        var value = self.scalar(kind, 0, true, type_id)
        value.width = width
        for k in 0..<width:
            if k >= lanes:
                value.lanes[k] = self.b.constant(kind, 0)
            elif width == 1:
                value.lanes[k] = self.b.uniform(name, kind, defaults[0])
            else:
                var room: u8[300]
                let lane_name = strings.format(room, f"{name}[{k}]") else name
                value.lanes[k] = self.b.uniform(try self.texts.keep_text(lane_name.bytes), kind, defaults[k])
        return value

    ## The bits of a literal default (a negative number included) as `kind`.
    func default_bits(given: ast.Node*, kind: Kind) -> u64!:
        var negative = false
        var literal_node = given
        if given.kind == ast.Kind.unary and given.text == "-":
            if let inner = given.left:
                negative = true
                literal_node = inner
        if literal_node.kind != ast.Kind.literal:
            try self.fail(given, "a parameter's default must be a literal")
        if let bits = self.literal_bits(literal_node, kind, negative):
            return bits
        try self.fail(given, "a parameter's default must be a number")
        return 0

    # mark: Indexing ==========================================================================

    func index(e: ast.Node*) -> Value!:
        let owner_node = e.left else return self.nothing()
        let index_node = e.body else return self.nothing()
        let owner = try self.expression(owner_node)
        if let constant = self.c.exact_integer(index_node, 64, true):
            let lane = try self.lane_number(index_node, constant, owner_node)
            var value = self.scalar(owner.kind, owner.lanes[lane], owner.uniform, e.type_id)
            value.borrowed = owner.borrowed
            return value
        let at = try self.expression(index_node)
        self.position(e)
        self.sync()
        let picked = self.b.pick(self.consecutive(owner), owner.width, at.lanes[0])
        return self.scalar(owner.kind, picked, owner.uniform and at.uniform, e.type_id)

    # mark: Operators =========================================================================

    func unary(e: ast.Node*) -> Value!:
        let operand_node = e.left else return self.nothing()
        if e.text == "-" and operand_node.kind == ast.Kind.literal:
            let (kind, width) = try self.shape_or_fail(e, e.type_id)
            _ = width
            if let bits = self.literal_bits(operand_node, kind, true):
                return self.scalar(kind, self.b.constant(kind, bits), true, e.type_id)
        let operand = try self.expression(operand_node)
        self.position(e)
        let op: Op = match e.text:
            "-" => Op.neg
            "-%" => Op.wneg
            "~", "not" => Op.bnot
            _ => Op.copy
        if op == .copy:
            return try self.not_available(e, "pointers")
        if op == .neg and not operand.kind.is_float():
            self.sync()
        var result = operand
        result.borrowed = false
        result.type_id = e.type_id
        for k in 0..<operand.width:
            result.lanes[k] = self.b.unary(op, operand.lanes[k])
        return result

    func binary(e: ast.Node*) -> Value!:
        let left_node = e.left else return self.nothing()
        let right_node = e.right else return self.nothing()
        if e.text == "and" or e.text == "or":
            return try self.logical(e, left_node, right_node)
        if e.text == "+?" or e.text == "-?" or e.text == "*?":
            return try self.not_available(e, "optional arithmetic")
        let left = try self.expression(left_node)
        let right = try self.expression(right_node)
        self.position(e)
        let value = try self.operate(e, e.text, left, try self.converted_operand(right, left, right_node))
        var typed = value
        if value.kind != .mask: typed.type_id = e.type_id
        return typed

    ## `a and b`, `a or b`: `b` runs only on the lanes it decides (it may fault).
    func logical(e: ast.Node*, left_node: ast.Node*, right_node: ast.Node*) -> Value!:
        let left = try self.expression(left_node)
        let both = e.text == "and"
        if not may_fault(right_node):
            let right = try self.expression(right_node)
            let joined = self.b.binary(.band if both else .bor, left.lanes[0], right.lanes[0])
            return self.scalar(.mask, joined, left.uniform and right.uniform, types.bool_id)
        let deciding = left.lanes[0] if both else self.b.unary(.bnot, left.lanes[0])
        let result = self.b.copy(left.lanes[0])
        try self.push_frame(deciding)
        let skip = self.b.label()
        self.skip_if_idle(skip)
        let right = try self.expression(right_node)
        self.sync()
        self.b.assign(result, right.lanes[0])
        self.pop_frame()
        self.join(skip)
        return self.scalar(.mask, result, left.uniform and right.uniform, types.bool_id)

    ## `a op b` lane by lane (a scalar standing for every lane of a vector).
    func operate(node: ast.Node*, symbol: str, a: Value, b: Value) -> Value!:
        let op = operator(symbol, a.kind) else return try self.not_available(node, "this operator")
        if not op.accepts(a.kind):
            return try self.not_available(node, "this operator on this type")
        if op == .eq or op == .ne or op == .lt or op == .le or op == .gt or op == .ge:
            if a.width != 1:
                return try self.not_available(node, "comparing vectors")
            return self.scalar(.mask, self.b.compare(op, a.lanes[0], b.lanes[0]), a.uniform and b.uniform, types.bool_id)
        if faults(op, a.kind):
            self.sync()
        let width = a.width if a.width > b.width else b.width
        var result = a if a.width >= b.width else b
        result.borrowed = false
        result.uniform = a.uniform and b.uniform
        for k in 0..<width:
            let x = a.lanes[k] if a.width > 1 else a.lanes[0]
            let y = b.lanes[k] if b.width > 1 else b.lanes[0]
            result.lanes[k] = self.b.binary(op, x, y)
        return result

    ## The right operand in the left one's kind: an integer widened, a shift count cast.
    func converted_operand(right: Value, left: Value, node: ast.Node*) -> Value!:
        if right.kind == left.kind:
            return right
        if left.width > 1 and right.width == 1 and right.kind == left.kind:
            return right
        if right.kind.is_integer() and left.kind.is_integer():
            var cast = right
            for k in 0..<right.width:
                cast.lanes[k] = self.b.cast(right.lanes[k], left.kind)
            cast.kind = left.kind
            cast.borrowed = false
            return cast
        return try self.fail_value(node, "operands of different types")

    # mark: Conversions =======================================================================

    ## `value` as type `type_id`: the same registers when it already is, an integer widened
    ## (the conversion Base makes without a spelling).
    func converted(value: Value, type_id: u32, node: ast.Node*) -> Value!:
        if value.mixed or value.handle:
            if value.type_id != type_id and self.record(type_id) == none:
                return try self.fail_value(node, "a value of another type than expected")
            return value
        let (kind, width) = try self.shape_or_fail(node, type_id)
        if value.kind == kind and value.width == width:
            var same = value
            same.type_id = type_id
            return same
        if value.width == width and value.kind.is_integer() and kind.is_integer():
            var cast = value
            for k in 0..<width:
                cast.lanes[k] = self.b.cast(value.lanes[k], kind)
            cast.kind = kind
            cast.type_id = type_id
            cast.borrowed = false
            return cast
        return try self.fail_value(node, "a value of another type than expected")

    ## `(T)x`: C's cast, lane by lane.
    func cast(e: ast.Node*) -> Value!:
        let operand_node = e.left else return self.nothing()
        let operand = try self.expression(operand_node)
        let (kind, width) = try self.shape_or_fail(e, e.type_id)
        if width != operand.width:
            return try self.not_available(e, "this cast")
        var result = operand
        result.kind = kind
        result.type_id = e.type_id
        result.borrowed = false
        if operand.kind != kind:
            for k in 0..<width:
                result.lanes[k] = self.b.cast(operand.lanes[k], kind)
        return result

    # mark: Conditional and arrays ============================================================

    ## `x if c else y`: each side computed on its own lanes when it could fault.
    func conditional(e: ast.Node*) -> Value!:
        let decision_node = e.ty else return self.nothing()
        let then_node = e.left else return self.nothing()
        let else_node = e.right else return self.nothing()
        let decision = try self.expression(decision_node)
        if not may_fault(then_node) and not may_fault(else_node):
            let yes = try self.converted(try self.expression(then_node), e.type_id, then_node)
            let no = try self.converted(try self.expression(else_node), e.type_id, else_node)
            var result = yes
            result.borrowed = false
            result.uniform = decision.uniform and yes.uniform and no.uniform
            for k in 0..<yes.width:
                result.lanes[k] = self.b.select(decision.lanes[0], yes.lanes[k], no.lanes[k])
            return result
        let held = self.copied(try self.zero_value(e, e.type_id))
        try self.side(decision.lanes[0], then_node, held, e.type_id)
        try self.side(self.b.unary(.bnot, decision.lanes[0]), else_node, held, e.type_id)
        var result = held
        result.uniform = false
        return result

    ## Compute `node` on the lanes in `mask` into `held`.
    func side(mask: u16, node: ast.Node*, held: Value, type_id: u32) -> !:
        try self.push_frame(mask)
        let skip = self.b.label()
        self.skip_if_idle(skip)
        let value = try self.converted(try self.expression(node), type_id, node)
        self.write_registers(held, value, every_lane, false)
        self.pop_frame()
        self.join(skip)

    func array(e: ast.Node*) -> Value!:
        let (kind, width) = try self.shape_or_fail(e, e.type_id)
        let element_type = self.c.table.get(e.type_id).elem
        var result = self.scalar(kind, 0, true, e.type_id)
        result.width = width
        var cursor = e.body
        var at: usize = 0
        while let element = cursor:
            if at >= width:
                return try self.fail_value(element, "an array literal longer than its type")
            let value = try self.converted(try self.expression(element), element_type, element)
            result.lanes[at] = value.lanes[0]
            result.uniform = result.uniform and value.uniform
            at += 1
            cursor = element.next
        return result

## The operation a binary operator spells for operands of `kind`.
func operator(symbol: str, kind: Kind) -> Op?:
    let floating = kind.is_float()
    if symbol == "+": return Op.add
    if symbol == "-": return Op.sub
    if symbol == "*": return Op.mul
    if symbol == "/": return Op.div
    if symbol == "//": return Op.idiv
    if symbol == "%": return Op.fmod if floating else Op.rem
    if symbol == "+%": return Op.wadd
    if symbol == "-%": return Op.wsub
    if symbol == "*%": return Op.wmul
    if symbol == "+|": return Op.sadd
    if symbol == "-|": return Op.ssub
    if symbol == "*|": return Op.smul
    if symbol == "&": return Op.band
    if symbol == "|": return Op.bor
    if symbol == "^": return Op.bxor
    if symbol == "<<": return Op.shl
    if symbol == ">>": return Op.shr
    if symbol == "==": return Op.eq
    if symbol == "!=": return Op.ne
    if symbol == "<": return Op.lt
    if symbol == "<=": return Op.le
    if symbol == ">": return Op.gt
    if symbol == ">=": return Op.ge
    return none

## Whether `op` on `kind` can fault (and so needs the exec mask set).
func faults(op: Op, kind: Kind) -> bool:
    if kind.is_float():
        return false
    return op == .add or op == .sub or op == .mul or op == .idiv or op == .rem or op == .shl or op == .shr or op == .neg or op == .abs

## Whether evaluating `e` could fault: integer arithmetic, conversions, indexing by a
## value, and calls (which may assert).
func may_fault(e: ast.Node*?) -> bool:
    let node = e else return false
    match node.kind:
        .literal, .name:
            return false
        .call, .index:
            return true
        .binary:
            let integer = node.type_id != types.f32_id and node.type_id != types.f64_id and node.type_id != types.bool_id
            if integer and node.text != "&" and node.text != "|" and node.text != "^" and node.text != "+%" and node.text != "-%" and node.text != "*%":
                return true
            return may_fault(node.left) or may_fault(node.right)
        .unary:
            return (node.text == "-" and node.type_id != types.f32_id and node.type_id != types.f64_id) or may_fault(node.left)
        _:
            var cursor = node.body
            while let child = cursor:
                if may_fault(child): return true
                cursor = child.next
            return may_fault(node.left) or may_fault(node.right) or may_fault(node.ty)