 @@ -1,14 +1,14 @@
-/*	$NetBSD: bpfjit.c,v 1.45 2016/05/29 17:20:22 alnsn Exp $	*/
+/*	$NetBSD: bpfjit.c,v 1.46 2016/07/29 20:29:38 alnsn Exp $	*/
 /*-
  * Copyright (c) 2011-2015 Alexander Nasonov.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
+ *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
 @@ -21,29 +21,29 @@
  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifdef _KERNEL
-__KERNEL_RCSID(0, "$NetBSD: bpfjit.c,v 1.45 2016/05/29 17:20:22 alnsn Exp $");
+__KERNEL_RCSID(0, "$NetBSD: bpfjit.c,v 1.46 2016/07/29 20:29:38 alnsn Exp $");
 #else
-__RCSID("$NetBSD: bpfjit.c,v 1.45 2016/05/29 17:20:22 alnsn Exp $");
+__RCSID("$NetBSD: bpfjit.c,v 1.46 2016/07/29 20:29:38 alnsn Exp $");
 #endif
 #include <sys/types.h>
 #include <sys/queue.h>
 #ifndef _KERNEL
 #include <assert.h>
 #define BJ_ASSERT(c) assert(c)
 #else
 #define BJ_ASSERT(c) KASSERT(c)
 #endif
 #ifndef _KERNEL
 @@ -1584,80 +1584,94 @@ optimize(const bpf_ctx_t *bc, const stru
 	if (!optimize_pass1(bc, insns, insn_dat, insn_count, initmask, hints))
 		return false;
 	optimize_pass2(bc, insns, insn_dat, insn_count);
 	optimize_pass3(insns, insn_dat, insn_count);
 	return true;
+}
 /*
  * Convert BPF_ALU operations except BPF_NEG and BPF_DIV to sljit operation.
  */
-static int
+static bool
-bpf_alu_to_sljit_op(const struct bpf_insn *pc)
+alu_to_op(const struct bpf_insn *pc, int *res)
+{
 	const int bad = SLJIT_UNUSED;
 	const uint32_t k = pc->k;
 	/*
 	 * Note: all supported 64bit arches have 32bit multiply
 	 * instruction so SLJIT_I32_OP doesn't have any overhead.
 	 */
 	switch (BPF_OP(pc->code)) {
-	case BPF_ADD: return SLJIT_ADD;
+	case BPF_ADD:
-	case BPF_SUB: return SLJIT_SUB;
+		*res = SLJIT_ADD;
-	case BPF_MUL: return SLJIT_MUL|SLJIT_I32_OP;
+		return true;
-	case BPF_OR:  return SLJIT_OR;
+	case BPF_SUB:
-	case BPF_XOR: return SLJIT_XOR;
+		*res = SLJIT_SUB;
-	case BPF_AND: return SLJIT_AND;
+		return true;
-	case BPF_LSH: return (k > 31) ? bad : SLJIT_SHL;
+	case BPF_MUL:
-	case BPF_RSH: return (k > 31) ? bad : SLJIT_LSHR|SLJIT_I32_OP;
+		*res = SLJIT_MUL|SLJIT_I32_OP;
 		return true;
 	case BPF_OR:
 		*res = SLJIT_OR;
 		return true;
 	case BPF_XOR:
 		*res = SLJIT_XOR;
 		return true;
 	case BPF_AND:
 		*res = SLJIT_AND;
 		return true;
 	case BPF_LSH:
 		*res = SLJIT_SHL;
 		return k < 32;
 	case BPF_RSH:
 		*res = SLJIT_LSHR|SLJIT_I32_OP;
 		return k < 32;
 	default:
-		return bad;
+		return false;
+	}
+}
 /*
  * Convert BPF_JMP operations except BPF_JA to sljit condition.
  */
-static int
+static bool
-bpf_jmp_to_sljit_cond(const struct bpf_insn *pc, bool negate)
+jmp_to_cond(const struct bpf_insn *pc, bool negate, int *res)
+{
 	/*
 	 * Note: all supported 64bit arches have 32bit comparison
 	 * instructions so SLJIT_I32_OP doesn't have any overhead.
 	 */
-	int rv = SLJIT_I32_OP;
+	*res = SLJIT_I32_OP;
 	switch (BPF_OP(pc->code)) {
 	case BPF_JGT:
-		rv |= negate ? SLJIT_LESS_EQUAL : SLJIT_GREATER;
+		*res |= negate ? SLJIT_LESS_EQUAL : SLJIT_GREATER;
-		break;
+		return true;
 	case BPF_JGE:
-		rv |= negate ? SLJIT_LESS : SLJIT_GREATER_EQUAL;
+		*res |= negate ? SLJIT_LESS : SLJIT_GREATER_EQUAL;
-		break;
+		return true;
 	case BPF_JEQ:
-		rv |= negate ? SLJIT_NOT_EQUAL : SLJIT_EQUAL;
+		*res |= negate ? SLJIT_NOT_EQUAL : SLJIT_EQUAL;
-		break;
+		return true;
 	case BPF_JSET:
-		rv |= negate ? SLJIT_EQUAL : SLJIT_NOT_EQUAL;
+		*res |= negate ? SLJIT_EQUAL : SLJIT_NOT_EQUAL;
-		break;
+		return true;
 	default:
-		BJ_ASSERT(false);
+		return false;
+	}
 	return rv;
+}
 /*
  * Convert BPF_K and BPF_X to sljit register.
  */
 static int
 kx_to_reg(const struct bpf_insn *pc)
+{
 	switch (BPF_SRC(pc->code)) {
 	case BPF_K: return SLJIT_IMM;
 	case BPF_X: return BJ_XREG;
 	default:
 @@ -1685,29 +1699,29 @@ generate_insn_code(struct sljit_compiler
     struct bpfjit_insn_data *insn_dat, size_t insn_count)
+{
 	/* a list of jumps to out-of-bound return from a generated function */
 	struct sljit_jump **ret0;
 	size_t ret0_size, ret0_maxsize;
 	struct sljit_jump *jump;
 	struct sljit_label *label;
 	const struct bpf_insn *pc;
 	struct bpfjit_jump *bjump, *jtf;
 	struct sljit_jump *to_mchain_jump;
 	size_t i;
 	int status;
 	int branching, negate;
 	unsigned int rval, mode, src, op;
 	int branching, negate;
 	int status, cond, op2;
 	uint32_t jt, jf;
 	bool unconditional_ret;
 	bool rv;
 	const size_t extwords = GET_EXTWORDS(bc);
 	const size_t memwords = GET_MEMWORDS(bc);
 	ret0 = NULL;
 	rv = false;
 	ret0_size = 0;
 	ret0_maxsize = 64;
 @@ -1925,30 +1939,29 @@ generate_insn_code(struct sljit_compiler
 			if (pc->code == (BPF_ALU|BPF_NEG)) {
 				status = sljit_emit_op1(compiler,
 				    SLJIT_NEG,
 				    BJ_AREG, 0,
 				    BJ_AREG, 0);
 				if (status != SLJIT_SUCCESS)
 					goto fail;
 				continue;
+			}
 			op = BPF_OP(pc->code);
 			if (op != BPF_DIV && op != BPF_MOD) {
-				const int op2 = bpf_alu_to_sljit_op(pc);
+				if (!alu_to_op(pc, &op2))
 				if (op2 == SLJIT_UNUSED)
 					goto fail;
 				status = sljit_emit_op2(compiler,
 				    op2, BJ_AREG, 0, BJ_AREG, 0,
 				    kx_to_reg(pc), kx_to_reg_arg(pc));
 				if (status != SLJIT_SUCCESS)
 					goto fail;
 				continue;
+			}
 			/* BPF_DIV/BPF_MOD */
 			src = BPF_SRC(pc->code);
 			if (src != BPF_X && src != BPF_K)
 @@ -1995,43 +2008,44 @@ generate_insn_code(struct sljit_compiler
 			if (op == BPF_JA) {
 				jt = jf = pc->k;
 			} else {
 				jt = pc->jt;
 				jf = pc->jf;
+			}
 			negate = (jt == 0) ? 1 : 0;
 			branching = (jt == jf) ? 0 : 1;
 			jtf = insn_dat[i].u.jdata.jtf;
 			if (branching) {
 				if (op != BPF_JSET) {
 					if (!jmp_to_cond(pc, negate, &cond))
 						goto fail;
 					jump = sljit_emit_cmp(compiler,
-					    bpf_jmp_to_sljit_cond(pc, negate),
+					    cond, BJ_AREG, 0,
 					    BJ_AREG, 0,
 					    kx_to_reg(pc), kx_to_reg_arg(pc));
 				} else {
 					status = sljit_emit_op2(compiler,
 					    SLJIT_AND,
 					    BJ_TMP1REG, 0,
 					    BJ_AREG, 0,
 					    kx_to_reg(pc), kx_to_reg_arg(pc));
 					if (status != SLJIT_SUCCESS)
 						goto fail;
 					if (!jmp_to_cond(pc, negate, &cond))
 						goto fail;
 					jump = sljit_emit_cmp(compiler,
-					    bpf_jmp_to_sljit_cond(pc, negate),
+					    cond, BJ_TMP1REG, 0, SLJIT_IMM, 0);
 					    BJ_TMP1REG, 0,
 					    SLJIT_IMM, 0);
+				}
 				if (jump == NULL)
 					goto fail;
 				BJ_ASSERT(jtf[negate].sjump == NULL);
 				jtf[negate].sjump = jump;
+			}
 			if (!branching || (jt != 0 && jf != 0)) {
 				jump = sljit_emit_jump(compiler, SLJIT_JUMP);
 				if (jump == NULL)
 					goto fail;