Commit a5a36544 authored by Johan Almbladh's avatar Johan Almbladh Committed by Daniel Borkmann
Browse files

bpf/tests: Add exhaustive tests of JMP operand magnitudes 



This patch adds a set of tests for conditional JMP and JMP32 operations to
verify correctness for all possible magnitudes of the immediate and
register operands. Mainly intended for JIT testing.

Signed-off-by: default avatarJohan Almbladh <johan.almbladh@anyfinetworks.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20210914091842.4186267-6-johan.almbladh@anyfinetworks.com
parent 9298e63e

lib/test_bpf.c

+779 −0
Original line number Diff line number Diff line
@@ -1104,6 +1104,384 @@ static int bpf_fill_alu32_mod_reg(struct bpf_test *self) 
	return __bpf_fill_alu32_reg(self, BPF_MOD);

}





/*

 * Exhaustive tests of JMP operations for all combinations of power-of-two

 * magnitudes of the operands, both for positive and negative values. The

 * test is designed to verify e.g. the JMP and JMP32 operations for JITs that

 * emit different code depending on the magnitude of the immediate value.

 */



static bool __bpf_match_jmp_cond(s64 v1, s64 v2, u8 op)

{

	switch (op) {

	case BPF_JSET:

		return !!(v1 & v2);

	case BPF_JEQ:

		return v1 == v2;

	case BPF_JNE:

		return v1 != v2;

	case BPF_JGT:

		return (u64)v1 > (u64)v2;

	case BPF_JGE:

		return (u64)v1 >= (u64)v2;

	case BPF_JLT:

		return (u64)v1 < (u64)v2;

	case BPF_JLE:

		return (u64)v1 <= (u64)v2;

	case BPF_JSGT:

		return v1 > v2;

	case BPF_JSGE:

		return v1 >= v2;

	case BPF_JSLT:

		return v1 < v2;

	case BPF_JSLE:

		return v1 <= v2;

	}

	return false;

}



static int __bpf_emit_jmp_imm(struct bpf_test *self, void *arg,

			      struct bpf_insn *insns, s64 dst, s64 imm)

{

	int op = *(int *)arg;



	if (insns) {

		bool match = __bpf_match_jmp_cond(dst, (s32)imm, op);

		int i = 0;



		insns[i++] = BPF_ALU32_IMM(BPF_MOV, R0, match);



		i += __bpf_ld_imm64(&insns[i], R1, dst);

		insns[i++] = BPF_JMP_IMM(op, R1, imm, 1);

		if (!match)

			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);

		insns[i++] = BPF_EXIT_INSN();



		return i;

	}



	return 5 + 1;

}



static int __bpf_emit_jmp32_imm(struct bpf_test *self, void *arg,

				struct bpf_insn *insns, s64 dst, s64 imm)

{

	int op = *(int *)arg;



	if (insns) {

		bool match = __bpf_match_jmp_cond((s32)dst, (s32)imm, op);

		int i = 0;



		i += __bpf_ld_imm64(&insns[i], R1, dst);

		insns[i++] = BPF_JMP32_IMM(op, R1, imm, 1);

		if (!match)

			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);

		insns[i++] = BPF_EXIT_INSN();



		return i;

	}



	return 5;

}



static int __bpf_emit_jmp_reg(struct bpf_test *self, void *arg,

			      struct bpf_insn *insns, s64 dst, s64 src)

{

	int op = *(int *)arg;



	if (insns) {

		bool match = __bpf_match_jmp_cond(dst, src, op);

		int i = 0;



		i += __bpf_ld_imm64(&insns[i], R1, dst);

		i += __bpf_ld_imm64(&insns[i], R2, src);

		insns[i++] = BPF_JMP_REG(op, R1, R2, 1);

		if (!match)

			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);

		insns[i++] = BPF_EXIT_INSN();



		return i;

	}



	return 7;

}



static int __bpf_emit_jmp32_reg(struct bpf_test *self, void *arg,

				struct bpf_insn *insns, s64 dst, s64 src)

{

	int op = *(int *)arg;



	if (insns) {

		bool match = __bpf_match_jmp_cond((s32)dst, (s32)src, op);

		int i = 0;



		i += __bpf_ld_imm64(&insns[i], R1, dst);

		i += __bpf_ld_imm64(&insns[i], R2, src);

		insns[i++] = BPF_JMP32_REG(op, R1, R2, 1);

		if (!match)

			insns[i++] = BPF_JMP_IMM(BPF_JA, 0, 0, 1);

		insns[i++] = BPF_EXIT_INSN();



		return i;

	}



	return 7;

}



static int __bpf_fill_jmp_imm(struct bpf_test *self, int op)

{

	return __bpf_fill_pattern(self, &op, 64, 32,

				  PATTERN_BLOCK1, PATTERN_BLOCK2,

				  &__bpf_emit_jmp_imm);

}



static int __bpf_fill_jmp32_imm(struct bpf_test *self, int op)

{

	return __bpf_fill_pattern(self, &op, 64, 32,

				  PATTERN_BLOCK1, PATTERN_BLOCK2,

				  &__bpf_emit_jmp32_imm);

}



static int __bpf_fill_jmp_reg(struct bpf_test *self, int op)

{

	return __bpf_fill_pattern(self, &op, 64, 64,

				  PATTERN_BLOCK1, PATTERN_BLOCK2,

				  &__bpf_emit_jmp_reg);

}



static int __bpf_fill_jmp32_reg(struct bpf_test *self, int op)

{

	return __bpf_fill_pattern(self, &op, 64, 64,

				  PATTERN_BLOCK1, PATTERN_BLOCK2,

				  &__bpf_emit_jmp32_reg);

}



/* JMP immediate tests */

static int bpf_fill_jmp_jset_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JSET);

}



static int bpf_fill_jmp_jeq_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JEQ);

}



static int bpf_fill_jmp_jne_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JNE);

}



static int bpf_fill_jmp_jgt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JGT);

}



static int bpf_fill_jmp_jge_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JGE);

}



static int bpf_fill_jmp_jlt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JLT);

}



static int bpf_fill_jmp_jle_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JLE);

}



static int bpf_fill_jmp_jsgt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JSGT);

}



static int bpf_fill_jmp_jsge_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JSGE);

}



static int bpf_fill_jmp_jslt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JSLT);

}



static int bpf_fill_jmp_jsle_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp_imm(self, BPF_JSLE);

}



/* JMP32 immediate tests */

static int bpf_fill_jmp32_jset_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JSET);

}



static int bpf_fill_jmp32_jeq_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JEQ);

}



static int bpf_fill_jmp32_jne_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JNE);

}



static int bpf_fill_jmp32_jgt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JGT);

}



static int bpf_fill_jmp32_jge_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JGE);

}



static int bpf_fill_jmp32_jlt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JLT);

}



static int bpf_fill_jmp32_jle_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JLE);

}



static int bpf_fill_jmp32_jsgt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JSGT);

}



static int bpf_fill_jmp32_jsge_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JSGE);

}



static int bpf_fill_jmp32_jslt_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JSLT);

}



static int bpf_fill_jmp32_jsle_imm(struct bpf_test *self)

{

	return __bpf_fill_jmp32_imm(self, BPF_JSLE);

}



/* JMP register tests */

static int bpf_fill_jmp_jset_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JSET);

}



static int bpf_fill_jmp_jeq_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JEQ);

}



static int bpf_fill_jmp_jne_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JNE);

}



static int bpf_fill_jmp_jgt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JGT);

}



static int bpf_fill_jmp_jge_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JGE);

}



static int bpf_fill_jmp_jlt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JLT);

}



static int bpf_fill_jmp_jle_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JLE);

}



static int bpf_fill_jmp_jsgt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JSGT);

}



static int bpf_fill_jmp_jsge_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JSGE);

}



static int bpf_fill_jmp_jslt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JSLT);

}



static int bpf_fill_jmp_jsle_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp_reg(self, BPF_JSLE);

}



/* JMP32 register tests */

static int bpf_fill_jmp32_jset_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JSET);

}



static int bpf_fill_jmp32_jeq_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JEQ);

}



static int bpf_fill_jmp32_jne_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JNE);

}



static int bpf_fill_jmp32_jgt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JGT);

}



static int bpf_fill_jmp32_jge_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JGE);

}



static int bpf_fill_jmp32_jlt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JLT);

}



static int bpf_fill_jmp32_jle_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JLE);

}



static int bpf_fill_jmp32_jsgt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JSGT);

}



static int bpf_fill_jmp32_jsge_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JSGE);

}



static int bpf_fill_jmp32_jslt_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JSLT);

}



static int bpf_fill_jmp32_jsle_reg(struct bpf_test *self)

{

	return __bpf_fill_jmp32_reg(self, BPF_JSLE);

}





static struct bpf_test tests[] = {

	{

		"TAX",
@@ -9281,6 +9659,7 @@ static struct bpf_test tests[] = { 
		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_alu32_mod_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	/* ALU64 register magnitudes */

	{
@@ -9446,6 +9825,406 @@ static struct bpf_test tests[] = { 
		.fill_helper = bpf_fill_alu32_mod_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	/* JMP immediate magnitudes */

	{

		"JMP_JSET_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jset_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JEQ_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jeq_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JNE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jne_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JGT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jgt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JGE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jge_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JLT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jlt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JLE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jle_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSGT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jsgt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSGE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jsge_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSLT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jslt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSLE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jsle_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	/* JMP register magnitudes */

	{

		"JMP_JSET_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jset_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JEQ_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jeq_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JNE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jne_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JGT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jgt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JGE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jge_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JLT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jlt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JLE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jle_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSGT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jsgt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSGE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jsge_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSLT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jslt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP_JSLE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp_jsle_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	/* JMP32 immediate magnitudes */

	{

		"JMP32_JSET_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jset_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JEQ_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jeq_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JNE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jne_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JGT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jgt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JGE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jge_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JLT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jlt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JLE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jle_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSGT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jsgt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSGE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jsge_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSLT_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jslt_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSLE_K: all immediate value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jsle_imm,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	/* JMP32 register magnitudes */

	{

		"JMP32_JSET_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jset_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JEQ_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jeq_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JNE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jne_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JGT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jgt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JGE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jge_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JLT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jlt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JLE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jle_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSGT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jsgt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSGE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jsge_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSLT_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jslt_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

	{

		"JMP32_JSLE_X: all register value magnitudes",

		{ },

		INTERNAL | FLAG_NO_DATA,

		{ },

		{ { 0, 1 } },

		.fill_helper = bpf_fill_jmp32_jsle_reg,

		.nr_testruns = NR_PATTERN_RUNS,

	},

};



static struct net_device dev;