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: Johan Almbladh <johan.almbladh@anyfinetworks.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20210914091842.4186267-6-johan.almbladh@anyfinetworks.com

diff --git a/lib/test_bpf.c b/lib/test_bpf.c
index 228e681..fb27a25 100644 (file)
--- a/lib/test_bpf.c
+++ b/lib/test_bpf.c
@@ -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;