vm: remove old JIT
diff --git a/vm/Makefile b/vm/Makefile
index 3e180b9..a7b3f48 100644
--- a/vm/Makefile
+++ b/vm/Makefile
@@ -12,9 +12,7 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-DYNASM := ../dynasm
-
-CFLAGS := -Wall -Werror -Iinc -I$(DYNASM) -O2 -g
+CFLAGS := -Wall -Werror -Iinc -O2 -g
LDLIBS := -lm
ifeq ($(COVERAGE),1)
@@ -29,9 +27,6 @@
all: libubpf.a test
-%.c: %.dasm minilua
- LUA_PATH=$(DYNASM)/?.lua ./minilua $(DYNASM)/dynasm.lua -o $@ $<
-
ubpf_jit_x86_64.o: ubpf_jit_x86_64.c ubpf_jit_x86_64.h
libubpf.a: ubpf_vm.o ubpf_jit_x86_64.o ubpf_loader.o
@@ -39,8 +34,5 @@
test: test.o libubpf.a
-minilua: ../luajit-2.0/src/host/minilua.c
- $(CC) -o $@ $< -lm
-
clean:
- rm -f test libubpf.a *.o ubpf_jit.c
+ rm -f test libubpf.a *.o
diff --git a/vm/ubpf_jit.dasm b/vm/ubpf_jit.dasm
deleted file mode 100644
index 4dcaa71..0000000
--- a/vm/ubpf_jit.dasm
+++ /dev/null
@@ -1,636 +0,0 @@
-// vi: ft=c
-/*
- * Copyright 2015 Big Switch Networks, Inc
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define _GNU_SOURCE
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <unistd.h>
-#include <inttypes.h>
-#include <sys/mman.h>
-#include <errno.h>
-#include <assert.h>
-#include "ubpf_int.h"
-
-#define DASM_CHECKS
-#include <dasm_proto.h>
-#include <dasm_x86.h>
-
-|.arch x64
-
-/* The hardcoded dasm_State variable name is confusing given our use of 'dst' */
-#define dasm Dst
-
-#define STACK_SIZE 128
-
-/*
- * Register mapping:
- *
- * eBPF -> x86
- * 0 -> rax
- * 1 -> rdi
- * 2 -> rsi
- * 3 -> rdx
- * 4 -> r9
- * 5 -> r8
- * 6 -> rbx
- * 7 -> r13
- * 8 -> r14
- * 9 -> r15
- * 10 -> rbp
- *
- * eBPF calling convention:
- * - Registers r6-r10 are callee save.
- * - Function call arguments go in r1-r5.
- * - Return value goes in r0.
- *
- * x86 calling convention:
- * - Registers rbp, rbx, r12, r13, r14, and r15 are callee save.
- * - Function call arguments go in rdi, rsi, rdx, rcx, r8, and r9.
- * - Return value goes in rax.
- *
- * rcx (cl) is a required operand for shifts by a register. We reserve it.
- * rsp could not be used for the stack pointer due to DynASM issues.
- * r12 could not be used due to DynASM issues.
- */
-#define RAX 0
-#define RCX 1
-#define RDX 2
-#define RBX 3
-#define RSP 4
-#define RBP 5
-#define RSI 6
-#define RDI 7
-#define R8 8
-#define R9 9
-#define R10 10
-#define R11 11
-/* r12 is unused (encoding problems) */
-#define R13 13
-#define R14 14
-#define R15 15
-
-#define REGISTER_MAP_SIZE 11
-static int register_map[REGISTER_MAP_SIZE] = {
- RAX,
- RDI,
- RSI,
- RDX,
- R9,
- R8,
- RBX,
- R13,
- R14,
- R15,
- RBP,
-};
-
-/* Return the x86 register for the given eBPF register */
-static int
-map_register(int r)
-{
- assert(r < REGISTER_MAP_SIZE);
- return register_map[r % REGISTER_MAP_SIZE];
-}
-
-/* For testing, this changes the mapping between x86 and eBPF registers */
-void
-ubpf_set_register_offset(int x)
-{
- int i;
- if (x < REGISTER_MAP_SIZE) {
- int tmp[REGISTER_MAP_SIZE];
- memcpy(tmp, register_map, sizeof(register_map));
- for (i = 0; i < REGISTER_MAP_SIZE; i++) {
- register_map[i] = tmp[(i+x)%REGISTER_MAP_SIZE];
- }
- } else {
- /* Shuffle array */
- unsigned int seed = x;
- for (i = 0; i < REGISTER_MAP_SIZE-1; i++) {
- int j = i + (rand_r(&seed) % (REGISTER_MAP_SIZE-i));
- int tmp = register_map[j];
- register_map[j] = register_map[i];
- register_map[i] = tmp;
- }
- }
-}
-
-static void muldivmod(dasm_State **dasm, uint16_t pc, uint8_t opcode, int src, int dst, int32_t imm);
-
-|.actionlist actions
-
-ubpf_jit_fn
-ubpf_compile(struct ubpf_vm *vm, char **errmsg)
-{
- dasm_State *d;
- void *jitted = NULL;
- size_t jitted_size;
- int ret;
-
- *errmsg = NULL;
-
- if (vm->jitted) {
- return vm->jitted;
- }
-
- if (!vm->insts) {
- *errmsg = ubpf_error("code has not been loaded into this VM");
- return NULL;
- }
-
- |.section code
- dasm_init(&d, DASM_MAXSECTION);
-
- |.globals lbl_
- void *labels[lbl__MAX];
- dasm_setupglobal(&d, labels, lbl__MAX);
-
- dasm_setup(&d, actions);
-
- dasm_growpc(&d, vm->num_insts);
-
- dasm_State **dasm = &d;
-
- if ((ret = dasm_checkstep(dasm, 0)) != DASM_S_OK) {
- *errmsg = ubpf_error("DynASM error %#x before prologue", ret);
- goto error;
- }
-
- /* Prologue */
- |.code
- |->entry:
- /* rbp, rbx, r13, r14, and r15 are callee save */
- /* TODO don't save registers we don't write to */
- | push rbp
- | push rbx
- | push r13
- | push r14
- | push r15
-
- /* Move rdi into register 1 */
- if (map_register(1) != RDI) {
- | mov Rq(map_register(1)), rdi
- }
-
- /* Allocate stack space and store address in r10 */
- | sub rsp, STACK_SIZE
- | mov Rq(map_register(10)), Rq(RSP)
-
- if ((ret = dasm_checkstep(dasm, 0)) != DASM_S_OK) {
- *errmsg = ubpf_error("DynASM error %#x after prologue", ret);
- goto error;
- }
-
- int i;
- for (i = 0; i < vm->num_insts; i++) {
- struct ebpf_inst inst = vm->insts[i];
- |=>i:
-
- int src = map_register(inst.src);
- int dst = map_register(inst.dst);
- int jmp_target = i + inst.offset + 1;
-
- switch (inst.opcode) {
- case EBPF_OP_ADD_IMM:
- | add Rd(dst), inst.imm
- break;
- case EBPF_OP_ADD_REG:
- | add Rd(dst), Rd(src)
- break;
- case EBPF_OP_SUB_IMM:
- | sub Rd(dst), inst.imm
- break;
- case EBPF_OP_SUB_REG:
- | sub Rd(dst), Rd(src)
- break;
- case EBPF_OP_MUL_IMM:
- case EBPF_OP_MUL_REG:
- case EBPF_OP_DIV_IMM:
- case EBPF_OP_DIV_REG:
- case EBPF_OP_MOD_IMM:
- case EBPF_OP_MOD_REG:
- muldivmod(dasm, i, inst.opcode, src, dst, inst.imm);
- break;
- case EBPF_OP_OR_IMM:
- | or Rd(dst), inst.imm
- break;
- case EBPF_OP_OR_REG:
- | or Rd(dst), Rd(src)
- break;
- case EBPF_OP_AND_IMM:
- | and Rd(dst), inst.imm
- break;
- case EBPF_OP_AND_REG:
- | and Rd(dst), Rd(src)
- break;
- case EBPF_OP_LSH_IMM:
- | shl Rd(dst), inst.imm
- break;
- case EBPF_OP_LSH_REG:
- | mov Rq(RCX), Rq(src)
- | shl Rd(dst), cl
- break;
- case EBPF_OP_RSH_IMM:
- | shr Rd(dst), inst.imm
- break;
- case EBPF_OP_RSH_REG:
- | mov Rq(RCX), Rq(src)
- | shr Rd(dst), cl
- break;
- case EBPF_OP_NEG:
- | neg Rd(dst)
- break;
- case EBPF_OP_XOR_IMM:
- | xor Rd(dst), inst.imm
- break;
- case EBPF_OP_XOR_REG:
- | xor Rd(dst), Rd(src)
- break;
- case EBPF_OP_MOV_IMM:
- | mov Rd(dst), inst.imm
- break;
- case EBPF_OP_MOV_REG:
- | mov Rd(dst), Rd(src)
- break;
- case EBPF_OP_ARSH_IMM:
- | sar Rd(dst), inst.imm
- break;
- case EBPF_OP_ARSH_REG:
- | mov Rq(RCX), Rq(src)
- | sar Rd(dst), cl
- break;
-
- case EBPF_OP_LE:
- /* No-op */
- break;
- case EBPF_OP_BE:
- if (inst.imm == 16) {
- | rol Rw(dst), 8
- | and Rd(dst), 0xffff
- } else if (inst.imm == 32) {
- /* bswap of r8d+ is misassembled */
- if (dst < 8) {
- | bswap Rd(dst)
- } else {
- | mov Rq(RCX), Rq(dst)
- | bswap ecx
- | mov Rd(dst), ecx
- }
- } else if (inst.imm == 64) {
- /* bswap of r8+ is misassembled */
- if (dst < 8) {
- | bswap Rq(dst)
- } else {
- | mov Rq(RCX), Rq(dst)
- | bswap rcx
- | mov Rq(dst), rcx
- }
- }
- break;
-
- case EBPF_OP_ADD64_IMM:
- | add Rq(dst), inst.imm
- break;
- case EBPF_OP_ADD64_REG:
- | add Rq(dst), Rq(src)
- break;
- case EBPF_OP_SUB64_IMM:
- | sub Rq(dst), inst.imm
- break;
- case EBPF_OP_SUB64_REG:
- | sub Rq(dst), Rq(src)
- break;
- case EBPF_OP_MUL64_IMM:
- case EBPF_OP_MUL64_REG:
- case EBPF_OP_DIV64_IMM:
- case EBPF_OP_DIV64_REG:
- case EBPF_OP_MOD64_IMM:
- case EBPF_OP_MOD64_REG:
- muldivmod(dasm, i, inst.opcode, src, dst, inst.imm);
- break;
- case EBPF_OP_OR64_IMM:
- | or Rq(dst), inst.imm
- break;
- case EBPF_OP_OR64_REG:
- | or Rq(dst), Rq(src)
- break;
- case EBPF_OP_AND64_IMM:
- | and Rq(dst), inst.imm
- break;
- case EBPF_OP_AND64_REG:
- | and Rq(dst), Rq(src)
- break;
- case EBPF_OP_LSH64_IMM:
- | shl Rq(dst), inst.imm
- break;
- case EBPF_OP_LSH64_REG:
- | mov Rq(RCX), Rq(src)
- | shl Rq(dst), cl
- break;
- case EBPF_OP_RSH64_IMM:
- | shr Rq(dst), inst.imm
- break;
- case EBPF_OP_RSH64_REG:
- | mov Rq(RCX), Rq(src)
- | shr Rq(dst), cl
- break;
- case EBPF_OP_NEG64:
- | neg Rq(dst)
- break;
- case EBPF_OP_XOR64_IMM:
- | xor Rq(dst), inst.imm
- break;
- case EBPF_OP_XOR64_REG:
- | xor Rq(dst), Rq(src)
- break;
- case EBPF_OP_MOV64_IMM:
- /* TODO use shorter mov for smaller immediates */
- | mov Rq(dst), inst.imm
- break;
- case EBPF_OP_MOV64_REG:
- | mov Rq(dst), Rq(src)
- break;
- case EBPF_OP_ARSH64_IMM:
- | sar Rq(dst), inst.imm
- break;
- case EBPF_OP_ARSH64_REG:
- | mov Rq(RCX), Rq(src)
- | sar Rq(dst), cl
- break;
-
- case EBPF_OP_JA:
- | jmp =>jmp_target
- break;
- case EBPF_OP_JEQ_IMM:
- | cmp Rq(dst), inst.imm
- | je =>jmp_target
- break;
- case EBPF_OP_JEQ_REG:
- | cmp Rq(dst), Rq(src)
- | je =>jmp_target
- break;
- case EBPF_OP_JGT_IMM:
- | cmp Rq(dst), inst.imm
- | ja =>jmp_target
- break;
- case EBPF_OP_JGT_REG:
- | cmp Rq(dst), Rq(src)
- | ja =>jmp_target
- break;
- case EBPF_OP_JGE_IMM:
- | cmp Rq(dst), inst.imm
- | jae =>jmp_target
- break;
- case EBPF_OP_JGE_REG:
- | cmp Rq(dst), Rq(src)
- | jae =>jmp_target
- break;
- case EBPF_OP_JSET_IMM:
- | test Rq(dst), inst.imm
- | jnz =>jmp_target
- break;
- case EBPF_OP_JSET_REG:
- | test Rq(dst), Rq(src)
- | jnz =>jmp_target
- break;
- case EBPF_OP_JNE_IMM:
- | cmp Rq(dst), inst.imm
- | jne =>jmp_target
- break;
- case EBPF_OP_JNE_REG:
- | cmp Rq(dst), Rq(src)
- | jne =>jmp_target
- break;
- case EBPF_OP_JSGT_IMM:
- | cmp Rq(dst), inst.imm
- | jg =>jmp_target
- break;
- case EBPF_OP_JSGT_REG:
- | cmp Rq(dst), Rq(src)
- | jg =>jmp_target
- break;
- case EBPF_OP_JSGE_IMM:
- | cmp Rq(dst), inst.imm
- | jge =>jmp_target
- break;
- case EBPF_OP_JSGE_REG:
- | cmp Rq(dst), Rq(src)
- | jge =>jmp_target
- break;
- case EBPF_OP_CALL:
- /* We reserve RCX for shifts */
- | mov rcx, r9
- /* TODO direct call */
- | mov rax, vm->ext_funcs[inst.imm]
- | call rax
- break;
- case EBPF_OP_EXIT:
- if (i != vm->num_insts - 1) {
- | jmp ->exit
- }
- break;
-
- case EBPF_OP_LDXW:
- | mov Rd(dst), dword [Rq(src)+inst.offset]
- break;
- case EBPF_OP_LDXH:
- /* movzx is not assembled correctly */
- | xor ecx, ecx
- | mov cx, word [Rq(src)+inst.offset]
- | mov Rq(dst), Rq(RCX)
- break;
- case EBPF_OP_LDXB:
- /* movzx is not assembled correctly */
- | xor ecx, ecx
- | mov cl, byte [Rq(src)+inst.offset]
- | mov Rq(dst), Rq(RCX)
- break;
- case EBPF_OP_LDXDW:
- | mov Rq(dst), qword [Rq(src)+inst.offset]
- break;
-
- case EBPF_OP_STW:
- | mov dword [Rq(dst)+inst.offset], inst.imm
- break;
- case EBPF_OP_STH:
- | mov word [Rq(dst)+inst.offset], inst.imm
- break;
- case EBPF_OP_STB:
- | mov byte [Rq(dst)+inst.offset], inst.imm
- break;
- case EBPF_OP_STDW:
- | mov qword [Rq(dst)+inst.offset], inst.imm
- break;
-
- case EBPF_OP_STXW:
- | mov dword [Rq(dst)+inst.offset], Rd(src)
- break;
- case EBPF_OP_STXH:
- | mov word [Rq(dst)+inst.offset], Rw(src)
- break;
- case EBPF_OP_STXB:
- /* Rb(src) generates the wrong byte registers */
- /* mov rcx, Rq(src) also did not work */
- | mov Rq(RCX), Rq(src)
- | mov byte [Rq(dst)+inst.offset], cl
- break;
- case EBPF_OP_STXDW:
- | mov qword [Rq(dst)+inst.offset], Rq(src)
- break;
-
- case EBPF_OP_LDDW: {
- struct ebpf_inst inst2 = vm->insts[++i];
- uint64_t imm = (uint32_t)inst.imm | ((uint64_t)inst2.imm << 32);
- | mov64 Rq(dst), imm
- break;
- }
-
- }
-
- if ((ret = dasm_checkstep(dasm, 0)) != DASM_S_OK) {
- *errmsg = ubpf_error("DynASM error %#x at PC %d: opcode %02x src %u dst %u", ret, i, inst.opcode, src, dst);
- goto error;
- }
- }
-
- /* Epilogue */
- | ->exit:
- /* Move register 0 into rax */
- if (map_register(0) != RAX) {
- | mov Rq(RAX), Rq(map_register(0))
- }
- | ->exit2:
- | add rsp, STACK_SIZE
- | pop r15
- | pop r14
- | pop r13
- | pop rbx
- | pop rbp
- | ret
-
- /* Division by zero handler */
- const char *div_by_zero_fmt = "uBPF error: division by zero at PC %u\n";
- | ->div_by_zero:
- | mov64 rdi, (uintptr_t)stderr
- | mov64 rsi, (uintptr_t)div_by_zero_fmt
- | mov64 rax, (uintptr_t)fprintf
- | call rax
- | mov rax, -1
- | jmp ->exit2
-
- if ((ret = dasm_checkstep(dasm, 0)) != DASM_S_OK) {
- *errmsg = ubpf_error("DynASM error %#x after epilogue", ret);
- goto error;
- }
-
- if ((ret = dasm_link(dasm, &jitted_size)) != DASM_S_OK) {
- *errmsg = ubpf_error("internal uBPF error: dasm_link failed: %d", ret);
- goto error;
- }
-
- jitted = mmap(0, jitted_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
- if (jitted == MAP_FAILED) {
- *errmsg = ubpf_error("internal uBPF error: mmap failed: %s\n", strerror(errno));
- goto error;
- }
-
- if ((ret = dasm_encode(dasm, jitted)) != DASM_S_OK) {
- *errmsg = ubpf_error("internal uBPF error: dasm_encode failed: %d\n", ret);
- goto error;
- }
-
- if (mprotect(jitted, jitted_size, PROT_READ | PROT_EXEC) < 0) {
- *errmsg = ubpf_error("internal uBPF error: mprotect failed: %s\n", strerror(errno));
- goto error;
- }
-
- assert(labels[lbl_entry] == jitted);
-
- dasm_free(dasm);
- vm->jitted = labels[lbl_entry];
- vm->jitted_size = jitted_size;
- return vm->jitted;
-
-error:
- dasm_free(dasm);
- if (jitted) {
- munmap(jitted, jitted_size);
- }
- return NULL;
-}
-
-static void
-muldivmod(dasm_State **dasm, uint16_t pc, uint8_t opcode, int src, int dst, int32_t imm)
-{
- bool mul = (opcode & EBPF_ALU_OP_MASK) == (EBPF_OP_MUL_IMM & EBPF_ALU_OP_MASK);
- bool div = (opcode & EBPF_ALU_OP_MASK) == (EBPF_OP_DIV_IMM & EBPF_ALU_OP_MASK);
- bool mod = (opcode & EBPF_ALU_OP_MASK) == (EBPF_OP_MOD_IMM & EBPF_ALU_OP_MASK);
- bool is64 = (opcode & EBPF_CLS_MASK) == EBPF_CLS_ALU64;
-
- if (div || mod) {
- if (is64) {
- | test Rq(src), Rq(src)
- } else {
- | test Rd(src), Rd(src)
- }
- | jnz >1
- | mov rdx, pc
- | jmp ->div_by_zero
- |1:
- }
-
- if (dst != RAX) {
- | push rax
- }
- if (dst != RDX) {
- | push rdx
- }
- if (imm) {
- | mov Rq(RCX), imm
- } else {
- | mov Rq(RCX), Rq(src)
- }
- | mov Rq(RAX), Rq(dst)
- if (div || mod) {
- | xor edx, edx
- if (is64) {
- | div rcx
- } else {
- | div ecx
- }
- } else {
- if (is64) {
- | mul rcx
- } else {
- | mul ecx
- }
- }
- if (dst != RDX) {
- if (mod) {
- | mov Rq(dst), Rq(RDX)
- }
- | pop rdx
- }
- if (dst != RAX) {
- if (div || mul) {
- | mov Rq(dst), Rq(RAX)
- }
- | pop rax
- }
-}
