3159990762

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/iovisor/ubpf/commit/<a class=hub.com/iovisor/ubpf/commit/<a class="double-link" href="https://git"><a class=hub.com/iovisor/ubpf/commit/<a class="double-link" href="https://git"><a class=hub.com/iovisor/ubpf/commit/<a class="double-link" href="https://git"><a class=hub.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd">c6e758863">&lt;a href=&quot;https://github.com/iovisor/ubpf/commit/</a><a class="double-link" href="https://github.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd">c6e758863</a><a href="https://github.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/iovisor/ubpf/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd&quot;&gt;c6e758863&lt;/a&gt;&lt;a href=&quot;https://github.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/iovisor/ubpf/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/iovisor/ubpf/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot... (continued)

Pull Request Pull Request #119: uBPF unit tests that run natively with out Python.

Run Details

398 of 398 new or added lines in 3 files covered. (100.0%)

2910 of 3529 relevant lines covered (82.46%)

110075.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.57

/code_gen_tests/bpf_assembler.cc

// Copyright (c) 2022-present, IO Visor Project
// SPDX-License-Identifier: MIT

#include <array>
#include <functional>
#include <unordered_map>
#include <variant>
#include <sstream>

#include "bpf_assembler.h"

typedef std::variant<ebpf_inst, std::array<ebpf_inst, 2>> bpf_encode_result_t;

typedef std::function<bpf_encode_result_t(const std::string& mnemonic, const std::vector<std::string>& operands)>
    bpf_encode_t;

static const std::unordered_map<std::string, int> _bpf_encode_register_map{
    {"r0", 0},
    {"r1", 1},
    {"r2", 2},
    {"r3", 3},
    {"r4", 4},
    {"r5", 5},
    {"r6", 6},
    {"r7", 7},
    {"r8", 8},
    {"r9", 9},
    {"r10", 10},
};

static const std::unordered_map<std::string, int> _bpf_encode_alu_ops{
    {"add", 0x0},
    {"sub", 0x1},
    {"mul", 0x2},
    {"div", 0x3},
    {"or", 0x4},
    {"and", 0x5},
    {"lsh", 0x6},
    {"rsh", 0x7},
    {"neg", 0x8},
    {"mod", 0x9},
    {"xor", 0xa},
    {"mov", 0xb},
    {"arsh", 0xc},
    {"le", 0xd},
    {"be", 0xd},
};

static const std::unordered_map<std::string, int> _bpf_encode_jmp_ops{
    {"jeq", 0x1},
    {"jgt", 0x2},
    {"jge", 0x3},
    {"jset", 0x4},
    {"jne", 0x5},
    {"jsgt", 0x6},
    {"jsge", 0x7},
    {"jlt", 0xa},
    {"jle", 0xb},
    {"jslt", 0xc},
    {"jsle", 0xd},
};

static uint64_t
_decode_imm64(const std::string& str)
{
    if (str.find("0x") == std::string::npos) {
        return std::stoull(str);
    } else {
        return std::stoull(str, nullptr, 16);
    }
}

static uint32_t
_decode_imm32(const std::string& str)
{
    if (str.find("0x") == std::string::npos) {
        return std::stoul(str);
    } else {
        return std::stoul(str, nullptr, 16);
    }
}

static uint16_t
_decode_offset(const std::string& str)
{
    if (str.find("0x") == std::string::npos) {
        return static_cast<uint16_t>(std::stoul(str));
    } else {
        return static_cast<uint16_t>(std::stoul(str, nullptr, 16));
    }
}

static uint8_t
_decode_register(const std::string& register_name)
{
    auto reg = _bpf_encode_register_map.find(register_name);
    if (reg == _bpf_encode_register_map.end()) {
        throw std::runtime_error(std::string("Invalid register: ") + register_name);
    }
    return static_cast<uint8_t>(reg->second);
}

static std::tuple<uint8_t, uint16_t>
_decode_register_and_offset(const std::string& operand)
{
    auto reg_start = operand.find('[');
    auto reg_end = operand.find('+');
    reg_end = (reg_end != std::string::npos) ? reg_end : operand.find('-');
    reg_end = (reg_end != std::string::npos) ? reg_end : operand.find(']');

    if (reg_start == std::string::npos || reg_end == std::string::npos) {
        throw std::runtime_error(std::string("Invalid operand: ") + operand);
    }

    if (operand.substr(reg_end).starts_with(']')) {
        return std::make_tuple<uint8_t, uint16_t>(
            _decode_register(operand.substr(reg_start + 1, reg_end - reg_start - 1)), 0);
    } else {
        return std::make_tuple<uint8_t, uint16_t>(
            _decode_register(operand.substr(reg_start + 1, reg_end - reg_start - 1)),
            _decode_offset(operand.substr(reg_end)));
    }
}

static bpf_encode_result_t
_encode_ld(const std::string& mnemonic, const std::vector<std::string>& operands)
{
    std::array<ebpf_inst, 2> inst{};
    if (mnemonic != "lddw") {
        throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);
    }
    if (operands.size() != 2) {
        throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
    }
    inst[0].opcode = EBPF_OP_LDDW;
    inst[0].dst = _decode_register(operands[0]);
    uint64_t immediate = _decode_imm64(operands[1]);
    inst[0].imm = static_cast<uint32_t>(immediate);
    inst[1].imm = static_cast<uint32_t>(immediate >> 32);

    return inst;
}

static bpf_encode_result_t
_encode_ldx(const std::string& mnemonic, const std::vector<std::string>& operands)
{
    ebpf_inst inst{};
    if (operands.size() != 2) {
        throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
    }
    inst.dst = _decode_register(operands[0]);
    auto [src, offset] = _decode_register_and_offset(operands[1]);
    inst.src = src;
    inst.offset = offset;
    if (mnemonic == "ldxb") {
        inst.opcode = EBPF_OP_LDXB;
    } else if (mnemonic == "ldxdw") {
        inst.opcode = EBPF_OP_LDXDW;
    } else if (mnemonic == "ldxh") {
        inst.opcode = EBPF_OP_LDXH;
    } else if (mnemonic == "ldxw") {
        inst.opcode = EBPF_OP_LDXW;
    } else {
        throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);
    }

    return inst;
}

static bpf_encode_result_t
_encode_st(const std::string& mnemonic, const std::vector<std::string>& operands)
{
    ebpf_inst inst{};
    if (operands.size() != 2) {
        throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
    }
    auto [dst, offset] = _decode_register_and_offset(operands[0]);
    inst.dst = dst;
    inst.offset = offset;
    if (mnemonic == "stb") {
        inst.opcode = EBPF_OP_STB;
    } else if (mnemonic == "stdw") {
        inst.opcode = EBPF_OP_STDW;
    } else if (mnemonic == "sth") {
        inst.opcode = EBPF_OP_STH;
    } else if (mnemonic == "stw") {
        inst.opcode = EBPF_OP_STW;
    } else {
        throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);
    }
    inst.imm = _decode_imm32(operands[1]);
    return inst;
}

static bpf_encode_result_t
_encode_stx(const std::string& mnemonic, const std::vector<std::string>& operands)
{
    ebpf_inst inst{};
    if (operands.size() != 2) {
        throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
    }
    auto [dst, offset] = _decode_register_and_offset(operands[0]);
    inst.dst = dst;
    inst.offset = offset;
    inst.src = _decode_register(operands[1]);
    if (mnemonic == "stxb") {
        inst.opcode = EBPF_OP_STXB;
    } else if (mnemonic == "stxdw") {
        inst.opcode = EBPF_OP_STXDW;
    } else if (mnemonic == "stxh") {
        inst.opcode = EBPF_OP_STXH;
    } else if (mnemonic == "stxw") {
        inst.opcode = EBPF_OP_STXW;
    } else {
        throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);
    }

    return inst;
}

static bpf_encode_result_t
_encode_alu(const std::string& mnemonic, const std::vector<std::string>& operands)
{
    ebpf_inst inst{};
    std::string alu_op;
    if (mnemonic.starts_with("be")) {
        if (operands.size() != 1) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }
        inst.opcode = EBPF_OP_BE;
        inst.dst = _decode_register(operands[0]);
        inst.imm = _decode_imm32(mnemonic.substr(2));
        return inst;
    } else if (mnemonic.starts_with("le")) {
        if (operands.size() != 1) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }
        inst.opcode = EBPF_OP_LE;
        inst.dst = _decode_register(operands[0]);
        inst.imm = _decode_imm32(mnemonic.substr(2));
        return inst;
    }

    if (mnemonic.starts_with("neg")) {
        if (operands.size() != 1) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }
    } else {
        if (operands.size() != 2) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }
    }

    if (mnemonic.ends_with("32")) {
        inst.opcode |= EBPF_CLS_ALU;
        alu_op = mnemonic.substr(0, mnemonic.size() - 2);
    } else {
        inst.opcode |= EBPF_CLS_ALU64;
        alu_op = mnemonic;
    }
    auto iter = _bpf_encode_alu_ops.find(alu_op);
    if (iter == _bpf_encode_alu_ops.end()) {
        throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);
    }
    inst.opcode |= iter->second << 4;

    inst.dst = _decode_register(operands[0]);

    if (operands.size() == 2) {
        if (operands[1].starts_with('r')) {
            inst.opcode |= EBPF_SRC_REG;
            inst.src = _decode_register(operands[1]);
        } else {
            inst.opcode |= EBPF_SRC_IMM;
            inst.imm = _decode_imm32(operands[1]);
        }
    }

    return inst;
}

static bpf_encode_result_t
_encode_jmp(const std::string& mnemonic, const std::vector<std::string>& operands)
{
    ebpf_inst inst{};
    inst.opcode |= EBPF_CLS_JMP;
    if (mnemonic == "ja") {
        if (operands.size() != 1) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }

        inst.offset = _decode_offset(operands[0]);
    } else if (mnemonic == "exit") {
        if (operands.size() != 0) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }
        inst.opcode = EBPF_OP_EXIT;
    } else if (mnemonic == "call") {
        if (operands.size() != 1) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }
        inst.opcode = EBPF_OP_CALL;
        inst.imm = _decode_imm32(operands[0]);
    } else {
        if (operands.size() != 3) {
            throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);
        }
        auto iter = _bpf_encode_jmp_ops.find(mnemonic);
        inst.opcode |= iter->second << 4;
        inst.dst = _decode_register(operands[0]);
        if (operands[1].starts_with('r')) {
            inst.opcode |= EBPF_SRC_REG;
            inst.src = _decode_register(operands[1]);
        } else {
            inst.opcode |= EBPF_SRC_IMM;
            inst.imm = _decode_imm32(operands[1]);
        }
        inst.offset = _decode_offset(operands[2]);
    }
    return inst;
}

static const std::unordered_map<std::string, bpf_encode_t> _bpf_mnemonic_map{
    {"add", _encode_alu},   {"add32", _encode_alu},  {"and", _encode_alu},   {"and32", _encode_alu},
    {"arsh", _encode_alu},  {"arsh32", _encode_alu}, {"be16", _encode_alu},  {"be32", _encode_alu},
    {"be64", _encode_alu},  {"call", _encode_jmp},   {"div", _encode_alu},   {"div32", _encode_alu},
    {"exit", _encode_jmp},  {"ja", _encode_jmp},     {"jeq", _encode_jmp},   {"jge", _encode_jmp},
    {"jgt", _encode_jmp},   {"jle", _encode_jmp},    {"jlt", _encode_jmp},   {"jne", _encode_jmp},
    {"jset", _encode_jmp},  {"jsge", _encode_jmp},   {"jsgt", _encode_jmp},  {"jsle", _encode_jmp},
    {"jslt", _encode_jmp},  {"lddw", _encode_ld},    {"ldxb", _encode_ldx},  {"ldxdw", _encode_ldx},
    {"ldxh", _encode_ldx},  {"ldxw", _encode_ldx},   {"le16", _encode_alu},  {"le32", _encode_alu},
    {"le64", _encode_alu},  {"lsh", _encode_alu},    {"lsh32", _encode_alu}, {"mod", _encode_alu},
    {"mod32", _encode_alu}, {"mov", _encode_alu},    {"mov32", _encode_alu}, {"mul", _encode_alu},
    {"mul32", _encode_alu}, {"neg", _encode_alu},    {"neg32", _encode_alu}, {"or", _encode_alu},
    {"or32", _encode_alu},  {"rsh", _encode_alu},    {"rsh32", _encode_alu}, {"stb", _encode_st},
    {"stdw", _encode_st},   {"sth", _encode_st},     {"stw", _encode_st},    {"stxb", _encode_stx},
    {"stxdw", _encode_stx}, {"stxh", _encode_stx},   {"stxw", _encode_stx},  {"sub", _encode_alu},
    {"sub32", _encode_alu}, {"xor", _encode_alu},    {"xor32", _encode_alu},
};

std::vector<ebpf_inst>
bpf_assembler(std::istream& input)
{
    std::vector<ebpf_inst> output;
    std::string line;
    // Parse the input stream one line at a time.
    while (std::getline(input, line)) {
        std::istringstream line_stream(line);
        std::string mnemonic;
        std::string operand;
        std::vector<std::string> operands;
        // Check for empty lines.
        if (!std::getline(line_stream, mnemonic, ' ')) {
            continue;
        }
        // Split the line on ' '
        while (std::getline(line_stream, operand, ' ')) {
            if (operand.starts_with('#')) {
                break;
            }
            if (operand.ends_with(',')) {
                operand = operand.substr(0, operand.length() - 1);
            }
            operands.emplace_back(operand);
        }
        // Find the handler for this mnemonic.
        auto iter = _bpf_mnemonic_map.find(mnemonic);
        if (iter == _bpf_mnemonic_map.end()) {
            throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);
        }
        // Invoke handler and store result.
        auto result = iter->second(mnemonic, operands);
        if (std::holds_alternative<ebpf_inst>(result)) {
            output.emplace_back(std::get<ebpf_inst>(result));
        } else {
            for (const auto& inst : std::get<std::array<ebpf_inst, 2>>(result)) {
                output.emplace_back(inst);
            }
        }
    }
    return output;
}

1	// Copyright (c) 2022-present, IO Visor Project
2	// SPDX-License-Identifier: MIT
3
4	#include <array>
5	#include <functional>
6	#include <unordered_map>
7	#include <variant>
8	#include <sstream>
9
10	#include "bpf_assembler.h"
11
12	typedef std::variant<ebpf_inst, std::array<ebpf_inst, 2>> bpf_encode_result_t;
13
14	typedef std::function<bpf_encode_result_t(const std::string& mnemonic, const std::vector<std::string>& operands)>
15	bpf_encode_t;
16
17	static const std::unordered_map<std::string, int> _bpf_encode_register_map{	251✔
18	{"r0", 0},	251✔
19	{"r1", 1},	251✔
20	{"r2", 2},	251✔
21	{"r3", 3},	251✔
22	{"r4", 4},	251✔
23	{"r5", 5},	251✔
24	{"r6", 6},	251✔
25	{"r7", 7},	251✔
26	{"r8", 8},	251✔
27	{"r9", 9},	251✔
28	{"r10", 10},	251✔
29	};
30
31	static const std::unordered_map<std::string, int> _bpf_encode_alu_ops{	251✔
32	{"add", 0x0},	251✔
33	{"sub", 0x1},	251✔
34	{"mul", 0x2},	251✔
35	{"div", 0x3},	251✔
36	{"or", 0x4},	251✔
37	{"and", 0x5},	251✔
38	{"lsh", 0x6},	251✔
39	{"rsh", 0x7},	251✔
40	{"neg", 0x8},	251✔
41	{"mod", 0x9},	251✔
42	{"xor", 0xa},	251✔
43	{"mov", 0xb},	251✔
44	{"arsh", 0xc},	251✔
45	{"le", 0xd},	251✔
46	{"be", 0xd},	251✔
47	};
48
49	static const std::unordered_map<std::string, int> _bpf_encode_jmp_ops{	251✔
50	{"jeq", 0x1},	251✔
51	{"jgt", 0x2},	251✔
52	{"jge", 0x3},	251✔
53	{"jset", 0x4},	251✔
54	{"jne", 0x5},	251✔
55	{"jsgt", 0x6},	251✔
56	{"jsge", 0x7},	251✔
57	{"jlt", 0xa},	251✔
58	{"jle", 0xb},	251✔
59	{"jslt", 0xc},	251✔
60	{"jsle", 0xd},	251✔
61	};
62
63	static uint64_t
64	_decode_imm64(const std::string& str)	14✔
65	{
66	if (str.find("0x") == std::string::npos) {	14✔
67	return std::stoull(str);	×
68	} else {
69	return std::stoull(str, nullptr, 16);	14✔
70	}
71	}	14✔
72
73	static uint32_t
74	_decode_imm32(const std::string& str)	886✔
75	{
76	if (str.find("0x") == std::string::npos) {	886✔
77	return std::stoul(str);	584✔
78	} else {
79	return std::stoul(str, nullptr, 16);	302✔
80	}
81	}	886✔
82
83	static uint16_t
84	_decode_offset(const std::string& str)	394✔
85	{
86	if (str.find("0x") == std::string::npos) {	394✔
87	return static_cast<uint16_t>(std::stoul(str));	394✔
88	} else {
89	return static_cast<uint16_t>(std::stoul(str, nullptr, 16));	×
90	}
91	}	394✔
92
93	static uint8_t
94	_decode_register(const std::string& register_name)	2,068✔
95	{
96	auto reg = _bpf_encode_register_map.find(register_name);	2,068✔
97	if (reg == _bpf_encode_register_map.end()) {	2,068✔
98	throw std::runtime_error(std::string("Invalid register: ") + register_name);	×
99	}
100	return static_cast<uint8_t>(reg->second);	4,136✔
101	}	2,068✔
102
103	static std::tuple<uint8_t, uint16_t>
104	_decode_register_and_offset(const std::string& operand)	284✔
105	{
106	auto reg_start = operand.find('[');	284✔
107	auto reg_end = operand.find('+');	284✔
108	reg_end = (reg_end != std::string::npos) ? reg_end : operand.find('-');	284✔
109	reg_end = (reg_end != std::string::npos) ? reg_end : operand.find(']');	284✔
110
111	if (reg_start == std::string::npos \|\| reg_end == std::string::npos) {	284✔
112	throw std::runtime_error(std::string("Invalid operand: ") + operand);	×
113	}
114
115	if (operand.substr(reg_end).starts_with(']')) {	284✔
116	return std::make_tuple<uint8_t, uint16_t>(	46✔
117	_decode_register(operand.substr(reg_start + 1, reg_end - reg_start - 1)), 0);	46✔
118	} else {
119	return std::make_tuple<uint8_t, uint16_t>(	238✔
120	_decode_register(operand.substr(reg_start + 1, reg_end - reg_start - 1)),	238✔
121	_decode_offset(operand.substr(reg_end)));	238✔
122	}
123	}	284✔
124
125	static bpf_encode_result_t
126	_encode_ld(const std::string& mnemonic, const std::vector<std::string>& operands)	14✔
127	{
128	std::array<ebpf_inst, 2> inst{};	14✔
129	if (mnemonic != "lddw") {	14✔
130	throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);	×
131	}
132	if (operands.size() != 2) {	14✔
133	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
134	}
135	inst[0].opcode = EBPF_OP_LDDW;	14✔
136	inst[0].dst = _decode_register(operands[0]);	14✔
137	uint64_t immediate = _decode_imm64(operands[1]);	14✔
138	inst[0].imm = static_cast<uint32_t>(immediate);	14✔
139	inst[1].imm = static_cast<uint32_t>(immediate >> 32);	14✔
140
141	return inst;	14✔
142	}	14✔
143
144	static bpf_encode_result_t
145	_encode_ldx(const std::string& mnemonic, const std::vector<std::string>& operands)	184✔
146	{
147	ebpf_inst inst{};	184✔
148	if (operands.size() != 2) {	184✔
149	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
150	}
151	inst.dst = _decode_register(operands[0]);	184✔
152	auto [src, offset] = _decode_register_and_offset(operands[1]);	184✔
153	inst.src = src;	184✔
154	inst.offset = offset;	184✔
155	if (mnemonic == "ldxb") {	184✔
156	inst.opcode = EBPF_OP_LDXB;	56✔
157	} else if (mnemonic == "ldxdw") {	184✔
158	inst.opcode = EBPF_OP_LDXDW;	26✔
159	} else if (mnemonic == "ldxh") {	128✔
160	inst.opcode = EBPF_OP_LDXH;	60✔
161	} else if (mnemonic == "ldxw") {	102✔
162	inst.opcode = EBPF_OP_LDXW;	42✔
163	} else {
164	throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);	×
165	}
166
167	return inst;	184✔
168	}	184✔
169
170	static bpf_encode_result_t
171	_encode_st(const std::string& mnemonic, const std::vector<std::string>& operands)	36✔
172	{
173	ebpf_inst inst{};	36✔
174	if (operands.size() != 2) {	36✔
175	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
176	}
177	auto [dst, offset] = _decode_register_and_offset(operands[0]);	36✔
178	inst.dst = dst;	36✔
179	inst.offset = offset;	36✔
180	if (mnemonic == "stb") {	36✔
181	inst.opcode = EBPF_OP_STB;	10✔
182	} else if (mnemonic == "stdw") {	36✔
183	inst.opcode = EBPF_OP_STDW;	10✔
184	} else if (mnemonic == "sth") {	26✔
185	inst.opcode = EBPF_OP_STH;	4✔
186	} else if (mnemonic == "stw") {	16✔
187	inst.opcode = EBPF_OP_STW;	12✔
188	} else {
189	throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);	×
190	}
191	inst.imm = _decode_imm32(operands[1]);	36✔
192	return inst;	36✔
193	}	36✔
194
195	static bpf_encode_result_t
196	_encode_stx(const std::string& mnemonic, const std::vector<std::string>& operands)	64✔
197	{
198	ebpf_inst inst{};	64✔
199	if (operands.size() != 2) {	64✔
200	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
201	}
202	auto [dst, offset] = _decode_register_and_offset(operands[0]);	64✔
203	inst.dst = dst;	64✔
204	inst.offset = offset;	64✔
205	inst.src = _decode_register(operands[1]);	64✔
206	if (mnemonic == "stxb") {	64✔
207	inst.opcode = EBPF_OP_STXB;	44✔
208	} else if (mnemonic == "stxdw") {	64✔
209	inst.opcode = EBPF_OP_STXDW;	2✔
210	} else if (mnemonic == "stxh") {	20✔
211	inst.opcode = EBPF_OP_STXH;	2✔
212	} else if (mnemonic == "stxw") {	18✔
213	inst.opcode = EBPF_OP_STXW;	16✔
214	} else {
215	throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);	×
216	}
217
218	return inst;	64✔
219	}	64✔
220
221	static bpf_encode_result_t
222	_encode_alu(const std::string& mnemonic, const std::vector<std::string>& operands)	1,040✔
223	{
224	ebpf_inst inst{};	1,040✔
225	std::string alu_op;	1,040✔
226	if (mnemonic.starts_with("be")) {	1,040✔
227	if (operands.size() != 1) {	82✔
228	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
229	}
230	inst.opcode = EBPF_OP_BE;	82✔
231	inst.dst = _decode_register(operands[0]);	82✔
232	inst.imm = _decode_imm32(mnemonic.substr(2));	82✔
233	return inst;	82✔
234	} else if (mnemonic.starts_with("le")) {	958✔
235	if (operands.size() != 1) {	12✔
236	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
237	}
238	inst.opcode = EBPF_OP_LE;	12✔
239	inst.dst = _decode_register(operands[0]);	12✔
240	inst.imm = _decode_imm32(mnemonic.substr(2));	12✔
241	return inst;	12✔
242	}
243
244	if (mnemonic.starts_with("neg")) {	946✔
245	if (operands.size() != 1) {	8✔
246	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
247	}
248	} else {
249	if (operands.size() != 2) {	938✔
250	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
251	}
252	}
253
254	if (mnemonic.ends_with("32")) {	946✔
255	inst.opcode \|= EBPF_CLS_ALU;	346✔
256	alu_op = mnemonic.substr(0, mnemonic.size() - 2);	346✔
257	} else {	346✔
258	inst.opcode \|= EBPF_CLS_ALU64;	600✔
259	alu_op = mnemonic;	600✔
260	}
261	auto iter = _bpf_encode_alu_ops.find(alu_op);	946✔
262	if (iter == _bpf_encode_alu_ops.end()) {	946✔
263	throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);	×
264	}
265	inst.opcode \|= iter->second << 4;	946✔
266
267	inst.dst = _decode_register(operands[0]);	946✔
268
269	if (operands.size() == 2) {	946✔
270	if (operands[1].starts_with('r')) {	938✔
271	inst.opcode \|= EBPF_SRC_REG;	272✔
272	inst.src = _decode_register(operands[1]);	272✔
273	} else {	272✔
274	inst.opcode \|= EBPF_SRC_IMM;	666✔
275	inst.imm = _decode_imm32(operands[1]);	666✔
276	}
277	}
278
279	return inst;	946✔
280	}	1,040✔
281
282	static bpf_encode_result_t
283	_encode_jmp(const std::string& mnemonic, const std::vector<std::string>& operands)	416✔
284	{
285	ebpf_inst inst{};	416✔
286	inst.opcode \|= EBPF_CLS_JMP;	416✔
287	if (mnemonic == "ja") {	416✔
288	if (operands.size() != 1) {	16✔
289	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
290	}
291
292	inst.offset = _decode_offset(operands[0]);	16✔
293	} else if (mnemonic == "exit") {	416✔
294	if (operands.size() != 0) {	240✔
295	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
296	}
297	inst.opcode = EBPF_OP_EXIT;	240✔
298	} else if (mnemonic == "call") {	400✔
299	if (operands.size() != 1) {	20✔
300	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
301	}
302	inst.opcode = EBPF_OP_CALL;	20✔
303	inst.imm = _decode_imm32(operands[0]);	20✔
304	} else {	20✔
305	if (operands.size() != 3) {	140✔
306	throw std::runtime_error(std::string("Wrong operand count: ") + mnemonic);	×
307	}
308	auto iter = _bpf_encode_jmp_ops.find(mnemonic);	140✔
309	inst.opcode \|= iter->second << 4;	140✔
310	inst.dst = _decode_register(operands[0]);	140✔
311	if (operands[1].starts_with('r')) {	140✔
312	inst.opcode \|= EBPF_SRC_REG;	70✔
313	inst.src = _decode_register(operands[1]);	70✔
314	} else {	70✔
315	inst.opcode \|= EBPF_SRC_IMM;	70✔
316	inst.imm = _decode_imm32(operands[1]);	70✔
317	}
318	inst.offset = _decode_offset(operands[2]);	140✔
319	}	140✔
320	return inst;	416✔
321	}	416✔
322
323	static const std::unordered_map<std::string, bpf_encode_t> _bpf_mnemonic_map{	251✔
324	{"add", _encode_alu}, {"add32", _encode_alu}, {"and", _encode_alu}, {"and32", _encode_alu},	251✔
325	{"arsh", _encode_alu}, {"arsh32", _encode_alu}, {"be16", _encode_alu}, {"be32", _encode_alu},	251✔
326	{"be64", _encode_alu}, {"call", _encode_jmp}, {"div", _encode_alu}, {"div32", _encode_alu},	251✔
327	{"exit", _encode_jmp}, {"ja", _encode_jmp}, {"jeq", _encode_jmp}, {"jge", _encode_jmp},	251✔
328	{"jgt", _encode_jmp}, {"jle", _encode_jmp}, {"jlt", _encode_jmp}, {"jne", _encode_jmp},	251✔
329	{"jset", _encode_jmp}, {"jsge", _encode_jmp}, {"jsgt", _encode_jmp}, {"jsle", _encode_jmp},	251✔
330	{"jslt", _encode_jmp}, {"lddw", _encode_ld}, {"ldxb", _encode_ldx}, {"ldxdw", _encode_ldx},	251✔
331	{"ldxh", _encode_ldx}, {"ldxw", _encode_ldx}, {"le16", _encode_alu}, {"le32", _encode_alu},	251✔
332	{"le64", _encode_alu}, {"lsh", _encode_alu}, {"lsh32", _encode_alu}, {"mod", _encode_alu},	251✔
333	{"mod32", _encode_alu}, {"mov", _encode_alu}, {"mov32", _encode_alu}, {"mul", _encode_alu},	251✔
334	{"mul32", _encode_alu}, {"neg", _encode_alu}, {"neg32", _encode_alu}, {"or", _encode_alu},	251✔
335	{"or32", _encode_alu}, {"rsh", _encode_alu}, {"rsh32", _encode_alu}, {"stb", _encode_st},	251✔
336	{"stdw", _encode_st}, {"sth", _encode_st}, {"stw", _encode_st}, {"stxb", _encode_stx},	251✔
337	{"stxdw", _encode_stx}, {"stxh", _encode_stx}, {"stxw", _encode_stx}, {"sub", _encode_alu},	251✔
338	{"sub32", _encode_alu}, {"xor", _encode_alu}, {"xor32", _encode_alu},	251✔
339	};
340
341	std::vector<ebpf_inst>
342	bpf_assembler(std::istream& input)	224✔
343	{
344	std::vector<ebpf_inst> output;	224✔
345	std::string line;	224✔
346	// Parse the input stream one line at a time.
347	while (std::getline(input, line)) {	2,046✔
348	std::istringstream line_stream(line);	7,882✔
349	std::string mnemonic;	7,882✔
350	std::string operand;	7,882✔
351	std::vector<std::string> operands;	7,882✔
352	// Check for empty lines.
353	if (!std::getline(line_stream, mnemonic, ' ')) {	7,882✔
354	continue;	68✔
355	}
356	// Split the line on ' '
357	while (std::getline(line_stream, operand, ' ')) {	1,754✔
358	if (operand.starts_with('#')) {	3,030✔
359	break;
360	}
361	if (operand.ends_with(',')) {	3,030✔
362	operand = operand.substr(0, operand.length() - 1);	1,516✔
363	}	1,516✔
364	operands.emplace_back(operand);	3,030✔
365	}
366	// Find the handler for this mnemonic.
367	auto iter = _bpf_mnemonic_map.find(mnemonic);	1,754✔
368	if (iter == _bpf_mnemonic_map.end()) {	1,754✔
369	throw std::runtime_error(std::string("Invalid mnemonic: ") + mnemonic);	×
370	}
371	// Invoke handler and store result.
372	auto result = iter->second(mnemonic, operands);	1,754✔
373	if (std::holds_alternative<ebpf_inst>(result)) {	1,754✔
374	output.emplace_back(std::get<ebpf_inst>(result));	1,740✔
375	} else {
376	for (const auto& inst : std::get<std::array<ebpf_inst, 2>>(result)) {	42✔
377	output.emplace_back(inst);	28✔
378	}
379	}
380	}	1,822✔
381	return output;
382	}	17,956✔

iovisor / ubpf / 3159990762

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous