在前一篇中我们支持了通过函数名称来添加断点,我们同时也提到了在Lua中一个函数的名称的并不是确定的。准确的说,Lua中的函数并没有名称,所谓名称其实是保存这个函数值的变量的名称。

于是通过函数名称添加断点就造成了一定的不确定性,因为函数被调用时并不一定是以这个名字被调用的。另外,多个不同的函数也可能以相同的名字进行调用。

所以为了解决这个问题,本篇我们将继续扩展断点的设置接口,支持通过包名来添加断点。因为包名相对更具确定性,配合行号可以进行精确定位。

源码已经上传Github,欢迎watch/star😘。

本博客已迁移至CatBro's Blog,那是我自己搭建的个人博客,欢迎关注。本文链接

实现分析

为何选用包名的方式

其实一开始的想法并不是通过包名来添加断点,而是通过源文件名。但是源文件名同样存在重复的可能,我们只能考虑使用类似后缀匹配这种模糊的方式进行查找。这样的话,每个call事件中都需要对通过源文件名设置的断点表进行遍历。

使用绝对路径虽然可以解决重复的问题,但是使用上不方便,在添加断点的时候也不一定知道源文件的具体位置,况且short_src也不一定是绝对路径。

所以出于性能及易用性的考虑,采用了通过包名来设置断点的方式,这样就可以利用Lua本身的包名搜索机制,使用搜索包路径的方法package.searchpackage()将包名转成路径。而这个路径就是debug.getinfo获取到的调试信息中的short_src

下面是一个例子:

package.searchpath( "foo.bar.baz", package.path )
--> (e.g.) "/usr/share/lua/5.3/foo/bar/baz.lua"

断点的保存解析和查找

跟上一篇中通过函数名称添加的断点不同的是,通过包名添加的断点都是确定的,所以最终都可以将其转换为函数的断点。但是只有当执行过该函数之后,我们才能获取到该函数的相关信息,进行断点的转换,所以在此之前我们需要将它们临时存放在一个表中,跟之前的status.funcbptstatus.namebpt类似,我们把这个表定义为status.srcbpt

当执行到该函数之后,我们就可以将status.srcbpt中对应的断点转移到status.funcbpt表中,后续就可以通过普通函数断点的方式进行处理了。

为了提升性能,我们可以将之前执行过的函数的信息保存下来,后续再(通过包名方式)在相同的函数中添加断点时,就可以快速地确定其所在函数,直接在添加断点的时候就转换为普通函数断点了,而不需要推迟到后面进行查找比对转换了。之前我们已经有了一个保存函数信息的表status.funcinfos,但是那个表是以函数作为键,而这里我们需要通过源文件路径进行查找,所以需要新的数据结构。

解决断点歧义

通过包名添加断点存在着一种歧义的情况:当断点落在函数定义的范围之内时,它是表示对mainchunk中的函数声明添加断点,还是表示在该子函数执行时添加断点。(本质上是因为mainchunk的有效行和子函数有效行存在重叠)

所以为了优雅地解决这个歧义问题,我们使用行号的正负表示是在mainchunk中还是在子函数中添加断点。如果行号是正数,表示子函数,跟前几篇中的情况保持一致;如果行号是负数,则表示在mainchunk中添加断点。

好了,解决了最关键的几个问题,我们就可以开始着手写代码了

添加断点

同样依照惯例,我们先修改设置断点函数。它的改动较大,因为函数名称和包名称都是通过字符串参数指定,所以需要一个区分手段,我们这里采用了一个跟在名称后面的特殊字符来进行区分。如果后面跟的是@,表示是函数名称,如果后面跟的是:,表示是包名。

先来看通过包名添加断点的情况,首先查找标记符号:,如果找到则前面部分表示包名,后面部分表示行号。切分之后,检查包名是否为空,再检查行号是否合法。如果没有指定行号,那么默认设置为-1,也就是mainchunk的第一行。接下来调用package.searchpath()将包名转化为路径,如果找到了指定的包,再通过setsrcbp()函数来设置断点。setsrcbp()我们稍后介绍。

local function setbreakpoint(where, line)
    -- 省略
    if type(where) == "function" then
        return setfuncbp(where, line)
    else            -- "string"
        local i = string.find(where, ":")
        if i then   -- package name
            local packname = string.sub(where, 1, i-1)
            local line = string.sub(where, i+1)
            if packname == "" then
                io.write("no package name specified!\n")
                return nil
            end
            if line ~= "" then
                line = tonumber(line)
                if not line then
                    io.write("no valid line number specified!\n")
                    return nil
                end
            else
                line = -1
            end
            local path, err = package.searchpath(packname, package.path)
            if not path then
                io.write(err)
                return nil
            end
            return setsrcbp(path, line)
        else
end

通过函数名称添加断点的情况也是类似,不过省了路径转换的步骤。首先查找标记符号@,然后切分函数名和行号,检查函数名是否为空,检查行号是否合法,都ok之后再交给setnamebp()进行后面的工作。setnamebp()函数我们在上一篇已经介绍过了。

local function setbreakpoint(where, line)
    -- 省略
        else
            local i = string.find(where, "@")
            if i then   -- function name
                local funcname = string.sub(where, 1, i-1)
                local line = string.sub(where, i+1)
                if funcname == "" then
                    io.write("no function name specified!\n")
                    return nil
                end
                if line ~= "" then
                    line = tonumber(line)
                    if not line then
                        io.write("no valid line number specified!\n")
                        return nil
                    end
                else
                    line = nil
                end
                return setnamebp(funcname, line)
            end
        end
    end
end

下面我们来看setsrcbp()函数的实现,这个函数跟setnamebp()大体上类似,开头部分稍有不同。首先会通过lookforfunc()查看断点是否位于已知函数中,如果是的话返回该函数,然后直接调用setfuncbp()函数作为函数断点处理。lookforfunc()我们稍晚一点再介绍。后面的流程跟setnamebp()并无二致就不再赘述。

local function setsrcbp(src, line)
    local s = status

    -- 检查断点是否位于已知函数中
    local func = lookforfunc(src, line)
    if func then
        return setfuncbp(func, line)
    end

    local srcbp = s.srcbpt[src]
    -- 检查相同的断点是否已经设置
    if srcbp and srcbp[line] then
        return srcbp[line]
    end
    -- 省略
end

钩子函数

钩子函数的改动都是在call事件中。首先,在获取到当前函数及其信息之后,调用solvesrcbp()处理status.srcbpt表中还未转换的断点,如果发现有位于当前函数中的断点,那么就进行相应的断点转换。接下来,如果当前函数不是C函数,就调用setsrcfunc()函数保存函数信息。

local function hook (event, line)
    local s = status
    if event == "call" or event == "tail call" then
        local stackinfo = debug.getinfo(2, "nf")
        local func = stackinfo.func
        local name = stackinfo.name
        local funcinfo = getfuncinfo(func)
        local hasbreak = false
        -- 处理通过包名添加的还未转换的断点
        solvesrcbp(funcinfo, func)

        if funcinfo.what ~= "C" then
            setsrcfunc(funcinfo, func)
        end

        if s.funcbpt[func] then
            local id = s.funcbpt[func]
            if s.bptable[id] and not s.bptable[id].src then
                s.bptable[id].src = funcinfo.short_src
            end
            hasbreak = true
        end
        -- 省略
end

断点转换

接下来看下solvesrcbp()函数的实现,如果当前源文件中存在未转换的断点,那么遍历这些断点,调用verifyfuncline()判断断点是否在当前函数中,如果是的话就调用modsrcbp()函数进行实际的转换操作。

local function solvesrcbp (info, func)
    local s = status
    local srcbp = s.srcbpt[info.short_src]
    if srcbp then
        for k, v in pairs(srcbp) do
            if k ~= "num" then
                line = verifyfuncline(info, k)
                if line then
                    modsrcbp(info.short_src, func, k, line)
                end
            end
        end
    end
end

modsrcbp()函数的实现如下,它有4个参数第一个src是源文件路径、第二个func是函数、第三个oline是设置断点时的行号、第四个nlineverifyfuncline()进行修正后的行号。

该函数首先以srcoline为索引将断点从status.srcbpt表中移除,然后设置到status.funcbpt表中。如果同一个断点已经设置过了,那么将新添加的断点删除,然后返回旧的断点id。

local function modsrcbp(src, func, oline, nline)
    local s = status
    local srcbp = s.srcbpt[src]
    local id = srcbp[oline]

    -- 从srcbpt中移除
    srcbp.num = srcbp.num - 1
    srcbp[oline] = nil
    if srcbp.num == 0 then
        srcbp = nil
    end

    -- 设置funcbpt
    local funcbp = s.funcbpt[func]
    -- 检查是否已经设置了相同的断点
    if funcbp and funcbp[nline] then
        s.bptable[id] = nil      -- 如果已经设置了,删除新加的断点
        s.bpnum = s.bpnum - 1
        assert(s.bpnum > 0)
        return funcbp[nline]     -- 返回旧的断点id
    end

    -- 省略
end

如果还未添加过这个断点,那么就在status.funcbpt中添加该断点,然后将断点所在的函数和修正后的行号更新到s.bptable表中。

local function modsrcbp(src, func, oline, nline)
    -- 省略
    if not funcbp then            -- 该函数的第一个断点
        s.funcbpt[func] = {}
        funcbp = s.funcbpt[func]
        funcbp.num = 0
    end
    funcbp.num = funcbp.num + 1
    funcbp[nline] = id

    -- 更新bptable中字段
    s.bptable[id].func = func
    s.bptable[id].line = nline

    return id
end

行号扩展

因为我们对行号进行了扩展了,使用负数来表示mainchunk中的断点,所以verifyfuncline()也需要进行相应的扩展。对于行号是负数的情况,如果不是mainchunk函数,直接返回nil,否则对行号取反还原为正常的行号。

local function verifyfuncline (info, line)
    if not line then
        return info.sortedlines[1]
    end
    if line < 0 then
        if info.what ~= "main" then
            return nil
        end
        line = -line
    end
    if line < info.linedefined or line > info.lastlinedefined then
        return nil
    end
    for _, v in ipairs(info.sortedlines) do
        if v >= line then
            return v
        end
    end
    assert(false)   -- impossible to reach here
end

这里还有一个问题,通过debug.getinfo()函数获取到的函数信息中,对于mainchunk的情况,linedefinedlastlinedefined字段的值都是0,于是我们的getfuncinfo()函数也要进行相应的调整:

local function getfuncinfo (func)
    local s = status
    local info = s.funcinfos[func]
    if not info then
        info = debug.getinfo(func, "SL")
        if (info.activelines) then
            info.sortedlines = {}
            for k, _ in pairs(info.activelines) do
               table.insert(info.sortedlines, k)
            end
            table.sort(info.sortedlines)
            -- mainchunk需要特殊处理以使`verifyfuncline`能够正常工作
            if info.what == "main" then
                info.linedefined = 1
                info.lastlinedefined = info.sortedlines[#info.sortedlines]
            end
        end
        s.funcinfos[func] = info
    end
    return info
end

对于mainchunk函数进行特殊处理,将linedefined设置为1,将lastlinedefined设置为最后一个有效行的行号。

缓存及查找源文件的函数

我们在钩子函数中调用setsrcfunc()保存函数信息,将函数与源文件关联。在setsrcbp()中调用lookforfunc()通过源文件和行号查找对应的函数。先来看setsrcfunc()函数实现:

local function setsrcfunc (info, func)
    local s = status
    local srcfunc = s.srcfuncmap[info.short_src]
    if not srcfunc then
        srcfunc = {}
        s.srcfuncmap[info.short_src] = srcfunc
    end
    if not srcfunc[func] then
        srcfunc[func] = info
    end
end

其中status.srcfuncmap就是我们新增的数据结构,它是一个以源文件路径为键的表,其值也是一个表,保存位于该源文件中的函数信息,以函数为键,以函数信息为值。

再来看lookforfunc()函数的实现:

local function lookforfunc (src, line)
    assert(line)
    local srcfunc = status.srcfuncmap[src]
    if srcfunc then
        for func, info in pairs(srcfunc) do
            if info.what == "main" then
                if line < 0 then
                    return func
                end
            elseif line >= info.linedefined
                and line <= info.lastlinedefined then
                return func
            end
        end
    end
    return nil
end

lookforfunc()函数中首先判断该源文件是否有缓存的函数信息,如果有则进行遍历。如果行号是负数,则只要找到mainchunk就可以返回了。否则,需要判断断点的行号是否在函数定义的范围内。找到了,就返回断点所在函数;没有找到返回nil

测试

首先,编写一个用于测试的包testlib.lua,实现了两个简单的函数foo和bar。

local function foo ()
    local a = 1
end

local function bar()
    local a = 1
end

local a = 1

return {
    foo = foo,
    bar = bar,
}

测试通过函数名和包名添加断点

我们通过函数名添加了两个断点,其中一个省略行号,默认为函数第一个有效行。又通过包名添加了两个有效断点id3和id4,id5虽然能添加成功,但是并不落在有效函数范围内。id6和id7都是参数错误的情况,添加断点失败。

设置完断点,先分别调用foo和bar函数一次,预期都在foo函数第2行第3行会碰到断点,然后在bar函数的第6行第7行碰到断点。接着分别删除foo和bar函数中的1个断点,再分别调用foo和bar函数一次,预期在foo函数的第3行和bar函数的第7行碰到断点。最后删除foo和bar函数中的另一个断点,再分别调用foo和bar函数一次,预期不再碰到断点。

local ldb = require "luadebug"
local lib = require "testlib"
local setbp = ldb.setbreakpoint
local rmbp = ldb.removebreakpoint

local id1 = setbp("foo@")           -- foo 2
local id2 = setbp("foo@3")          -- foo 3

local id3 = setbp("testlib:5")      -- bar 6
local id4 = setbp("testlib:7")      -- bar 7
local id5 = setbp("testlib:100")    -- invalid line
local id6 = setbp(":5")
assert(not id6)
local id7 = setbp("testlib:aa")
assert(not id7)

lib.foo(1)              -- break twice
lib.bar(1)              -- break twice

rmbp(id1)
rmbp(id3)

lib.foo(2)              -- break once
lib.bar(2)              -- break once

rmbp(id2)
rmbp(id4)

lib.foo(3)              -- not break
lib.bar(3)              -- not break

运行测试脚本,分别在foo函数和bar函数中碰到两个断点。

$ lua setbpbysrc.lua
no package name specified!
no valid line number specified!
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:2
lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont
Lua (field)bar /usr/local/share/lua/5.3/testlib.lua:6
lua_debug> cont
Lua (field)bar /usr/local/share/lua/5.3/testlib.lua:7
lua_debug>

继续执行,分别在foo函数和bar函数中碰到一个断点。

lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont
Lua (field)bar /usr/local/share/lua/5.3/testlib.lua:7
lua_debug>

继续执行,没有再碰到断点。

lua_debug> cont
$

测试行号扩展

编写如下测试脚本,在mainchunk中添加了4个断点,其中不指定行号时默认是mainchunk的第一个有效行。当require该包时,预期在mainchunk的第3行、第7行、第9行和第13行分别碰到断点。

接着在子函数foo中添加两个断点,调用foo函数,预期在foo函数第2行和第3行碰到断点。然后其中一个断点,再调用foo函数,预期在foo函数第3行碰到断点。最后删除剩余一个断点,再调用foo函数,预期不再碰到断点。

local ldb = require "luadebug"
local setbp = ldb.setbreakpoint
local rmbp = ldb.removebreakpoint

local id1 = setbp("testlib:")       -- main 3
local id2 = setbp("testlib:-5")     -- main 7
local id3 = setbp("testlib:-9")     -- main 9
local id4 = setbp("testlib:-13")    -- main 13

local lib = require "testlib"       -- break 4 times

local id5 = setbp("testlib:2")      -- foo 2
local id6 = setbp("testlib:3")      -- foo 3

lib.foo()   -- break 2 times

rmbp(id5)

lib.foo()   -- break 1 time

rmbp(id6)

lib.foo()   -- not break

运行测试脚本,首先碰到了mainchunk中的4个断点

lua mainchunk.lua
main ()nil /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont
main ()nil /usr/local/share/lua/5.3/testlib.lua:7
lua_debug> cont
main ()nil /usr/local/share/lua/5.3/testlib.lua:9
lua_debug> cont
main ()nil /usr/local/share/lua/5.3/testlib.lua:13
lua_debug>

继续执行,碰到foo函数中两个断点

lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:2
lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug>

再继续执行,碰到foo函数中一个断点

lua_debug> cont
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug>

再cont就结束了。

lua_debug> cont
$

测试断点重复及缓存源文件的函数

编写如下测试脚本,首先我们通过函数添加一个断点,然后再通过包名添加一个断点。虽然这两个实际是同一个断点,但是刚开始的时候因为还没有缓存信息,所以第二个断点也会添加成功。接着调用 foo函数,预期在foo函数第2行碰到断点。在钩子函数call事件中会处理未转换的断点2,因为已经存在同样的断点了,所以会将断点2删除。

接下来我们删除断点1之后,就没有断点了,再次调用foo函数,预期不会碰到断点。

然后我们再通过包名添加一个断点,这里因为已经有了对应的函数信息,所以预期会直接转换成对应的函数断点。当我们再对函数添加同样的断点的时候预期返回之前的断点号。

调用foo函数,预期在foo函数第3行碰到断点。删除断点3,预期不再碰到断点。

local ldb = require "luadebug"
local lib = require "testlib"
local setbp = ldb.setbreakpoint
local rmbp = ldb.removebreakpoint

local id1 = setbp(lib.foo)

local id2 = setbp("testlib:1")  -- foo 2

lib.foo()   -- break once

rmbp(id1)

lib.foo()   -- not break
print("not break")

local id3 = setbp("testlib:3")  -- foo 3
assert(id3 == 3)
local id4 = setbp(lib.foo, 3)
assert(id3 == id4)

lib.foo()   -- break once

rmbp(id3)

lib.foo()   -- not break

运行测试脚本,结果符合预期。

$ lua srcfuncmap.lua
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:2
lua_debug> cont
not break
Lua (field)foo /usr/local/share/lua/5.3/testlib.lua:3
lua_debug> cont
03-15 18:44