Implements a few improvements to the code generation of if-expressions.

Author: modlfo

src/core/passes.ml

@@ -249,6 +249,21 @@ module Location = struct
 end
 
 module IfExpressions = struct
+  (* Check if an expression is simple enough to remain as a ternary operator *)
+  let rec isSimpleValue (e : exp) =
+    match e.e with
+    | EUnit | EBool _ | EInt _ | EReal _ | EFixed _ | EString _ -> true
+    | EId _ | EMember _ -> true
+    | EUnOp (_, e) -> isSimpleValue e
+    | _ -> false
+
+
+  let isSimpleIf (e : exp) =
+    match e.e with
+    | EIf { cond; then_; else_ } -> isSimpleValue cond && isSimpleValue then_ && isSimpleValue else_
+    | _ -> false
+
+
   let stmt_env =
     Mapper.makeEnv
     @@ fun env (s : stmt) ->
@@ -291,6 +306,8 @@ module IfExpressions = struct
           then_
         else
           else_ )
+    (* Preserve simple if-expressions as ternary operators *)
+    | { e = EIf _; _ } when isSimpleIf e -> state, e
     (* Bind if-expressions to a variable in function context *)
     | { e = EIf _; t; loc } when (not env.in_if_exp) && (not env.bound_if) && env.in_function ->
       let tick = getTick env state in
@@ -929,12 +946,30 @@ module StrengthReduction = struct
       | TReal -> reapply state, C.ereal ~loc:e.loc 0.0
       | TFix16 -> reapply state, C.efix16 ~loc:e.loc 0.0
       | _ -> state, e)
+    (* x * -1 -> -x *)
+    | { e = EOp (OpMul, e1, { e = EInt -1; _ }); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e1) }
+    | { e = EOp (OpMul, { e = EInt -1; _ }, e2); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e2) }
+    (* x % 1 -> 0 *)
+    | { e = EOp (OpMod, _, { e = EInt 1; _ }); loc; _ } -> reapply state, C.eint ~loc 0
+    (* NOTE: x % 2^n -> x & (2^n - 1) optimization removed because Lua 5.1/LuaJIT
+       doesn't support native bitwise operators, and modulo works correctly *)
+    (* 0 / x -> 0 *)
+    | { e = EOp (OpDiv, { e = EInt 0; _ }, _); loc; _ } -> reapply state, C.eint ~loc 0
+    (* 0 - x -> -x *)
+    | { e = EOp (OpSub, { e = EInt 0; _ }, e2); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e2) }
     (* ========== FLOATING POINT ARITHMETIC OPTIMIZATIONS ========== *)
     (* x * 0.0 -> 0.0, x * 1.0 -> x *)
     | { e = EOp (OpMul, _, { e = EReal 0.0; _ }); _ } | { e = EOp (OpMul, { e = EReal 0.0; _ }, _); _ } ->
       reapply state, { e with e = EReal 0.0 }
     | { e = EOp (OpMul, e1, { e = EReal 1.0; _ }); _ } -> reapply state, e1
     | { e = EOp (OpMul, { e = EReal 1.0; _ }, e2); _ } -> reapply state, e2
+    (* x * -1.0 -> -x *)
+    | { e = EOp (OpMul, e1, { e = EReal -1.0; _ }); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e1) }
+    | { e = EOp (OpMul, { e = EReal -1.0; _ }, e2); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e2) }
+    (* 0.0 / x -> 0.0 *)
+    | { e = EOp (OpDiv, { e = EReal 0.0; _ }, _); loc; _ } -> reapply state, C.ereal ~loc 0.0
+    (* 0.0 - x -> -x *)
+    | { e = EOp (OpSub, { e = EReal 0.0; _ }, e2); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e2) }
     (* Removed x * 2.0 -> x + x transformation as it interferes with constant folding *)
     (* Removed x * 0.5 <-> x / 2.0 transformations as they create cycles with other passes *)
     (* Removed problematic power-of-2 real multiplication transformation *)
@@ -945,6 +980,18 @@ module StrengthReduction = struct
     | { e = EOp (OpMul, e1, { e = EFixed 1.0; _ }); _ } -> reapply state, e1
     | { e = EOp (OpMul, { e = EFixed 1.0; _ }, e2); _ } ->
       reapply state, e2 (* Removed x * 2.0 -> x + x for fixed point as it interferes with constant folding *)
+    (* x * -1.0 -> -x (fixed) *)
+    | { e = EOp (OpMul, e1, { e = EFixed -1.0; _ }); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e1) }
+    | { e = EOp (OpMul, { e = EFixed -1.0; _ }, e2); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e2) }
+    (* 0.0 / x -> 0.0 (fixed) *)
+    | { e = EOp (OpDiv, { e = EFixed 0.0; _ }, _); loc; _ } -> reapply state, C.efix16 ~loc 0.0
+    (* 0.0 - x -> -x (fixed) *)
+    | { e = EOp (OpSub, { e = EFixed 0.0; _ }, e2); _ } -> reapply state, { e with e = EUnOp (UOpNeg, e2) }
+    (* ========== DIVISION BY 1 OPTIMIZATIONS ========== *)
+    (* x / 1 -> x (for all numeric types) *)
+    | { e = EOp (OpDiv, e1, { e = EInt 1; _ }); _ } -> reapply state, e1
+    | { e = EOp (OpDiv, e1, { e = EReal 1.0; _ }); _ } -> reapply state, e1
+    | { e = EOp (OpDiv, e1, { e = EFixed 1.0; _ }); _ } -> reapply state, e1
     (* ========== FUNCTION CALL OPTIMIZATIONS ========== *)
     (* pow(x, 2) -> x * x *)
     | { e = ECall { path = "pow"; args = [ x; { e = EReal 2.0; _ } ] }; _ } ->
@@ -975,6 +1022,13 @@ module StrengthReduction = struct
       reapply state, { e with e = EOp (OpDiv, C.ereal ~loc 1.0, x) }
     | { e = ECall { path = "pow"; args = [ x; { e = EInt -1; _ } ] }; loc; _ } ->
       reapply state, { e with e = EOp (OpDiv, C.ereal ~loc 1.0, x) }
+    (* pow(x, -2) -> 1.0 / (x * x) *)
+    | { e = ECall { path = "pow"; args = [ x; { e = EReal -2.0; _ } ] }; loc; _ } ->
+      let x_squared = { e with e = EOp (OpMul, x, x) } in
+      reapply state, { e with e = EOp (OpDiv, C.ereal ~loc 1.0, x_squared) }
+    | { e = ECall { path = "pow"; args = [ x; { e = EInt -2; _ } ] }; loc; _ } ->
+      let x_squared = { e with e = EOp (OpMul, x, x) } in
+      reapply state, { e with e = EOp (OpDiv, C.ereal ~loc 1.0, x_squared) }
     (* pow(x, 1) -> x *)
     | { e = ECall { path = "pow"; args = [ x; { e = EReal 1.0; _ } ] }; _ } -> reapply state, x
     | { e = ECall { path = "pow"; args = [ x; { e = EInt 1; _ } ] }; _ } -> reapply state, x
@@ -1013,6 +1067,46 @@ module StrengthReduction = struct
     (* x << 0 -> x, x >> 0 -> x *)
     | { e = EOp (OpLsh, e1, { e = EInt 0; _ }); _ } -> reapply state, e1
     | { e = EOp (OpRsh, e1, { e = EInt 0; _ }); _ } -> reapply state, e1
+    (* x & x -> x, x | x -> x *)
+    | { e = EOp (OpBand, e1, e2); _ } when Compare.exp e1 e2 = 0 -> reapply state, e1
+    | { e = EOp (OpBor, e1, e2); _ } when Compare.exp e1 e2 = 0 -> reapply state, e1
+    (* x & -1 -> x (all bits set) *)
+    | { e = EOp (OpBand, e1, { e = EInt -1; _ }); _ } -> reapply state, e1
+    | { e = EOp (OpBand, { e = EInt -1; _ }, e2); _ } -> reapply state, e2
+    (* ========== NEGATION OPTIMIZATIONS ========== *)
+    (* -(-x) -> x *)
+    | { e = EUnOp (UOpNeg, { e = EUnOp (UOpNeg, x); _ }); _ } -> reapply state, x
+    (* not(not(x)) -> x *)
+    | { e = EUnOp (UOpNot, { e = EUnOp (UOpNot, x); _ }); _ } -> reapply state, x
+    (* ========== BOOLEAN LOGIC OPTIMIZATIONS ========== *)
+    (* x && true -> x *)
+    | { e = EOp (OpLand, e1, { e = EBool true; _ }); _ } -> reapply state, e1
+    | { e = EOp (OpLand, { e = EBool true; _ }, e2); _ } -> reapply state, e2
+    (* x && false -> false *)
+    | { e = EOp (OpLand, _, { e = EBool false; loc; _ }); _ } -> reapply state, C.ebool ~loc false
+    | { e = EOp (OpLand, { e = EBool false; loc; _ }, _); _ } -> reapply state, C.ebool ~loc false
+    (* x || false -> x *)
+    | { e = EOp (OpLor, e1, { e = EBool false; _ }); _ } -> reapply state, e1
+    | { e = EOp (OpLor, { e = EBool false; _ }, e2); _ } -> reapply state, e2
+    (* x || true -> true *)
+    | { e = EOp (OpLor, _, { e = EBool true; loc; _ }); _ } -> reapply state, C.ebool ~loc true
+    | { e = EOp (OpLor, { e = EBool true; loc; _ }, _); _ } -> reapply state, C.ebool ~loc true
+    (* ========== COMPARISON SELF-IDENTITIES ========== *)
+    (* x == x -> true (int only, floats have NaN) *)
+    | { e = EOp (OpEq, e1, e2); loc; _ } when Compare.exp e1 e2 = 0 && e1.t.t = TInt -> reapply state, C.ebool ~loc true
+    (* x != x -> false (int only) *)
+    | { e = EOp (OpNe, e1, e2); loc; _ } when Compare.exp e1 e2 = 0 && e1.t.t = TInt ->
+      reapply state, C.ebool ~loc false
+    (* x < x -> false, x > x -> false *)
+    | { e = EOp (OpLt, e1, e2); loc; _ } when Compare.exp e1 e2 = 0 -> reapply state, C.ebool ~loc false
+    | { e = EOp (OpGt, e1, e2); loc; _ } when Compare.exp e1 e2 = 0 -> reapply state, C.ebool ~loc false
+    (* x <= x -> true, x >= x -> true (int only) *)
+    | { e = EOp (OpLe, e1, e2); loc; _ } when Compare.exp e1 e2 = 0 && e1.t.t = TInt -> reapply state, C.ebool ~loc true
+    | { e = EOp (OpGe, e1, e2); loc; _ } when Compare.exp e1 e2 = 0 && e1.t.t = TInt -> reapply state, C.ebool ~loc true
+    (* ========== MIN/MAX OPTIMIZATIONS ========== *)
+    (* min(x, x) -> x, max(x, x) -> x *)
+    | { e = ECall { path = "min"; args = [ x1; x2 ] }; _ } when Compare.exp x1 x2 = 0 -> reapply state, x1
+    | { e = ECall { path = "max"; args = [ x1; x2 ] }; _ } when Compare.exp x1 x2 = 0 -> reapply state, x1
     (* No optimization found *)
     | _ -> state, e
 

src/generators/lua.ml

@@ -126,8 +126,10 @@ function list_clear(t)      for k in pairs(t) do t[k] = nil end end
 
 let rec isValueOrIf (e : exp) =
   match e.e with
-  | EUnit | EBool _ | EInt _ | EReal _ | EString _ | EId _ | EMember _ -> true
+  | EUnit | EBool _ | EInt _ | EReal _ | EString _ | EId _ | EMember _ | EFixed _ -> true
   | EUnOp (_, e) -> isValueOrIf e
+  | EOp (_, e1, e2) -> isValueOrIf e1 && isValueOrIf e2
+  | EIndex { e; index } -> isValueOrIf e && isValueOrIf index
   | EIf { then_; else_; _ } -> isValueOrIf then_ && isValueOrIf else_
   | _ -> false
 
@@ -182,7 +184,7 @@ let rec print_exp e =
   | EIndex { e; index } ->
     let e = print_exp e in
     let index = print_exp index in
-    {%pla|<#e#>[<#index#> + 1]|}
+    {%pla|get(<#e#>, <#index#>)|}
   | EArray l -> Pla.wrap (Pla.string "{") (Pla.string "}") (Pla.map_sep Pla.commaspace print_exp l)
   | ECall { path; args } -> (
     (* Use optimized functions when available *)
@@ -225,8 +227,8 @@ let rec print_exp e =
     | "list_get", [ l; i ] ->
       let l = print_exp l in
       let i = print_exp i in
-      (* Lua is 1-based *)
-      {%pla|<#l#>[<#i#> + 1]|}
+      (* Use get() helper for 1-based indexing *)
+      {%pla|get(<#l#>, <#i#>)|}
     | "list_set", [ l; i; v ] ->
       let l = print_exp l in
       let i = print_exp i in

test/code/ConstSpecialization.lua.base

@@ -264,7 +264,7 @@ function ConstSpecialization_setMatrix2(m, row, col, value)
 end
 
 function ConstSpecialization_getMatrix2(m, row, col)
-   return m[(row + lshift(col, 1)) + 1]
+   return get(m, (row + lshift(col, 1)))
 end
 
 function ConstSpecialization_test_matrix_mutation(m, x)

test/code/FixedAndFloat.lua.base

@@ -112,57 +112,57 @@ end
 FixedAndFloat_take_fix_return_fixed_c0 = {};
 FixedAndFloat_take_fix_return_fixed_c1 = {};
 function FixedAndFloat_take_fix_return_fixed_raw_c0(index)
-   return FixedAndFloat_take_fix_return_fixed_c0[index + 1]
+   return get(FixedAndFloat_take_fix_return_fixed_c0, index)
 end
 
 function FixedAndFloat_take_fix_return_fixed_raw_c1(index)
-   return FixedAndFloat_take_fix_return_fixed_c1[index + 1]
+   return get(FixedAndFloat_take_fix_return_fixed_c1, index)
 end
 
 function FixedAndFloat_take_fix_return_fixed(x)
    local value = clip((x * 32.0), 0.0, 32.0)
    local index = int(value)
    local decimal = (value - floor(value))
-   return (FixedAndFloat_take_fix_return_fixed_c0[index + 1] + (FixedAndFloat_take_fix_return_fixed_c1[index + 1] * decimal))
+   return (get(FixedAndFloat_take_fix_return_fixed_c0, index) + (get(FixedAndFloat_take_fix_return_fixed_c1, index) * decimal))
 end
 
 FixedAndFloat_take_fix_return_real_c0 = {};
 FixedAndFloat_take_fix_return_real_c1 = {};
 FixedAndFloat_take_fix_return_real_c2 = {};
 function FixedAndFloat_take_fix_return_real_raw_c0(index)
-   return FixedAndFloat_take_fix_return_real_c0[index + 1]
+   return get(FixedAndFloat_take_fix_return_real_c0, index)
 end
 
 function FixedAndFloat_take_fix_return_real_raw_c1(index)
-   return FixedAndFloat_take_fix_return_real_c1[index + 1]
+   return get(FixedAndFloat_take_fix_return_real_c1, index)
 end
 
 function FixedAndFloat_take_fix_return_real_raw_c2(index)
-   return FixedAndFloat_take_fix_return_real_c2[index + 1]
+   return get(FixedAndFloat_take_fix_return_real_c2, index)
 end
 
 function FixedAndFloat_take_fix_return_real(x)
    local index = clip(fix_to_int((x * 31.0)), 0, 31)
-   return (FixedAndFloat_take_fix_return_real_c0[index + 1] + (fix_to_float(x) * (FixedAndFloat_take_fix_return_real_c1[index + 1] + (FixedAndFloat_take_fix_return_real_c2[index + 1] * fix_to_float(x)))))
+   return (get(FixedAndFloat_take_fix_return_real_c0, index) + (fix_to_float(x) * (get(FixedAndFloat_take_fix_return_real_c1, index) + (get(FixedAndFloat_take_fix_return_real_c2, index) * fix_to_float(x)))))
 end
 
 FixedAndFloat_take_real_return_fixed_c0 = {};
 FixedAndFloat_take_real_return_fixed_c1 = {};
 FixedAndFloat_take_real_return_fixed_c2 = {};
 function FixedAndFloat_take_real_return_fixed_raw_c0(index)
-   return FixedAndFloat_take_real_return_fixed_c0[index + 1]
+   return get(FixedAndFloat_take_real_return_fixed_c0, index)
 end
 
 function FixedAndFloat_take_real_return_fixed_raw_c1(index)
-   return FixedAndFloat_take_real_return_fixed_c1[index + 1]
+   return get(FixedAndFloat_take_real_return_fixed_c1, index)
 end
 
 function FixedAndFloat_take_real_return_fixed_raw_c2(index)
-   return FixedAndFloat_take_real_return_fixed_c2[index + 1]
+   return get(FixedAndFloat_take_real_return_fixed_c2, index)
 end
 
 function FixedAndFloat_take_real_return_fixed(x)
    local index = clip(math.floor((x * 31.0)), 0, 31)
-   return (FixedAndFloat_take_real_return_fixed_c0[index + 1] + (float_to_fix(x) * (FixedAndFloat_take_real_return_fixed_c1[index + 1] + (FixedAndFloat_take_real_return_fixed_c2[index + 1] * float_to_fix(x)))))
+   return (get(FixedAndFloat_take_real_return_fixed_c0, index) + (float_to_fix(x) * (get(FixedAndFloat_take_real_return_fixed_c1, index) + (get(FixedAndFloat_take_real_return_fixed_c2, index) * float_to_fix(x)))))
 end
 

test/code/GenericArrays.lua.base

@@ -94,7 +94,7 @@ function GenericArrays_sum(data)
    local i__1 = 0
    while (i__1 < size(data)) do
       do
-         total = (total + data[i__1 + 1])
+         total = (total + get(data, i__1))
          i__1 = (1 + i__1)
       end
    end

test/code/InstanceArray.lua.base

@@ -126,7 +126,7 @@ function InstanceArray_test1(_ctx)
    local i__1 = 0
    while (i__1 < 4) do
       do
-         sum = (sum + InstanceArray_counter(_ctx.instances[i__1 + 1]))
+         sum = (sum + InstanceArray_counter(get(_ctx.instances, i__1)))
          i__1 = (1 + i__1)
       end
    end

test/code/SaveState.lua.base

@@ -166,7 +166,7 @@ function SaveState_main_type_serialize_data(buffer, index, _ctx)
    local i_0 = 0
    while (i_0 < 3) do
       do
-         index = SaveState_point_serialize_data(buffer, index, _ctx.point_array[i_0 + 1])
+         index = SaveState_point_serialize_data(buffer, index, get(_ctx.point_array, i_0))
          i_0 = (1 + i_0)
       end
    end
@@ -261,7 +261,7 @@ function SaveState_main_type_deserialize_data(buffer, type_descr, index, _ctx)
          local i_5 = 0
          while (i_5 < 3) do
             do
-               SaveState_point_deserialize_data(buffer, field_descr_4, field_index, _ctx.point_array[i_5 + 1])
+               SaveState_point_deserialize_data(buffer, field_descr_4, field_index, get(_ctx.point_array, i_5))
                i_5 = (1 + i_5)
                field_index = next_object(buffer, field_index)
             end

test/code/Tables.lua.base

@@ -93,66 +93,66 @@ Tables_sineTable1_c0 = {};
 Tables_sineTable1_c1 = {};
 Tables_sineTable1_c2 = {};
 function Tables_sineTable1_raw_c0(index)
-   return Tables_sineTable1_c0[index + 1]
+   return get(Tables_sineTable1_c0, index)
 end
 
 function Tables_sineTable1_raw_c1(index)
-   return Tables_sineTable1_c1[index + 1]
+   return get(Tables_sineTable1_c1, index)
 end
 
 function Tables_sineTable1_raw_c2(index)
-   return Tables_sineTable1_c2[index + 1]
+   return get(Tables_sineTable1_c2, index)
 end
 
 function Tables_sineTable1(x)
    local index = clip(math.floor((x * 31.0)), 0, 31)
-   return (Tables_sineTable1_c0[index + 1] + (x * (Tables_sineTable1_c1[index + 1] + (Tables_sineTable1_c2[index + 1] * x))))
+   return (get(Tables_sineTable1_c0, index) + (x * (get(Tables_sineTable1_c1, index) + (get(Tables_sineTable1_c2, index) * x))))
 end
 
 Tables_sineTable2_c0 = {};
 Tables_sineTable2_c1 = {};
 function Tables_sineTable2_raw_c0(index)
-   return Tables_sineTable2_c0[index + 1]
+   return get(Tables_sineTable2_c0, index)
 end
 
 function Tables_sineTable2_raw_c1(index)
-   return Tables_sineTable2_c1[index + 1]
+   return get(Tables_sineTable2_c1, index)
 end
 
 function Tables_sineTable2(x)
    local index = clip(math.floor((x * 31.0)), 0, 31)
-   return (Tables_sineTable2_c0[index + 1] + (x * Tables_sineTable2_c1[index + 1]))
+   return (get(Tables_sineTable2_c0, index) + (x * get(Tables_sineTable2_c1, index)))
 end
 
 Tables_sineTable3_c0 = {};
 Tables_sineTable3_c1 = {};
 function Tables_sineTable3_raw_c0(index)
-   return Tables_sineTable3_c0[index + 1]
+   return get(Tables_sineTable3_c0, index)
 end
 
 function Tables_sineTable3_raw_c1(index)
-   return Tables_sineTable3_c1[index + 1]
+   return get(Tables_sineTable3_c1, index)
 end
 
 function Tables_sineTable3(x)
    local value = clip((x * 32.0), 0.0, 32.0)
    local index = int(value)
    local decimal = (value - floor(value))
-   return (Tables_sineTable3_c0[index + 1] + (Tables_sineTable3_c1[index + 1] * decimal))
+   return (get(Tables_sineTable3_c0, index) + (get(Tables_sineTable3_c1, index) * decimal))
 end
 
 Tables_power2_table = {};
 function Tables_power2(x)
-   return Tables_power2_table[(int_clip(x, -4, 4) + 4) + 1]
+   return get(Tables_power2_table, (int_clip(x, -4, 4) + 4))
 end
 
 Tables_square_table = {};
 function Tables_square(x)
-   return Tables_square_table[(int_clip(x, -4, 4) + 4) + 1]
+   return get(Tables_square_table, (int_clip(x, -4, 4) + 4))
 end
 
 Tables_square16_table = {};
 function Tables_square16(x)
-   return Tables_square16_table[(int_clip(x, -4, 4) + 4) + 1]
+   return get(Tables_square16_table, (int_clip(x, -4, 4) + 4))
 end