ludic/selfhost/emit_expr.ludic

# emit_expr.ludic — lower an expression to IR, returning its register and type.

fn emit_load_at(addr: ptr, ty: ptr) -> Val {
  let r = emit_bind(`load {llty(ty)}, ptr {addr}`)
  return val(r, ty)
}

# short-circuit `and`/`or`: seed a slot with (left!=0), branch to decide whether
# to overwrite with (right!=0).
fn emit_logic(e: Node) -> Val {
  let slot = emit_alloca("i32")
  let la = emit_expr(e.a)
  let lc = emit_bind(`icmp ne i32 {la.code}, 0`)
  let lz = emit_bind(`zext i1 {lc} to i32`)
  emit("  store i32 ");  emit(lz);  emit(", ptr ");  emit(slot);  emit("\n")
  let ev = lbl("sc");  let done = lbl("scend")
  if (e.s == "and") { emit("  br i1 ");  emit(lc);  emit(", label %");  emit(ev);  emit(", label %");  emit(done);  emit("\n") }
  else { emit("  br i1 ");  emit(lc);  emit(", label %");  emit(done);  emit(", label %");  emit(ev);  emit("\n") }
  emit(ev);  emit(":\n")
  let rb = emit_expr(e.b)
  let rc = emit_bind(`icmp ne i32 {rb.code}, 0`)
  let rz = emit_bind(`zext i1 {rc} to i32`)
  emit("  store i32 ");  emit(rz);  emit(", ptr ");  emit(slot);  emit("\n")
  emit("  br label %");  emit(done);  emit("\n")
  emit(done);  emit(":\n")
  return val(emit_bind(`load i32, ptr {slot}`), "bool")
}

fn cmp_code(op: ptr) -> ptr {
  if (op == ("<"))  { return "slt" }
  if (op == ("<=")) { return "sle" }
  if (op == (">"))  { return "sgt" }
  if (op == (">=")) { return "sge" }
  if (op == ("==")) { return "eq" }
  return "ne"
}
fn is_cmp(op: ptr) -> bool {
  return (op == ("<")) or (op == ("<=")) or (op == (">")) or (op == (">=")) or (op == ("==")) or (op == ("!="))
}
fn arith_code(op: ptr) -> ptr {
  if (op == ("+")) { return "add" }
  if (op == ("-")) { return "sub" }
  if (op == ("*")) { return "mul" }
  if (op == ("/")) { return "sdiv" }
  if (op == ("&")) { return "and" }
  if (op == ("|")) { return "or" }
  if (op == ("^")) { return "xor" }
  if (op == ("<<")) { return "shl" }
  if (op == (">>")) { return "lshr" }             # logical shift (unsigned)
  return "srem"
}

# widen an int value to Q16.16 by shifting left 16 (a fixed value passes through)
fn to_fixed(v: Val) -> ptr {
  if (v.ty == "fixed") { return v.code }
  return emit_bind(`shl i32 {v.code}, 16`)
}

# string operators: `a + b` concatenates, `a == b` / `a != b` compare by content.
# Both call the @fn_str_* prelude (emitted once per program that uses them).
fn emit_str_op(op: ptr, a: Val, b: Val) -> Val {
  g_uses_str = true
  if (op == ("+")) {
    return val(emit_bind(`call ptr @fn_str_concat(ptr {a.code}, ptr {b.code})`), "str")
  }
  let r = emit_bind(`call i32 @fn_str_eq(ptr {a.code}, ptr {b.code})`)
  if (op == ("!=")) {
    let c = emit_bind(`icmp eq i32 {r}, 0`)
    return val(emit_bind(`zext i1 {c} to i32`), "bool")
  }
  return val(r, "bool")
}

fn emit_bin(e: Node) -> Val {
  if (e.s == "and") or (e.s == "or") { return emit_logic(e) }
  let a = emit_expr(e.a)
  let b = emit_expr(e.b)
  # strings are pointer-typed, so any `+` with a pointer operand is concatenation,
  # and `==`/`!=` between pointers is content comparison — except `x == null`,
  # which is a pointer-identity test and falls through to the icmp below.
  let ptrish = (llty(a.ty) == "ptr") or (llty(b.ty) == "ptr")
  let isnull = e.a.kind == E_NULL or e.b.kind == E_NULL
  if ptrish {
    if (e.s == ("+")) { return emit_str_op("+", a, b) }
    if ((e.s == ("==")) or (e.s == ("!="))) and not isnull { return emit_str_op(e.s, a, b) }
  }
  let fx = (a.ty == "fixed") or (b.ty == "fixed")
  if is_cmp(e.s) {
    var ac = a.code;  var bc = b.code
    var ct = "i32"
    if fx { ac = to_fixed(a);  bc = to_fixed(b) }
    else { if (llty(a.ty) == "ptr") or (llty(b.ty) == "ptr") { ct = "ptr" } }   # `p == null`, str/record identity
    let c = emit_bind(`icmp {cmp_code(e.s)} {ct} {ac}, {bc}`)
    return val(emit_bind(`zext i1 {c} to i32`), "bool")
  }
  if fx {
    let af = to_fixed(a);  let bf = to_fixed(b)
    if (e.s == ("*")) {
      let a64 = emit_bind(`sext i32 {af} to i64`)
      let b64 = emit_bind(`sext i32 {bf} to i64`)
      let m = emit_bind(`mul i64 {a64}, {b64}`)
      let sh = emit_bind(`ashr i64 {m}, 16`)
      return val(emit_bind(`trunc i64 {sh} to i32`), "fixed")
    }
    if (e.s == ("/")) {
      let a64 = emit_bind(`sext i32 {af} to i64`)
      let ash = emit_bind(`shl i64 {a64}, 16`)
      let b64 = emit_bind(`sext i32 {bf} to i64`)
      let dv = emit_bind(`sdiv i64 {ash}, {b64}`)
      return val(emit_bind(`trunc i64 {dv} to i32`), "fixed")
    }
    let r = emit_bind(`{arith_code(e.s)} i32 {af}, {bf}`)
    return val(r, "fixed")
  }
  let r = emit_bind(`{arith_code(e.s)} i32 {a.code}, {b.code}`)
  return val(r, "int")
}

fn emit_call(e: Node) -> Val {
  let name = e.a.s
  if (name == "self") { if nself == 0 { return val("0", "entity") };  return val(emit_bind(`load i32, ptr {self_stk[nself - 1]}`), "entity") }
  if (name == "key") { return val(emit_bind("load i32, ptr @L_key"), "int") }
  if (name == "save") { emit("  call void @L_save()\n");  return val("0", "void") }
  if (name == "ui_build") { emit("  call void @ui_build()\n");  return val("0", "void") }
  if (name == "load") { return val(emit_bind("call i32 @L_load()"), "bool") }
  if (name == "quit") { emit("  store i32 0, ptr @L_running\n");  return val("0", "void") }
  if (name == "len") { return emit_len(e) }
  if (name == "push") { return emit_push(e) }
  if (name == "str") {                            # str(x): int/bool/fixed -> text, a string passes through
    let a = emit_expr(e.kids[0])
    if (llty(a.ty) == "ptr") { return a }
    g_uses_intstr = true
    return val(emit_bind(`call ptr @fn_int_str(i32 {a.code})`), "str")
  }
  if (name == "print") {                          # print(x): a value + newline (int or string)
    let a = emit_expr(e.kids[0])
    if (llty(a.ty) == "ptr") { emit("  call i32 (ptr, ...) @printf(ptr @.fmt_line, ptr " + `{a.code})\n`) }
    else { emit("  call i32 (ptr, ...) @printf(ptr @.fmt_int, i32 " + `{a.code})\n`) }
    return val("0", "void")
  }
  if (name == "fx") { let a = emit_expr(e.kids[0]);  return val(emit_bind(`shl i32 {a.code}, 16`), "fixed") }
  if (name == "flr") { let a = emit_expr(e.kids[0]);  return val(emit_bind(`ashr i32 {a.code}, 16`), "int") }
  if is_intrinsic(name) { return emit_intrinsic(name, e) }
  if is_intrinsic2(name) { return emit_intrinsic2(name, e) }
  if is_math_builtin(name) { return emit_math_builtin(name, e) }
  var fn2 = find_fn(name)
  var cname = name
  if (fn2 == null) {
    # a builtin like clear()/reg() is satisfied by its rt_ function
    let rtname = `rt_{name}`
    fn2 = find_fn(rtname)
    if (fn2 == null) { perr(`unknown function {name}`) }
    cname = rtname
  }
  # evaluate args first (their IR is emitted before the call instruction)
  let args = new []ptr
  let atys = new []ptr
  var i = 0
  while i < len(e.kids) { let v = emit_expr(e.kids[i]);  push(args, v.code);  push(atys, v.ty);  i = i + 1 }
  let rl = llty(fn2.ty)
  emit("  ")
  var rreg = "0"
  if not (rl == "void") { rreg = nreg();  emit(rreg);  emit(" = ") }
  emit("call ");  emit(rl);  emit(" @fn_");  emit(cname);  emit("(")
  i = 0
  while i < len(args) {
    if i > 0 { emit(", ") }
    emit(llty(atys[i]));  emit(" ");  emit(args[i])
    i = i + 1
  }
  emit(")\n")
  return val(rreg, fn2.ty)
}

fn emit_expr(e: Node) -> Val {
  if (e == null) { return val("0", "int") }
  if e.kind == E_INT  { return val(itoa(e.ival), "int") }
  if e.kind == E_FLOAT { return val(itoa(e.ival), "fixed") }
  if e.kind == E_BOOL { return val(itoa(e.ival), "bool") }
  if e.kind == E_NULL { return val("null", "ptr") }
  if e.kind == E_STR  { return val(emit_str_const(e.s), "str") }
  if e.kind == E_NEW  {
    if is_slice_ty(e.s) { return emit_new_slice(e.s) }
    return emit_new_struct(e.s)
  }
  if e.kind == E_ID {
    let li = loc_find(e.s)
    if li >= 0 { return emit_load_at(loc_reg[li], loc_ty[li]) }
    let g = find_global(e.s)
    if (g != null) {
      if g.kind == N_CONST { return val(itoa(g.a.ival), "int") }
      let r = emit_bind(`load {llty(g.ty)}, ptr @g_{e.s}`)
      return val(r, g.ty)
    }
    # a UI_<name> that is not a const/var resolves to its widget index
    if is_ui_ident(e.s) { return val(itoa(ui_index_of(e.s)), "int") }
    perr(`unknown identifier {e.s}`)
  }
  if e.kind == E_MEMBER {
    if e.a.kind == E_ID {                        # `Enum.Variant` -> its ordinal, a compile-time int
      let ord = enum_ordinal(e.a.s, e.s)
      if ord >= 0 { return val(itoa(ord), "int") }
    }
    let bt = static_type(e.a)                    # `x.field` where field is @Computed -> inline it
    if (bt != null) {
      let cx = computed_expr(bt, e.s)
      if (cx != null) { return emit_expr(qualify_fields(cx, e.a)) }
    }
    let a = emit_member_addr(e);  return emit_load_at(a, g_addr_ty)
  }
  if e.kind == E_INDEX  { let a = emit_index_addr(e);   return emit_load_at(a, g_addr_ty) }
  if e.kind == E_CALL   { return emit_call(e) }
  if e.kind == E_BIN    { return emit_bin(e) }
  if e.kind == E_UN {
    let a = emit_expr(e.a)
    if (e.s == ("-")) { return val(emit_bind(`sub i32 0, {a.code}`), "int") }
    if (e.s == "~") { return val(emit_bind(`xor i32 {a.code}, -1`), "int") }
    let c = emit_bind(`icmp eq i32 {a.code}, 0`)
    return val(emit_bind(`zext i1 {c} to i32`), "bool")
  }
  perr("cannot emit expression")
  return val("0", "int")
}