Basic-blocks-based intermediate language and flow analysis.

spec/execution_tests.lua

@@ -2318,6 +2318,14 @@ function execution_tests.run(compile_file, backend, _ENV, only_compile)
                 end
             end
 
+            function m.non_breaking_loop2(): integer
+                local i = 1
+                repeat
+                    if i == 42 then return i end
+                    i = i + 1
+                until false
+            end
+
             function m.initialize_inside_loop(): integer
                 local x: integer
                 repeat

src/pallene/coder.lua

@@ -373,6 +373,10 @@ function Coder:c_value(value)
     end
 end
 
+function Coder:c_label(index)
+    return "L" .. index
+end
+
 -- The information for creating a C local var for a given Pallene local var.
 function Coder:prepare_local_var(func, v_id)
     local c_name = self:c_var(v_id)
@@ -458,7 +462,7 @@ function Coder:pallene_entry_point_definition(f_id)
     local slots_needed = max_frame_size + self.max_lua_call_stack_usage[func]
 
     local setline = ""
-    local void_frameexit = ""
+    local frameexit = ""
     if self.flags.use_traceback then
         table.insert(prologue, util.render([[
             /**/
@@ -469,10 +473,7 @@ function Coder:pallene_entry_point_definition(f_id)
         }));
 
         setline = string.format("PALLENE_SETLINE(%d);", func.loc and func.loc.line or 0)
-
-        if #func.typ.ret_types == 0 then
-            void_frameexit = "PALLENE_FRAMEEXIT();"
-        end
+        frameexit = "PALLENE_FRAMEEXIT();"
     end
 
     if slots_needed > 0 then
@@ -490,7 +491,6 @@ function Coder:pallene_entry_point_definition(f_id)
     table.insert(prologue, self:savestack())
     table.insert(prologue, "/**/")
 
-
     for v_id = #arg_types + 1, #func.vars do
         -- To avoid -Wmaybe-uninitialized warnings we have to initialize our local variables of type
         -- "Any". Nils and Booleans only set the type tag of the TValue and leave the "._value"
@@ -502,22 +502,44 @@ function Coder:pallene_entry_point_definition(f_id)
         table.insert(prologue, decl..initializer..";"..comment)
     end
 
-    local body = self:generate_cmd(func, func.body)
+    local body = self:generate_blocks(func)
+
+    local ret_mult = ""
+    local ret = ""
+    if #func.ret_vars > 0 then
+        -- We assign the dsts from right to left, in order to match Lua's semantics when a
+        -- destination variable appears more than once in the LHS. For example, in `x,x = f()`.
+        -- For a more in-depth discussion, see the implementation of ast.Stat.Assign in to_ir.lua
+        local returns = {}
+        for i = #func.ret_vars, 2, -1 do
+            local var = self:c_var(func.ret_vars[i])
+            table.insert(returns,
+                util.render([[ *$reti = $v; ]], { reti = self:c_ret_var(i), v = var }))
+        end
+        ret_mult = table.concat(returns, "\n")
+
+        local var1 = self:c_var(func.ret_vars[1])
+        ret = "return " .. var1 .. ";"
+    end
 
     return (util.render([[
         ${name_comment}
         ${fun_decl} {
             ${prologue}
             /**/
             ${body}
-            ${void_fe}
+            ${ret_mult}
+            ${frameexit}
+            ${ret}
         }
     ]], {
         name_comment = C.comment(name_comment),
         fun_decl = self:pallene_entry_point_declaration(f_id),
         prologue = table.concat(prologue, "\n"),
         body = body,
-        void_fe = void_frameexit
+        ret_mult = ret_mult,
+        frameexit = frameexit,
+        ret = ret,
     }))
 end
 
@@ -725,7 +747,7 @@ function Coder:init_upvalues()
 
     -- String Literals
     for _, func in ipairs(self.module.functions) do
-        for cmd in ir.iter(func.body) do
+        for cmd in ir.iter(func.blocks) do
             for _, v in ipairs(ir.get_srcs(cmd)) do
                 if v._tag == "ir.Value.String" then
                     local str = v.value
@@ -929,7 +951,7 @@ function Coder:init_gc()
 
     for _, func in ipairs(self.module.functions) do
         local max = 0
-        for cmd in ir.iter(func.body) do
+        for cmd in ir.iter(func.blocks) do
             if cmd._tag == "ir.Cmd.CallDyn" then
                 -- Although in the end the fn call leaves only ndst items in
                 -- the stack, we actually need ndst+1 to appease the apicheck
@@ -1652,118 +1674,54 @@ gen_cmd["Nop"] = function(self, _cmd, _func)
     return ""
 end
 
-gen_cmd["Seq"] = function(self, cmd, func)
-    local out = {}
-    for _, c in ipairs(cmd.cmds) do
-        table.insert(out, self:generate_cmd(func, c))
-    end
-    return table.concat(out, "\n")
-end
-
-gen_cmd["Return"] = function(self, cmd)
-    local frameexit = ""
-    if self.flags.use_traceback then
-        frameexit = "PALLENE_FRAMEEXIT();"
-    end
-
-    if #cmd.srcs == 0 then
-        return util.render([[ ${fexit}
-        return; ]], { fexit = frameexit })
-    else
-        -- We assign the dsts from right to left, in order to match Lua's semantics when a
-        -- destination variable appears more than once in the LHS. For example, in `x,x = f()`.
-        -- For a more in-depth discussion, see the implementation of ast.Stat.Assign in to_ir.lua
-        local returns = {}
-        for i = #cmd.srcs, 2, -1 do
-            local src = self:c_value(cmd.srcs[i])
-            table.insert(returns,
-                util.render([[ *$reti = $v; ]], { reti = self:c_ret_var(i), v = src }))
-        end
-        local src1 = self:c_value(cmd.srcs[1])
-        table.insert(returns, util.render([[ ${fexit}
-        return $v; ]], { fexit = frameexit, v = src1 }))
-        return table.concat(returns, "\n")
-    end
-end
-
-gen_cmd["Break"] = function(self, _cmd, _func)
-    return [[ break; ]]
-end
-
-gen_cmd["If"] = function(self, cmd, func)
-    local condition = self:c_value(cmd.src_condition)
-    local then_ = self:generate_cmd(func, cmd.then_)
-    local else_ = self:generate_cmd(func, cmd.else_)
-
-    local A = (then_ ~= "")
-    local B = (else_ ~= "")
-
-    local tmpl
-    if A and (not B) then
-        tmpl = [[
-            if ($condition) {
-                ${then_}
-            }
-        ]]
-    elseif (not A) and B then
-        tmpl = [[
-            if (!$condition) {
-                ${else_}
-            }
-        ]]
+gen_cmd["InitFor"] = function(self, cmd, func)
+    local typ = func.vars[cmd.dst_i].typ
+    local macro
+    if     typ._tag == "types.T.Integer" then
+        macro = "PALLENE_INT_INIT_FOR_LOOP"
+    elseif typ._tag == "types.T.Float" then
+        macro = "PALLENE_FLT_INIT_FOR_LOOP"
     else
-        tmpl = [[
-            if ($condition) {
-                ${then_}
-            } else {
-                ${else_}
-            }
-        ]]
+        tagged_union.error(typ._tag)
     end
 
-    return util.render(tmpl, {
-        condition = condition,
-        then_ = then_,
-        else_ = else_,
-    })
-end
-
-gen_cmd["Loop"] = function(self, cmd, func)
-    local body = self:generate_cmd(func, cmd.body)
     return (util.render([[
-        while (1) {
-            ${body}
-        }
+        ${macro}($i, $cond, $iter, $count, $start, $limit, $step)
     ]], {
-        body = body
+        macro = macro,
+        i     = self:c_var(cmd.dst_i),
+        cond  = self:c_var(cmd.dst_cond),
+        iter  = self:c_var(cmd.dst_iter),
+        count = self:c_var(cmd.dst_count),
+        start = self:c_value(cmd.src_start),
+        limit = self:c_value(cmd.src_limit),
+        step  = self:c_value(cmd.src_step),
     }))
 end
 
-gen_cmd["For"] = function(self, cmd, func)
-    local typ = func.vars[cmd.dst].typ
+gen_cmd["IterFor"] = function(self, cmd, func)
+    local typ = func.vars[cmd.dst_i].typ
 
     local macro
     if     typ._tag == "types.T.Integer" then
-        macro = "PALLENE_INT_FOR_LOOP"
+        macro = "PALLENE_INT_ITER_FOR_LOOP"
     elseif typ._tag == "types.T.Float" then
-        macro = "PALLENE_FLT_FOR_LOOP"
+        macro = "PALLENE_FLT_ITER_FOR_LOOP"
     else
         tagged_union.error(typ._tag)
     end
 
     return (util.render([[
-        ${macro}_BEGIN($x, $start, $limit, $step)
-        {
-            $body
-        }
-        ${macro}_END
+        ${macro}($i, $cond, $iter, $count, $start, $limit, $step)
     ]], {
         macro = macro,
-        x     = self:c_var(cmd.dst),
+        i     = self:c_var(cmd.dst_i),
+        cond  = self:c_var(cmd.dst_cond),
+        iter  = self:c_var(cmd.dst_iter),
+        count = self:c_var(cmd.dst_count),
         start = self:c_value(cmd.src_start),
         limit = self:c_value(cmd.src_limit),
         step  = self:c_value(cmd.src_step),
-        body  = self:generate_cmd(func, cmd.body)
     }))
 end
 
@@ -1772,6 +1730,31 @@ gen_cmd["CheckGC"] = function(self, cmd, func)
         update_stack_top = self:update_stack_top(func, cmd) })
 end
 
+function Coder:generate_blocks(func)
+    local out = ""
+    for i,block in ipairs(func.blocks) do
+        -- putting a "(void)0" at the label so compiler doesn't complain about dangling labels
+        local content = self:c_label(i) .. ":(void)0;\n"
+        for _,cmd in ipairs(block.cmds) do
+            content = content .. self:generate_cmd(func, cmd) .. "\n"
+        end
+        local jump_cond = ""
+        if block.jmp_false then
+            jump_cond = util.render("if(!($v)) {goto $l;}\n", {
+                v = self:c_value(block.jmp_false.src_condition),
+                l = self:c_label(block.jmp_false.target),
+            })
+        end
+        local jump = ""
+        if block.next and block.next ~= i + 1 then
+            jump = "goto " .. self:c_label(block.next) .. ";\n"
+        end
+        content = content .. jump_cond .. jump
+        out = out .. content
+    end
+    return out
+end
+
 function Coder:generate_cmd(func, cmd)
     assert(tagged_union.typename(cmd._tag) == "ir.Cmd")
     local name = tagged_union.consname(cmd._tag)

src/pallene/constant_propagation.lua

@@ -81,7 +81,7 @@ function constant_propagation.run(module)
         -- pass takes care of variables that are used before being initialized.
         local f_data = assert(data_of_func[f_id])
 
-        for cmd in ir.iter(func.body) do
+        for cmd in ir.iter(func.blocks) do
             local tag = cmd._tag
             if     tag == "ir.Cmd.Move" then
                 local id = cmd.dst
@@ -123,7 +123,7 @@ function constant_propagation.run(module)
         local f_data   = assert(data_of_func[f_id])
         local n_writes = f_data.n_writes_of_locvar
 
-        for cmd in ir.iter(func.body) do
+        for cmd in ir.iter(func.blocks) do
             local tag = cmd._tag
             if tag == "ir.Cmd.InitUpvalues" then
                 local next_f = assert(data_of_func[cmd.f_id])
@@ -159,7 +159,7 @@ function constant_propagation.run(module)
         --         x1 <- 20
         --     }
         --
-        for cmd in ir.iter(func.body) do
+        for cmd in ir.iter(func.blocks) do
             local tag = cmd._tag
             if tag == "ir.Cmd.InitUpvalues" then
                 local next_f = assert(data_of_func[cmd.f_id])
@@ -178,7 +178,7 @@ function constant_propagation.run(module)
     --
 
     for _, func in ipairs(module.functions) do
-        for cmd in ir.iter(func.body) do
+        for cmd in ir.iter(func.blocks) do
             if cmd._tag == "ir.Cmd.InitUpvalues" then
                 local next_f   = assert(data_of_func[cmd.f_id])
                 local new_u_id = next_f.new_upvalue_id
@@ -243,21 +243,24 @@ function constant_propagation.run(module)
             func.f_id_of_upvalue = new_f_id_of_upvalue
         end
 
-        func.body = ir.map_cmd(func.body, function(cmd)
-            local inputs = ir.get_value_field_names(cmd)
-            for _, src_field in ipairs(inputs.src) do
-                cmd[src_field] = updated_value(f_data, cmd[src_field])
-            end
+        for _,block in ipairs(func.blocks) do
+            for _,cmd in ipairs(block.cmds) do
+                local inputs = ir.get_value_field_names(cmd)
+                for _, src_field in ipairs(inputs.src) do
+                    cmd[src_field] = updated_value(f_data, cmd[src_field])
+                end
 
-            for _, src_field in ipairs(inputs.srcs) do
-                local srcs = cmd[src_field]
-                for i, value in ipairs(srcs) do
-                    srcs[i] = updated_value(f_data, value)
+                for _, src_field in ipairs(inputs.srcs) do
+                    local srcs = cmd[src_field]
+                    for i, value in ipairs(srcs) do
+                        srcs[i] = updated_value(f_data, value)
+                    end
                 end
             end
-
-            return false
-        end)
+            if block.jmp_false then
+                block.jmp_false.src_condition = updated_value(f_data, block.jmp_false.src_condition)
+            end
+        end
     end
 
     ir.clean_all(module)

src/pallene/gc.lua

@@ -39,7 +39,7 @@ local gc = {}
 
 function gc.compute_stack_slots(func)
 
-    local flat_cmds = ir.flatten_cmd(func.body)
+    local flat_cmds = ir.flatten_cmd(func.blocks)
 
     -- 1) Compute approximated live intervals for GC variables defined by the function. Function
     -- parameters are only counted if they are redefined, since their original value was already