Merge pull request #652 from pallene-lang/renormarr-command

Introducing new IR commands RenormArr and Nop

Author: hugomg

build

@@ -0,0 +1,48 @@
+#!/bin/bash
+eval "$(luarocks path)"
+export PATH="$(pwd)/src/bin/:$PATH"
+export LUA_PATH="$(pwd)/src/?.lua;$LUA_PATH"
+export CFLAGS='-O2 -std=c99 -Wall -Werror -Wundef -Wpedantic -Wno-unused'
+
+function count_stack_saves() {
+    file="$1"
+    grep -Eo 'set[^\n]*\( *L *, *s2v\( *base' "$file" | wc -l
+}
+
+function is_in() {
+    element="$1"
+    shift
+    list="$*"
+    found=false
+    for e in $list; do
+        [ "$e" = "$element" ] && found=true && break
+    done
+    $found
+}
+
+if [ "$1" = "test" ]; then
+    shift
+    ./run-tests "$@"
+elif [ "$1" = "testgc" ]; then
+    shift
+    EXTRACFLAGS="-DHARDMEMTESTS" ./run-tests "$@"
+else
+
+    file="$1"
+    shift
+
+    lint_cmd="./run-lint -q"
+    run_cmd="lua lua_$file.lua"
+    flags=''
+    is_in c      $* && flags="$flags --emit-c" && run_cmd=true
+    is_in ir     $* && flags="$flags --print-ir"
+    is_in O0     $* && flags="$flags -O0"
+    is_in trace  $* && flags="$flags --use-traceback"
+    is_in gc     $* && CFLAGS='-O4 -DHARDMEMTESTS'
+    is_in nolint $* && lint_cmd=true
+    is_in norun  $* && run_cmd=true
+
+    $lint_cmd &&
+        pallenec $flags "$file".pln &&
+        $run_cmd
+fi

src/pallene/coder.lua

@@ -88,7 +88,7 @@ function Coder:init(module, modname, filename, flags)
         self.record_coders[typ] = RecordCoder.new(self, typ)
     end
 
-    self.gc = {} -- (see gc.compute_stack_slots)
+    self.gc = {} -- { func => gc_info } see gc.compute_gc_info
     self.max_lua_call_stack_usage = {} -- func => integer
     self:init_gc()
 end
@@ -1265,6 +1265,20 @@ gen_cmd["NewArr"] = function(self, args)
     }))
 end
 
+gen_cmd["RenormArr"] = function(self, args)
+    local arr = self:c_value(args.cmd.src_arr)
+    local i   = self:c_value(args.cmd.src_i)
+    local line = C.integer(args.cmd.loc.line)
+
+    return (util.render([[
+        pallene_renormalize_array(L, $arr, $i, PALLENE_SOURCE_FILE, $line);
+    ]], {
+        arr = arr,
+        i = i,
+        line = line,
+    }))
+end
+
 gen_cmd["GetArr"] = function(self, args)
     local dst = self:c_var(args.cmd.dst)
     local arr = self:c_value(args.cmd.src_arr)
@@ -1274,7 +1288,6 @@ gen_cmd["GetArr"] = function(self, args)
 
     return (util.render([[
         {
-            pallene_renormalize_array(L, $arr, $i, PALLENE_SOURCE_FILE, $line);
             TValue *slot = &$arr->array[$i - 1];
             $get_slot
         }
@@ -1295,7 +1308,6 @@ gen_cmd["SetArr"] = function(self, args)
     local line = C.integer(args.cmd.loc.line)
     return (util.render([[
         {
-            pallene_renormalize_array(L, $arr, $i, PALLENE_SOURCE_FILE, $line);
             TValue *slot = &$arr->array[$i - 1];
             ${set_heap_slot}
         }
@@ -1768,6 +1780,10 @@ gen_cmd["JmpIf"] = function(self, args)
     })
 end
 
+gen_cmd["Nop"] = function()
+    return ""
+end
+
 gen_cmd["CheckGC"] = function(self, args)
     return util.render([[ luaC_condGC(L, ${update_stack_top}, (void)0); ]], {
         update_stack_top = self:update_stack_top(args.position) })

src/pallene/gc.lua

@@ -88,7 +88,8 @@ local function compute_stack_slots(func)
         return gk
     end
 
-    local flow_info = flow.FlowInfo(flow.Order.Backwards, compute_gen_kill, init_start)
+    local flow_info = flow.FlowInfo(
+        flow.Order.Backwards, compute_gen_kill, init_start)
     local sets_list = flow.flow_analysis(func.blocks, flow_info)
 
     -- 2) Find which GC'd variables are live at each GC spot in the program and
@@ -160,12 +161,116 @@ local function compute_stack_slots(func)
     return live_gc_vars, max_frame_size, slot_of_variable
 end
 
+local function Definition(block_i, cmd_i, var_i)
+    return {
+        block_i = block_i,
+        cmd_i   = cmd_i,
+        var_i   = var_i,
+    }
+end
+
+local function make_definition_list(func)
+    local def_list = {}  -- { Definition }
+    local cmd_def_map  = {}  -- { block_id => { cmd_id => {definition_id} } }
+    local var_def_map  = {}  -- { var_id => {definition_id}? }
+    for var_i, var in ipairs(func.vars) do
+        if types.is_gc(var.typ) then
+            var_def_map[var_i] = {}
+        else
+            var_def_map[var_i] = false
+        end
+    end
+    for block_i, block in ipairs(func.blocks) do
+        local block_map = {}
+        cmd_def_map[block_i] = block_map
+        for cmd_i, cmd in ipairs(block.cmds) do
+            local cmd_map = {}
+            block_map[cmd_i] = cmd_map
+            for _, dst in ipairs(ir.get_dsts(cmd)) do
+                local typ = func.vars[dst].typ
+                if types.is_gc(typ) then
+                    local def = Definition(block_i,cmd_i,dst)
+                    table.insert(def_list, def)
+                    local def_id = #def_list
+                    table.insert(cmd_map, def_id)
+
+                    local var_defs = var_def_map[dst]
+                    table.insert(var_defs, def_id)
+                end
+            end
+        end
+    end
+    return def_list, cmd_def_map, var_def_map
+end
+
+local function compute_vars_to_mirror(func)
+
+    -- 1) Register definitions of GC'd variables
+    local def_list, cmd_def_map, var_def_map = make_definition_list(func)
+
+    -- 2) Find reaching definitions for each basic block
+    local function init_start(_start_set, _block_index)
+    end
+
+    local function compute_gen_kill(block_i, cmd_i)
+        local cmd = func.blocks[block_i].cmds[cmd_i]
+        local gk = flow.GenKill()
+        for _, dst in ipairs(ir.get_dsts(cmd)) do
+            local typ = func.vars[dst].typ
+            if types.is_gc(typ) then
+                local var_defs = var_def_map[dst]
+                for _, def_id in ipairs(var_defs) do
+                    flow.kill_value(gk, def_id)
+                end
+            end
+        end
+        local current_defs = cmd_def_map[block_i][cmd_i]
+        if current_defs then
+            for _, def in ipairs(current_defs) do
+                flow.gen_value(gk, def)
+            end
+        end
+        return gk
+    end
+
+    local flow_info = flow.FlowInfo(
+        flow.Order.Forward, compute_gen_kill, init_start)
+    local sets_list = flow.flow_analysis(func.blocks, flow_info)
+
+    -- 3) Find which definitions reach commands that might call the GC, that is, which definitions
+    -- writes have to be mirroed to the stack
+    local vars_to_mirror = {}  -- { block_id => { cmd_id => set of var_i } }
+    for block_i, block in ipairs(func.blocks) do
+        local block_defs = {}
+        vars_to_mirror[block_i] = block_defs
+        for cmd_i = 1, #block.cmds do
+            block_defs[cmd_i] = {}
+        end
+    end
+    for block_i, block in ipairs(func.blocks) do
+        local defs_block = sets_list[block_i]
+        for cmd_i, cmd in ipairs(block.cmds) do
+            flow.update_set(defs_block, flow_info, block_i, cmd_i)
+            if cmd_uses_gc(cmd) then
+                for def_i, _ in pairs(defs_block) do
+                    local def = def_list[def_i]
+                    vars_to_mirror[def.block_i][def.cmd_i][def.var_i] = true
+                end
+            end
+        end
+    end
+
+    return vars_to_mirror
+end
+
 function gc.compute_gc_info(func)
     local live_gc_vars, max_frame_size, slot_of_variable = compute_stack_slots(func)
+    local vars_to_mirror = compute_vars_to_mirror(func)
     return {
         live_gc_vars = live_gc_vars,
         max_frame_size = max_frame_size,
         slot_of_variable = slot_of_variable,
+        vars_to_mirror = vars_to_mirror,
     }
 end
 

src/pallene/ir.lua

@@ -42,6 +42,18 @@ function ir.VarDecl(name, typ)
     }
 end
 
+function ir.ForLoop()
+    return {
+        step_is_positive = false,      -- boolean
+        prep_block_id = false,         -- block_id
+        body_first_block_id = false,   -- block_id
+        body_last_block_id = false,    -- block_id
+        iteration_variable_id = false, -- v_id
+        limit_value = false,           -- ir.Value
+        loc = false,                   -- Location
+    }
+end
+
 function ir.Function(loc, name, typ)
     return {
         loc = loc,            -- Location
@@ -53,6 +65,7 @@ function ir.Function(loc, name, typ)
         f_id_of_local = {},   -- { v_id => integer }
         blocks = {},          -- { ir.BasicBlock }
         ret_vars = {},        -- { v_id }, list of return variables
+        for_loops = {},       -- { ir.ForLoop }
     }
 end
 
@@ -125,6 +138,15 @@ define_union("Value", {
     Upvalue    = {"id"},
 })
 
+function ir.is_constant(value)
+    local tag = value._tag
+    return tag == "ir.Value.Nil" or
+           tag == "ir.Value.Bool" or
+           tag == "ir.Value.Integer" or
+           tag == "ir.Value.Float" or
+           tag == "ir.Value.String"
+end
+
 -- define_union("Cmd"
 local ir_cmd_constructors = {
     -- [IMPORTANT] Please use this naming convention:
@@ -148,6 +170,7 @@ local ir_cmd_constructors = {
 
     -- Arrays
     NewArr     = {"loc", "dst", "src_size"},
+    RenormArr  = {"loc", "src_arr", "src_i"}, -- renormalize array
 
     GetArr     = {"loc", "dst_typ", "dst", "src_arr", "src_i"},
     SetArr     = {"loc", "src_typ",        "src_arr", "src_i", "src_v"},
@@ -209,6 +232,8 @@ local ir_cmd_constructors = {
     Jmp        = {"target"},
     JmpIf      = {"loc", "src_cond", "target_true", "target_false"},
 
+    Nop = {}, -- does nothing
+
     -- Garbage Collection (appears after memory allocations)
     CheckGC = {},
 }
@@ -277,13 +302,13 @@ function ir.BasicBlock()
     }
 end
 
-local function is_jump(cmd)
+function ir.is_jump(cmd)
     return cmd._tag == "ir.Cmd.Jmp" or cmd._tag == "ir.Cmd.JmpIf"
 end
 
 function ir.get_jump(block)
     local cmd = block.cmds[#block.cmds]
-    if not cmd or not is_jump(cmd) then
+    if not cmd or not ir.is_jump(cmd) then
         return false
     end
     return cmd
@@ -394,29 +419,41 @@ function ir.get_predecessor_depth_search_topological_sort(predecessor_list)
     return reverse_order
 end
 
--- Iterate over the cmds of basic blocks using a naive ordering.
-function ir.iter(block_list)
-    local function go()
-        for _,block in ipairs(block_list) do
-            for _, cmd in ipairs(block.cmds) do
-                coroutine.yield(cmd)
+-- Inserts a block into a given index on a function's block list and updates block index references
+-- accordingly.
+function ir.insert_block(func, new_block, index)
+    assert(index > 0)
+    for _, block in ipairs(func.blocks) do
+        for _, cmd in ipairs(block.cmds) do
+            if cmd._tag == "ir.Cmd.Jmp" then
+                cmd.target = cmd.target + (cmd.target >= index and 1 or 0)
+            elseif cmd._tag == "ir.Cmd.JmpIf" then
+                cmd.target_true = cmd.target_true + (cmd.target_true >= index and 1 or 0)
+                cmd.target_false = cmd.target_false + (cmd.target_false >= index and 1 or 0)
             end
         end
     end
-    return coroutine.wrap(function() go() end)
-end
 
-function ir.flatten_cmd(block_list)
-    local res = {}
-    for _,block in ipairs(block_list) do
-        for _,cmd in ipairs(block.cmds) do
-            table.insert(res, cmd)
+    for _, loop in ipairs(func.for_loops) do
+        loop.prep_block_id = loop.prep_block_id + (loop.prep_block_id >= index and 1 or 0)
+        loop.body_first_block_id = loop.body_first_block_id + (loop.body_first_block_id >= index and 1 or 0)
+        loop.body_last_block_id = loop.body_last_block_id + (loop.body_last_block_id >= index and 1 or 0)
+    end
+
+    local offset = index - 1
+    for _, cmd in ipairs(new_block.cmds) do
+        if cmd._tag == "ir.Cmd.Jmp" then
+            cmd.target = cmd.target + offset
+        elseif cmd._tag == "ir.Cmd.JmpIf" then
+            cmd.target_true = cmd.target_true + offset
+            cmd.target_false = cmd.target_false + offset
         end
     end
-    return res
+
+    table.insert(func.blocks, index, new_block)
 end
 
--- Remove jumps that are never taken
+-- Remove jumps that are never taken.
 function ir.clean(func)
     for _, block in ipairs(func.blocks) do
         local jump = ir.get_jump(block)

src/pallene/print_ir.lua

@@ -122,9 +122,7 @@ local function Cmd(cmd)
     local tag = cmd._tag
 
     local lhs
-    if     tag == "ir.Cmd.Nop" then
-        return "nop"
-    elseif tag == "ir.Cmd.Return" then
+    if tag == "ir.Cmd.Return" then
         return "return " .. comma_concat(Vals(cmd.srcs))
     elseif tag == "ir.Cmd.SetArr"      then lhs = Bracket(cmd.src_arr, cmd.src_i)
     elseif tag == "ir.Cmd.SetTable"    then lhs = Bracket(cmd.src_tab, cmd.src_k)
@@ -154,6 +152,7 @@ local function Cmd(cmd)
     elseif tag == "ir.Cmd.JmpIf" then
         rhs = "jmpIf " .. Val(cmd.src_cond) .. ", " .. cmd.target_true .. ", " .. cmd.target_false
     elseif tag == "ir.Cmd.Jmp" then rhs = "jmp " .. cmd.target
+    elseif tag == "ir.Cmd.Nop" then rhs = "nop"
     elseif tagged_union.typename(cmd._tag) == "ir.Cmd" then
         local name = tagged_union.consname(cmd._tag)
         rhs = Call(name, Vals(ir.get_srcs(cmd)))