aboutsummaryrefslogtreecommitdiff
path: root/mkelf.lua
blob: 2bbc2da5eea5cf3a51c02a271f1c9efcd881ff13 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
local elf = require("elf")
local ec = require("elf.constants")

local function die(fmt, ...)
    io.stderr:write("mkelf: ", string.format(fmt, ...), "\n")
    os.exit(1)
end

local function usage()
    die("[-o output] [input]")
end

local function setup_header(state)
    return function (t)
        if type(t) ~= "table" then
            error("header must be a table", 2)
        end
        if state.header == nil then
            state.header = elf.header.normalize(t)
        else
            error("multiple headers are disallowed", 2)
        end
    end
end

local function setup_segments(state)
    return function (t)
        if type(t) ~= "table" then
            error("segments must be a table", 2)
        end
        for i, s in ipairs(t) do
            if type(s) ~= "table" then
                error(("segment #%d must be a table"):format(i), 2)
            end
            table.insert(state.segments, elf.segment.normalize(s))
        end
    end
end

local function setup_sections(state)
    return function (t)
        if type(t) ~= "table" then
            error("sections must be a table", 2)
        end
        for i, s in ipairs(t) do
            if type(s) ~= "table" then
                error(("section #%d must be a table"):format(i), 2)
            end
            table.insert(state.sections, elf.section.normalize(s))
        end
    end
end

local function setup_env(state)
    return setmetatable({}, {
        __index = {
            Class = ec.Class,
            Endian = ec.Endian,
            Osabi = ec.Osabi,
            Type = ec.Type,
            Machine = ec.Machine,
            SegmentType = ec.SegmentType,
            SegmentFlags = ec.SegmentFlags,
            SectionType = ec.SectionType,
            SectionFlags = ec.SectionFlags,
            ELFVERSION = ec.VERSION,
            header = setup_header(state),
            segments = setup_segments(state),
            sections = setup_sections(state),
        },
        __newindex = function (_, name)
            error(("may not define global %q"):format(name), 2)
        end,
        __metatable = false,
    })
end

local function loadconfig(fn)
    local state = { header, segments = {}, sections = {} }
    local env = setup_env(state)
    local chunk, err = loadfile(fn, "t", env)
    if not chunk then die("%s", err) end
    -- TODO sandbox against malformed configs
    local ok, perr = pcall(chunk)
    if not ok then die("%s", perr) end
    return state.header, state.segments, state.sections
end

local function main()
    local outfn = "a.out"
    local infn
    local i = 1
    while arg[i] do
        if arg[i] == "-o" then
            i = i + 1
            outfn = arg[i] or die("missing filename after -o")
        elseif infn == nil then
            infn = arg[i]
        else
            usage()
        end
        i = i + 1
    end
    local header, segments, sections = loadconfig(infn)
    if not header then die("header missing") end
    -- TODO check against headerOptions not normalized header.
    if header.phnum == 0 then header.phnum = #segments end
    if header.shnum == 0 then header.shnum = #sections end
    local out <close> = io.open(outfn, "wb")
    if out == nil then die("failed to open %s", outfn) end
    out:write(elf.header.pack(header))
    for _, segment in ipairs(segments) do
        out:write(elf.segment.pack(segment, header.data, header.class))
    end
    for _, section in ipairs(sections) do
        out:write(elf.section.pack(section, header.data, header.class))
    end
end

main()