1 // SPDX-License-Identifier: GPL-2.0-only
3 * Testsuite for BPF interpreter and BPF JIT compiler
5 * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/filter.h>
13 #include <linux/bpf.h>
14 #include <linux/skbuff.h>
15 #include <linux/netdevice.h>
16 #include <linux/if_vlan.h>
17 #include <linux/random.h>
18 #include <linux/highmem.h>
19 #include <linux/sched.h>
21 /* General test specific settings */
22 #define MAX_SUBTESTS 3
23 #define MAX_TESTRUNS 1000
26 #define MAX_K 0xffffFFFF
28 /* Few constants used to init test 'skb' */
30 #define SKB_MARK 0x1234aaaa
31 #define SKB_HASH 0x1234aaab
32 #define SKB_QUEUE_MAP 123
33 #define SKB_VLAN_TCI 0xffff
34 #define SKB_VLAN_PRESENT 1
35 #define SKB_DEV_IFINDEX 577
36 #define SKB_DEV_TYPE 588
38 /* Redefine REGs to make tests less verbose */
49 #define R10 BPF_REG_10
51 /* Flags that can be passed to test cases */
52 #define FLAG_NO_DATA BIT(0)
53 #define FLAG_EXPECTED_FAIL BIT(1)
54 #define FLAG_SKB_FRAG BIT(2)
57 CLASSIC = BIT(6), /* Old BPF instructions only. */
58 INTERNAL = BIT(7), /* Extended instruction set. */
61 #define TEST_TYPE_MASK (CLASSIC | INTERNAL)
66 struct sock_filter insns[MAX_INSNS];
67 struct bpf_insn insns_int[MAX_INSNS];
79 int (*fill_helper)(struct bpf_test *self);
80 int expected_errcode; /* used when FLAG_EXPECTED_FAIL is set in the aux */
81 __u8 frag_data[MAX_DATA];
82 int stack_depth; /* for eBPF only, since tests don't call verifier */
85 /* Large test cases need separate allocation and fill handler. */
87 static int bpf_fill_maxinsns1(struct bpf_test *self)
89 unsigned int len = BPF_MAXINSNS;
90 struct sock_filter *insn;
94 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
98 for (i = 0; i < len; i++, k--)
99 insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
101 self->u.ptr.insns = insn;
102 self->u.ptr.len = len;
107 static int bpf_fill_maxinsns2(struct bpf_test *self)
109 unsigned int len = BPF_MAXINSNS;
110 struct sock_filter *insn;
113 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
117 for (i = 0; i < len; i++)
118 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
120 self->u.ptr.insns = insn;
121 self->u.ptr.len = len;
126 static int bpf_fill_maxinsns3(struct bpf_test *self)
128 unsigned int len = BPF_MAXINSNS;
129 struct sock_filter *insn;
130 struct rnd_state rnd;
133 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
137 prandom_seed_state(&rnd, 3141592653589793238ULL);
139 for (i = 0; i < len - 1; i++) {
140 __u32 k = prandom_u32_state(&rnd);
142 insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
145 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
147 self->u.ptr.insns = insn;
148 self->u.ptr.len = len;
153 static int bpf_fill_maxinsns4(struct bpf_test *self)
155 unsigned int len = BPF_MAXINSNS + 1;
156 struct sock_filter *insn;
159 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
163 for (i = 0; i < len; i++)
164 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
166 self->u.ptr.insns = insn;
167 self->u.ptr.len = len;
172 static int bpf_fill_maxinsns5(struct bpf_test *self)
174 unsigned int len = BPF_MAXINSNS;
175 struct sock_filter *insn;
178 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
182 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
184 for (i = 1; i < len - 1; i++)
185 insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
187 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
189 self->u.ptr.insns = insn;
190 self->u.ptr.len = len;
195 static int bpf_fill_maxinsns6(struct bpf_test *self)
197 unsigned int len = BPF_MAXINSNS;
198 struct sock_filter *insn;
201 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
205 for (i = 0; i < len - 1; i++)
206 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
207 SKF_AD_VLAN_TAG_PRESENT);
209 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
211 self->u.ptr.insns = insn;
212 self->u.ptr.len = len;
217 static int bpf_fill_maxinsns7(struct bpf_test *self)
219 unsigned int len = BPF_MAXINSNS;
220 struct sock_filter *insn;
223 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
227 for (i = 0; i < len - 4; i++)
228 insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
231 insn[len - 4] = __BPF_STMT(BPF_MISC | BPF_TAX, 0);
232 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
234 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
235 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
237 self->u.ptr.insns = insn;
238 self->u.ptr.len = len;
243 static int bpf_fill_maxinsns8(struct bpf_test *self)
245 unsigned int len = BPF_MAXINSNS;
246 struct sock_filter *insn;
247 int i, jmp_off = len - 3;
249 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
253 insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
255 for (i = 1; i < len - 1; i++)
256 insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
258 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
260 self->u.ptr.insns = insn;
261 self->u.ptr.len = len;
266 static int bpf_fill_maxinsns9(struct bpf_test *self)
268 unsigned int len = BPF_MAXINSNS;
269 struct bpf_insn *insn;
272 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
276 insn[0] = BPF_JMP_IMM(BPF_JA, 0, 0, len - 2);
277 insn[1] = BPF_ALU32_IMM(BPF_MOV, R0, 0xcbababab);
278 insn[2] = BPF_EXIT_INSN();
280 for (i = 3; i < len - 2; i++)
281 insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
283 insn[len - 2] = BPF_EXIT_INSN();
284 insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
286 self->u.ptr.insns = insn;
287 self->u.ptr.len = len;
292 static int bpf_fill_maxinsns10(struct bpf_test *self)
294 unsigned int len = BPF_MAXINSNS, hlen = len - 2;
295 struct bpf_insn *insn;
298 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
302 for (i = 0; i < hlen / 2; i++)
303 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 2 - 2 * i);
304 for (i = hlen - 1; i > hlen / 2; i--)
305 insn[i] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen - 1 - 2 * i);
307 insn[hlen / 2] = BPF_JMP_IMM(BPF_JA, 0, 0, hlen / 2 - 1);
308 insn[hlen] = BPF_ALU32_IMM(BPF_MOV, R0, 0xabababac);
309 insn[hlen + 1] = BPF_EXIT_INSN();
311 self->u.ptr.insns = insn;
312 self->u.ptr.len = len;
317 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
320 struct sock_filter *insn;
324 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
328 rlen = (len % plen) - 1;
330 for (i = 0; i + plen < len; i += plen)
331 for (j = 0; j < plen; j++)
332 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA,
334 for (j = 0; j < rlen; j++)
335 insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
338 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
340 self->u.ptr.insns = insn;
341 self->u.ptr.len = len;
346 static int bpf_fill_maxinsns11(struct bpf_test *self)
348 /* Hits 70 passes on x86_64 and triggers NOPs padding. */
349 return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
352 static int bpf_fill_maxinsns12(struct bpf_test *self)
354 unsigned int len = BPF_MAXINSNS;
355 struct sock_filter *insn;
358 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
362 insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
364 for (i = 1; i < len - 1; i++)
365 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
367 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
369 self->u.ptr.insns = insn;
370 self->u.ptr.len = len;
375 static int bpf_fill_maxinsns13(struct bpf_test *self)
377 unsigned int len = BPF_MAXINSNS;
378 struct sock_filter *insn;
381 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
385 for (i = 0; i < len - 3; i++)
386 insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
388 insn[len - 3] = __BPF_STMT(BPF_LD | BPF_IMM, 0xabababab);
389 insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0);
390 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
392 self->u.ptr.insns = insn;
393 self->u.ptr.len = len;
398 static int bpf_fill_ja(struct bpf_test *self)
400 /* Hits exactly 11 passes on x86_64 JIT. */
401 return __bpf_fill_ja(self, 12, 9);
404 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
406 unsigned int len = BPF_MAXINSNS;
407 struct sock_filter *insn;
410 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
414 for (i = 0; i < len - 1; i += 2) {
415 insn[i] = __BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 0);
416 insn[i + 1] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
417 SKF_AD_OFF + SKF_AD_CPU);
420 insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
422 self->u.ptr.insns = insn;
423 self->u.ptr.len = len;
428 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
430 unsigned int len = BPF_MAXINSNS;
431 struct bpf_insn *insn;
434 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
438 insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
439 insn[1] = BPF_ST_MEM(size, R10, -40, 42);
441 for (i = 2; i < len - 2; i++)
442 insn[i] = BPF_STX_XADD(size, R10, R0, -40);
444 insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
445 insn[len - 1] = BPF_EXIT_INSN();
447 self->u.ptr.insns = insn;
448 self->u.ptr.len = len;
449 self->stack_depth = 40;
454 static int bpf_fill_stxw(struct bpf_test *self)
456 return __bpf_fill_stxdw(self, BPF_W);
459 static int bpf_fill_stxdw(struct bpf_test *self)
461 return __bpf_fill_stxdw(self, BPF_DW);
464 static int bpf_fill_long_jmp(struct bpf_test *self)
466 unsigned int len = BPF_MAXINSNS;
467 struct bpf_insn *insn;
470 insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
474 insn[0] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
475 insn[1] = BPF_JMP_IMM(BPF_JEQ, R0, 1, len - 2 - 1);
478 * Fill with a complex 64-bit operation that expands to a lot of
479 * instructions on 32-bit JITs. The large jump offset can then
480 * overflow the conditional branch field size, triggering a branch
481 * conversion mechanism in some JITs.
483 * Note: BPF_MAXINSNS of ALU64 MUL is enough to trigger such branch
484 * conversion on the 32-bit MIPS JIT. For other JITs, the instruction
485 * count and/or operation may need to be modified to trigger the
488 for (i = 2; i < len - 1; i++)
489 insn[i] = BPF_ALU64_IMM(BPF_MUL, R0, (i << 16) + i);
491 insn[len - 1] = BPF_EXIT_INSN();
493 self->u.ptr.insns = insn;
494 self->u.ptr.len = len;
499 static struct bpf_test tests[] = {
503 BPF_STMT(BPF_LD | BPF_IMM, 1),
504 BPF_STMT(BPF_MISC | BPF_TAX, 0),
505 BPF_STMT(BPF_LD | BPF_IMM, 2),
506 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
507 BPF_STMT(BPF_ALU | BPF_NEG, 0), /* A == -3 */
508 BPF_STMT(BPF_MISC | BPF_TAX, 0),
509 BPF_STMT(BPF_LD | BPF_LEN, 0),
510 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
511 BPF_STMT(BPF_MISC | BPF_TAX, 0), /* X == len - 3 */
512 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 1),
513 BPF_STMT(BPF_RET | BPF_A, 0)
516 { 10, 20, 30, 40, 50 },
517 { { 2, 10 }, { 3, 20 }, { 4, 30 } },
522 BPF_STMT(BPF_LDX | BPF_LEN, 0),
523 BPF_STMT(BPF_MISC | BPF_TXA, 0),
524 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
525 BPF_STMT(BPF_RET | BPF_A, 0) /* A == len * 2 */
528 { 10, 20, 30, 40, 50 },
529 { { 1, 2 }, { 3, 6 }, { 4, 8 } },
534 BPF_STMT(BPF_LD | BPF_IMM, 1),
535 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 2),
536 BPF_STMT(BPF_LDX | BPF_IMM, 3),
537 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
538 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0xffffffff),
539 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 3),
540 BPF_STMT(BPF_RET | BPF_A, 0)
542 CLASSIC | FLAG_NO_DATA,
544 { { 0, 0xfffffffd } }
549 BPF_STMT(BPF_LD | BPF_IMM, 8),
550 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 2),
551 BPF_STMT(BPF_MISC | BPF_TAX, 0),
552 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
553 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
554 BPF_STMT(BPF_MISC | BPF_TAX, 0),
555 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
556 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x70000000),
557 BPF_STMT(BPF_MISC | BPF_TAX, 0),
558 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
559 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
560 BPF_STMT(BPF_MISC | BPF_TAX, 0),
561 BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff),
562 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x70000000),
563 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
564 BPF_STMT(BPF_RET | BPF_A, 0)
566 CLASSIC | FLAG_NO_DATA,
568 { { 0, 0x20000000 } }
573 BPF_STMT(BPF_LD | BPF_IMM, 0xff),
574 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
575 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 27),
576 BPF_STMT(BPF_MISC | BPF_TAX, 0),
577 BPF_STMT(BPF_LD | BPF_IMM, 0xf),
578 BPF_STMT(BPF_ALU | BPF_OR | BPF_K, 0xf0),
579 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
580 BPF_STMT(BPF_RET | BPF_A, 0)
582 CLASSIC | FLAG_NO_DATA,
584 { { 0, 0x800000ff }, { 1, 0x800000ff } },
589 BPF_STMT(BPF_LD | BPF_IMM, 0), /* ld #0 */
590 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0, 1, 0),
591 BPF_STMT(BPF_RET | BPF_K, 0),
592 BPF_STMT(BPF_RET | BPF_K, 1),
601 BPF_STMT(BPF_LDX | BPF_LEN, 0),
602 BPF_STMT(BPF_LD | BPF_H | BPF_IND, MAX_K),
603 BPF_STMT(BPF_RET | BPF_K, 1)
607 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
612 BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
613 BPF_STMT(BPF_RET | BPF_K, 1)
617 { { 1, 0 }, { 10, 0 }, { 60, 0 } },
622 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF),
623 BPF_STMT(BPF_MISC | BPF_TAX, 0),
624 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_LL_OFF + 1),
625 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
626 BPF_STMT(BPF_RET | BPF_A, 0)
630 { { 1, 0 }, { 2, 3 } },
635 BPF_STMT(BPF_LD | BPF_IMM, SKF_LL_OFF - 1),
636 BPF_STMT(BPF_LDX | BPF_LEN, 0),
637 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
638 BPF_STMT(BPF_MISC | BPF_TAX, 0),
639 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
640 BPF_STMT(BPF_RET | BPF_A, 0)
644 { { 1, 1 }, { 3, 3 }, { 4, 0xff } },
649 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF),
650 BPF_STMT(BPF_MISC | BPF_TAX, 0),
651 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, SKF_NET_OFF + 1),
652 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
653 BPF_STMT(BPF_RET | BPF_A, 0)
656 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
657 { { 15, 0 }, { 16, 3 } },
662 BPF_STMT(BPF_LD | BPF_IMM, SKF_NET_OFF - 15),
663 BPF_STMT(BPF_LDX | BPF_LEN, 0),
664 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
665 BPF_STMT(BPF_MISC | BPF_TAX, 0),
666 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 0),
667 BPF_STMT(BPF_RET | BPF_A, 0)
670 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
671 { { 14, 0 }, { 15, 1 }, { 17, 3 } },
676 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
677 SKF_AD_OFF + SKF_AD_PKTTYPE),
678 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
679 BPF_STMT(BPF_RET | BPF_K, 1),
680 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
681 SKF_AD_OFF + SKF_AD_PKTTYPE),
682 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
683 BPF_STMT(BPF_RET | BPF_K, 1),
684 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
685 SKF_AD_OFF + SKF_AD_PKTTYPE),
686 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, SKB_TYPE, 1, 0),
687 BPF_STMT(BPF_RET | BPF_K, 1),
688 BPF_STMT(BPF_RET | BPF_A, 0)
692 { { 1, 3 }, { 10, 3 } },
697 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
698 SKF_AD_OFF + SKF_AD_MARK),
699 BPF_STMT(BPF_RET | BPF_A, 0)
703 { { 1, SKB_MARK}, { 10, SKB_MARK} },
708 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
709 SKF_AD_OFF + SKF_AD_RXHASH),
710 BPF_STMT(BPF_RET | BPF_A, 0)
714 { { 1, SKB_HASH}, { 10, SKB_HASH} },
719 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
720 SKF_AD_OFF + SKF_AD_QUEUE),
721 BPF_STMT(BPF_RET | BPF_A, 0)
725 { { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
730 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 1),
731 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 20, 1, 0),
732 BPF_STMT(BPF_RET | BPF_K, 0),
733 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
734 SKF_AD_OFF + SKF_AD_PROTOCOL),
735 BPF_STMT(BPF_MISC | BPF_TAX, 0),
736 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
737 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 30, 1, 0),
738 BPF_STMT(BPF_RET | BPF_K, 0),
739 BPF_STMT(BPF_MISC | BPF_TXA, 0),
740 BPF_STMT(BPF_RET | BPF_A, 0)
744 { { 10, ETH_P_IP }, { 100, ETH_P_IP } },
749 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
750 SKF_AD_OFF + SKF_AD_VLAN_TAG),
751 BPF_STMT(BPF_RET | BPF_A, 0)
761 "LD_VLAN_TAG_PRESENT",
763 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
764 SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT),
765 BPF_STMT(BPF_RET | BPF_A, 0)
770 { 1, SKB_VLAN_PRESENT },
771 { 10, SKB_VLAN_PRESENT }
777 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
778 SKF_AD_OFF + SKF_AD_IFINDEX),
779 BPF_STMT(BPF_RET | BPF_A, 0)
783 { { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
788 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
789 SKF_AD_OFF + SKF_AD_HATYPE),
790 BPF_STMT(BPF_RET | BPF_A, 0)
794 { { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
799 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
800 SKF_AD_OFF + SKF_AD_CPU),
801 BPF_STMT(BPF_MISC | BPF_TAX, 0),
802 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
803 SKF_AD_OFF + SKF_AD_CPU),
804 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
805 BPF_STMT(BPF_RET | BPF_A, 0)
809 { { 1, 0 }, { 10, 0 } },
814 BPF_STMT(BPF_LDX | BPF_IMM, 2),
815 BPF_STMT(BPF_MISC | BPF_TXA, 0),
816 BPF_STMT(BPF_LDX | BPF_IMM, 3),
817 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
818 SKF_AD_OFF + SKF_AD_NLATTR),
819 BPF_STMT(BPF_RET | BPF_A, 0)
823 { 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
825 { 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
827 { { 4, 0 }, { 20, 6 } },
832 BPF_STMT(BPF_LD | BPF_IMM, 2),
833 BPF_STMT(BPF_LDX | BPF_IMM, 3),
834 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
835 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
836 BPF_STMT(BPF_LD | BPF_IMM, 2),
837 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
838 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
839 BPF_STMT(BPF_LD | BPF_IMM, 2),
840 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
841 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
842 BPF_STMT(BPF_LD | BPF_IMM, 2),
843 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
844 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
845 BPF_STMT(BPF_LD | BPF_IMM, 2),
846 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
847 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
848 BPF_STMT(BPF_LD | BPF_IMM, 2),
849 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
850 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
851 BPF_STMT(BPF_LD | BPF_IMM, 2),
852 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
853 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
854 BPF_STMT(BPF_LD | BPF_IMM, 2),
855 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
856 SKF_AD_OFF + SKF_AD_NLATTR_NEST),
857 BPF_STMT(BPF_RET | BPF_A, 0)
861 { 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
863 { 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
865 { { 4, 0 }, { 20, 10 } },
870 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
871 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
872 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
873 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
874 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
875 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
876 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
877 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
878 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
879 SKF_AD_OFF + SKF_AD_PAY_OFFSET),
880 BPF_STMT(BPF_RET | BPF_A, 0)
883 /* 00:00:00:00:00:00 > 00:00:00:00:00:00, ethtype IPv4 (0x0800),
884 * length 98: 127.0.0.1 > 127.0.0.1: ICMP echo request,
885 * id 9737, seq 1, length 64
887 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
888 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
890 0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
891 0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
892 { { 30, 0 }, { 100, 42 } },
897 BPF_STMT(BPF_LD | BPF_IMM, 10),
898 BPF_STMT(BPF_LDX | BPF_IMM, 300),
899 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
900 SKF_AD_OFF + SKF_AD_ALU_XOR_X),
901 BPF_STMT(BPF_RET | BPF_A, 0)
905 { { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
910 BPF_STMT(BPF_LDX | BPF_LEN, 0),
911 BPF_STMT(BPF_LD | BPF_IMM, 2),
912 BPF_STMT(BPF_ALU | BPF_RSH, 1),
913 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
914 BPF_STMT(BPF_ST, 1), /* M1 = 1 ^ len */
915 BPF_STMT(BPF_ALU | BPF_XOR | BPF_K, 0x80000000),
916 BPF_STMT(BPF_ST, 2), /* M2 = 1 ^ len ^ 0x80000000 */
917 BPF_STMT(BPF_STX, 15), /* M3 = len */
918 BPF_STMT(BPF_LDX | BPF_MEM, 1),
919 BPF_STMT(BPF_LD | BPF_MEM, 2),
920 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
921 BPF_STMT(BPF_LDX | BPF_MEM, 15),
922 BPF_STMT(BPF_ALU | BPF_XOR | BPF_X, 0),
923 BPF_STMT(BPF_RET | BPF_A, 0)
927 { { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
932 BPF_STMT(BPF_LDX | BPF_LEN, 0),
933 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
934 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 0, 1),
935 BPF_STMT(BPF_RET | BPF_K, 1),
936 BPF_STMT(BPF_RET | BPF_K, MAX_K)
940 { { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
945 BPF_STMT(BPF_LDX | BPF_LEN, 0),
946 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
947 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_X, 0, 0, 1),
948 BPF_STMT(BPF_RET | BPF_K, 1),
949 BPF_STMT(BPF_RET | BPF_K, MAX_K)
953 { { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
956 "JGE (jt 0), test 1",
958 BPF_STMT(BPF_LDX | BPF_LEN, 0),
959 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
960 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
961 BPF_STMT(BPF_RET | BPF_K, 1),
962 BPF_STMT(BPF_RET | BPF_K, MAX_K)
966 { { 2, 0 }, { 3, 1 }, { 4, 1 } },
969 "JGE (jt 0), test 2",
971 BPF_STMT(BPF_LDX | BPF_LEN, 0),
972 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 2),
973 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_X, 0, 0, 1),
974 BPF_STMT(BPF_RET | BPF_K, 1),
975 BPF_STMT(BPF_RET | BPF_K, MAX_K)
979 { { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
984 BPF_STMT(BPF_LDX | BPF_LEN, 0),
985 BPF_STMT(BPF_LD | BPF_B | BPF_IND, MAX_K),
986 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 1, 1, 0),
987 BPF_STMT(BPF_RET | BPF_K, 10),
988 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 2, 1, 0),
989 BPF_STMT(BPF_RET | BPF_K, 20),
990 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 3, 1, 0),
991 BPF_STMT(BPF_RET | BPF_K, 30),
992 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 4, 1, 0),
993 BPF_STMT(BPF_RET | BPF_K, 40),
994 BPF_STMT(BPF_RET | BPF_K, MAX_K)
998 { { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
1003 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1004 BPF_JUMP(BPF_JMP | BPF_JA, 1, 1, 1),
1005 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1006 BPF_JUMP(BPF_JMP | BPF_JA, 0, 0, 0),
1007 BPF_STMT(BPF_LDX | BPF_LEN, 0),
1008 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1009 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, 4),
1010 BPF_STMT(BPF_MISC | BPF_TAX, 0),
1011 BPF_STMT(BPF_LD | BPF_W | BPF_IND, 0),
1012 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 1, 0, 1),
1013 BPF_STMT(BPF_RET | BPF_K, 10),
1014 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x80000000, 0, 1),
1015 BPF_STMT(BPF_RET | BPF_K, 20),
1016 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1017 BPF_STMT(BPF_RET | BPF_K, 30),
1018 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1019 BPF_STMT(BPF_RET | BPF_K, 30),
1020 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1021 BPF_STMT(BPF_RET | BPF_K, 30),
1022 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1023 BPF_STMT(BPF_RET | BPF_K, 30),
1024 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0xffffff, 1, 0),
1025 BPF_STMT(BPF_RET | BPF_K, 30),
1026 BPF_STMT(BPF_RET | BPF_K, MAX_K)
1029 { 0, 0xAA, 0x55, 1 },
1030 { { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
1035 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1036 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 0, 8), /* IPv6 */
1037 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 20),
1038 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1039 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1040 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 17),
1041 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 54),
1042 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 14, 0),
1043 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 56),
1044 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 12, 13),
1045 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0800, 0, 12), /* IPv4 */
1046 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1047 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x84, 2, 0),
1048 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 1, 0),
1049 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x11, 0, 8),
1050 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1051 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 6, 0),
1052 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1053 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1054 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1055 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1056 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 1),
1057 BPF_STMT(BPF_RET | BPF_K, 0xffff),
1058 BPF_STMT(BPF_RET | BPF_K, 0),
1061 /* 3c:07:54:43:e5:76 > 10:bf:48:d6:43:d6, ethertype IPv4(0x0800)
1062 * length 114: 10.1.1.149.49700 > 10.1.2.10.22: Flags [P.],
1063 * seq 1305692979:1305693027, ack 3650467037, win 65535,
1064 * options [nop,nop,TS val 2502645400 ecr 3971138], length 48
1066 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1067 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1069 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1070 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1071 0x0a, 0x01, 0x01, 0x95, /* ip src */
1072 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1074 0x00, 0x16 /* dst port */ },
1075 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1080 /* tcpdump -nei eth0 'tcp port 22 and (((ip[2:2] -
1081 * ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0) and
1082 * (len > 115 or len < 30000000000)' -d
1084 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12),
1085 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x86dd, 30, 0),
1086 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x800, 0, 29),
1087 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 23),
1088 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x6, 0, 27),
1089 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20),
1090 BPF_JUMP(BPF_JMP | BPF_JSET | BPF_K, 0x1fff, 25, 0),
1091 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1092 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 14),
1093 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 2, 0),
1094 BPF_STMT(BPF_LD | BPF_H | BPF_IND, 16),
1095 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 22, 0, 20),
1096 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 16),
1097 BPF_STMT(BPF_ST, 1),
1098 BPF_STMT(BPF_LD | BPF_B | BPF_ABS, 14),
1099 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf),
1100 BPF_STMT(BPF_ALU | BPF_LSH | BPF_K, 2),
1101 BPF_STMT(BPF_MISC | BPF_TAX, 0x5), /* libpcap emits K on TAX */
1102 BPF_STMT(BPF_LD | BPF_MEM, 1),
1103 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
1104 BPF_STMT(BPF_ST, 5),
1105 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 14),
1106 BPF_STMT(BPF_LD | BPF_B | BPF_IND, 26),
1107 BPF_STMT(BPF_ALU | BPF_AND | BPF_K, 0xf0),
1108 BPF_STMT(BPF_ALU | BPF_RSH | BPF_K, 2),
1109 BPF_STMT(BPF_MISC | BPF_TAX, 0x9), /* libpcap emits K on TAX */
1110 BPF_STMT(BPF_LD | BPF_MEM, 5),
1111 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0, 4, 0),
1112 BPF_STMT(BPF_LD | BPF_LEN, 0),
1113 BPF_JUMP(BPF_JMP | BPF_JGT | BPF_K, 0x73, 1, 0),
1114 BPF_JUMP(BPF_JMP | BPF_JGE | BPF_K, 0xfc23ac00, 1, 0),
1115 BPF_STMT(BPF_RET | BPF_K, 0xffff),
1116 BPF_STMT(BPF_RET | BPF_K, 0),
1119 { 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1120 0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1122 0x45, 0x10, 0x00, 0x64, 0x75, 0xb5,
1123 0x40, 0x00, 0x40, 0x06, 0xad, 0x2e, /* IP header */
1124 0x0a, 0x01, 0x01, 0x95, /* ip src */
1125 0x0a, 0x01, 0x02, 0x0a, /* ip dst */
1127 0x00, 0x16 /* dst port */ },
1128 { { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1133 /* check that uninitialized X and A contain zeros */
1134 BPF_STMT(BPF_MISC | BPF_TXA, 0),
1135 BPF_STMT(BPF_RET | BPF_A, 0)
1144 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1145 BPF_ALU64_IMM(BPF_ADD, R1, 2),
1146 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1147 BPF_ALU64_REG(BPF_SUB, R1, R2),
1148 BPF_ALU64_IMM(BPF_ADD, R1, -1),
1149 BPF_ALU64_IMM(BPF_MUL, R1, 3),
1150 BPF_ALU64_REG(BPF_MOV, R0, R1),
1155 { { 0, 0xfffffffd } }
1160 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1161 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1162 BPF_ALU64_IMM(BPF_MOV, R2, 3),
1163 BPF_ALU64_REG(BPF_MUL, R1, R2),
1164 BPF_JMP_IMM(BPF_JEQ, R1, 0xfffffffd, 1),
1166 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1176 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1177 BPF_ALU32_IMM(BPF_MOV, R1, -1),
1178 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1179 BPF_ALU64_REG(BPF_MUL, R1, R2),
1180 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1181 BPF_JMP_IMM(BPF_JEQ, R1, 0x2ffffff, 1),
1183 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1193 BPF_ALU32_IMM(BPF_MOV, R0, -1),
1194 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1195 BPF_ALU32_IMM(BPF_MOV, R2, 3),
1196 BPF_ALU32_REG(BPF_MUL, R1, R2),
1197 BPF_ALU64_IMM(BPF_RSH, R1, 8),
1198 BPF_JMP_IMM(BPF_JEQ, R1, 0xffffff, 1),
1200 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1208 /* Have to test all register combinations, since
1209 * JITing of different registers will produce
1210 * different asm code.
1214 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1215 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1216 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1217 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1218 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1219 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1220 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1221 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1222 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1223 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1224 BPF_ALU64_IMM(BPF_ADD, R0, 20),
1225 BPF_ALU64_IMM(BPF_ADD, R1, 20),
1226 BPF_ALU64_IMM(BPF_ADD, R2, 20),
1227 BPF_ALU64_IMM(BPF_ADD, R3, 20),
1228 BPF_ALU64_IMM(BPF_ADD, R4, 20),
1229 BPF_ALU64_IMM(BPF_ADD, R5, 20),
1230 BPF_ALU64_IMM(BPF_ADD, R6, 20),
1231 BPF_ALU64_IMM(BPF_ADD, R7, 20),
1232 BPF_ALU64_IMM(BPF_ADD, R8, 20),
1233 BPF_ALU64_IMM(BPF_ADD, R9, 20),
1234 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1235 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1236 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1237 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1238 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1239 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1240 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1241 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1242 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1243 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1244 BPF_ALU64_REG(BPF_ADD, R0, R0),
1245 BPF_ALU64_REG(BPF_ADD, R0, R1),
1246 BPF_ALU64_REG(BPF_ADD, R0, R2),
1247 BPF_ALU64_REG(BPF_ADD, R0, R3),
1248 BPF_ALU64_REG(BPF_ADD, R0, R4),
1249 BPF_ALU64_REG(BPF_ADD, R0, R5),
1250 BPF_ALU64_REG(BPF_ADD, R0, R6),
1251 BPF_ALU64_REG(BPF_ADD, R0, R7),
1252 BPF_ALU64_REG(BPF_ADD, R0, R8),
1253 BPF_ALU64_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1254 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1256 BPF_ALU64_REG(BPF_ADD, R1, R0),
1257 BPF_ALU64_REG(BPF_ADD, R1, R1),
1258 BPF_ALU64_REG(BPF_ADD, R1, R2),
1259 BPF_ALU64_REG(BPF_ADD, R1, R3),
1260 BPF_ALU64_REG(BPF_ADD, R1, R4),
1261 BPF_ALU64_REG(BPF_ADD, R1, R5),
1262 BPF_ALU64_REG(BPF_ADD, R1, R6),
1263 BPF_ALU64_REG(BPF_ADD, R1, R7),
1264 BPF_ALU64_REG(BPF_ADD, R1, R8),
1265 BPF_ALU64_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1266 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1268 BPF_ALU64_REG(BPF_ADD, R2, R0),
1269 BPF_ALU64_REG(BPF_ADD, R2, R1),
1270 BPF_ALU64_REG(BPF_ADD, R2, R2),
1271 BPF_ALU64_REG(BPF_ADD, R2, R3),
1272 BPF_ALU64_REG(BPF_ADD, R2, R4),
1273 BPF_ALU64_REG(BPF_ADD, R2, R5),
1274 BPF_ALU64_REG(BPF_ADD, R2, R6),
1275 BPF_ALU64_REG(BPF_ADD, R2, R7),
1276 BPF_ALU64_REG(BPF_ADD, R2, R8),
1277 BPF_ALU64_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1278 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1280 BPF_ALU64_REG(BPF_ADD, R3, R0),
1281 BPF_ALU64_REG(BPF_ADD, R3, R1),
1282 BPF_ALU64_REG(BPF_ADD, R3, R2),
1283 BPF_ALU64_REG(BPF_ADD, R3, R3),
1284 BPF_ALU64_REG(BPF_ADD, R3, R4),
1285 BPF_ALU64_REG(BPF_ADD, R3, R5),
1286 BPF_ALU64_REG(BPF_ADD, R3, R6),
1287 BPF_ALU64_REG(BPF_ADD, R3, R7),
1288 BPF_ALU64_REG(BPF_ADD, R3, R8),
1289 BPF_ALU64_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1290 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1292 BPF_ALU64_REG(BPF_ADD, R4, R0),
1293 BPF_ALU64_REG(BPF_ADD, R4, R1),
1294 BPF_ALU64_REG(BPF_ADD, R4, R2),
1295 BPF_ALU64_REG(BPF_ADD, R4, R3),
1296 BPF_ALU64_REG(BPF_ADD, R4, R4),
1297 BPF_ALU64_REG(BPF_ADD, R4, R5),
1298 BPF_ALU64_REG(BPF_ADD, R4, R6),
1299 BPF_ALU64_REG(BPF_ADD, R4, R7),
1300 BPF_ALU64_REG(BPF_ADD, R4, R8),
1301 BPF_ALU64_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1302 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1304 BPF_ALU64_REG(BPF_ADD, R5, R0),
1305 BPF_ALU64_REG(BPF_ADD, R5, R1),
1306 BPF_ALU64_REG(BPF_ADD, R5, R2),
1307 BPF_ALU64_REG(BPF_ADD, R5, R3),
1308 BPF_ALU64_REG(BPF_ADD, R5, R4),
1309 BPF_ALU64_REG(BPF_ADD, R5, R5),
1310 BPF_ALU64_REG(BPF_ADD, R5, R6),
1311 BPF_ALU64_REG(BPF_ADD, R5, R7),
1312 BPF_ALU64_REG(BPF_ADD, R5, R8),
1313 BPF_ALU64_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1314 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1316 BPF_ALU64_REG(BPF_ADD, R6, R0),
1317 BPF_ALU64_REG(BPF_ADD, R6, R1),
1318 BPF_ALU64_REG(BPF_ADD, R6, R2),
1319 BPF_ALU64_REG(BPF_ADD, R6, R3),
1320 BPF_ALU64_REG(BPF_ADD, R6, R4),
1321 BPF_ALU64_REG(BPF_ADD, R6, R5),
1322 BPF_ALU64_REG(BPF_ADD, R6, R6),
1323 BPF_ALU64_REG(BPF_ADD, R6, R7),
1324 BPF_ALU64_REG(BPF_ADD, R6, R8),
1325 BPF_ALU64_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1326 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1328 BPF_ALU64_REG(BPF_ADD, R7, R0),
1329 BPF_ALU64_REG(BPF_ADD, R7, R1),
1330 BPF_ALU64_REG(BPF_ADD, R7, R2),
1331 BPF_ALU64_REG(BPF_ADD, R7, R3),
1332 BPF_ALU64_REG(BPF_ADD, R7, R4),
1333 BPF_ALU64_REG(BPF_ADD, R7, R5),
1334 BPF_ALU64_REG(BPF_ADD, R7, R6),
1335 BPF_ALU64_REG(BPF_ADD, R7, R7),
1336 BPF_ALU64_REG(BPF_ADD, R7, R8),
1337 BPF_ALU64_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1338 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1340 BPF_ALU64_REG(BPF_ADD, R8, R0),
1341 BPF_ALU64_REG(BPF_ADD, R8, R1),
1342 BPF_ALU64_REG(BPF_ADD, R8, R2),
1343 BPF_ALU64_REG(BPF_ADD, R8, R3),
1344 BPF_ALU64_REG(BPF_ADD, R8, R4),
1345 BPF_ALU64_REG(BPF_ADD, R8, R5),
1346 BPF_ALU64_REG(BPF_ADD, R8, R6),
1347 BPF_ALU64_REG(BPF_ADD, R8, R7),
1348 BPF_ALU64_REG(BPF_ADD, R8, R8),
1349 BPF_ALU64_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1350 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1352 BPF_ALU64_REG(BPF_ADD, R9, R0),
1353 BPF_ALU64_REG(BPF_ADD, R9, R1),
1354 BPF_ALU64_REG(BPF_ADD, R9, R2),
1355 BPF_ALU64_REG(BPF_ADD, R9, R3),
1356 BPF_ALU64_REG(BPF_ADD, R9, R4),
1357 BPF_ALU64_REG(BPF_ADD, R9, R5),
1358 BPF_ALU64_REG(BPF_ADD, R9, R6),
1359 BPF_ALU64_REG(BPF_ADD, R9, R7),
1360 BPF_ALU64_REG(BPF_ADD, R9, R8),
1361 BPF_ALU64_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1362 BPF_ALU64_REG(BPF_MOV, R0, R9),
1372 BPF_ALU32_IMM(BPF_MOV, R0, 20),
1373 BPF_ALU32_IMM(BPF_MOV, R1, 1),
1374 BPF_ALU32_IMM(BPF_MOV, R2, 2),
1375 BPF_ALU32_IMM(BPF_MOV, R3, 3),
1376 BPF_ALU32_IMM(BPF_MOV, R4, 4),
1377 BPF_ALU32_IMM(BPF_MOV, R5, 5),
1378 BPF_ALU32_IMM(BPF_MOV, R6, 6),
1379 BPF_ALU32_IMM(BPF_MOV, R7, 7),
1380 BPF_ALU32_IMM(BPF_MOV, R8, 8),
1381 BPF_ALU32_IMM(BPF_MOV, R9, 9),
1382 BPF_ALU64_IMM(BPF_ADD, R1, 10),
1383 BPF_ALU64_IMM(BPF_ADD, R2, 10),
1384 BPF_ALU64_IMM(BPF_ADD, R3, 10),
1385 BPF_ALU64_IMM(BPF_ADD, R4, 10),
1386 BPF_ALU64_IMM(BPF_ADD, R5, 10),
1387 BPF_ALU64_IMM(BPF_ADD, R6, 10),
1388 BPF_ALU64_IMM(BPF_ADD, R7, 10),
1389 BPF_ALU64_IMM(BPF_ADD, R8, 10),
1390 BPF_ALU64_IMM(BPF_ADD, R9, 10),
1391 BPF_ALU32_REG(BPF_ADD, R0, R1),
1392 BPF_ALU32_REG(BPF_ADD, R0, R2),
1393 BPF_ALU32_REG(BPF_ADD, R0, R3),
1394 BPF_ALU32_REG(BPF_ADD, R0, R4),
1395 BPF_ALU32_REG(BPF_ADD, R0, R5),
1396 BPF_ALU32_REG(BPF_ADD, R0, R6),
1397 BPF_ALU32_REG(BPF_ADD, R0, R7),
1398 BPF_ALU32_REG(BPF_ADD, R0, R8),
1399 BPF_ALU32_REG(BPF_ADD, R0, R9), /* R0 == 155 */
1400 BPF_JMP_IMM(BPF_JEQ, R0, 155, 1),
1402 BPF_ALU32_REG(BPF_ADD, R1, R0),
1403 BPF_ALU32_REG(BPF_ADD, R1, R1),
1404 BPF_ALU32_REG(BPF_ADD, R1, R2),
1405 BPF_ALU32_REG(BPF_ADD, R1, R3),
1406 BPF_ALU32_REG(BPF_ADD, R1, R4),
1407 BPF_ALU32_REG(BPF_ADD, R1, R5),
1408 BPF_ALU32_REG(BPF_ADD, R1, R6),
1409 BPF_ALU32_REG(BPF_ADD, R1, R7),
1410 BPF_ALU32_REG(BPF_ADD, R1, R8),
1411 BPF_ALU32_REG(BPF_ADD, R1, R9), /* R1 == 456 */
1412 BPF_JMP_IMM(BPF_JEQ, R1, 456, 1),
1414 BPF_ALU32_REG(BPF_ADD, R2, R0),
1415 BPF_ALU32_REG(BPF_ADD, R2, R1),
1416 BPF_ALU32_REG(BPF_ADD, R2, R2),
1417 BPF_ALU32_REG(BPF_ADD, R2, R3),
1418 BPF_ALU32_REG(BPF_ADD, R2, R4),
1419 BPF_ALU32_REG(BPF_ADD, R2, R5),
1420 BPF_ALU32_REG(BPF_ADD, R2, R6),
1421 BPF_ALU32_REG(BPF_ADD, R2, R7),
1422 BPF_ALU32_REG(BPF_ADD, R2, R8),
1423 BPF_ALU32_REG(BPF_ADD, R2, R9), /* R2 == 1358 */
1424 BPF_JMP_IMM(BPF_JEQ, R2, 1358, 1),
1426 BPF_ALU32_REG(BPF_ADD, R3, R0),
1427 BPF_ALU32_REG(BPF_ADD, R3, R1),
1428 BPF_ALU32_REG(BPF_ADD, R3, R2),
1429 BPF_ALU32_REG(BPF_ADD, R3, R3),
1430 BPF_ALU32_REG(BPF_ADD, R3, R4),
1431 BPF_ALU32_REG(BPF_ADD, R3, R5),
1432 BPF_ALU32_REG(BPF_ADD, R3, R6),
1433 BPF_ALU32_REG(BPF_ADD, R3, R7),
1434 BPF_ALU32_REG(BPF_ADD, R3, R8),
1435 BPF_ALU32_REG(BPF_ADD, R3, R9), /* R3 == 4063 */
1436 BPF_JMP_IMM(BPF_JEQ, R3, 4063, 1),
1438 BPF_ALU32_REG(BPF_ADD, R4, R0),
1439 BPF_ALU32_REG(BPF_ADD, R4, R1),
1440 BPF_ALU32_REG(BPF_ADD, R4, R2),
1441 BPF_ALU32_REG(BPF_ADD, R4, R3),
1442 BPF_ALU32_REG(BPF_ADD, R4, R4),
1443 BPF_ALU32_REG(BPF_ADD, R4, R5),
1444 BPF_ALU32_REG(BPF_ADD, R4, R6),
1445 BPF_ALU32_REG(BPF_ADD, R4, R7),
1446 BPF_ALU32_REG(BPF_ADD, R4, R8),
1447 BPF_ALU32_REG(BPF_ADD, R4, R9), /* R4 == 12177 */
1448 BPF_JMP_IMM(BPF_JEQ, R4, 12177, 1),
1450 BPF_ALU32_REG(BPF_ADD, R5, R0),
1451 BPF_ALU32_REG(BPF_ADD, R5, R1),
1452 BPF_ALU32_REG(BPF_ADD, R5, R2),
1453 BPF_ALU32_REG(BPF_ADD, R5, R3),
1454 BPF_ALU32_REG(BPF_ADD, R5, R4),
1455 BPF_ALU32_REG(BPF_ADD, R5, R5),
1456 BPF_ALU32_REG(BPF_ADD, R5, R6),
1457 BPF_ALU32_REG(BPF_ADD, R5, R7),
1458 BPF_ALU32_REG(BPF_ADD, R5, R8),
1459 BPF_ALU32_REG(BPF_ADD, R5, R9), /* R5 == 36518 */
1460 BPF_JMP_IMM(BPF_JEQ, R5, 36518, 1),
1462 BPF_ALU32_REG(BPF_ADD, R6, R0),
1463 BPF_ALU32_REG(BPF_ADD, R6, R1),
1464 BPF_ALU32_REG(BPF_ADD, R6, R2),
1465 BPF_ALU32_REG(BPF_ADD, R6, R3),
1466 BPF_ALU32_REG(BPF_ADD, R6, R4),
1467 BPF_ALU32_REG(BPF_ADD, R6, R5),
1468 BPF_ALU32_REG(BPF_ADD, R6, R6),
1469 BPF_ALU32_REG(BPF_ADD, R6, R7),
1470 BPF_ALU32_REG(BPF_ADD, R6, R8),
1471 BPF_ALU32_REG(BPF_ADD, R6, R9), /* R6 == 109540 */
1472 BPF_JMP_IMM(BPF_JEQ, R6, 109540, 1),
1474 BPF_ALU32_REG(BPF_ADD, R7, R0),
1475 BPF_ALU32_REG(BPF_ADD, R7, R1),
1476 BPF_ALU32_REG(BPF_ADD, R7, R2),
1477 BPF_ALU32_REG(BPF_ADD, R7, R3),
1478 BPF_ALU32_REG(BPF_ADD, R7, R4),
1479 BPF_ALU32_REG(BPF_ADD, R7, R5),
1480 BPF_ALU32_REG(BPF_ADD, R7, R6),
1481 BPF_ALU32_REG(BPF_ADD, R7, R7),
1482 BPF_ALU32_REG(BPF_ADD, R7, R8),
1483 BPF_ALU32_REG(BPF_ADD, R7, R9), /* R7 == 328605 */
1484 BPF_JMP_IMM(BPF_JEQ, R7, 328605, 1),
1486 BPF_ALU32_REG(BPF_ADD, R8, R0),
1487 BPF_ALU32_REG(BPF_ADD, R8, R1),
1488 BPF_ALU32_REG(BPF_ADD, R8, R2),
1489 BPF_ALU32_REG(BPF_ADD, R8, R3),
1490 BPF_ALU32_REG(BPF_ADD, R8, R4),
1491 BPF_ALU32_REG(BPF_ADD, R8, R5),
1492 BPF_ALU32_REG(BPF_ADD, R8, R6),
1493 BPF_ALU32_REG(BPF_ADD, R8, R7),
1494 BPF_ALU32_REG(BPF_ADD, R8, R8),
1495 BPF_ALU32_REG(BPF_ADD, R8, R9), /* R8 == 985799 */
1496 BPF_JMP_IMM(BPF_JEQ, R8, 985799, 1),
1498 BPF_ALU32_REG(BPF_ADD, R9, R0),
1499 BPF_ALU32_REG(BPF_ADD, R9, R1),
1500 BPF_ALU32_REG(BPF_ADD, R9, R2),
1501 BPF_ALU32_REG(BPF_ADD, R9, R3),
1502 BPF_ALU32_REG(BPF_ADD, R9, R4),
1503 BPF_ALU32_REG(BPF_ADD, R9, R5),
1504 BPF_ALU32_REG(BPF_ADD, R9, R6),
1505 BPF_ALU32_REG(BPF_ADD, R9, R7),
1506 BPF_ALU32_REG(BPF_ADD, R9, R8),
1507 BPF_ALU32_REG(BPF_ADD, R9, R9), /* R9 == 2957380 */
1508 BPF_ALU32_REG(BPF_MOV, R0, R9),
1515 { /* Mainly checking JIT here. */
1518 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1519 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1520 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1521 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1522 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1523 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1524 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1525 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1526 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1527 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1528 BPF_ALU64_REG(BPF_SUB, R0, R0),
1529 BPF_ALU64_REG(BPF_SUB, R0, R1),
1530 BPF_ALU64_REG(BPF_SUB, R0, R2),
1531 BPF_ALU64_REG(BPF_SUB, R0, R3),
1532 BPF_ALU64_REG(BPF_SUB, R0, R4),
1533 BPF_ALU64_REG(BPF_SUB, R0, R5),
1534 BPF_ALU64_REG(BPF_SUB, R0, R6),
1535 BPF_ALU64_REG(BPF_SUB, R0, R7),
1536 BPF_ALU64_REG(BPF_SUB, R0, R8),
1537 BPF_ALU64_REG(BPF_SUB, R0, R9),
1538 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1539 BPF_JMP_IMM(BPF_JEQ, R0, -55, 1),
1541 BPF_ALU64_REG(BPF_SUB, R1, R0),
1542 BPF_ALU64_REG(BPF_SUB, R1, R2),
1543 BPF_ALU64_REG(BPF_SUB, R1, R3),
1544 BPF_ALU64_REG(BPF_SUB, R1, R4),
1545 BPF_ALU64_REG(BPF_SUB, R1, R5),
1546 BPF_ALU64_REG(BPF_SUB, R1, R6),
1547 BPF_ALU64_REG(BPF_SUB, R1, R7),
1548 BPF_ALU64_REG(BPF_SUB, R1, R8),
1549 BPF_ALU64_REG(BPF_SUB, R1, R9),
1550 BPF_ALU64_IMM(BPF_SUB, R1, 10),
1551 BPF_ALU64_REG(BPF_SUB, R2, R0),
1552 BPF_ALU64_REG(BPF_SUB, R2, R1),
1553 BPF_ALU64_REG(BPF_SUB, R2, R3),
1554 BPF_ALU64_REG(BPF_SUB, R2, R4),
1555 BPF_ALU64_REG(BPF_SUB, R2, R5),
1556 BPF_ALU64_REG(BPF_SUB, R2, R6),
1557 BPF_ALU64_REG(BPF_SUB, R2, R7),
1558 BPF_ALU64_REG(BPF_SUB, R2, R8),
1559 BPF_ALU64_REG(BPF_SUB, R2, R9),
1560 BPF_ALU64_IMM(BPF_SUB, R2, 10),
1561 BPF_ALU64_REG(BPF_SUB, R3, R0),
1562 BPF_ALU64_REG(BPF_SUB, R3, R1),
1563 BPF_ALU64_REG(BPF_SUB, R3, R2),
1564 BPF_ALU64_REG(BPF_SUB, R3, R4),
1565 BPF_ALU64_REG(BPF_SUB, R3, R5),
1566 BPF_ALU64_REG(BPF_SUB, R3, R6),
1567 BPF_ALU64_REG(BPF_SUB, R3, R7),
1568 BPF_ALU64_REG(BPF_SUB, R3, R8),
1569 BPF_ALU64_REG(BPF_SUB, R3, R9),
1570 BPF_ALU64_IMM(BPF_SUB, R3, 10),
1571 BPF_ALU64_REG(BPF_SUB, R4, R0),
1572 BPF_ALU64_REG(BPF_SUB, R4, R1),
1573 BPF_ALU64_REG(BPF_SUB, R4, R2),
1574 BPF_ALU64_REG(BPF_SUB, R4, R3),
1575 BPF_ALU64_REG(BPF_SUB, R4, R5),
1576 BPF_ALU64_REG(BPF_SUB, R4, R6),
1577 BPF_ALU64_REG(BPF_SUB, R4, R7),
1578 BPF_ALU64_REG(BPF_SUB, R4, R8),
1579 BPF_ALU64_REG(BPF_SUB, R4, R9),
1580 BPF_ALU64_IMM(BPF_SUB, R4, 10),
1581 BPF_ALU64_REG(BPF_SUB, R5, R0),
1582 BPF_ALU64_REG(BPF_SUB, R5, R1),
1583 BPF_ALU64_REG(BPF_SUB, R5, R2),
1584 BPF_ALU64_REG(BPF_SUB, R5, R3),
1585 BPF_ALU64_REG(BPF_SUB, R5, R4),
1586 BPF_ALU64_REG(BPF_SUB, R5, R6),
1587 BPF_ALU64_REG(BPF_SUB, R5, R7),
1588 BPF_ALU64_REG(BPF_SUB, R5, R8),
1589 BPF_ALU64_REG(BPF_SUB, R5, R9),
1590 BPF_ALU64_IMM(BPF_SUB, R5, 10),
1591 BPF_ALU64_REG(BPF_SUB, R6, R0),
1592 BPF_ALU64_REG(BPF_SUB, R6, R1),
1593 BPF_ALU64_REG(BPF_SUB, R6, R2),
1594 BPF_ALU64_REG(BPF_SUB, R6, R3),
1595 BPF_ALU64_REG(BPF_SUB, R6, R4),
1596 BPF_ALU64_REG(BPF_SUB, R6, R5),
1597 BPF_ALU64_REG(BPF_SUB, R6, R7),
1598 BPF_ALU64_REG(BPF_SUB, R6, R8),
1599 BPF_ALU64_REG(BPF_SUB, R6, R9),
1600 BPF_ALU64_IMM(BPF_SUB, R6, 10),
1601 BPF_ALU64_REG(BPF_SUB, R7, R0),
1602 BPF_ALU64_REG(BPF_SUB, R7, R1),
1603 BPF_ALU64_REG(BPF_SUB, R7, R2),
1604 BPF_ALU64_REG(BPF_SUB, R7, R3),
1605 BPF_ALU64_REG(BPF_SUB, R7, R4),
1606 BPF_ALU64_REG(BPF_SUB, R7, R5),
1607 BPF_ALU64_REG(BPF_SUB, R7, R6),
1608 BPF_ALU64_REG(BPF_SUB, R7, R8),
1609 BPF_ALU64_REG(BPF_SUB, R7, R9),
1610 BPF_ALU64_IMM(BPF_SUB, R7, 10),
1611 BPF_ALU64_REG(BPF_SUB, R8, R0),
1612 BPF_ALU64_REG(BPF_SUB, R8, R1),
1613 BPF_ALU64_REG(BPF_SUB, R8, R2),
1614 BPF_ALU64_REG(BPF_SUB, R8, R3),
1615 BPF_ALU64_REG(BPF_SUB, R8, R4),
1616 BPF_ALU64_REG(BPF_SUB, R8, R5),
1617 BPF_ALU64_REG(BPF_SUB, R8, R6),
1618 BPF_ALU64_REG(BPF_SUB, R8, R7),
1619 BPF_ALU64_REG(BPF_SUB, R8, R9),
1620 BPF_ALU64_IMM(BPF_SUB, R8, 10),
1621 BPF_ALU64_REG(BPF_SUB, R9, R0),
1622 BPF_ALU64_REG(BPF_SUB, R9, R1),
1623 BPF_ALU64_REG(BPF_SUB, R9, R2),
1624 BPF_ALU64_REG(BPF_SUB, R9, R3),
1625 BPF_ALU64_REG(BPF_SUB, R9, R4),
1626 BPF_ALU64_REG(BPF_SUB, R9, R5),
1627 BPF_ALU64_REG(BPF_SUB, R9, R6),
1628 BPF_ALU64_REG(BPF_SUB, R9, R7),
1629 BPF_ALU64_REG(BPF_SUB, R9, R8),
1630 BPF_ALU64_IMM(BPF_SUB, R9, 10),
1631 BPF_ALU64_IMM(BPF_SUB, R0, 10),
1632 BPF_ALU64_IMM(BPF_NEG, R0, 0),
1633 BPF_ALU64_REG(BPF_SUB, R0, R1),
1634 BPF_ALU64_REG(BPF_SUB, R0, R2),
1635 BPF_ALU64_REG(BPF_SUB, R0, R3),
1636 BPF_ALU64_REG(BPF_SUB, R0, R4),
1637 BPF_ALU64_REG(BPF_SUB, R0, R5),
1638 BPF_ALU64_REG(BPF_SUB, R0, R6),
1639 BPF_ALU64_REG(BPF_SUB, R0, R7),
1640 BPF_ALU64_REG(BPF_SUB, R0, R8),
1641 BPF_ALU64_REG(BPF_SUB, R0, R9),
1648 { /* Mainly checking JIT here. */
1651 BPF_ALU64_REG(BPF_SUB, R0, R0),
1652 BPF_ALU64_REG(BPF_XOR, R1, R1),
1653 BPF_JMP_REG(BPF_JEQ, R0, R1, 1),
1655 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1656 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1657 BPF_ALU64_REG(BPF_SUB, R1, R1),
1658 BPF_ALU64_REG(BPF_XOR, R2, R2),
1659 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
1661 BPF_ALU64_REG(BPF_SUB, R2, R2),
1662 BPF_ALU64_REG(BPF_XOR, R3, R3),
1663 BPF_ALU64_IMM(BPF_MOV, R0, 10),
1664 BPF_ALU64_IMM(BPF_MOV, R1, -1),
1665 BPF_JMP_REG(BPF_JEQ, R2, R3, 1),
1667 BPF_ALU64_REG(BPF_SUB, R3, R3),
1668 BPF_ALU64_REG(BPF_XOR, R4, R4),
1669 BPF_ALU64_IMM(BPF_MOV, R2, 1),
1670 BPF_ALU64_IMM(BPF_MOV, R5, -1),
1671 BPF_JMP_REG(BPF_JEQ, R3, R4, 1),
1673 BPF_ALU64_REG(BPF_SUB, R4, R4),
1674 BPF_ALU64_REG(BPF_XOR, R5, R5),
1675 BPF_ALU64_IMM(BPF_MOV, R3, 1),
1676 BPF_ALU64_IMM(BPF_MOV, R7, -1),
1677 BPF_JMP_REG(BPF_JEQ, R5, R4, 1),
1679 BPF_ALU64_IMM(BPF_MOV, R5, 1),
1680 BPF_ALU64_REG(BPF_SUB, R5, R5),
1681 BPF_ALU64_REG(BPF_XOR, R6, R6),
1682 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1683 BPF_ALU64_IMM(BPF_MOV, R8, -1),
1684 BPF_JMP_REG(BPF_JEQ, R5, R6, 1),
1686 BPF_ALU64_REG(BPF_SUB, R6, R6),
1687 BPF_ALU64_REG(BPF_XOR, R7, R7),
1688 BPF_JMP_REG(BPF_JEQ, R7, R6, 1),
1690 BPF_ALU64_REG(BPF_SUB, R7, R7),
1691 BPF_ALU64_REG(BPF_XOR, R8, R8),
1692 BPF_JMP_REG(BPF_JEQ, R7, R8, 1),
1694 BPF_ALU64_REG(BPF_SUB, R8, R8),
1695 BPF_ALU64_REG(BPF_XOR, R9, R9),
1696 BPF_JMP_REG(BPF_JEQ, R9, R8, 1),
1698 BPF_ALU64_REG(BPF_SUB, R9, R9),
1699 BPF_ALU64_REG(BPF_XOR, R0, R0),
1700 BPF_JMP_REG(BPF_JEQ, R9, R0, 1),
1702 BPF_ALU64_REG(BPF_SUB, R1, R1),
1703 BPF_ALU64_REG(BPF_XOR, R0, R0),
1704 BPF_JMP_REG(BPF_JEQ, R9, R0, 2),
1705 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1707 BPF_ALU64_IMM(BPF_MOV, R0, 1),
1714 { /* Mainly checking JIT here. */
1717 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1718 BPF_ALU64_IMM(BPF_MOV, R1, 1),
1719 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1720 BPF_ALU64_IMM(BPF_MOV, R3, 3),
1721 BPF_ALU64_IMM(BPF_MOV, R4, 4),
1722 BPF_ALU64_IMM(BPF_MOV, R5, 5),
1723 BPF_ALU64_IMM(BPF_MOV, R6, 6),
1724 BPF_ALU64_IMM(BPF_MOV, R7, 7),
1725 BPF_ALU64_IMM(BPF_MOV, R8, 8),
1726 BPF_ALU64_IMM(BPF_MOV, R9, 9),
1727 BPF_ALU64_REG(BPF_MUL, R0, R0),
1728 BPF_ALU64_REG(BPF_MUL, R0, R1),
1729 BPF_ALU64_REG(BPF_MUL, R0, R2),
1730 BPF_ALU64_REG(BPF_MUL, R0, R3),
1731 BPF_ALU64_REG(BPF_MUL, R0, R4),
1732 BPF_ALU64_REG(BPF_MUL, R0, R5),
1733 BPF_ALU64_REG(BPF_MUL, R0, R6),
1734 BPF_ALU64_REG(BPF_MUL, R0, R7),
1735 BPF_ALU64_REG(BPF_MUL, R0, R8),
1736 BPF_ALU64_REG(BPF_MUL, R0, R9),
1737 BPF_ALU64_IMM(BPF_MUL, R0, 10),
1738 BPF_JMP_IMM(BPF_JEQ, R0, 439084800, 1),
1740 BPF_ALU64_REG(BPF_MUL, R1, R0),
1741 BPF_ALU64_REG(BPF_MUL, R1, R2),
1742 BPF_ALU64_REG(BPF_MUL, R1, R3),
1743 BPF_ALU64_REG(BPF_MUL, R1, R4),
1744 BPF_ALU64_REG(BPF_MUL, R1, R5),
1745 BPF_ALU64_REG(BPF_MUL, R1, R6),
1746 BPF_ALU64_REG(BPF_MUL, R1, R7),
1747 BPF_ALU64_REG(BPF_MUL, R1, R8),
1748 BPF_ALU64_REG(BPF_MUL, R1, R9),
1749 BPF_ALU64_IMM(BPF_MUL, R1, 10),
1750 BPF_ALU64_REG(BPF_MOV, R2, R1),
1751 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1752 BPF_JMP_IMM(BPF_JEQ, R2, 0x5a924, 1),
1754 BPF_ALU64_IMM(BPF_LSH, R1, 32),
1755 BPF_ALU64_IMM(BPF_ARSH, R1, 32),
1756 BPF_JMP_IMM(BPF_JEQ, R1, 0xebb90000, 1),
1758 BPF_ALU64_REG(BPF_MUL, R2, R0),
1759 BPF_ALU64_REG(BPF_MUL, R2, R1),
1760 BPF_ALU64_REG(BPF_MUL, R2, R3),
1761 BPF_ALU64_REG(BPF_MUL, R2, R4),
1762 BPF_ALU64_REG(BPF_MUL, R2, R5),
1763 BPF_ALU64_REG(BPF_MUL, R2, R6),
1764 BPF_ALU64_REG(BPF_MUL, R2, R7),
1765 BPF_ALU64_REG(BPF_MUL, R2, R8),
1766 BPF_ALU64_REG(BPF_MUL, R2, R9),
1767 BPF_ALU64_IMM(BPF_MUL, R2, 10),
1768 BPF_ALU64_IMM(BPF_RSH, R2, 32),
1769 BPF_ALU64_REG(BPF_MOV, R0, R2),
1774 { { 0, 0x35d97ef2 } }
1776 { /* Mainly checking JIT here. */
1779 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1780 BPF_MOV64_REG(R1, R0),
1781 BPF_MOV64_REG(R2, R1),
1782 BPF_MOV64_REG(R3, R2),
1783 BPF_MOV64_REG(R4, R3),
1784 BPF_MOV64_REG(R5, R4),
1785 BPF_MOV64_REG(R6, R5),
1786 BPF_MOV64_REG(R7, R6),
1787 BPF_MOV64_REG(R8, R7),
1788 BPF_MOV64_REG(R9, R8),
1789 BPF_ALU64_IMM(BPF_MOV, R0, 0),
1790 BPF_ALU64_IMM(BPF_MOV, R1, 0),
1791 BPF_ALU64_IMM(BPF_MOV, R2, 0),
1792 BPF_ALU64_IMM(BPF_MOV, R3, 0),
1793 BPF_ALU64_IMM(BPF_MOV, R4, 0),
1794 BPF_ALU64_IMM(BPF_MOV, R5, 0),
1795 BPF_ALU64_IMM(BPF_MOV, R6, 0),
1796 BPF_ALU64_IMM(BPF_MOV, R7, 0),
1797 BPF_ALU64_IMM(BPF_MOV, R8, 0),
1798 BPF_ALU64_IMM(BPF_MOV, R9, 0),
1799 BPF_ALU64_REG(BPF_ADD, R0, R0),
1800 BPF_ALU64_REG(BPF_ADD, R0, R1),
1801 BPF_ALU64_REG(BPF_ADD, R0, R2),
1802 BPF_ALU64_REG(BPF_ADD, R0, R3),
1803 BPF_ALU64_REG(BPF_ADD, R0, R4),
1804 BPF_ALU64_REG(BPF_ADD, R0, R5),
1805 BPF_ALU64_REG(BPF_ADD, R0, R6),
1806 BPF_ALU64_REG(BPF_ADD, R0, R7),
1807 BPF_ALU64_REG(BPF_ADD, R0, R8),
1808 BPF_ALU64_REG(BPF_ADD, R0, R9),
1809 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1816 { /* Mainly checking JIT here. */
1819 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1820 BPF_MOV64_REG(R1, R0),
1821 BPF_MOV64_REG(R2, R1),
1822 BPF_MOV64_REG(R3, R2),
1823 BPF_MOV64_REG(R4, R3),
1824 BPF_MOV64_REG(R5, R4),
1825 BPF_MOV64_REG(R6, R5),
1826 BPF_MOV64_REG(R7, R6),
1827 BPF_MOV64_REG(R8, R7),
1828 BPF_MOV64_REG(R9, R8),
1829 BPF_ALU32_IMM(BPF_MOV, R0, 0),
1830 BPF_ALU32_IMM(BPF_MOV, R1, 0),
1831 BPF_ALU32_IMM(BPF_MOV, R2, 0),
1832 BPF_ALU32_IMM(BPF_MOV, R3, 0),
1833 BPF_ALU32_IMM(BPF_MOV, R4, 0),
1834 BPF_ALU32_IMM(BPF_MOV, R5, 0),
1835 BPF_ALU32_IMM(BPF_MOV, R6, 0),
1836 BPF_ALU32_IMM(BPF_MOV, R7, 0),
1837 BPF_ALU32_IMM(BPF_MOV, R8, 0),
1838 BPF_ALU32_IMM(BPF_MOV, R9, 0),
1839 BPF_ALU64_REG(BPF_ADD, R0, R0),
1840 BPF_ALU64_REG(BPF_ADD, R0, R1),
1841 BPF_ALU64_REG(BPF_ADD, R0, R2),
1842 BPF_ALU64_REG(BPF_ADD, R0, R3),
1843 BPF_ALU64_REG(BPF_ADD, R0, R4),
1844 BPF_ALU64_REG(BPF_ADD, R0, R5),
1845 BPF_ALU64_REG(BPF_ADD, R0, R6),
1846 BPF_ALU64_REG(BPF_ADD, R0, R7),
1847 BPF_ALU64_REG(BPF_ADD, R0, R8),
1848 BPF_ALU64_REG(BPF_ADD, R0, R9),
1849 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1856 { /* Mainly checking JIT here. */
1859 BPF_LD_IMM64(R0, 0xffffffffffffffffLL),
1860 BPF_MOV64_REG(R1, R0),
1861 BPF_MOV64_REG(R2, R1),
1862 BPF_MOV64_REG(R3, R2),
1863 BPF_MOV64_REG(R4, R3),
1864 BPF_MOV64_REG(R5, R4),
1865 BPF_MOV64_REG(R6, R5),
1866 BPF_MOV64_REG(R7, R6),
1867 BPF_MOV64_REG(R8, R7),
1868 BPF_MOV64_REG(R9, R8),
1869 BPF_LD_IMM64(R0, 0x0LL),
1870 BPF_LD_IMM64(R1, 0x0LL),
1871 BPF_LD_IMM64(R2, 0x0LL),
1872 BPF_LD_IMM64(R3, 0x0LL),
1873 BPF_LD_IMM64(R4, 0x0LL),
1874 BPF_LD_IMM64(R5, 0x0LL),
1875 BPF_LD_IMM64(R6, 0x0LL),
1876 BPF_LD_IMM64(R7, 0x0LL),
1877 BPF_LD_IMM64(R8, 0x0LL),
1878 BPF_LD_IMM64(R9, 0x0LL),
1879 BPF_ALU64_REG(BPF_ADD, R0, R0),
1880 BPF_ALU64_REG(BPF_ADD, R0, R1),
1881 BPF_ALU64_REG(BPF_ADD, R0, R2),
1882 BPF_ALU64_REG(BPF_ADD, R0, R3),
1883 BPF_ALU64_REG(BPF_ADD, R0, R4),
1884 BPF_ALU64_REG(BPF_ADD, R0, R5),
1885 BPF_ALU64_REG(BPF_ADD, R0, R6),
1886 BPF_ALU64_REG(BPF_ADD, R0, R7),
1887 BPF_ALU64_REG(BPF_ADD, R0, R8),
1888 BPF_ALU64_REG(BPF_ADD, R0, R9),
1889 BPF_ALU64_IMM(BPF_ADD, R0, 0xfefe),
1899 BPF_ALU64_IMM(BPF_MOV, R0, 11),
1900 BPF_ALU64_IMM(BPF_ADD, R0, -1),
1901 BPF_ALU64_IMM(BPF_MOV, R2, 2),
1902 BPF_ALU64_IMM(BPF_XOR, R2, 3),
1903 BPF_ALU64_REG(BPF_DIV, R0, R2),
1904 BPF_JMP_IMM(BPF_JEQ, R0, 10, 1),
1906 BPF_ALU64_IMM(BPF_MOD, R0, 3),
1907 BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1909 BPF_ALU64_IMM(BPF_MOV, R0, -1),
1917 "INT: shifts by register",
1919 BPF_MOV64_IMM(R0, -1234),
1920 BPF_MOV64_IMM(R1, 1),
1921 BPF_ALU32_REG(BPF_RSH, R0, R1),
1922 BPF_JMP_IMM(BPF_JEQ, R0, 0x7ffffd97, 1),
1924 BPF_MOV64_IMM(R2, 1),
1925 BPF_ALU64_REG(BPF_LSH, R0, R2),
1926 BPF_MOV32_IMM(R4, -1234),
1927 BPF_JMP_REG(BPF_JEQ, R0, R4, 1),
1929 BPF_ALU64_IMM(BPF_AND, R4, 63),
1930 BPF_ALU64_REG(BPF_LSH, R0, R4), /* R0 <= 46 */
1931 BPF_MOV64_IMM(R3, 47),
1932 BPF_ALU64_REG(BPF_ARSH, R0, R3),
1933 BPF_JMP_IMM(BPF_JEQ, R0, -617, 1),
1935 BPF_MOV64_IMM(R2, 1),
1936 BPF_ALU64_REG(BPF_LSH, R4, R2), /* R4 = 46 << 1 */
1937 BPF_JMP_IMM(BPF_JEQ, R4, 92, 1),
1939 BPF_MOV64_IMM(R4, 4),
1940 BPF_ALU64_REG(BPF_LSH, R4, R4), /* R4 = 4 << 4 */
1941 BPF_JMP_IMM(BPF_JEQ, R4, 64, 1),
1943 BPF_MOV64_IMM(R4, 5),
1944 BPF_ALU32_REG(BPF_LSH, R4, R4), /* R4 = 5 << 5 */
1945 BPF_JMP_IMM(BPF_JEQ, R4, 160, 1),
1947 BPF_MOV64_IMM(R0, -1),
1956 * Register (non-)clobbering test, in the case where a 32-bit
1957 * JIT implements complex ALU64 operations via function calls.
1958 * If so, the function call must be invisible in the eBPF
1959 * registers. The JIT must then save and restore relevant
1960 * registers during the call. The following tests check that
1961 * the eBPF registers retain their values after such a call.
1963 "INT: Register clobbering, R1 updated",
1965 BPF_ALU32_IMM(BPF_MOV, R0, 0),
1966 BPF_ALU32_IMM(BPF_MOV, R1, 123456789),
1967 BPF_ALU32_IMM(BPF_MOV, R2, 2),
1968 BPF_ALU32_IMM(BPF_MOV, R3, 3),
1969 BPF_ALU32_IMM(BPF_MOV, R4, 4),
1970 BPF_ALU32_IMM(BPF_MOV, R5, 5),
1971 BPF_ALU32_IMM(BPF_MOV, R6, 6),
1972 BPF_ALU32_IMM(BPF_MOV, R7, 7),
1973 BPF_ALU32_IMM(BPF_MOV, R8, 8),
1974 BPF_ALU32_IMM(BPF_MOV, R9, 9),
1975 BPF_ALU64_IMM(BPF_DIV, R1, 123456789),
1976 BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
1977 BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
1978 BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
1979 BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
1980 BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
1981 BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
1982 BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
1983 BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
1984 BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
1985 BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
1986 BPF_ALU32_IMM(BPF_MOV, R0, 1),
1994 "INT: Register clobbering, R2 updated",
1996 BPF_ALU32_IMM(BPF_MOV, R0, 0),
1997 BPF_ALU32_IMM(BPF_MOV, R1, 1),
1998 BPF_ALU32_IMM(BPF_MOV, R2, 2 * 123456789),
1999 BPF_ALU32_IMM(BPF_MOV, R3, 3),
2000 BPF_ALU32_IMM(BPF_MOV, R4, 4),
2001 BPF_ALU32_IMM(BPF_MOV, R5, 5),
2002 BPF_ALU32_IMM(BPF_MOV, R6, 6),
2003 BPF_ALU32_IMM(BPF_MOV, R7, 7),
2004 BPF_ALU32_IMM(BPF_MOV, R8, 8),
2005 BPF_ALU32_IMM(BPF_MOV, R9, 9),
2006 BPF_ALU64_IMM(BPF_DIV, R2, 123456789),
2007 BPF_JMP_IMM(BPF_JNE, R0, 0, 10),
2008 BPF_JMP_IMM(BPF_JNE, R1, 1, 9),
2009 BPF_JMP_IMM(BPF_JNE, R2, 2, 8),
2010 BPF_JMP_IMM(BPF_JNE, R3, 3, 7),
2011 BPF_JMP_IMM(BPF_JNE, R4, 4, 6),
2012 BPF_JMP_IMM(BPF_JNE, R5, 5, 5),
2013 BPF_JMP_IMM(BPF_JNE, R6, 6, 4),
2014 BPF_JMP_IMM(BPF_JNE, R7, 7, 3),
2015 BPF_JMP_IMM(BPF_JNE, R8, 8, 2),
2016 BPF_JMP_IMM(BPF_JNE, R9, 9, 1),
2017 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2026 * Test 32-bit JITs that implement complex ALU64 operations as
2027 * function calls R0 = f(R1, R2), and must re-arrange operands.
2029 #define NUMER 0xfedcba9876543210ULL
2030 #define DENOM 0x0123456789abcdefULL
2031 "ALU64_DIV X: Operand register permutations",
2034 BPF_LD_IMM64(R0, NUMER),
2035 BPF_LD_IMM64(R2, DENOM),
2036 BPF_ALU64_REG(BPF_DIV, R0, R2),
2037 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
2040 BPF_LD_IMM64(R1, NUMER),
2041 BPF_LD_IMM64(R0, DENOM),
2042 BPF_ALU64_REG(BPF_DIV, R1, R0),
2043 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
2046 BPF_LD_IMM64(R0, NUMER),
2047 BPF_LD_IMM64(R1, DENOM),
2048 BPF_ALU64_REG(BPF_DIV, R0, R1),
2049 BPF_JMP_IMM(BPF_JEQ, R0, NUMER / DENOM, 1),
2052 BPF_LD_IMM64(R2, NUMER),
2053 BPF_LD_IMM64(R0, DENOM),
2054 BPF_ALU64_REG(BPF_DIV, R2, R0),
2055 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
2058 BPF_LD_IMM64(R2, NUMER),
2059 BPF_LD_IMM64(R1, DENOM),
2060 BPF_ALU64_REG(BPF_DIV, R2, R1),
2061 BPF_JMP_IMM(BPF_JEQ, R2, NUMER / DENOM, 1),
2064 BPF_LD_IMM64(R1, NUMER),
2065 BPF_LD_IMM64(R2, DENOM),
2066 BPF_ALU64_REG(BPF_DIV, R1, R2),
2067 BPF_JMP_IMM(BPF_JEQ, R1, NUMER / DENOM, 1),
2070 BPF_LD_IMM64(R1, NUMER),
2071 BPF_ALU64_REG(BPF_DIV, R1, R1),
2072 BPF_JMP_IMM(BPF_JEQ, R1, 1, 1),
2075 BPF_LD_IMM64(R2, DENOM),
2076 BPF_ALU64_REG(BPF_DIV, R2, R2),
2077 BPF_JMP_IMM(BPF_JEQ, R2, 1, 1),
2080 BPF_LD_IMM64(R3, NUMER),
2081 BPF_LD_IMM64(R4, DENOM),
2082 BPF_ALU64_REG(BPF_DIV, R3, R4),
2083 BPF_JMP_IMM(BPF_JEQ, R3, NUMER / DENOM, 1),
2085 /* Successful return */
2086 BPF_LD_IMM64(R0, 1),
2097 "INT: 32-bit context pointer word order and zero-extension",
2099 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2100 BPF_JMP32_IMM(BPF_JEQ, R1, 0, 3),
2101 BPF_ALU64_IMM(BPF_RSH, R1, 32),
2102 BPF_JMP32_IMM(BPF_JNE, R1, 0, 1),
2103 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2112 "check: missing ret",
2114 BPF_STMT(BPF_LD | BPF_IMM, 1),
2116 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2119 .fill_helper = NULL,
2120 .expected_errcode = -EINVAL,
2125 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
2126 BPF_STMT(BPF_RET | BPF_K, 0)
2128 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2131 .fill_helper = NULL,
2132 .expected_errcode = -EINVAL,
2135 "check: unknown insn",
2137 /* seccomp insn, rejected in socket filter */
2138 BPF_STMT(BPF_LDX | BPF_W | BPF_ABS, 0),
2139 BPF_STMT(BPF_RET | BPF_K, 0)
2141 CLASSIC | FLAG_EXPECTED_FAIL,
2144 .fill_helper = NULL,
2145 .expected_errcode = -EINVAL,
2148 "check: out of range spill/fill",
2150 BPF_STMT(BPF_STX, 16),
2151 BPF_STMT(BPF_RET | BPF_K, 0)
2153 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2156 .fill_helper = NULL,
2157 .expected_errcode = -EINVAL,
2162 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2163 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 15),
2164 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2165 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2166 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2167 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2168 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2169 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2170 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2171 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2172 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2173 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2174 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2175 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2176 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2177 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 3, 4),
2178 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2179 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90c2894d, 1, 2),
2180 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2181 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2182 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2183 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2184 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2185 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2186 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2187 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2188 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2189 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2190 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2191 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2192 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2193 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2194 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2195 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2196 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 2, 3),
2197 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x2ac28349, 1, 2),
2198 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2199 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 14, 15),
2200 BPF_JUMP(BPF_JMP | BPF_JGE, 0, 13, 14),
2201 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2202 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2203 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2204 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2205 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2206 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2207 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2208 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2209 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2210 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2211 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2212 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2213 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2214 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 2, 3),
2215 BPF_JUMP(BPF_JMP | BPF_JEQ, 0x90d2ff41, 1, 2),
2216 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 0),
2217 BPF_STMT(BPF_RET | BPF_A, 0),
2218 BPF_STMT(BPF_RET | BPF_A, 0),
2221 { 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
2222 0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2224 0x45, 0x00, 0x00, 0x28, 0x00, 0x00,
2225 0x20, 0x00, 0x40, 0x11, 0x00, 0x00, /* IP header */
2226 0xc0, 0xa8, 0x33, 0x01,
2227 0xc0, 0xa8, 0x33, 0x02,
2230 0x00, 0x14, 0x00, 0x00,
2231 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2232 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2233 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2234 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2235 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2236 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2237 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
2238 0xcc, 0xcc, 0xcc, 0xcc },
2244 BPF_STMT(BPF_RET | BPF_X, 0),
2246 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2249 .fill_helper = NULL,
2250 .expected_errcode = -EINVAL,
2253 "check: LDX + RET X",
2255 BPF_STMT(BPF_LDX | BPF_IMM, 42),
2256 BPF_STMT(BPF_RET | BPF_X, 0),
2258 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2261 .fill_helper = NULL,
2262 .expected_errcode = -EINVAL,
2264 { /* Mainly checking JIT here. */
2265 "M[]: alt STX + LDX",
2267 BPF_STMT(BPF_LDX | BPF_IMM, 100),
2268 BPF_STMT(BPF_STX, 0),
2269 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2270 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2271 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2272 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2273 BPF_STMT(BPF_STX, 1),
2274 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2275 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2276 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2277 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2278 BPF_STMT(BPF_STX, 2),
2279 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2280 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2281 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2282 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2283 BPF_STMT(BPF_STX, 3),
2284 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2285 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2286 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2287 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2288 BPF_STMT(BPF_STX, 4),
2289 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2290 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2291 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2292 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2293 BPF_STMT(BPF_STX, 5),
2294 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2295 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2296 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2297 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2298 BPF_STMT(BPF_STX, 6),
2299 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2300 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2301 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2302 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2303 BPF_STMT(BPF_STX, 7),
2304 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2305 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2306 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2307 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2308 BPF_STMT(BPF_STX, 8),
2309 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2310 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2311 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2312 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2313 BPF_STMT(BPF_STX, 9),
2314 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2315 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2316 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2317 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2318 BPF_STMT(BPF_STX, 10),
2319 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2320 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2321 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2322 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2323 BPF_STMT(BPF_STX, 11),
2324 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2325 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2326 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2327 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2328 BPF_STMT(BPF_STX, 12),
2329 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2330 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2331 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2332 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2333 BPF_STMT(BPF_STX, 13),
2334 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2335 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2336 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2337 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2338 BPF_STMT(BPF_STX, 14),
2339 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2340 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2341 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2342 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2343 BPF_STMT(BPF_STX, 15),
2344 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2345 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2346 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 1),
2347 BPF_STMT(BPF_MISC | BPF_TAX, 0),
2348 BPF_STMT(BPF_RET | BPF_A, 0),
2350 CLASSIC | FLAG_NO_DATA,
2354 { /* Mainly checking JIT here. */
2355 "M[]: full STX + full LDX",
2357 BPF_STMT(BPF_LDX | BPF_IMM, 0xbadfeedb),
2358 BPF_STMT(BPF_STX, 0),
2359 BPF_STMT(BPF_LDX | BPF_IMM, 0xecabedae),
2360 BPF_STMT(BPF_STX, 1),
2361 BPF_STMT(BPF_LDX | BPF_IMM, 0xafccfeaf),
2362 BPF_STMT(BPF_STX, 2),
2363 BPF_STMT(BPF_LDX | BPF_IMM, 0xbffdcedc),
2364 BPF_STMT(BPF_STX, 3),
2365 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbbbdccb),
2366 BPF_STMT(BPF_STX, 4),
2367 BPF_STMT(BPF_LDX | BPF_IMM, 0xfbabcbda),
2368 BPF_STMT(BPF_STX, 5),
2369 BPF_STMT(BPF_LDX | BPF_IMM, 0xaedecbdb),
2370 BPF_STMT(BPF_STX, 6),
2371 BPF_STMT(BPF_LDX | BPF_IMM, 0xadebbade),
2372 BPF_STMT(BPF_STX, 7),
2373 BPF_STMT(BPF_LDX | BPF_IMM, 0xfcfcfaec),
2374 BPF_STMT(BPF_STX, 8),
2375 BPF_STMT(BPF_LDX | BPF_IMM, 0xbcdddbdc),
2376 BPF_STMT(BPF_STX, 9),
2377 BPF_STMT(BPF_LDX | BPF_IMM, 0xfeefdfac),
2378 BPF_STMT(BPF_STX, 10),
2379 BPF_STMT(BPF_LDX | BPF_IMM, 0xcddcdeea),
2380 BPF_STMT(BPF_STX, 11),
2381 BPF_STMT(BPF_LDX | BPF_IMM, 0xaccfaebb),
2382 BPF_STMT(BPF_STX, 12),
2383 BPF_STMT(BPF_LDX | BPF_IMM, 0xbdcccdcf),
2384 BPF_STMT(BPF_STX, 13),
2385 BPF_STMT(BPF_LDX | BPF_IMM, 0xaaedecde),
2386 BPF_STMT(BPF_STX, 14),
2387 BPF_STMT(BPF_LDX | BPF_IMM, 0xfaeacdad),
2388 BPF_STMT(BPF_STX, 15),
2389 BPF_STMT(BPF_LDX | BPF_MEM, 0),
2390 BPF_STMT(BPF_MISC | BPF_TXA, 0),
2391 BPF_STMT(BPF_LDX | BPF_MEM, 1),
2392 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2393 BPF_STMT(BPF_LDX | BPF_MEM, 2),
2394 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2395 BPF_STMT(BPF_LDX | BPF_MEM, 3),
2396 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2397 BPF_STMT(BPF_LDX | BPF_MEM, 4),
2398 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2399 BPF_STMT(BPF_LDX | BPF_MEM, 5),
2400 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2401 BPF_STMT(BPF_LDX | BPF_MEM, 6),
2402 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2403 BPF_STMT(BPF_LDX | BPF_MEM, 7),
2404 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2405 BPF_STMT(BPF_LDX | BPF_MEM, 8),
2406 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2407 BPF_STMT(BPF_LDX | BPF_MEM, 9),
2408 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2409 BPF_STMT(BPF_LDX | BPF_MEM, 10),
2410 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2411 BPF_STMT(BPF_LDX | BPF_MEM, 11),
2412 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2413 BPF_STMT(BPF_LDX | BPF_MEM, 12),
2414 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2415 BPF_STMT(BPF_LDX | BPF_MEM, 13),
2416 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2417 BPF_STMT(BPF_LDX | BPF_MEM, 14),
2418 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2419 BPF_STMT(BPF_LDX | BPF_MEM, 15),
2420 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
2421 BPF_STMT(BPF_RET | BPF_A, 0),
2423 CLASSIC | FLAG_NO_DATA,
2425 { { 0, 0x2a5a5e5 } },
2428 "check: SKF_AD_MAX",
2430 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2431 SKF_AD_OFF + SKF_AD_MAX),
2432 BPF_STMT(BPF_RET | BPF_A, 0),
2434 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2437 .fill_helper = NULL,
2438 .expected_errcode = -EINVAL,
2440 { /* Passes checker but fails during runtime. */
2441 "LD [SKF_AD_OFF-1]",
2443 BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2445 BPF_STMT(BPF_RET | BPF_K, 1),
2452 "load 64-bit immediate",
2454 BPF_LD_IMM64(R1, 0x567800001234LL),
2455 BPF_MOV64_REG(R2, R1),
2456 BPF_MOV64_REG(R3, R2),
2457 BPF_ALU64_IMM(BPF_RSH, R2, 32),
2458 BPF_ALU64_IMM(BPF_LSH, R3, 32),
2459 BPF_ALU64_IMM(BPF_RSH, R3, 32),
2460 BPF_ALU64_IMM(BPF_MOV, R0, 0),
2461 BPF_JMP_IMM(BPF_JEQ, R2, 0x5678, 1),
2463 BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2465 BPF_LD_IMM64(R0, 0x1ffffffffLL),
2466 BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
2473 /* BPF_ALU | BPF_MOV | BPF_X */
2475 "ALU_MOV_X: dst = 2",
2477 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2478 BPF_ALU32_REG(BPF_MOV, R0, R1),
2486 "ALU_MOV_X: dst = 4294967295",
2488 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2489 BPF_ALU32_REG(BPF_MOV, R0, R1),
2494 { { 0, 4294967295U } },
2497 "ALU64_MOV_X: dst = 2",
2499 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2500 BPF_ALU64_REG(BPF_MOV, R0, R1),
2508 "ALU64_MOV_X: dst = 4294967295",
2510 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2511 BPF_ALU64_REG(BPF_MOV, R0, R1),
2516 { { 0, 4294967295U } },
2518 /* BPF_ALU | BPF_MOV | BPF_K */
2520 "ALU_MOV_K: dst = 2",
2522 BPF_ALU32_IMM(BPF_MOV, R0, 2),
2530 "ALU_MOV_K: dst = 4294967295",
2532 BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
2537 { { 0, 4294967295U } },
2540 "ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2542 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2543 BPF_LD_IMM64(R3, 0x00000000ffffffffLL),
2544 BPF_ALU32_IMM(BPF_MOV, R2, 0xffffffff),
2545 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2546 BPF_MOV32_IMM(R0, 2),
2548 BPF_MOV32_IMM(R0, 1),
2556 "ALU_MOV_K: small negative",
2558 BPF_ALU32_IMM(BPF_MOV, R0, -123),
2566 "ALU_MOV_K: small negative zero extension",
2568 BPF_ALU32_IMM(BPF_MOV, R0, -123),
2569 BPF_ALU64_IMM(BPF_RSH, R0, 32),
2577 "ALU_MOV_K: large negative",
2579 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2584 { { 0, -123456789 } }
2587 "ALU_MOV_K: large negative zero extension",
2589 BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2590 BPF_ALU64_IMM(BPF_RSH, R0, 32),
2598 "ALU64_MOV_K: dst = 2",
2600 BPF_ALU64_IMM(BPF_MOV, R0, 2),
2608 "ALU64_MOV_K: dst = 2147483647",
2610 BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2615 { { 0, 2147483647 } },
2618 "ALU64_OR_K: dst = 0x0",
2620 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2621 BPF_LD_IMM64(R3, 0x0),
2622 BPF_ALU64_IMM(BPF_MOV, R2, 0x0),
2623 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2624 BPF_MOV32_IMM(R0, 2),
2626 BPF_MOV32_IMM(R0, 1),
2634 "ALU64_MOV_K: dst = -1",
2636 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
2637 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2638 BPF_ALU64_IMM(BPF_MOV, R2, 0xffffffff),
2639 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2640 BPF_MOV32_IMM(R0, 2),
2642 BPF_MOV32_IMM(R0, 1),
2650 "ALU64_MOV_K: small negative",
2652 BPF_ALU64_IMM(BPF_MOV, R0, -123),
2660 "ALU64_MOV_K: small negative sign extension",
2662 BPF_ALU64_IMM(BPF_MOV, R0, -123),
2663 BPF_ALU64_IMM(BPF_RSH, R0, 32),
2668 { { 0, 0xffffffff } }
2671 "ALU64_MOV_K: large negative",
2673 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2678 { { 0, -123456789 } }
2681 "ALU64_MOV_K: large negative sign extension",
2683 BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2684 BPF_ALU64_IMM(BPF_RSH, R0, 32),
2689 { { 0, 0xffffffff } }
2691 /* BPF_ALU | BPF_ADD | BPF_X */
2693 "ALU_ADD_X: 1 + 2 = 3",
2695 BPF_LD_IMM64(R0, 1),
2696 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2697 BPF_ALU32_REG(BPF_ADD, R0, R1),
2705 "ALU_ADD_X: 1 + 4294967294 = 4294967295",
2707 BPF_LD_IMM64(R0, 1),
2708 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2709 BPF_ALU32_REG(BPF_ADD, R0, R1),
2714 { { 0, 4294967295U } },
2717 "ALU_ADD_X: 2 + 4294967294 = 0",
2719 BPF_LD_IMM64(R0, 2),
2720 BPF_LD_IMM64(R1, 4294967294U),
2721 BPF_ALU32_REG(BPF_ADD, R0, R1),
2722 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2723 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2725 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2733 "ALU64_ADD_X: 1 + 2 = 3",
2735 BPF_LD_IMM64(R0, 1),
2736 BPF_ALU32_IMM(BPF_MOV, R1, 2),
2737 BPF_ALU64_REG(BPF_ADD, R0, R1),
2745 "ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2747 BPF_LD_IMM64(R0, 1),
2748 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2749 BPF_ALU64_REG(BPF_ADD, R0, R1),
2754 { { 0, 4294967295U } },
2757 "ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2759 BPF_LD_IMM64(R0, 2),
2760 BPF_LD_IMM64(R1, 4294967294U),
2761 BPF_LD_IMM64(R2, 4294967296ULL),
2762 BPF_ALU64_REG(BPF_ADD, R0, R1),
2763 BPF_JMP_REG(BPF_JEQ, R0, R2, 2),
2764 BPF_MOV32_IMM(R0, 0),
2766 BPF_MOV32_IMM(R0, 1),
2773 /* BPF_ALU | BPF_ADD | BPF_K */
2775 "ALU_ADD_K: 1 + 2 = 3",
2777 BPF_LD_IMM64(R0, 1),
2778 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2786 "ALU_ADD_K: 3 + 0 = 3",
2788 BPF_LD_IMM64(R0, 3),
2789 BPF_ALU32_IMM(BPF_ADD, R0, 0),
2797 "ALU_ADD_K: 1 + 4294967294 = 4294967295",
2799 BPF_LD_IMM64(R0, 1),
2800 BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
2805 { { 0, 4294967295U } },
2808 "ALU_ADD_K: 4294967294 + 2 = 0",
2810 BPF_LD_IMM64(R0, 4294967294U),
2811 BPF_ALU32_IMM(BPF_ADD, R0, 2),
2812 BPF_JMP_IMM(BPF_JEQ, R0, 0, 2),
2813 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2815 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2823 "ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2825 BPF_LD_IMM64(R2, 0x0),
2826 BPF_LD_IMM64(R3, 0x00000000ffffffff),
2827 BPF_ALU32_IMM(BPF_ADD, R2, 0xffffffff),
2828 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2829 BPF_MOV32_IMM(R0, 2),
2831 BPF_MOV32_IMM(R0, 1),
2839 "ALU_ADD_K: 0 + 0xffff = 0xffff",
2841 BPF_LD_IMM64(R2, 0x0),
2842 BPF_LD_IMM64(R3, 0xffff),
2843 BPF_ALU32_IMM(BPF_ADD, R2, 0xffff),
2844 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2845 BPF_MOV32_IMM(R0, 2),
2847 BPF_MOV32_IMM(R0, 1),
2855 "ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2857 BPF_LD_IMM64(R2, 0x0),
2858 BPF_LD_IMM64(R3, 0x7fffffff),
2859 BPF_ALU32_IMM(BPF_ADD, R2, 0x7fffffff),
2860 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2861 BPF_MOV32_IMM(R0, 2),
2863 BPF_MOV32_IMM(R0, 1),
2871 "ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
2873 BPF_LD_IMM64(R2, 0x0),
2874 BPF_LD_IMM64(R3, 0x80000000),
2875 BPF_ALU32_IMM(BPF_ADD, R2, 0x80000000),
2876 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2877 BPF_MOV32_IMM(R0, 2),
2879 BPF_MOV32_IMM(R0, 1),
2887 "ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2889 BPF_LD_IMM64(R2, 0x0),
2890 BPF_LD_IMM64(R3, 0x80008000),
2891 BPF_ALU32_IMM(BPF_ADD, R2, 0x80008000),
2892 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2893 BPF_MOV32_IMM(R0, 2),
2895 BPF_MOV32_IMM(R0, 1),
2903 "ALU64_ADD_K: 1 + 2 = 3",
2905 BPF_LD_IMM64(R0, 1),
2906 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2914 "ALU64_ADD_K: 3 + 0 = 3",
2916 BPF_LD_IMM64(R0, 3),
2917 BPF_ALU64_IMM(BPF_ADD, R0, 0),
2925 "ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2927 BPF_LD_IMM64(R0, 1),
2928 BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2933 { { 0, 2147483647 } },
2936 "ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2938 BPF_LD_IMM64(R0, 4294967294U),
2939 BPF_LD_IMM64(R1, 4294967296ULL),
2940 BPF_ALU64_IMM(BPF_ADD, R0, 2),
2941 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
2942 BPF_ALU32_IMM(BPF_MOV, R0, 0),
2944 BPF_ALU32_IMM(BPF_MOV, R0, 1),
2952 "ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2954 BPF_LD_IMM64(R0, 2147483646),
2955 BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2963 "ALU64_ADD_K: 1 + 0 = 1",
2965 BPF_LD_IMM64(R2, 0x1),
2966 BPF_LD_IMM64(R3, 0x1),
2967 BPF_ALU64_IMM(BPF_ADD, R2, 0x0),
2968 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2969 BPF_MOV32_IMM(R0, 2),
2971 BPF_MOV32_IMM(R0, 1),
2979 "ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2981 BPF_LD_IMM64(R2, 0x0),
2982 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
2983 BPF_ALU64_IMM(BPF_ADD, R2, 0xffffffff),
2984 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
2985 BPF_MOV32_IMM(R0, 2),
2987 BPF_MOV32_IMM(R0, 1),
2995 "ALU64_ADD_K: 0 + 0xffff = 0xffff",
2997 BPF_LD_IMM64(R2, 0x0),
2998 BPF_LD_IMM64(R3, 0xffff),
2999 BPF_ALU64_IMM(BPF_ADD, R2, 0xffff),
3000 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3001 BPF_MOV32_IMM(R0, 2),
3003 BPF_MOV32_IMM(R0, 1),
3011 "ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
3013 BPF_LD_IMM64(R2, 0x0),
3014 BPF_LD_IMM64(R3, 0x7fffffff),
3015 BPF_ALU64_IMM(BPF_ADD, R2, 0x7fffffff),
3016 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3017 BPF_MOV32_IMM(R0, 2),
3019 BPF_MOV32_IMM(R0, 1),
3027 "ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
3029 BPF_LD_IMM64(R2, 0x0),
3030 BPF_LD_IMM64(R3, 0xffffffff80000000LL),
3031 BPF_ALU64_IMM(BPF_ADD, R2, 0x80000000),
3032 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3033 BPF_MOV32_IMM(R0, 2),
3035 BPF_MOV32_IMM(R0, 1),
3043 "ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
3045 BPF_LD_IMM64(R2, 0x0),
3046 BPF_LD_IMM64(R3, 0xffffffff80008000LL),
3047 BPF_ALU64_IMM(BPF_ADD, R2, 0x80008000),
3048 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3049 BPF_MOV32_IMM(R0, 2),
3051 BPF_MOV32_IMM(R0, 1),
3058 /* BPF_ALU | BPF_SUB | BPF_X */
3060 "ALU_SUB_X: 3 - 1 = 2",
3062 BPF_LD_IMM64(R0, 3),
3063 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3064 BPF_ALU32_REG(BPF_SUB, R0, R1),
3072 "ALU_SUB_X: 4294967295 - 4294967294 = 1",
3074 BPF_LD_IMM64(R0, 4294967295U),
3075 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
3076 BPF_ALU32_REG(BPF_SUB, R0, R1),
3084 "ALU64_SUB_X: 3 - 1 = 2",
3086 BPF_LD_IMM64(R0, 3),
3087 BPF_ALU32_IMM(BPF_MOV, R1, 1),
3088 BPF_ALU64_REG(BPF_SUB, R0, R1),
3096 "ALU64_SUB_X: 4294967295 - 4294967294 = 1",
3098 BPF_LD_IMM64(R0, 4294967295U),
3099 BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
3100 BPF_ALU64_REG(BPF_SUB, R0, R1),
3107 /* BPF_ALU | BPF_SUB | BPF_K */
3109 "ALU_SUB_K: 3 - 1 = 2",
3111 BPF_LD_IMM64(R0, 3),
3112 BPF_ALU32_IMM(BPF_SUB, R0, 1),
3120 "ALU_SUB_K: 3 - 0 = 3",
3122 BPF_LD_IMM64(R0, 3),
3123 BPF_ALU32_IMM(BPF_SUB, R0, 0),
3131 "ALU_SUB_K: 4294967295 - 4294967294 = 1",
3133 BPF_LD_IMM64(R0, 4294967295U),
3134 BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
3142 "ALU64_SUB_K: 3 - 1 = 2",
3144 BPF_LD_IMM64(R0, 3),
3145 BPF_ALU64_IMM(BPF_SUB, R0, 1),
3153 "ALU64_SUB_K: 3 - 0 = 3",
3155 BPF_LD_IMM64(R0, 3),
3156 BPF_ALU64_IMM(BPF_SUB, R0, 0),
3164 "ALU64_SUB_K: 4294967294 - 4294967295 = -1",
3166 BPF_LD_IMM64(R0, 4294967294U),
3167 BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
3175 "ALU64_ADD_K: 2147483646 - 2147483647 = -1",
3177 BPF_LD_IMM64(R0, 2147483646),
3178 BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
3185 /* BPF_ALU | BPF_MUL | BPF_X */
3187 "ALU_MUL_X: 2 * 3 = 6",
3189 BPF_LD_IMM64(R0, 2),
3190 BPF_ALU32_IMM(BPF_MOV, R1, 3),
3191 BPF_ALU32_REG(BPF_MUL, R0, R1),
3199 "ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3201 BPF_LD_IMM64(R0, 2),
3202 BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
3203 BPF_ALU32_REG(BPF_MUL, R0, R1),
3208 { { 0, 0xFFFFFFF0 } },
3211 "ALU_MUL_X: -1 * -1 = 1",
3213 BPF_LD_IMM64(R0, -1),
3214 BPF_ALU32_IMM(BPF_MOV, R1, -1),
3215 BPF_ALU32_REG(BPF_MUL, R0, R1),
3223 "ALU64_MUL_X: 2 * 3 = 6",
3225 BPF_LD_IMM64(R0, 2),
3226 BPF_ALU32_IMM(BPF_MOV, R1, 3),
3227 BPF_ALU64_REG(BPF_MUL, R0, R1),
3235 "ALU64_MUL_X: 1 * 2147483647 = 2147483647",
3237 BPF_LD_IMM64(R0, 1),
3238 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3239 BPF_ALU64_REG(BPF_MUL, R0, R1),
3244 { { 0, 2147483647 } },
3247 "ALU64_MUL_X: 64x64 multiply, low word",
3249 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
3250 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
3251 BPF_ALU64_REG(BPF_MUL, R0, R1),
3256 { { 0, 0xe5618cf0 } }
3259 "ALU64_MUL_X: 64x64 multiply, high word",
3261 BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
3262 BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
3263 BPF_ALU64_REG(BPF_MUL, R0, R1),
3264 BPF_ALU64_IMM(BPF_RSH, R0, 32),
3269 { { 0, 0x2236d88f } }
3271 /* BPF_ALU | BPF_MUL | BPF_K */
3273 "ALU_MUL_K: 2 * 3 = 6",
3275 BPF_LD_IMM64(R0, 2),
3276 BPF_ALU32_IMM(BPF_MUL, R0, 3),
3284 "ALU_MUL_K: 3 * 1 = 3",
3286 BPF_LD_IMM64(R0, 3),
3287 BPF_ALU32_IMM(BPF_MUL, R0, 1),
3295 "ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3297 BPF_LD_IMM64(R0, 2),
3298 BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
3303 { { 0, 0xFFFFFFF0 } },
3306 "ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
3308 BPF_LD_IMM64(R2, 0x1),
3309 BPF_LD_IMM64(R3, 0x00000000ffffffff),
3310 BPF_ALU32_IMM(BPF_MUL, R2, 0xffffffff),
3311 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3312 BPF_MOV32_IMM(R0, 2),
3314 BPF_MOV32_IMM(R0, 1),
3322 "ALU64_MUL_K: 2 * 3 = 6",
3324 BPF_LD_IMM64(R0, 2),
3325 BPF_ALU64_IMM(BPF_MUL, R0, 3),
3333 "ALU64_MUL_K: 3 * 1 = 3",
3335 BPF_LD_IMM64(R0, 3),
3336 BPF_ALU64_IMM(BPF_MUL, R0, 1),
3344 "ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3346 BPF_LD_IMM64(R0, 1),
3347 BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
3352 { { 0, 2147483647 } },
3355 "ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3357 BPF_LD_IMM64(R0, 1),
3358 BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
3363 { { 0, -2147483647 } },
3366 "ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3368 BPF_LD_IMM64(R2, 0x1),
3369 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3370 BPF_ALU64_IMM(BPF_MUL, R2, 0xffffffff),
3371 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3372 BPF_MOV32_IMM(R0, 2),
3374 BPF_MOV32_IMM(R0, 1),
3382 "ALU64_MUL_K: 64x32 multiply, low word",
3384 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3385 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
3390 { { 0, 0xe242d208 } }
3393 "ALU64_MUL_K: 64x32 multiply, high word",
3395 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3396 BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
3397 BPF_ALU64_IMM(BPF_RSH, R0, 32),
3402 { { 0, 0xc28f5c28 } }
3404 /* BPF_ALU | BPF_DIV | BPF_X */
3406 "ALU_DIV_X: 6 / 2 = 3",
3408 BPF_LD_IMM64(R0, 6),
3409 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3410 BPF_ALU32_REG(BPF_DIV, R0, R1),
3418 "ALU_DIV_X: 4294967295 / 4294967295 = 1",
3420 BPF_LD_IMM64(R0, 4294967295U),
3421 BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
3422 BPF_ALU32_REG(BPF_DIV, R0, R1),
3430 "ALU64_DIV_X: 6 / 2 = 3",
3432 BPF_LD_IMM64(R0, 6),
3433 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3434 BPF_ALU64_REG(BPF_DIV, R0, R1),
3442 "ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3444 BPF_LD_IMM64(R0, 2147483647),
3445 BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3446 BPF_ALU64_REG(BPF_DIV, R0, R1),
3454 "ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3456 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3457 BPF_LD_IMM64(R4, 0xffffffffffffffffLL),
3458 BPF_LD_IMM64(R3, 0x0000000000000001LL),
3459 BPF_ALU64_REG(BPF_DIV, R2, R4),
3460 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3461 BPF_MOV32_IMM(R0, 2),
3463 BPF_MOV32_IMM(R0, 1),
3470 /* BPF_ALU | BPF_DIV | BPF_K */
3472 "ALU_DIV_K: 6 / 2 = 3",
3474 BPF_LD_IMM64(R0, 6),
3475 BPF_ALU32_IMM(BPF_DIV, R0, 2),
3483 "ALU_DIV_K: 3 / 1 = 3",
3485 BPF_LD_IMM64(R0, 3),
3486 BPF_ALU32_IMM(BPF_DIV, R0, 1),
3494 "ALU_DIV_K: 4294967295 / 4294967295 = 1",
3496 BPF_LD_IMM64(R0, 4294967295U),
3497 BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
3505 "ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3507 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3508 BPF_LD_IMM64(R3, 0x1UL),
3509 BPF_ALU32_IMM(BPF_DIV, R2, 0xffffffff),
3510 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3511 BPF_MOV32_IMM(R0, 2),
3513 BPF_MOV32_IMM(R0, 1),
3521 "ALU64_DIV_K: 6 / 2 = 3",
3523 BPF_LD_IMM64(R0, 6),
3524 BPF_ALU64_IMM(BPF_DIV, R0, 2),
3532 "ALU64_DIV_K: 3 / 1 = 3",
3534 BPF_LD_IMM64(R0, 3),
3535 BPF_ALU64_IMM(BPF_DIV, R0, 1),
3543 "ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3545 BPF_LD_IMM64(R0, 2147483647),
3546 BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3554 "ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3556 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3557 BPF_LD_IMM64(R3, 0x0000000000000001LL),
3558 BPF_ALU64_IMM(BPF_DIV, R2, 0xffffffff),
3559 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3560 BPF_MOV32_IMM(R0, 2),
3562 BPF_MOV32_IMM(R0, 1),
3569 /* BPF_ALU | BPF_MOD | BPF_X */
3571 "ALU_MOD_X: 3 % 2 = 1",
3573 BPF_LD_IMM64(R0, 3),
3574 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3575 BPF_ALU32_REG(BPF_MOD, R0, R1),
3583 "ALU_MOD_X: 4294967295 % 4294967293 = 2",
3585 BPF_LD_IMM64(R0, 4294967295U),
3586 BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
3587 BPF_ALU32_REG(BPF_MOD, R0, R1),
3595 "ALU64_MOD_X: 3 % 2 = 1",
3597 BPF_LD_IMM64(R0, 3),
3598 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3599 BPF_ALU64_REG(BPF_MOD, R0, R1),
3607 "ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3609 BPF_LD_IMM64(R0, 2147483647),
3610 BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3611 BPF_ALU64_REG(BPF_MOD, R0, R1),
3618 /* BPF_ALU | BPF_MOD | BPF_K */
3620 "ALU_MOD_K: 3 % 2 = 1",
3622 BPF_LD_IMM64(R0, 3),
3623 BPF_ALU32_IMM(BPF_MOD, R0, 2),
3631 "ALU_MOD_K: 3 % 1 = 0",
3633 BPF_LD_IMM64(R0, 3),
3634 BPF_ALU32_IMM(BPF_MOD, R0, 1),
3642 "ALU_MOD_K: 4294967295 % 4294967293 = 2",
3644 BPF_LD_IMM64(R0, 4294967295U),
3645 BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
3653 "ALU64_MOD_K: 3 % 2 = 1",
3655 BPF_LD_IMM64(R0, 3),
3656 BPF_ALU64_IMM(BPF_MOD, R0, 2),
3664 "ALU64_MOD_K: 3 % 1 = 0",
3666 BPF_LD_IMM64(R0, 3),
3667 BPF_ALU64_IMM(BPF_MOD, R0, 1),
3675 "ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3677 BPF_LD_IMM64(R0, 2147483647),
3678 BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3685 /* BPF_ALU | BPF_AND | BPF_X */
3687 "ALU_AND_X: 3 & 2 = 2",
3689 BPF_LD_IMM64(R0, 3),
3690 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3691 BPF_ALU32_REG(BPF_AND, R0, R1),
3699 "ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3701 BPF_LD_IMM64(R0, 0xffffffff),
3702 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3703 BPF_ALU32_REG(BPF_AND, R0, R1),
3708 { { 0, 0xffffffff } },
3711 "ALU64_AND_X: 3 & 2 = 2",
3713 BPF_LD_IMM64(R0, 3),
3714 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3715 BPF_ALU64_REG(BPF_AND, R0, R1),
3723 "ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3725 BPF_LD_IMM64(R0, 0xffffffff),
3726 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3727 BPF_ALU64_REG(BPF_AND, R0, R1),
3732 { { 0, 0xffffffff } },
3734 /* BPF_ALU | BPF_AND | BPF_K */
3736 "ALU_AND_K: 3 & 2 = 2",
3738 BPF_LD_IMM64(R0, 3),
3739 BPF_ALU32_IMM(BPF_AND, R0, 2),
3747 "ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3749 BPF_LD_IMM64(R0, 0xffffffff),
3750 BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3755 { { 0, 0xffffffff } },
3758 "ALU_AND_K: Small immediate",
3760 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3761 BPF_ALU32_IMM(BPF_AND, R0, 15),
3769 "ALU_AND_K: Large immediate",
3771 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
3772 BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
3777 { { 0, 0xa1b2c3d4 } }
3780 "ALU_AND_K: Zero extension",
3782 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3783 BPF_LD_IMM64(R1, 0x0000000080a0c0e0LL),
3784 BPF_ALU32_IMM(BPF_AND, R0, 0xf0f0f0f0),
3785 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3786 BPF_MOV32_IMM(R0, 2),
3788 BPF_MOV32_IMM(R0, 1),
3796 "ALU64_AND_K: 3 & 2 = 2",
3798 BPF_LD_IMM64(R0, 3),
3799 BPF_ALU64_IMM(BPF_AND, R0, 2),
3807 "ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3809 BPF_LD_IMM64(R0, 0xffffffff),
3810 BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3815 { { 0, 0xffffffff } },
3818 "ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
3820 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3821 BPF_LD_IMM64(R3, 0x0000000000000000LL),
3822 BPF_ALU64_IMM(BPF_AND, R2, 0x0),
3823 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3824 BPF_MOV32_IMM(R0, 2),
3826 BPF_MOV32_IMM(R0, 1),
3834 "ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
3836 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
3837 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
3838 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3839 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3840 BPF_MOV32_IMM(R0, 2),
3842 BPF_MOV32_IMM(R0, 1),
3850 "ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3852 BPF_LD_IMM64(R2, 0xffffffffffffffffLL),
3853 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
3854 BPF_ALU64_IMM(BPF_AND, R2, 0xffffffff),
3855 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
3856 BPF_MOV32_IMM(R0, 2),
3858 BPF_MOV32_IMM(R0, 1),
3866 "ALU64_AND_K: Sign extension 1",
3868 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3869 BPF_LD_IMM64(R1, 0x00000000090b0d0fLL),
3870 BPF_ALU64_IMM(BPF_AND, R0, 0x0f0f0f0f),
3871 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3872 BPF_MOV32_IMM(R0, 2),
3874 BPF_MOV32_IMM(R0, 1),
3882 "ALU64_AND_K: Sign extension 2",
3884 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3885 BPF_LD_IMM64(R1, 0x0123456780a0c0e0LL),
3886 BPF_ALU64_IMM(BPF_AND, R0, 0xf0f0f0f0),
3887 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3888 BPF_MOV32_IMM(R0, 2),
3890 BPF_MOV32_IMM(R0, 1),
3897 /* BPF_ALU | BPF_OR | BPF_X */
3899 "ALU_OR_X: 1 | 2 = 3",
3901 BPF_LD_IMM64(R0, 1),
3902 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3903 BPF_ALU32_REG(BPF_OR, R0, R1),
3911 "ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3913 BPF_LD_IMM64(R0, 0),
3914 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3915 BPF_ALU32_REG(BPF_OR, R0, R1),
3920 { { 0, 0xffffffff } },
3923 "ALU64_OR_X: 1 | 2 = 3",
3925 BPF_LD_IMM64(R0, 1),
3926 BPF_ALU32_IMM(BPF_MOV, R1, 2),
3927 BPF_ALU64_REG(BPF_OR, R0, R1),
3935 "ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3937 BPF_LD_IMM64(R0, 0),
3938 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3939 BPF_ALU64_REG(BPF_OR, R0, R1),
3944 { { 0, 0xffffffff } },
3946 /* BPF_ALU | BPF_OR | BPF_K */
3948 "ALU_OR_K: 1 | 2 = 3",
3950 BPF_LD_IMM64(R0, 1),
3951 BPF_ALU32_IMM(BPF_OR, R0, 2),
3959 "ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3961 BPF_LD_IMM64(R0, 0),
3962 BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3967 { { 0, 0xffffffff } },
3970 "ALU_OR_K: Small immediate",
3972 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3973 BPF_ALU32_IMM(BPF_OR, R0, 1),
3978 { { 0, 0x01020305 } }
3981 "ALU_OR_K: Large immediate",
3983 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3984 BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
3989 { { 0, 0xa1b2c3d4 } }
3992 "ALU_OR_K: Zero extension",
3994 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3995 BPF_LD_IMM64(R1, 0x00000000f9fbfdffLL),
3996 BPF_ALU32_IMM(BPF_OR, R0, 0xf0f0f0f0),
3997 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
3998 BPF_MOV32_IMM(R0, 2),
4000 BPF_MOV32_IMM(R0, 1),
4008 "ALU64_OR_K: 1 | 2 = 3",
4010 BPF_LD_IMM64(R0, 1),
4011 BPF_ALU64_IMM(BPF_OR, R0, 2),
4019 "ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
4021 BPF_LD_IMM64(R0, 0),
4022 BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
4027 { { 0, 0xffffffff } },
4030 "ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
4032 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4033 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
4034 BPF_ALU64_IMM(BPF_OR, R2, 0x0),
4035 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4036 BPF_MOV32_IMM(R0, 2),
4038 BPF_MOV32_IMM(R0, 1),
4046 "ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
4048 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4049 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4050 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
4051 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4052 BPF_MOV32_IMM(R0, 2),
4054 BPF_MOV32_IMM(R0, 1),
4062 "ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
4064 BPF_LD_IMM64(R2, 0x0000000000000000LL),
4065 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4066 BPF_ALU64_IMM(BPF_OR, R2, 0xffffffff),
4067 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4068 BPF_MOV32_IMM(R0, 2),
4070 BPF_MOV32_IMM(R0, 1),
4078 "ALU64_OR_K: Sign extension 1",
4080 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4081 BPF_LD_IMM64(R1, 0x012345678fafcfefLL),
4082 BPF_ALU64_IMM(BPF_OR, R0, 0x0f0f0f0f),
4083 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4084 BPF_MOV32_IMM(R0, 2),
4086 BPF_MOV32_IMM(R0, 1),
4094 "ALU64_OR_K: Sign extension 2",
4096 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4097 BPF_LD_IMM64(R1, 0xfffffffff9fbfdffLL),
4098 BPF_ALU64_IMM(BPF_OR, R0, 0xf0f0f0f0),
4099 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4100 BPF_MOV32_IMM(R0, 2),
4102 BPF_MOV32_IMM(R0, 1),
4109 /* BPF_ALU | BPF_XOR | BPF_X */
4111 "ALU_XOR_X: 5 ^ 6 = 3",
4113 BPF_LD_IMM64(R0, 5),
4114 BPF_ALU32_IMM(BPF_MOV, R1, 6),
4115 BPF_ALU32_REG(BPF_XOR, R0, R1),
4123 "ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
4125 BPF_LD_IMM64(R0, 1),
4126 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
4127 BPF_ALU32_REG(BPF_XOR, R0, R1),
4132 { { 0, 0xfffffffe } },
4135 "ALU64_XOR_X: 5 ^ 6 = 3",
4137 BPF_LD_IMM64(R0, 5),
4138 BPF_ALU32_IMM(BPF_MOV, R1, 6),
4139 BPF_ALU64_REG(BPF_XOR, R0, R1),
4147 "ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
4149 BPF_LD_IMM64(R0, 1),
4150 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
4151 BPF_ALU64_REG(BPF_XOR, R0, R1),
4156 { { 0, 0xfffffffe } },
4158 /* BPF_ALU | BPF_XOR | BPF_K */
4160 "ALU_XOR_K: 5 ^ 6 = 3",
4162 BPF_LD_IMM64(R0, 5),
4163 BPF_ALU32_IMM(BPF_XOR, R0, 6),
4171 "ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
4173 BPF_LD_IMM64(R0, 1),
4174 BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
4179 { { 0, 0xfffffffe } },
4182 "ALU_XOR_K: Small immediate",
4184 BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
4185 BPF_ALU32_IMM(BPF_XOR, R0, 15),
4190 { { 0, 0x0102030b } }
4193 "ALU_XOR_K: Large immediate",
4195 BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
4196 BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
4201 { { 0, 0x5e4d3c2b } }
4204 "ALU_XOR_K: Zero extension",
4206 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4207 BPF_LD_IMM64(R1, 0x00000000795b3d1fLL),
4208 BPF_ALU32_IMM(BPF_XOR, R0, 0xf0f0f0f0),
4209 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4210 BPF_MOV32_IMM(R0, 2),
4212 BPF_MOV32_IMM(R0, 1),
4220 "ALU64_XOR_K: 5 ^ 6 = 3",
4222 BPF_LD_IMM64(R0, 5),
4223 BPF_ALU64_IMM(BPF_XOR, R0, 6),
4231 "ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
4233 BPF_LD_IMM64(R0, 1),
4234 BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
4239 { { 0, 0xfffffffe } },
4242 "ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
4244 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4245 BPF_LD_IMM64(R3, 0x0000ffffffff0000LL),
4246 BPF_ALU64_IMM(BPF_XOR, R2, 0x0),
4247 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4248 BPF_MOV32_IMM(R0, 2),
4250 BPF_MOV32_IMM(R0, 1),
4258 "ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
4260 BPF_LD_IMM64(R2, 0x0000ffffffff0000LL),
4261 BPF_LD_IMM64(R3, 0xffff00000000ffffLL),
4262 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
4263 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4264 BPF_MOV32_IMM(R0, 2),
4266 BPF_MOV32_IMM(R0, 1),
4274 "ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
4276 BPF_LD_IMM64(R2, 0x0000000000000000LL),
4277 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
4278 BPF_ALU64_IMM(BPF_XOR, R2, 0xffffffff),
4279 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
4280 BPF_MOV32_IMM(R0, 2),
4282 BPF_MOV32_IMM(R0, 1),
4290 "ALU64_XOR_K: Sign extension 1",
4292 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4293 BPF_LD_IMM64(R1, 0x0123456786a4c2e0LL),
4294 BPF_ALU64_IMM(BPF_XOR, R0, 0x0f0f0f0f),
4295 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4296 BPF_MOV32_IMM(R0, 2),
4298 BPF_MOV32_IMM(R0, 1),
4306 "ALU64_XOR_K: Sign extension 2",
4308 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4309 BPF_LD_IMM64(R1, 0xfedcba98795b3d1fLL),
4310 BPF_ALU64_IMM(BPF_XOR, R0, 0xf0f0f0f0),
4311 BPF_JMP_REG(BPF_JEQ, R0, R1, 2),
4312 BPF_MOV32_IMM(R0, 2),
4314 BPF_MOV32_IMM(R0, 1),
4321 /* BPF_ALU | BPF_LSH | BPF_X */
4323 "ALU_LSH_X: 1 << 1 = 2",
4325 BPF_LD_IMM64(R0, 1),
4326 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4327 BPF_ALU32_REG(BPF_LSH, R0, R1),
4335 "ALU_LSH_X: 1 << 31 = 0x80000000",
4337 BPF_LD_IMM64(R0, 1),
4338 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4339 BPF_ALU32_REG(BPF_LSH, R0, R1),
4344 { { 0, 0x80000000 } },
4347 "ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
4349 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4350 BPF_ALU32_IMM(BPF_MOV, R1, 12),
4351 BPF_ALU32_REG(BPF_LSH, R0, R1),
4356 { { 0, 0x45678000 } }
4359 "ALU64_LSH_X: 1 << 1 = 2",
4361 BPF_LD_IMM64(R0, 1),
4362 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4363 BPF_ALU64_REG(BPF_LSH, R0, R1),
4371 "ALU64_LSH_X: 1 << 31 = 0x80000000",
4373 BPF_LD_IMM64(R0, 1),
4374 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4375 BPF_ALU64_REG(BPF_LSH, R0, R1),
4380 { { 0, 0x80000000 } },
4383 "ALU64_LSH_X: Shift < 32, low word",
4385 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4386 BPF_ALU32_IMM(BPF_MOV, R1, 12),
4387 BPF_ALU64_REG(BPF_LSH, R0, R1),
4392 { { 0, 0xbcdef000 } }
4395 "ALU64_LSH_X: Shift < 32, high word",
4397 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4398 BPF_ALU32_IMM(BPF_MOV, R1, 12),
4399 BPF_ALU64_REG(BPF_LSH, R0, R1),
4400 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4405 { { 0, 0x3456789a } }
4408 "ALU64_LSH_X: Shift > 32, low word",
4410 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4411 BPF_ALU32_IMM(BPF_MOV, R1, 36),
4412 BPF_ALU64_REG(BPF_LSH, R0, R1),
4420 "ALU64_LSH_X: Shift > 32, high word",
4422 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4423 BPF_ALU32_IMM(BPF_MOV, R1, 36),
4424 BPF_ALU64_REG(BPF_LSH, R0, R1),
4425 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4430 { { 0, 0x9abcdef0 } }
4433 "ALU64_LSH_X: Shift == 32, low word",
4435 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4436 BPF_ALU32_IMM(BPF_MOV, R1, 32),
4437 BPF_ALU64_REG(BPF_LSH, R0, R1),
4445 "ALU64_LSH_X: Shift == 32, high word",
4447 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4448 BPF_ALU32_IMM(BPF_MOV, R1, 32),
4449 BPF_ALU64_REG(BPF_LSH, R0, R1),
4450 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4455 { { 0, 0x89abcdef } }
4458 "ALU64_LSH_X: Zero shift, low word",
4460 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4461 BPF_ALU32_IMM(BPF_MOV, R1, 0),
4462 BPF_ALU64_REG(BPF_LSH, R0, R1),
4467 { { 0, 0x89abcdef } }
4470 "ALU64_LSH_X: Zero shift, high word",
4472 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4473 BPF_ALU32_IMM(BPF_MOV, R1, 0),
4474 BPF_ALU64_REG(BPF_LSH, R0, R1),
4475 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4480 { { 0, 0x01234567 } }
4482 /* BPF_ALU | BPF_LSH | BPF_K */
4484 "ALU_LSH_K: 1 << 1 = 2",
4486 BPF_LD_IMM64(R0, 1),
4487 BPF_ALU32_IMM(BPF_LSH, R0, 1),
4495 "ALU_LSH_K: 1 << 31 = 0x80000000",
4497 BPF_LD_IMM64(R0, 1),
4498 BPF_ALU32_IMM(BPF_LSH, R0, 31),
4503 { { 0, 0x80000000 } },
4506 "ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
4508 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4509 BPF_ALU32_IMM(BPF_LSH, R0, 12),
4514 { { 0, 0x45678000 } }
4517 "ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
4519 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4520 BPF_ALU32_IMM(BPF_LSH, R0, 0),
4525 { { 0, 0x12345678 } }
4528 "ALU64_LSH_K: 1 << 1 = 2",
4530 BPF_LD_IMM64(R0, 1),
4531 BPF_ALU64_IMM(BPF_LSH, R0, 1),
4539 "ALU64_LSH_K: 1 << 31 = 0x80000000",
4541 BPF_LD_IMM64(R0, 1),
4542 BPF_ALU64_IMM(BPF_LSH, R0, 31),
4547 { { 0, 0x80000000 } },
4550 "ALU64_LSH_K: Shift < 32, low word",
4552 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4553 BPF_ALU64_IMM(BPF_LSH, R0, 12),
4558 { { 0, 0xbcdef000 } }
4561 "ALU64_LSH_K: Shift < 32, high word",
4563 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4564 BPF_ALU64_IMM(BPF_LSH, R0, 12),
4565 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4570 { { 0, 0x3456789a } }
4573 "ALU64_LSH_K: Shift > 32, low word",
4575 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4576 BPF_ALU64_IMM(BPF_LSH, R0, 36),
4584 "ALU64_LSH_K: Shift > 32, high word",
4586 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4587 BPF_ALU64_IMM(BPF_LSH, R0, 36),
4588 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4593 { { 0, 0x9abcdef0 } }
4596 "ALU64_LSH_K: Shift == 32, low word",
4598 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4599 BPF_ALU64_IMM(BPF_LSH, R0, 32),
4607 "ALU64_LSH_K: Shift == 32, high word",
4609 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4610 BPF_ALU64_IMM(BPF_LSH, R0, 32),
4611 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4616 { { 0, 0x89abcdef } }
4619 "ALU64_LSH_K: Zero shift",
4621 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4622 BPF_ALU64_IMM(BPF_LSH, R0, 0),
4627 { { 0, 0x89abcdef } }
4629 /* BPF_ALU | BPF_RSH | BPF_X */
4631 "ALU_RSH_X: 2 >> 1 = 1",
4633 BPF_LD_IMM64(R0, 2),
4634 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4635 BPF_ALU32_REG(BPF_RSH, R0, R1),
4643 "ALU_RSH_X: 0x80000000 >> 31 = 1",
4645 BPF_LD_IMM64(R0, 0x80000000),
4646 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4647 BPF_ALU32_REG(BPF_RSH, R0, R1),
4655 "ALU_RSH_X: 0x12345678 >> 20 = 0x123",
4657 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4658 BPF_ALU32_IMM(BPF_MOV, R1, 20),
4659 BPF_ALU32_REG(BPF_RSH, R0, R1),
4667 "ALU64_RSH_X: 2 >> 1 = 1",
4669 BPF_LD_IMM64(R0, 2),
4670 BPF_ALU32_IMM(BPF_MOV, R1, 1),
4671 BPF_ALU64_REG(BPF_RSH, R0, R1),
4679 "ALU64_RSH_X: 0x80000000 >> 31 = 1",
4681 BPF_LD_IMM64(R0, 0x80000000),
4682 BPF_ALU32_IMM(BPF_MOV, R1, 31),
4683 BPF_ALU64_REG(BPF_RSH, R0, R1),
4691 "ALU64_RSH_X: Shift < 32, low word",
4693 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4694 BPF_ALU32_IMM(BPF_MOV, R1, 12),
4695 BPF_ALU64_REG(BPF_RSH, R0, R1),
4700 { { 0, 0x56789abc } }
4703 "ALU64_RSH_X: Shift < 32, high word",
4705 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4706 BPF_ALU32_IMM(BPF_MOV, R1, 12),
4707 BPF_ALU64_REG(BPF_RSH, R0, R1),
4708 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4713 { { 0, 0x00081234 } }
4716 "ALU64_RSH_X: Shift > 32, low word",
4718 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4719 BPF_ALU32_IMM(BPF_MOV, R1, 36),
4720 BPF_ALU64_REG(BPF_RSH, R0, R1),
4725 { { 0, 0x08123456 } }
4728 "ALU64_RSH_X: Shift > 32, high word",
4730 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4731 BPF_ALU32_IMM(BPF_MOV, R1, 36),
4732 BPF_ALU64_REG(BPF_RSH, R0, R1),
4733 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4741 "ALU64_RSH_X: Shift == 32, low word",
4743 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4744 BPF_ALU32_IMM(BPF_MOV, R1, 32),
4745 BPF_ALU64_REG(BPF_RSH, R0, R1),
4750 { { 0, 0x81234567 } }
4753 "ALU64_RSH_X: Shift == 32, high word",
4755 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4756 BPF_ALU32_IMM(BPF_MOV, R1, 32),
4757 BPF_ALU64_REG(BPF_RSH, R0, R1),
4758 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4766 "ALU64_RSH_X: Zero shift, low word",
4768 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4769 BPF_ALU32_IMM(BPF_MOV, R1, 0),
4770 BPF_ALU64_REG(BPF_RSH, R0, R1),
4775 { { 0, 0x89abcdef } }
4778 "ALU64_RSH_X: Zero shift, high word",
4780 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4781 BPF_ALU32_IMM(BPF_MOV, R1, 0),
4782 BPF_ALU64_REG(BPF_RSH, R0, R1),
4783 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4788 { { 0, 0x81234567 } }
4790 /* BPF_ALU | BPF_RSH | BPF_K */
4792 "ALU_RSH_K: 2 >> 1 = 1",
4794 BPF_LD_IMM64(R0, 2),
4795 BPF_ALU32_IMM(BPF_RSH, R0, 1),
4803 "ALU_RSH_K: 0x80000000 >> 31 = 1",
4805 BPF_LD_IMM64(R0, 0x80000000),
4806 BPF_ALU32_IMM(BPF_RSH, R0, 31),
4814 "ALU_RSH_K: 0x12345678 >> 20 = 0x123",
4816 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4817 BPF_ALU32_IMM(BPF_RSH, R0, 20),
4825 "ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
4827 BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4828 BPF_ALU32_IMM(BPF_RSH, R0, 0),
4833 { { 0, 0x12345678 } }
4836 "ALU64_RSH_K: 2 >> 1 = 1",
4838 BPF_LD_IMM64(R0, 2),
4839 BPF_ALU64_IMM(BPF_RSH, R0, 1),
4847 "ALU64_RSH_K: 0x80000000 >> 31 = 1",
4849 BPF_LD_IMM64(R0, 0x80000000),
4850 BPF_ALU64_IMM(BPF_RSH, R0, 31),
4858 "ALU64_RSH_K: Shift < 32, low word",
4860 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4861 BPF_ALU64_IMM(BPF_RSH, R0, 12),
4866 { { 0, 0x56789abc } }
4869 "ALU64_RSH_K: Shift < 32, high word",
4871 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4872 BPF_ALU64_IMM(BPF_RSH, R0, 12),
4873 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4878 { { 0, 0x00081234 } }
4881 "ALU64_RSH_K: Shift > 32, low word",
4883 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4884 BPF_ALU64_IMM(BPF_RSH, R0, 36),
4889 { { 0, 0x08123456 } }
4892 "ALU64_RSH_K: Shift > 32, high word",
4894 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4895 BPF_ALU64_IMM(BPF_RSH, R0, 36),
4896 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4904 "ALU64_RSH_K: Shift == 32, low word",
4906 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4907 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4912 { { 0, 0x81234567 } }
4915 "ALU64_RSH_K: Shift == 32, high word",
4917 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4918 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4919 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4927 "ALU64_RSH_K: Zero shift",
4929 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4930 BPF_ALU64_IMM(BPF_RSH, R0, 0),
4935 { { 0, 0x89abcdef } }
4937 /* BPF_ALU | BPF_ARSH | BPF_X */
4939 "ALU32_ARSH_X: -1234 >> 7 = -10",
4941 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
4942 BPF_ALU32_IMM(BPF_MOV, R1, 7),
4943 BPF_ALU32_REG(BPF_ARSH, R0, R1),
4951 "ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4953 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4954 BPF_ALU32_IMM(BPF_MOV, R1, 40),
4955 BPF_ALU64_REG(BPF_ARSH, R0, R1),
4960 { { 0, 0xffff00ff } },
4963 "ALU64_ARSH_X: Shift < 32, low word",
4965 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4966 BPF_ALU32_IMM(BPF_MOV, R1, 12),
4967 BPF_ALU64_REG(BPF_ARSH, R0, R1),
4972 { { 0, 0x56789abc } }
4975 "ALU64_ARSH_X: Shift < 32, high word",
4977 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4978 BPF_ALU32_IMM(BPF_MOV, R1, 12),
4979 BPF_ALU64_REG(BPF_ARSH, R0, R1),
4980 BPF_ALU64_IMM(BPF_RSH, R0, 32),
4985 { { 0, 0xfff81234 } }
4988 "ALU64_ARSH_X: Shift > 32, low word",
4990 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4991 BPF_ALU32_IMM(BPF_MOV, R1, 36),
4992 BPF_ALU64_REG(BPF_ARSH, R0, R1),
4997 { { 0, 0xf8123456 } }
5000 "ALU64_ARSH_X: Shift > 32, high word",
5002 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5003 BPF_ALU32_IMM(BPF_MOV, R1, 36),
5004 BPF_ALU64_REG(BPF_ARSH, R0, R1),
5005 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5013 "ALU64_ARSH_X: Shift == 32, low word",
5015 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5016 BPF_ALU32_IMM(BPF_MOV, R1, 32),
5017 BPF_ALU64_REG(BPF_ARSH, R0, R1),
5022 { { 0, 0x81234567 } }
5025 "ALU64_ARSH_X: Shift == 32, high word",
5027 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5028 BPF_ALU32_IMM(BPF_MOV, R1, 32),
5029 BPF_ALU64_REG(BPF_ARSH, R0, R1),
5030 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5038 "ALU64_ARSH_X: Zero shift, low word",
5040 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5041 BPF_ALU32_IMM(BPF_MOV, R1, 0),
5042 BPF_ALU64_REG(BPF_ARSH, R0, R1),
5047 { { 0, 0x89abcdef } }
5050 "ALU64_ARSH_X: Zero shift, high word",
5052 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5053 BPF_ALU32_IMM(BPF_MOV, R1, 0),
5054 BPF_ALU64_REG(BPF_ARSH, R0, R1),
5055 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5060 { { 0, 0x81234567 } }
5062 /* BPF_ALU | BPF_ARSH | BPF_K */
5064 "ALU32_ARSH_K: -1234 >> 7 = -10",
5066 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
5067 BPF_ALU32_IMM(BPF_ARSH, R0, 7),
5075 "ALU32_ARSH_K: -1234 >> 0 = -1234",
5077 BPF_ALU32_IMM(BPF_MOV, R0, -1234),
5078 BPF_ALU32_IMM(BPF_ARSH, R0, 0),
5086 "ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
5088 BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
5089 BPF_ALU64_IMM(BPF_ARSH, R0, 40),
5094 { { 0, 0xffff00ff } },
5097 "ALU64_ARSH_K: Shift < 32, low word",
5099 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5100 BPF_ALU64_IMM(BPF_RSH, R0, 12),
5105 { { 0, 0x56789abc } }
5108 "ALU64_ARSH_K: Shift < 32, high word",
5110 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5111 BPF_ALU64_IMM(BPF_ARSH, R0, 12),
5112 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5117 { { 0, 0xfff81234 } }
5120 "ALU64_ARSH_K: Shift > 32, low word",
5122 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5123 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
5128 { { 0, 0xf8123456 } }
5131 "ALU64_ARSH_K: Shift > 32, high word",
5133 BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
5134 BPF_ALU64_IMM(BPF_ARSH, R0, 36),
5135 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5143 "ALU64_ARSH_K: Shift == 32, low word",
5145 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5146 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
5151 { { 0, 0x81234567 } }
5154 "ALU64_ARSH_K: Shift == 32, high word",
5156 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5157 BPF_ALU64_IMM(BPF_ARSH, R0, 32),
5158 BPF_ALU64_IMM(BPF_RSH, R0, 32),
5166 "ALU64_ARSH_K: Zero shoft",
5168 BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5169 BPF_ALU64_IMM(BPF_ARSH, R0, 0),
5174 { { 0, 0x89abcdef } }
5176 /* BPF_ALU | BPF_NEG */
5178 "ALU_NEG: -(3) = -3",
5180 BPF_ALU32_IMM(BPF_MOV, R0, 3),
5181 BPF_ALU32_IMM(BPF_NEG, R0, 0),
5189 "ALU_NEG: -(-3) = 3",
5191 BPF_ALU32_IMM(BPF_MOV, R0, -3),
5192 BPF_ALU32_IMM(BPF_NEG, R0, 0),
5200 "ALU64_NEG: -(3) = -3",
5202 BPF_LD_IMM64(R0, 3),
5203 BPF_ALU64_IMM(BPF_NEG, R0, 0),
5211 "ALU64_NEG: -(-3) = 3",
5213 BPF_LD_IMM64(R0, -3),
5214 BPF_ALU64_IMM(BPF_NEG, R0, 0),
5221 /* BPF_ALU | BPF_END | BPF_FROM_BE */
5223 "ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
5225 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5226 BPF_ENDIAN(BPF_FROM_BE, R0, 16),
5231 { { 0, cpu_to_be16(0xcdef) } },
5234 "ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
5236 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5237 BPF_ENDIAN(BPF_FROM_BE, R0, 32),
5238 BPF_ALU64_REG(BPF_MOV, R1, R0),
5239 BPF_ALU64_IMM(BPF_RSH, R1, 32),
5240 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
5245 { { 0, cpu_to_be32(0x89abcdef) } },
5248 "ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
5250 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5251 BPF_ENDIAN(BPF_FROM_BE, R0, 64),
5256 { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
5258 /* BPF_ALU | BPF_END | BPF_FROM_LE */
5260 "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
5262 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5263 BPF_ENDIAN(BPF_FROM_LE, R0, 16),
5268 { { 0, cpu_to_le16(0xcdef) } },
5271 "ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
5273 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5274 BPF_ENDIAN(BPF_FROM_LE, R0, 32),
5275 BPF_ALU64_REG(BPF_MOV, R1, R0),
5276 BPF_ALU64_IMM(BPF_RSH, R1, 32),
5277 BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
5282 { { 0, cpu_to_le32(0x89abcdef) } },
5285 "ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
5287 BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5288 BPF_ENDIAN(BPF_FROM_LE, R0, 64),
5293 { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
5295 /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
5297 "ST_MEM_B: Store/Load byte: max negative",
5299 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5300 BPF_ST_MEM(BPF_B, R10, -40, 0xff),
5301 BPF_LDX_MEM(BPF_B, R0, R10, -40),
5310 "ST_MEM_B: Store/Load byte: max positive",
5312 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5313 BPF_ST_MEM(BPF_H, R10, -40, 0x7f),
5314 BPF_LDX_MEM(BPF_H, R0, R10, -40),
5323 "STX_MEM_B: Store/Load byte: max negative",
5325 BPF_LD_IMM64(R0, 0),
5326 BPF_LD_IMM64(R1, 0xffLL),
5327 BPF_STX_MEM(BPF_B, R10, R1, -40),
5328 BPF_LDX_MEM(BPF_B, R0, R10, -40),
5337 "ST_MEM_H: Store/Load half word: max negative",
5339 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5340 BPF_ST_MEM(BPF_H, R10, -40, 0xffff),
5341 BPF_LDX_MEM(BPF_H, R0, R10, -40),
5350 "ST_MEM_H: Store/Load half word: max positive",
5352 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5353 BPF_ST_MEM(BPF_H, R10, -40, 0x7fff),
5354 BPF_LDX_MEM(BPF_H, R0, R10, -40),
5363 "STX_MEM_H: Store/Load half word: max negative",
5365 BPF_LD_IMM64(R0, 0),
5366 BPF_LD_IMM64(R1, 0xffffLL),
5367 BPF_STX_MEM(BPF_H, R10, R1, -40),
5368 BPF_LDX_MEM(BPF_H, R0, R10, -40),
5377 "ST_MEM_W: Store/Load word: max negative",
5379 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5380 BPF_ST_MEM(BPF_W, R10, -40, 0xffffffff),
5381 BPF_LDX_MEM(BPF_W, R0, R10, -40),
5386 { { 0, 0xffffffff } },
5390 "ST_MEM_W: Store/Load word: max positive",
5392 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5393 BPF_ST_MEM(BPF_W, R10, -40, 0x7fffffff),
5394 BPF_LDX_MEM(BPF_W, R0, R10, -40),
5399 { { 0, 0x7fffffff } },
5403 "STX_MEM_W: Store/Load word: max negative",
5405 BPF_LD_IMM64(R0, 0),
5406 BPF_LD_IMM64(R1, 0xffffffffLL),
5407 BPF_STX_MEM(BPF_W, R10, R1, -40),
5408 BPF_LDX_MEM(BPF_W, R0, R10, -40),
5413 { { 0, 0xffffffff } },
5417 "ST_MEM_DW: Store/Load double word: max negative",
5419 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5420 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
5421 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5426 { { 0, 0xffffffff } },
5430 "ST_MEM_DW: Store/Load double word: max negative 2",
5432 BPF_LD_IMM64(R2, 0xffff00000000ffffLL),
5433 BPF_LD_IMM64(R3, 0xffffffffffffffffLL),
5434 BPF_ST_MEM(BPF_DW, R10, -40, 0xffffffff),
5435 BPF_LDX_MEM(BPF_DW, R2, R10, -40),
5436 BPF_JMP_REG(BPF_JEQ, R2, R3, 2),
5437 BPF_MOV32_IMM(R0, 2),
5439 BPF_MOV32_IMM(R0, 1),
5448 "ST_MEM_DW: Store/Load double word: max positive",
5450 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5451 BPF_ST_MEM(BPF_DW, R10, -40, 0x7fffffff),
5452 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5457 { { 0, 0x7fffffff } },
5461 "STX_MEM_DW: Store/Load double word: max negative",
5463 BPF_LD_IMM64(R0, 0),
5464 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
5465 BPF_STX_MEM(BPF_DW, R10, R1, -40),
5466 BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5471 { { 0, 0xffffffff } },
5475 "STX_MEM_DW: Store double word: first word in memory",
5477 BPF_LD_IMM64(R0, 0),
5478 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
5479 BPF_STX_MEM(BPF_DW, R10, R1, -40),
5480 BPF_LDX_MEM(BPF_W, R0, R10, -40),
5486 { { 0, 0x01234567 } },
5488 { { 0, 0x89abcdef } },
5493 "STX_MEM_DW: Store double word: second word in memory",
5495 BPF_LD_IMM64(R0, 0),
5496 BPF_LD_IMM64(R1, 0x0123456789abcdefLL),
5497 BPF_STX_MEM(BPF_DW, R10, R1, -40),
5498 BPF_LDX_MEM(BPF_W, R0, R10, -36),
5504 { { 0, 0x89abcdef } },
5506 { { 0, 0x01234567 } },
5510 /* BPF_STX | BPF_ATOMIC | BPF_W/DW */
5512 "STX_XADD_W: X + 1 + 1 + 1 + ...",
5517 .fill_helper = bpf_fill_stxw,
5520 "STX_XADD_DW: X + 1 + 1 + 1 + ...",
5525 .fill_helper = bpf_fill_stxdw,
5528 * Exhaustive tests of atomic operation variants.
5529 * Individual tests are expanded from template macros for all
5530 * combinations of ALU operation, word size and fetching.
5532 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result) \
5534 "BPF_ATOMIC | " #width ", " #op ": Test: " \
5535 #old " " #logic " " #update " = " #result, \
5537 BPF_ALU32_IMM(BPF_MOV, R5, update), \
5538 BPF_ST_MEM(width, R10, -40, old), \
5539 BPF_ATOMIC_OP(width, op, R10, R5, -40), \
5540 BPF_LDX_MEM(width, R0, R10, -40), \
5545 { { 0, result } }, \
5546 .stack_depth = 40, \
5548 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result) \
5550 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: " \
5551 #old " " #logic " " #update " = " #result, \
5553 BPF_ALU64_REG(BPF_MOV, R1, R10), \
5554 BPF_ALU32_IMM(BPF_MOV, R0, update), \
5555 BPF_ST_MEM(BPF_W, R10, -40, old), \
5556 BPF_ATOMIC_OP(width, op, R10, R0, -40), \
5557 BPF_ALU64_REG(BPF_MOV, R0, R10), \
5558 BPF_ALU64_REG(BPF_SUB, R0, R1), \
5564 .stack_depth = 40, \
5566 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result) \
5568 "BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: " \
5569 #old " " #logic " " #update " = " #result, \
5571 BPF_ALU64_REG(BPF_MOV, R0, R10), \
5572 BPF_ALU32_IMM(BPF_MOV, R1, update), \
5573 BPF_ST_MEM(width, R10, -40, old), \
5574 BPF_ATOMIC_OP(width, op, R10, R1, -40), \
5575 BPF_ALU64_REG(BPF_SUB, R0, R10), \
5581 .stack_depth = 40, \
5583 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result) \
5585 "BPF_ATOMIC | " #width ", " #op ": Test fetch: " \
5586 #old " " #logic " " #update " = " #result, \
5588 BPF_ALU32_IMM(BPF_MOV, R3, update), \
5589 BPF_ST_MEM(width, R10, -40, old), \
5590 BPF_ATOMIC_OP(width, op, R10, R3, -40), \
5591 BPF_ALU64_REG(BPF_MOV, R0, R3), \
5596 { { 0, (op) & BPF_FETCH ? old : update } }, \
5597 .stack_depth = 40, \
5599 /* BPF_ATOMIC | BPF_W: BPF_ADD */
5600 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5601 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5602 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5603 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD, +, 0x12, 0xab, 0xbd),
5604 /* BPF_ATOMIC | BPF_W: BPF_ADD | BPF_FETCH */
5605 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5606 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5607 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5608 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5609 /* BPF_ATOMIC | BPF_DW: BPF_ADD */
5610 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5611 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5612 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5613 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD, +, 0x12, 0xab, 0xbd),
5614 /* BPF_ATOMIC | BPF_DW: BPF_ADD | BPF_FETCH */
5615 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5616 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5617 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5618 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_ADD | BPF_FETCH, +, 0x12, 0xab, 0xbd),
5619 /* BPF_ATOMIC | BPF_W: BPF_AND */
5620 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5621 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5622 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5623 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND, &, 0x12, 0xab, 0x02),
5624 /* BPF_ATOMIC | BPF_W: BPF_AND | BPF_FETCH */
5625 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5626 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5627 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5628 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5629 /* BPF_ATOMIC | BPF_DW: BPF_AND */
5630 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5631 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5632 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5633 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND, &, 0x12, 0xab, 0x02),
5634 /* BPF_ATOMIC | BPF_DW: BPF_AND | BPF_FETCH */
5635 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5636 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5637 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5638 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_AND | BPF_FETCH, &, 0x12, 0xab, 0x02),
5639 /* BPF_ATOMIC | BPF_W: BPF_OR */
5640 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5641 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5642 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5643 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR, |, 0x12, 0xab, 0xbb),
5644 /* BPF_ATOMIC | BPF_W: BPF_OR | BPF_FETCH */
5645 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5646 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5647 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5648 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5649 /* BPF_ATOMIC | BPF_DW: BPF_OR */
5650 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5651 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5652 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5653 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR, |, 0x12, 0xab, 0xbb),
5654 /* BPF_ATOMIC | BPF_DW: BPF_OR | BPF_FETCH */
5655 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5656 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5657 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5658 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_OR | BPF_FETCH, |, 0x12, 0xab, 0xbb),
5659 /* BPF_ATOMIC | BPF_W: BPF_XOR */
5660 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5661 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5662 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5663 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5664 /* BPF_ATOMIC | BPF_W: BPF_XOR | BPF_FETCH */
5665 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5666 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5667 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5668 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5669 /* BPF_ATOMIC | BPF_DW: BPF_XOR */
5670 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5671 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5672 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5673 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR, ^, 0x12, 0xab, 0xb9),
5674 /* BPF_ATOMIC | BPF_DW: BPF_XOR | BPF_FETCH */
5675 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5676 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5677 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5678 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XOR | BPF_FETCH, ^, 0x12, 0xab, 0xb9),
5679 /* BPF_ATOMIC | BPF_W: BPF_XCHG */
5680 BPF_ATOMIC_OP_TEST1(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5681 BPF_ATOMIC_OP_TEST2(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5682 BPF_ATOMIC_OP_TEST3(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5683 BPF_ATOMIC_OP_TEST4(BPF_W, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5684 /* BPF_ATOMIC | BPF_DW: BPF_XCHG */
5685 BPF_ATOMIC_OP_TEST1(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5686 BPF_ATOMIC_OP_TEST2(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5687 BPF_ATOMIC_OP_TEST3(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5688 BPF_ATOMIC_OP_TEST4(BPF_DW, BPF_XCHG, xchg, 0x12, 0xab, 0xab),
5689 #undef BPF_ATOMIC_OP_TEST1
5690 #undef BPF_ATOMIC_OP_TEST2
5691 #undef BPF_ATOMIC_OP_TEST3
5692 #undef BPF_ATOMIC_OP_TEST4
5693 /* BPF_JMP32 | BPF_JEQ | BPF_K */
5695 "JMP32_JEQ_K: Small immediate",
5697 BPF_ALU32_IMM(BPF_MOV, R0, 123),
5698 BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
5699 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
5700 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5708 "JMP32_JEQ_K: Large immediate",
5710 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5711 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
5712 BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
5713 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5721 "JMP32_JEQ_K: negative immediate",
5723 BPF_ALU32_IMM(BPF_MOV, R0, -123),
5724 BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
5725 BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
5726 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5733 /* BPF_JMP32 | BPF_JEQ | BPF_X */
5737 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5738 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5739 BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
5740 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5741 BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
5742 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5749 /* BPF_JMP32 | BPF_JNE | BPF_K */
5751 "JMP32_JNE_K: Small immediate",
5753 BPF_ALU32_IMM(BPF_MOV, R0, 123),
5754 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
5755 BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
5756 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5764 "JMP32_JNE_K: Large immediate",
5766 BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5767 BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
5768 BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
5769 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5777 "JMP32_JNE_K: negative immediate",
5779 BPF_ALU32_IMM(BPF_MOV, R0, -123),
5780 BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
5781 BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
5782 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5789 /* BPF_JMP32 | BPF_JNE | BPF_X */
5793 BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5794 BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5795 BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
5796 BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5797 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
5798 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5805 /* BPF_JMP32 | BPF_JSET | BPF_K */
5807 "JMP32_JSET_K: Small immediate",
5809 BPF_ALU32_IMM(BPF_MOV, R0, 1),
5810 BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
5811 BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
5812 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5820 "JMP32_JSET_K: Large immediate",
5822 BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
5823 BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
5824 BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
5825 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5830 { { 0, 0x40000000 } }
5833 "JMP32_JSET_K: negative immediate",
5835 BPF_ALU32_IMM(BPF_MOV, R0, -123),
5836 BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
5837 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5844 /* BPF_JMP32 | BPF_JSET | BPF_X */
5848 BPF_ALU32_IMM(BPF_MOV, R0, 8),
5849 BPF_ALU32_IMM(BPF_MOV, R1, 7),
5850 BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
5851 BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
5852 BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
5853 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5860 /* BPF_JMP32 | BPF_JGT | BPF_K */
5862 "JMP32_JGT_K: Small immediate",
5864 BPF_ALU32_IMM(BPF_MOV, R0, 123),
5865 BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
5866 BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
5867 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5875 "JMP32_JGT_K: Large immediate",
5877 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5878 BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
5879 BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
5880 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5885 { { 0, 0xfffffffe } }
5887 /* BPF_JMP32 | BPF_JGT | BPF_X */
5891 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5892 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5893 BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
5894 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
5895 BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
5896 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5901 { { 0, 0xfffffffe } }
5903 /* BPF_JMP32 | BPF_JGE | BPF_K */
5905 "JMP32_JGE_K: Small immediate",
5907 BPF_ALU32_IMM(BPF_MOV, R0, 123),
5908 BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
5909 BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
5910 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5918 "JMP32_JGE_K: Large immediate",
5920 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5921 BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
5922 BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
5923 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5928 { { 0, 0xfffffffe } }
5930 /* BPF_JMP32 | BPF_JGE | BPF_X */
5934 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5935 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5936 BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
5937 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
5938 BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
5939 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5944 { { 0, 0xfffffffe } }
5946 /* BPF_JMP32 | BPF_JLT | BPF_K */
5948 "JMP32_JLT_K: Small immediate",
5950 BPF_ALU32_IMM(BPF_MOV, R0, 123),
5951 BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
5952 BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
5953 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5961 "JMP32_JLT_K: Large immediate",
5963 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5964 BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
5965 BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
5966 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5971 { { 0, 0xfffffffe } }
5973 /* BPF_JMP32 | BPF_JLT | BPF_X */
5977 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
5978 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
5979 BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
5980 BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
5981 BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
5982 BPF_ALU32_IMM(BPF_MOV, R0, 0),
5987 { { 0, 0xfffffffe } }
5989 /* BPF_JMP32 | BPF_JLE | BPF_K */
5991 "JMP32_JLE_K: Small immediate",
5993 BPF_ALU32_IMM(BPF_MOV, R0, 123),
5994 BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
5995 BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
5996 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6004 "JMP32_JLE_K: Large immediate",
6006 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6007 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
6008 BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
6009 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6014 { { 0, 0xfffffffe } }
6016 /* BPF_JMP32 | BPF_JLE | BPF_X */
6020 BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6021 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
6022 BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
6023 BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
6024 BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
6025 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6030 { { 0, 0xfffffffe } }
6032 /* BPF_JMP32 | BPF_JSGT | BPF_K */
6034 "JMP32_JSGT_K: Small immediate",
6036 BPF_ALU32_IMM(BPF_MOV, R0, -123),
6037 BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
6038 BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
6039 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6047 "JMP32_JSGT_K: Large immediate",
6049 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6050 BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
6051 BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
6052 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6057 { { 0, -12345678 } }
6059 /* BPF_JMP32 | BPF_JSGT | BPF_X */
6063 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6064 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6065 BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
6066 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
6067 BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
6068 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6073 { { 0, -12345678 } }
6075 /* BPF_JMP32 | BPF_JSGE | BPF_K */
6077 "JMP32_JSGE_K: Small immediate",
6079 BPF_ALU32_IMM(BPF_MOV, R0, -123),
6080 BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
6081 BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
6082 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6090 "JMP32_JSGE_K: Large immediate",
6092 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6093 BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
6094 BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
6095 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6100 { { 0, -12345678 } }
6102 /* BPF_JMP32 | BPF_JSGE | BPF_X */
6106 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6107 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
6108 BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
6109 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6110 BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
6111 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6116 { { 0, -12345678 } }
6118 /* BPF_JMP32 | BPF_JSLT | BPF_K */
6120 "JMP32_JSLT_K: Small immediate",
6122 BPF_ALU32_IMM(BPF_MOV, R0, -123),
6123 BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
6124 BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
6125 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6133 "JMP32_JSLT_K: Large immediate",
6135 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6136 BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
6137 BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
6138 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6143 { { 0, -12345678 } }
6145 /* BPF_JMP32 | BPF_JSLT | BPF_X */
6149 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6150 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6151 BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
6152 BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
6153 BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
6154 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6159 { { 0, -12345678 } }
6161 /* BPF_JMP32 | BPF_JSLE | BPF_K */
6163 "JMP32_JSLE_K: Small immediate",
6165 BPF_ALU32_IMM(BPF_MOV, R0, -123),
6166 BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
6167 BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
6168 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6176 "JMP32_JSLE_K: Large immediate",
6178 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6179 BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
6180 BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
6181 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6186 { { 0, -12345678 } }
6188 /* BPF_JMP32 | BPF_JSLE | BPF_K */
6192 BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6193 BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
6194 BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
6195 BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6196 BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
6197 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6202 { { 0, -12345678 } }
6204 /* BPF_JMP | BPF_EXIT */
6208 BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
6210 BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
6216 /* BPF_JMP | BPF_JA */
6218 "JMP_JA: Unconditional jump: if (true) return 1",
6220 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6221 BPF_JMP_IMM(BPF_JA, 0, 0, 1),
6223 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6230 /* BPF_JMP | BPF_JSLT | BPF_K */
6232 "JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
6234 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6235 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
6236 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
6238 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6246 "JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
6248 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6249 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6250 BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
6252 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6259 /* BPF_JMP | BPF_JSGT | BPF_K */
6261 "JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
6263 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6264 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6265 BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
6267 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6275 "JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
6277 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6278 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6279 BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
6281 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6288 /* BPF_JMP | BPF_JSLE | BPF_K */
6290 "JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
6292 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6293 BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
6294 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
6296 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6304 "JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
6306 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6307 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6308 BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
6310 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6318 "JMP_JSLE_K: Signed jump: value walk 1",
6320 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6321 BPF_LD_IMM64(R1, 3),
6322 BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
6323 BPF_ALU64_IMM(BPF_SUB, R1, 1),
6324 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
6325 BPF_ALU64_IMM(BPF_SUB, R1, 1),
6326 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
6327 BPF_ALU64_IMM(BPF_SUB, R1, 1),
6328 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
6329 BPF_EXIT_INSN(), /* bad exit */
6330 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
6338 "JMP_JSLE_K: Signed jump: value walk 2",
6340 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6341 BPF_LD_IMM64(R1, 3),
6342 BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
6343 BPF_ALU64_IMM(BPF_SUB, R1, 2),
6344 BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
6345 BPF_ALU64_IMM(BPF_SUB, R1, 2),
6346 BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
6347 BPF_EXIT_INSN(), /* bad exit */
6348 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
6355 /* BPF_JMP | BPF_JSGE | BPF_K */
6357 "JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
6359 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6360 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6361 BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
6363 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6371 "JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
6373 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6374 BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6375 BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
6377 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6385 "JMP_JSGE_K: Signed jump: value walk 1",
6387 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6388 BPF_LD_IMM64(R1, -3),
6389 BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
6390 BPF_ALU64_IMM(BPF_ADD, R1, 1),
6391 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6392 BPF_ALU64_IMM(BPF_ADD, R1, 1),
6393 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6394 BPF_ALU64_IMM(BPF_ADD, R1, 1),
6395 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6396 BPF_EXIT_INSN(), /* bad exit */
6397 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
6405 "JMP_JSGE_K: Signed jump: value walk 2",
6407 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6408 BPF_LD_IMM64(R1, -3),
6409 BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6410 BPF_ALU64_IMM(BPF_ADD, R1, 2),
6411 BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6412 BPF_ALU64_IMM(BPF_ADD, R1, 2),
6413 BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6414 BPF_EXIT_INSN(), /* bad exit */
6415 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* good exit */
6422 /* BPF_JMP | BPF_JGT | BPF_K */
6424 "JMP_JGT_K: if (3 > 2) return 1",
6426 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6427 BPF_LD_IMM64(R1, 3),
6428 BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
6430 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6438 "JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
6440 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6441 BPF_LD_IMM64(R1, -1),
6442 BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
6444 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6451 /* BPF_JMP | BPF_JLT | BPF_K */
6453 "JMP_JLT_K: if (2 < 3) return 1",
6455 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6456 BPF_LD_IMM64(R1, 2),
6457 BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
6459 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6467 "JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
6469 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6470 BPF_LD_IMM64(R1, 1),
6471 BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
6473 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6480 /* BPF_JMP | BPF_JGE | BPF_K */
6482 "JMP_JGE_K: if (3 >= 2) return 1",
6484 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6485 BPF_LD_IMM64(R1, 3),
6486 BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
6488 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6495 /* BPF_JMP | BPF_JLE | BPF_K */
6497 "JMP_JLE_K: if (2 <= 3) return 1",
6499 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6500 BPF_LD_IMM64(R1, 2),
6501 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6503 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6510 /* BPF_JMP | BPF_JGT | BPF_K jump backwards */
6512 "JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
6514 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6515 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6517 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6518 BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
6519 BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
6527 "JMP_JGE_K: if (3 >= 3) return 1",
6529 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6530 BPF_LD_IMM64(R1, 3),
6531 BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
6533 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6540 /* BPF_JMP | BPF_JLT | BPF_K jump backwards */
6542 "JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
6544 BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6545 BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6547 BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6548 BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
6549 BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
6557 "JMP_JLE_K: if (3 <= 3) return 1",
6559 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6560 BPF_LD_IMM64(R1, 3),
6561 BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6563 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6570 /* BPF_JMP | BPF_JNE | BPF_K */
6572 "JMP_JNE_K: if (3 != 2) return 1",
6574 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6575 BPF_LD_IMM64(R1, 3),
6576 BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
6578 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6585 /* BPF_JMP | BPF_JEQ | BPF_K */
6587 "JMP_JEQ_K: if (3 == 3) return 1",
6589 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6590 BPF_LD_IMM64(R1, 3),
6591 BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
6593 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6600 /* BPF_JMP | BPF_JSET | BPF_K */
6602 "JMP_JSET_K: if (0x3 & 0x2) return 1",
6604 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6605 BPF_LD_IMM64(R1, 3),
6606 BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
6608 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6616 "JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
6618 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6619 BPF_LD_IMM64(R1, 3),
6620 BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
6622 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6629 /* BPF_JMP | BPF_JSGT | BPF_X */
6631 "JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
6633 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6634 BPF_LD_IMM64(R1, -1),
6635 BPF_LD_IMM64(R2, -2),
6636 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6638 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6646 "JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
6648 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6649 BPF_LD_IMM64(R1, -1),
6650 BPF_LD_IMM64(R2, -1),
6651 BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6653 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6660 /* BPF_JMP | BPF_JSLT | BPF_X */
6662 "JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
6664 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6665 BPF_LD_IMM64(R1, -1),
6666 BPF_LD_IMM64(R2, -2),
6667 BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
6669 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6677 "JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
6679 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6680 BPF_LD_IMM64(R1, -1),
6681 BPF_LD_IMM64(R2, -1),
6682 BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
6684 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6691 /* BPF_JMP | BPF_JSGE | BPF_X */
6693 "JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
6695 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6696 BPF_LD_IMM64(R1, -1),
6697 BPF_LD_IMM64(R2, -2),
6698 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6700 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6708 "JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
6710 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6711 BPF_LD_IMM64(R1, -1),
6712 BPF_LD_IMM64(R2, -1),
6713 BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6715 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6722 /* BPF_JMP | BPF_JSLE | BPF_X */
6724 "JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
6726 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6727 BPF_LD_IMM64(R1, -1),
6728 BPF_LD_IMM64(R2, -2),
6729 BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
6731 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6739 "JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
6741 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6742 BPF_LD_IMM64(R1, -1),
6743 BPF_LD_IMM64(R2, -1),
6744 BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
6746 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6753 /* BPF_JMP | BPF_JGT | BPF_X */
6755 "JMP_JGT_X: if (3 > 2) return 1",
6757 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6758 BPF_LD_IMM64(R1, 3),
6759 BPF_LD_IMM64(R2, 2),
6760 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6762 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6770 "JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
6772 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6773 BPF_LD_IMM64(R1, -1),
6774 BPF_LD_IMM64(R2, 1),
6775 BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6777 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6784 /* BPF_JMP | BPF_JLT | BPF_X */
6786 "JMP_JLT_X: if (2 < 3) return 1",
6788 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6789 BPF_LD_IMM64(R1, 3),
6790 BPF_LD_IMM64(R2, 2),
6791 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6793 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6801 "JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
6803 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6804 BPF_LD_IMM64(R1, -1),
6805 BPF_LD_IMM64(R2, 1),
6806 BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6808 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6815 /* BPF_JMP | BPF_JGE | BPF_X */
6817 "JMP_JGE_X: if (3 >= 2) return 1",
6819 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6820 BPF_LD_IMM64(R1, 3),
6821 BPF_LD_IMM64(R2, 2),
6822 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
6824 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6832 "JMP_JGE_X: if (3 >= 3) return 1",
6834 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6835 BPF_LD_IMM64(R1, 3),
6836 BPF_LD_IMM64(R2, 3),
6837 BPF_JMP_REG(BPF_JGE, R1, R2, 1),
6839 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6846 /* BPF_JMP | BPF_JLE | BPF_X */
6848 "JMP_JLE_X: if (2 <= 3) return 1",
6850 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6851 BPF_LD_IMM64(R1, 3),
6852 BPF_LD_IMM64(R2, 2),
6853 BPF_JMP_REG(BPF_JLE, R2, R1, 1),
6855 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6863 "JMP_JLE_X: if (3 <= 3) return 1",
6865 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6866 BPF_LD_IMM64(R1, 3),
6867 BPF_LD_IMM64(R2, 3),
6868 BPF_JMP_REG(BPF_JLE, R1, R2, 1),
6870 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6878 /* Mainly testing JIT + imm64 here. */
6879 "JMP_JGE_X: ldimm64 test 1",
6881 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6882 BPF_LD_IMM64(R1, 3),
6883 BPF_LD_IMM64(R2, 2),
6884 BPF_JMP_REG(BPF_JGE, R1, R2, 2),
6885 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6886 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6891 { { 0, 0xeeeeeeeeU } },
6894 "JMP_JGE_X: ldimm64 test 2",
6896 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6897 BPF_LD_IMM64(R1, 3),
6898 BPF_LD_IMM64(R2, 2),
6899 BPF_JMP_REG(BPF_JGE, R1, R2, 0),
6900 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6905 { { 0, 0xffffffffU } },
6908 "JMP_JGE_X: ldimm64 test 3",
6910 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6911 BPF_LD_IMM64(R1, 3),
6912 BPF_LD_IMM64(R2, 2),
6913 BPF_JMP_REG(BPF_JGE, R1, R2, 4),
6914 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6915 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6923 "JMP_JLE_X: ldimm64 test 1",
6925 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6926 BPF_LD_IMM64(R1, 3),
6927 BPF_LD_IMM64(R2, 2),
6928 BPF_JMP_REG(BPF_JLE, R2, R1, 2),
6929 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6930 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6935 { { 0, 0xeeeeeeeeU } },
6938 "JMP_JLE_X: ldimm64 test 2",
6940 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6941 BPF_LD_IMM64(R1, 3),
6942 BPF_LD_IMM64(R2, 2),
6943 BPF_JMP_REG(BPF_JLE, R2, R1, 0),
6944 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6949 { { 0, 0xffffffffU } },
6952 "JMP_JLE_X: ldimm64 test 3",
6954 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6955 BPF_LD_IMM64(R1, 3),
6956 BPF_LD_IMM64(R2, 2),
6957 BPF_JMP_REG(BPF_JLE, R2, R1, 4),
6958 BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
6959 BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
6966 /* BPF_JMP | BPF_JNE | BPF_X */
6968 "JMP_JNE_X: if (3 != 2) return 1",
6970 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6971 BPF_LD_IMM64(R1, 3),
6972 BPF_LD_IMM64(R2, 2),
6973 BPF_JMP_REG(BPF_JNE, R1, R2, 1),
6975 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6982 /* BPF_JMP | BPF_JEQ | BPF_X */
6984 "JMP_JEQ_X: if (3 == 3) return 1",
6986 BPF_ALU32_IMM(BPF_MOV, R0, 0),
6987 BPF_LD_IMM64(R1, 3),
6988 BPF_LD_IMM64(R2, 3),
6989 BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
6991 BPF_ALU32_IMM(BPF_MOV, R0, 1),
6998 /* BPF_JMP | BPF_JSET | BPF_X */
7000 "JMP_JSET_X: if (0x3 & 0x2) return 1",
7002 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7003 BPF_LD_IMM64(R1, 3),
7004 BPF_LD_IMM64(R2, 2),
7005 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
7007 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7015 "JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
7017 BPF_ALU32_IMM(BPF_MOV, R0, 0),
7018 BPF_LD_IMM64(R1, 3),
7019 BPF_LD_IMM64(R2, 0xffffffff),
7020 BPF_JMP_REG(BPF_JSET, R1, R2, 1),
7022 BPF_ALU32_IMM(BPF_MOV, R0, 1),
7029 { /* Mainly checking JIT here. */
7030 "BPF_MAXINSNS: Very long conditional jump",
7032 INTERNAL | FLAG_NO_DATA,
7035 .fill_helper = bpf_fill_long_jmp,
7038 "JMP_JA: Jump, gap, jump, ...",
7040 CLASSIC | FLAG_NO_DATA,
7042 { { 0, 0xababcbac } },
7043 .fill_helper = bpf_fill_ja,
7045 { /* Mainly checking JIT here. */
7046 "BPF_MAXINSNS: Maximum possible literals",
7048 CLASSIC | FLAG_NO_DATA,
7050 { { 0, 0xffffffff } },
7051 .fill_helper = bpf_fill_maxinsns1,
7053 { /* Mainly checking JIT here. */
7054 "BPF_MAXINSNS: Single literal",
7056 CLASSIC | FLAG_NO_DATA,
7058 { { 0, 0xfefefefe } },
7059 .fill_helper = bpf_fill_maxinsns2,
7061 { /* Mainly checking JIT here. */
7062 "BPF_MAXINSNS: Run/add until end",
7064 CLASSIC | FLAG_NO_DATA,
7066 { { 0, 0x947bf368 } },
7067 .fill_helper = bpf_fill_maxinsns3,
7070 "BPF_MAXINSNS: Too many instructions",
7072 CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
7075 .fill_helper = bpf_fill_maxinsns4,
7076 .expected_errcode = -EINVAL,
7078 { /* Mainly checking JIT here. */
7079 "BPF_MAXINSNS: Very long jump",
7081 CLASSIC | FLAG_NO_DATA,
7083 { { 0, 0xabababab } },
7084 .fill_helper = bpf_fill_maxinsns5,
7086 { /* Mainly checking JIT here. */
7087 "BPF_MAXINSNS: Ctx heavy transformations",
7092 { 1, SKB_VLAN_PRESENT },
7093 { 10, SKB_VLAN_PRESENT }
7095 .fill_helper = bpf_fill_maxinsns6,
7097 { /* Mainly checking JIT here. */
7098 "BPF_MAXINSNS: Call heavy transformations",
7100 CLASSIC | FLAG_NO_DATA,
7102 { { 1, 0 }, { 10, 0 } },
7103 .fill_helper = bpf_fill_maxinsns7,
7105 { /* Mainly checking JIT here. */
7106 "BPF_MAXINSNS: Jump heavy test",
7108 CLASSIC | FLAG_NO_DATA,
7110 { { 0, 0xffffffff } },
7111 .fill_helper = bpf_fill_maxinsns8,
7113 { /* Mainly checking JIT here. */
7114 "BPF_MAXINSNS: Very long jump backwards",
7116 INTERNAL | FLAG_NO_DATA,
7118 { { 0, 0xcbababab } },
7119 .fill_helper = bpf_fill_maxinsns9,
7121 { /* Mainly checking JIT here. */
7122 "BPF_MAXINSNS: Edge hopping nuthouse",
7124 INTERNAL | FLAG_NO_DATA,
7126 { { 0, 0xabababac } },
7127 .fill_helper = bpf_fill_maxinsns10,
7130 "BPF_MAXINSNS: Jump, gap, jump, ...",
7132 CLASSIC | FLAG_NO_DATA,
7134 { { 0, 0xababcbac } },
7135 .fill_helper = bpf_fill_maxinsns11,
7138 "BPF_MAXINSNS: jump over MSH",
7140 CLASSIC | FLAG_EXPECTED_FAIL,
7141 { 0xfa, 0xfb, 0xfc, 0xfd, },
7142 { { 4, 0xabababab } },
7143 .fill_helper = bpf_fill_maxinsns12,
7144 .expected_errcode = -EINVAL,
7147 "BPF_MAXINSNS: exec all MSH",
7150 { 0xfa, 0xfb, 0xfc, 0xfd, },
7151 { { 4, 0xababab83 } },
7152 .fill_helper = bpf_fill_maxinsns13,
7155 "BPF_MAXINSNS: ld_abs+get_processor_id",
7160 .fill_helper = bpf_fill_ld_abs_get_processor_id,
7163 * LD_IND / LD_ABS on fragmented SKBs
7168 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7169 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
7170 BPF_STMT(BPF_RET | BPF_A, 0x0),
7172 CLASSIC | FLAG_SKB_FRAG,
7176 0x42, 0x00, 0x00, 0x00,
7177 0x43, 0x44, 0x00, 0x00,
7178 0x21, 0x07, 0x19, 0x83,
7182 "LD_IND halfword frag",
7184 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7185 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
7186 BPF_STMT(BPF_RET | BPF_A, 0x0),
7188 CLASSIC | FLAG_SKB_FRAG,
7192 0x42, 0x00, 0x00, 0x00,
7193 0x43, 0x44, 0x00, 0x00,
7194 0x21, 0x07, 0x19, 0x83,
7200 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7201 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
7202 BPF_STMT(BPF_RET | BPF_A, 0x0),
7204 CLASSIC | FLAG_SKB_FRAG,
7206 { {0x40, 0x21071983} },
7208 0x42, 0x00, 0x00, 0x00,
7209 0x43, 0x44, 0x00, 0x00,
7210 0x21, 0x07, 0x19, 0x83,
7214 "LD_IND halfword mixed head/frag",
7216 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7217 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
7218 BPF_STMT(BPF_RET | BPF_A, 0x0),
7220 CLASSIC | FLAG_SKB_FRAG,
7221 { [0x3e] = 0x25, [0x3f] = 0x05, },
7223 .frag_data = { 0x19, 0x82 },
7226 "LD_IND word mixed head/frag",
7228 BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7229 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
7230 BPF_STMT(BPF_RET | BPF_A, 0x0),
7232 CLASSIC | FLAG_SKB_FRAG,
7233 { [0x3e] = 0x25, [0x3f] = 0x05, },
7234 { {0x40, 0x25051982} },
7235 .frag_data = { 0x19, 0x82 },
7240 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
7241 BPF_STMT(BPF_RET | BPF_A, 0x0),
7243 CLASSIC | FLAG_SKB_FRAG,
7247 0x42, 0x00, 0x00, 0x00,
7248 0x43, 0x44, 0x00, 0x00,
7249 0x21, 0x07, 0x19, 0x83,
7253 "LD_ABS halfword frag",
7255 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
7256 BPF_STMT(BPF_RET | BPF_A, 0x0),
7258 CLASSIC | FLAG_SKB_FRAG,
7262 0x42, 0x00, 0x00, 0x00,
7263 0x43, 0x44, 0x00, 0x00,
7264 0x21, 0x07, 0x19, 0x83,
7270 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
7271 BPF_STMT(BPF_RET | BPF_A, 0x0),
7273 CLASSIC | FLAG_SKB_FRAG,
7275 { {0x40, 0x21071983} },
7277 0x42, 0x00, 0x00, 0x00,
7278 0x43, 0x44, 0x00, 0x00,
7279 0x21, 0x07, 0x19, 0x83,
7283 "LD_ABS halfword mixed head/frag",
7285 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
7286 BPF_STMT(BPF_RET | BPF_A, 0x0),
7288 CLASSIC | FLAG_SKB_FRAG,
7289 { [0x3e] = 0x25, [0x3f] = 0x05, },
7291 .frag_data = { 0x19, 0x82 },
7294 "LD_ABS word mixed head/frag",
7296 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
7297 BPF_STMT(BPF_RET | BPF_A, 0x0),
7299 CLASSIC | FLAG_SKB_FRAG,
7300 { [0x3e] = 0x25, [0x3f] = 0x05, },
7301 { {0x40, 0x25051982} },
7302 .frag_data = { 0x19, 0x82 },
7305 * LD_IND / LD_ABS on non fragmented SKBs
7309 * this tests that the JIT/interpreter correctly resets X
7310 * before using it in an LD_IND instruction.
7312 "LD_IND byte default X",
7314 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7315 BPF_STMT(BPF_RET | BPF_A, 0x0),
7322 "LD_IND byte positive offset",
7324 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7325 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7326 BPF_STMT(BPF_RET | BPF_A, 0x0),
7329 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7333 "LD_IND byte negative offset",
7335 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7336 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
7337 BPF_STMT(BPF_RET | BPF_A, 0x0),
7340 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7344 "LD_IND byte positive offset, all ff",
7346 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7347 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7348 BPF_STMT(BPF_RET | BPF_A, 0x0),
7351 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
7355 "LD_IND byte positive offset, out of bounds",
7357 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7358 BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7359 BPF_STMT(BPF_RET | BPF_A, 0x0),
7362 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7366 "LD_IND byte negative offset, out of bounds",
7368 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7369 BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
7370 BPF_STMT(BPF_RET | BPF_A, 0x0),
7373 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7377 "LD_IND byte negative offset, multiple calls",
7379 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7380 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
7381 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
7382 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
7383 BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
7384 BPF_STMT(BPF_RET | BPF_A, 0x0),
7387 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7391 "LD_IND halfword positive offset",
7393 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7394 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
7395 BPF_STMT(BPF_RET | BPF_A, 0x0),
7399 [0x1c] = 0xaa, [0x1d] = 0x55,
7400 [0x1e] = 0xbb, [0x1f] = 0x66,
7401 [0x20] = 0xcc, [0x21] = 0x77,
7402 [0x22] = 0xdd, [0x23] = 0x88,
7404 { {0x40, 0xdd88 } },
7407 "LD_IND halfword negative offset",
7409 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7410 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
7411 BPF_STMT(BPF_RET | BPF_A, 0x0),
7415 [0x1c] = 0xaa, [0x1d] = 0x55,
7416 [0x1e] = 0xbb, [0x1f] = 0x66,
7417 [0x20] = 0xcc, [0x21] = 0x77,
7418 [0x22] = 0xdd, [0x23] = 0x88,
7420 { {0x40, 0xbb66 } },
7423 "LD_IND halfword unaligned",
7425 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7426 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
7427 BPF_STMT(BPF_RET | BPF_A, 0x0),
7431 [0x1c] = 0xaa, [0x1d] = 0x55,
7432 [0x1e] = 0xbb, [0x1f] = 0x66,
7433 [0x20] = 0xcc, [0x21] = 0x77,
7434 [0x22] = 0xdd, [0x23] = 0x88,
7436 { {0x40, 0x66cc } },
7439 "LD_IND halfword positive offset, all ff",
7441 BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
7442 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7443 BPF_STMT(BPF_RET | BPF_A, 0x0),
7446 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
7447 { {0x40, 0xffff } },
7450 "LD_IND halfword positive offset, out of bounds",
7452 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7453 BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7454 BPF_STMT(BPF_RET | BPF_A, 0x0),
7457 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7461 "LD_IND halfword negative offset, out of bounds",
7463 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7464 BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
7465 BPF_STMT(BPF_RET | BPF_A, 0x0),
7468 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7472 "LD_IND word positive offset",
7474 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7475 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
7476 BPF_STMT(BPF_RET | BPF_A, 0x0),
7480 [0x1c] = 0xaa, [0x1d] = 0x55,
7481 [0x1e] = 0xbb, [0x1f] = 0x66,
7482 [0x20] = 0xcc, [0x21] = 0x77,
7483 [0x22] = 0xdd, [0x23] = 0x88,
7484 [0x24] = 0xee, [0x25] = 0x99,
7485 [0x26] = 0xff, [0x27] = 0xaa,
7487 { {0x40, 0xee99ffaa } },
7490 "LD_IND word negative offset",
7492 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7493 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
7494 BPF_STMT(BPF_RET | BPF_A, 0x0),
7498 [0x1c] = 0xaa, [0x1d] = 0x55,
7499 [0x1e] = 0xbb, [0x1f] = 0x66,
7500 [0x20] = 0xcc, [0x21] = 0x77,
7501 [0x22] = 0xdd, [0x23] = 0x88,
7502 [0x24] = 0xee, [0x25] = 0x99,
7503 [0x26] = 0xff, [0x27] = 0xaa,
7505 { {0x40, 0xaa55bb66 } },
7508 "LD_IND word unaligned (addr & 3 == 2)",
7510 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7511 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
7512 BPF_STMT(BPF_RET | BPF_A, 0x0),
7516 [0x1c] = 0xaa, [0x1d] = 0x55,
7517 [0x1e] = 0xbb, [0x1f] = 0x66,
7518 [0x20] = 0xcc, [0x21] = 0x77,
7519 [0x22] = 0xdd, [0x23] = 0x88,
7520 [0x24] = 0xee, [0x25] = 0x99,
7521 [0x26] = 0xff, [0x27] = 0xaa,
7523 { {0x40, 0xbb66cc77 } },
7526 "LD_IND word unaligned (addr & 3 == 1)",
7528 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7529 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
7530 BPF_STMT(BPF_RET | BPF_A, 0x0),
7534 [0x1c] = 0xaa, [0x1d] = 0x55,
7535 [0x1e] = 0xbb, [0x1f] = 0x66,
7536 [0x20] = 0xcc, [0x21] = 0x77,
7537 [0x22] = 0xdd, [0x23] = 0x88,
7538 [0x24] = 0xee, [0x25] = 0x99,
7539 [0x26] = 0xff, [0x27] = 0xaa,
7541 { {0x40, 0x55bb66cc } },
7544 "LD_IND word unaligned (addr & 3 == 3)",
7546 BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7547 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
7548 BPF_STMT(BPF_RET | BPF_A, 0x0),
7552 [0x1c] = 0xaa, [0x1d] = 0x55,
7553 [0x1e] = 0xbb, [0x1f] = 0x66,
7554 [0x20] = 0xcc, [0x21] = 0x77,
7555 [0x22] = 0xdd, [0x23] = 0x88,
7556 [0x24] = 0xee, [0x25] = 0x99,
7557 [0x26] = 0xff, [0x27] = 0xaa,
7559 { {0x40, 0x66cc77dd } },
7562 "LD_IND word positive offset, all ff",
7564 BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7565 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
7566 BPF_STMT(BPF_RET | BPF_A, 0x0),
7569 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
7570 { {0x40, 0xffffffff } },
7573 "LD_IND word positive offset, out of bounds",
7575 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7576 BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
7577 BPF_STMT(BPF_RET | BPF_A, 0x0),
7580 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7584 "LD_IND word negative offset, out of bounds",
7586 BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7587 BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
7588 BPF_STMT(BPF_RET | BPF_A, 0x0),
7591 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7597 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
7598 BPF_STMT(BPF_RET | BPF_A, 0x0),
7602 [0x1c] = 0xaa, [0x1d] = 0x55,
7603 [0x1e] = 0xbb, [0x1f] = 0x66,
7604 [0x20] = 0xcc, [0x21] = 0x77,
7605 [0x22] = 0xdd, [0x23] = 0x88,
7606 [0x24] = 0xee, [0x25] = 0x99,
7607 [0x26] = 0xff, [0x27] = 0xaa,
7612 "LD_ABS byte positive offset, all ff",
7614 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7615 BPF_STMT(BPF_RET | BPF_A, 0x0),
7618 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
7622 "LD_ABS byte positive offset, out of bounds",
7624 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7625 BPF_STMT(BPF_RET | BPF_A, 0x0),
7628 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7632 "LD_ABS byte negative offset, out of bounds load",
7634 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
7635 BPF_STMT(BPF_RET | BPF_A, 0x0),
7637 CLASSIC | FLAG_EXPECTED_FAIL,
7638 .expected_errcode = -EINVAL,
7641 "LD_ABS byte negative offset, in bounds",
7643 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7644 BPF_STMT(BPF_RET | BPF_A, 0x0),
7647 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7651 "LD_ABS byte negative offset, out of bounds",
7653 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7654 BPF_STMT(BPF_RET | BPF_A, 0x0),
7657 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7661 "LD_ABS byte negative offset, multiple calls",
7663 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
7664 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
7665 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
7666 BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7667 BPF_STMT(BPF_RET | BPF_A, 0x0),
7670 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7676 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
7677 BPF_STMT(BPF_RET | BPF_A, 0x0),
7681 [0x1c] = 0xaa, [0x1d] = 0x55,
7682 [0x1e] = 0xbb, [0x1f] = 0x66,
7683 [0x20] = 0xcc, [0x21] = 0x77,
7684 [0x22] = 0xdd, [0x23] = 0x88,
7685 [0x24] = 0xee, [0x25] = 0x99,
7686 [0x26] = 0xff, [0x27] = 0xaa,
7688 { {0x40, 0xdd88 } },
7691 "LD_ABS halfword unaligned",
7693 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
7694 BPF_STMT(BPF_RET | BPF_A, 0x0),
7698 [0x1c] = 0xaa, [0x1d] = 0x55,
7699 [0x1e] = 0xbb, [0x1f] = 0x66,
7700 [0x20] = 0xcc, [0x21] = 0x77,
7701 [0x22] = 0xdd, [0x23] = 0x88,
7702 [0x24] = 0xee, [0x25] = 0x99,
7703 [0x26] = 0xff, [0x27] = 0xaa,
7705 { {0x40, 0x99ff } },
7708 "LD_ABS halfword positive offset, all ff",
7710 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
7711 BPF_STMT(BPF_RET | BPF_A, 0x0),
7714 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
7715 { {0x40, 0xffff } },
7718 "LD_ABS halfword positive offset, out of bounds",
7720 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
7721 BPF_STMT(BPF_RET | BPF_A, 0x0),
7724 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7728 "LD_ABS halfword negative offset, out of bounds load",
7730 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
7731 BPF_STMT(BPF_RET | BPF_A, 0x0),
7733 CLASSIC | FLAG_EXPECTED_FAIL,
7734 .expected_errcode = -EINVAL,
7737 "LD_ABS halfword negative offset, in bounds",
7739 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7740 BPF_STMT(BPF_RET | BPF_A, 0x0),
7743 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7744 { {0x40, 0x1982 }, },
7747 "LD_ABS halfword negative offset, out of bounds",
7749 BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7750 BPF_STMT(BPF_RET | BPF_A, 0x0),
7753 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7759 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
7760 BPF_STMT(BPF_RET | BPF_A, 0x0),
7764 [0x1c] = 0xaa, [0x1d] = 0x55,
7765 [0x1e] = 0xbb, [0x1f] = 0x66,
7766 [0x20] = 0xcc, [0x21] = 0x77,
7767 [0x22] = 0xdd, [0x23] = 0x88,
7768 [0x24] = 0xee, [0x25] = 0x99,
7769 [0x26] = 0xff, [0x27] = 0xaa,
7771 { {0x40, 0xaa55bb66 } },
7774 "LD_ABS word unaligned (addr & 3 == 2)",
7776 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
7777 BPF_STMT(BPF_RET | BPF_A, 0x0),
7781 [0x1c] = 0xaa, [0x1d] = 0x55,
7782 [0x1e] = 0xbb, [0x1f] = 0x66,
7783 [0x20] = 0xcc, [0x21] = 0x77,
7784 [0x22] = 0xdd, [0x23] = 0x88,
7785 [0x24] = 0xee, [0x25] = 0x99,
7786 [0x26] = 0xff, [0x27] = 0xaa,
7788 { {0x40, 0xdd88ee99 } },
7791 "LD_ABS word unaligned (addr & 3 == 1)",
7793 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
7794 BPF_STMT(BPF_RET | BPF_A, 0x0),
7798 [0x1c] = 0xaa, [0x1d] = 0x55,
7799 [0x1e] = 0xbb, [0x1f] = 0x66,
7800 [0x20] = 0xcc, [0x21] = 0x77,
7801 [0x22] = 0xdd, [0x23] = 0x88,
7802 [0x24] = 0xee, [0x25] = 0x99,
7803 [0x26] = 0xff, [0x27] = 0xaa,
7805 { {0x40, 0x77dd88ee } },
7808 "LD_ABS word unaligned (addr & 3 == 3)",
7810 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
7811 BPF_STMT(BPF_RET | BPF_A, 0x0),
7815 [0x1c] = 0xaa, [0x1d] = 0x55,
7816 [0x1e] = 0xbb, [0x1f] = 0x66,
7817 [0x20] = 0xcc, [0x21] = 0x77,
7818 [0x22] = 0xdd, [0x23] = 0x88,
7819 [0x24] = 0xee, [0x25] = 0x99,
7820 [0x26] = 0xff, [0x27] = 0xaa,
7822 { {0x40, 0x88ee99ff } },
7825 "LD_ABS word positive offset, all ff",
7827 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
7828 BPF_STMT(BPF_RET | BPF_A, 0x0),
7831 { [0x3c] = 0xff, [0x3d] = 0xff, [0x3e] = 0xff, [0x3f] = 0xff },
7832 { {0x40, 0xffffffff } },
7835 "LD_ABS word positive offset, out of bounds",
7837 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
7838 BPF_STMT(BPF_RET | BPF_A, 0x0),
7841 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7845 "LD_ABS word negative offset, out of bounds load",
7847 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
7848 BPF_STMT(BPF_RET | BPF_A, 0x0),
7850 CLASSIC | FLAG_EXPECTED_FAIL,
7851 .expected_errcode = -EINVAL,
7854 "LD_ABS word negative offset, in bounds",
7856 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
7857 BPF_STMT(BPF_RET | BPF_A, 0x0),
7860 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7861 { {0x40, 0x25051982 }, },
7864 "LD_ABS word negative offset, out of bounds",
7866 BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
7867 BPF_STMT(BPF_RET | BPF_A, 0x0),
7870 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7874 "LDX_MSH standalone, preserved A",
7876 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7877 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
7878 BPF_STMT(BPF_RET | BPF_A, 0x0),
7881 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7882 { {0x40, 0xffeebbaa }, },
7885 "LDX_MSH standalone, preserved A 2",
7887 BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
7888 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
7889 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
7890 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
7891 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
7892 BPF_STMT(BPF_RET | BPF_A, 0x0),
7895 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7896 { {0x40, 0x175e9d63 }, },
7899 "LDX_MSH standalone, test result 1",
7901 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7902 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
7903 BPF_STMT(BPF_MISC | BPF_TXA, 0),
7904 BPF_STMT(BPF_RET | BPF_A, 0x0),
7907 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7911 "LDX_MSH standalone, test result 2",
7913 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7914 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
7915 BPF_STMT(BPF_MISC | BPF_TXA, 0),
7916 BPF_STMT(BPF_RET | BPF_A, 0x0),
7919 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7923 "LDX_MSH standalone, negative offset",
7925 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7926 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
7927 BPF_STMT(BPF_MISC | BPF_TXA, 0),
7928 BPF_STMT(BPF_RET | BPF_A, 0x0),
7931 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7935 "LDX_MSH standalone, negative offset 2",
7937 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7938 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
7939 BPF_STMT(BPF_MISC | BPF_TXA, 0),
7940 BPF_STMT(BPF_RET | BPF_A, 0x0),
7943 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7947 "LDX_MSH standalone, out of bounds",
7949 BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
7950 BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
7951 BPF_STMT(BPF_MISC | BPF_TXA, 0),
7952 BPF_STMT(BPF_RET | BPF_A, 0x0),
7955 { [0x3c] = 0x25, [0x3d] = 0x05, [0x3e] = 0x19, [0x3f] = 0x82 },
7959 * verify that the interpreter or JIT correctly sets A and X
7970 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
7971 BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
7972 BPF_STMT(BPF_RET | BPF_A, 0x0),
7974 CLASSIC | FLAG_NO_DATA,
7985 BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
7986 BPF_STMT(BPF_RET | BPF_A, 0x0),
7988 CLASSIC | FLAG_NO_DATA,
8000 BPF_STMT(BPF_LD | BPF_IMM, 0x66),
8001 BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
8002 BPF_STMT(BPF_RET | BPF_A, 0x0),
8004 CLASSIC | FLAG_NO_DATA,
8015 BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
8016 BPF_STMT(BPF_RET | BPF_A, 0x0),
8018 CLASSIC | FLAG_NO_DATA,
8030 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8031 BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
8032 BPF_STMT(BPF_RET | BPF_A, 0x0),
8034 CLASSIC | FLAG_NO_DATA,
8045 BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
8046 BPF_STMT(BPF_RET | BPF_A, 0x0),
8048 CLASSIC | FLAG_NO_DATA,
8057 * A = A / X ; this halt the filter execution if X is 0
8060 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8061 BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
8062 BPF_STMT(BPF_RET | BPF_K, 0x42),
8064 CLASSIC | FLAG_NO_DATA,
8075 BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
8076 BPF_STMT(BPF_RET | BPF_A, 0x0),
8078 CLASSIC | FLAG_NO_DATA,
8087 * A = A mod X ; this halt the filter execution if X is 0
8090 BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8091 BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
8092 BPF_STMT(BPF_RET | BPF_K, 0x42),
8094 CLASSIC | FLAG_NO_DATA,
8105 BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
8106 BPF_STMT(BPF_RET | BPF_A, 0x0),
8108 CLASSIC | FLAG_NO_DATA,
8120 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
8121 BPF_STMT(BPF_RET | BPF_K, 0x42),
8122 BPF_STMT(BPF_RET | BPF_K, 0x66),
8124 CLASSIC | FLAG_NO_DATA,
8137 BPF_STMT(BPF_LD | BPF_IMM, 0x0),
8138 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
8139 BPF_STMT(BPF_RET | BPF_K, 0x42),
8140 BPF_STMT(BPF_RET | BPF_K, 0x66),
8142 CLASSIC | FLAG_NO_DATA,
8146 /* Checking interpreter vs JIT wrt signed extended imms. */
8148 "JNE signed compare, test 1",
8150 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8151 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8152 BPF_MOV64_REG(R2, R1),
8153 BPF_ALU64_REG(BPF_AND, R2, R3),
8154 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8155 BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
8156 BPF_ALU32_IMM(BPF_MOV, R0, 2),
8164 "JNE signed compare, test 2",
8166 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8167 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8168 BPF_MOV64_REG(R2, R1),
8169 BPF_ALU64_REG(BPF_AND, R2, R3),
8170 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8171 BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
8172 BPF_ALU32_IMM(BPF_MOV, R0, 2),
8180 "JNE signed compare, test 3",
8182 BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8183 BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8184 BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
8185 BPF_MOV64_REG(R2, R1),
8186 BPF_ALU64_REG(BPF_AND, R2, R3),
8187 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8188 BPF_JMP_REG(BPF_JNE, R2, R4, 1),
8189 BPF_ALU32_IMM(BPF_MOV, R0, 2),
8197 "JNE signed compare, test 4",
8199 BPF_LD_IMM64(R1, -17104896),
8200 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8201 BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
8202 BPF_ALU32_IMM(BPF_MOV, R0, 2),
8210 "JNE signed compare, test 5",
8212 BPF_LD_IMM64(R1, 0xfefb0000),
8213 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8214 BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
8215 BPF_ALU32_IMM(BPF_MOV, R0, 2),
8223 "JNE signed compare, test 6",
8225 BPF_LD_IMM64(R1, 0x7efb0000),
8226 BPF_ALU32_IMM(BPF_MOV, R0, 1),
8227 BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
8228 BPF_ALU32_IMM(BPF_MOV, R0, 2),
8236 "JNE signed compare, test 7",
8238 BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
8239 BPF_STMT(BPF_MISC | BPF_TAX, 0),
8240 BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
8241 BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
8242 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
8243 BPF_STMT(BPF_RET | BPF_K, 1),
8244 BPF_STMT(BPF_RET | BPF_K, 2),
8246 CLASSIC | FLAG_NO_DATA,
8252 static struct net_device dev;
8254 static struct sk_buff *populate_skb(char *buf, int size)
8256 struct sk_buff *skb;
8258 if (size >= MAX_DATA)
8261 skb = alloc_skb(MAX_DATA, GFP_KERNEL);
8265 __skb_put_data(skb, buf, size);
8267 /* Initialize a fake skb with test pattern. */
8268 skb_reset_mac_header(skb);
8269 skb->protocol = htons(ETH_P_IP);
8270 skb->pkt_type = SKB_TYPE;
8271 skb->mark = SKB_MARK;
8272 skb->hash = SKB_HASH;
8273 skb->queue_mapping = SKB_QUEUE_MAP;
8274 skb->vlan_tci = SKB_VLAN_TCI;
8275 skb->vlan_present = SKB_VLAN_PRESENT;
8276 skb->vlan_proto = htons(ETH_P_IP);
8277 dev_net_set(&dev, &init_net);
8279 skb->dev->ifindex = SKB_DEV_IFINDEX;
8280 skb->dev->type = SKB_DEV_TYPE;
8281 skb_set_network_header(skb, min(size, ETH_HLEN));
8286 static void *generate_test_data(struct bpf_test *test, int sub)
8288 struct sk_buff *skb;
8291 if (test->aux & FLAG_NO_DATA)
8294 /* Test case expects an skb, so populate one. Various
8295 * subtests generate skbs of different sizes based on
8298 skb = populate_skb(test->data, test->test[sub].data_size);
8302 if (test->aux & FLAG_SKB_FRAG) {
8304 * when the test requires a fragmented skb, add a
8305 * single fragment to the skb, filled with
8310 page = alloc_page(GFP_KERNEL);
8318 memcpy(ptr, test->frag_data, MAX_DATA);
8320 skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
8332 static void release_test_data(const struct bpf_test *test, void *data)
8334 if (test->aux & FLAG_NO_DATA)
8340 static int filter_length(int which)
8342 struct sock_filter *fp;
8345 if (tests[which].fill_helper)
8346 return tests[which].u.ptr.len;
8348 fp = tests[which].u.insns;
8349 for (len = MAX_INSNS - 1; len > 0; --len)
8350 if (fp[len].code != 0 || fp[len].k != 0)
8356 static void *filter_pointer(int which)
8358 if (tests[which].fill_helper)
8359 return tests[which].u.ptr.insns;
8361 return tests[which].u.insns;
8364 static struct bpf_prog *generate_filter(int which, int *err)
8366 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8367 unsigned int flen = filter_length(which);
8368 void *fptr = filter_pointer(which);
8369 struct sock_fprog_kern fprog;
8370 struct bpf_prog *fp;
8372 switch (test_type) {
8374 fprog.filter = fptr;
8377 *err = bpf_prog_create(&fp, &fprog);
8378 if (tests[which].aux & FLAG_EXPECTED_FAIL) {
8379 if (*err == tests[which].expected_errcode) {
8381 /* Verifier rejected filter as expected. */
8385 pr_cont("UNEXPECTED_PASS\n");
8386 /* Verifier didn't reject the test that's
8387 * bad enough, just return!
8394 pr_cont("FAIL to prog_create err=%d len=%d\n",
8401 fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
8403 pr_cont("UNEXPECTED_FAIL no memory left\n");
8409 /* Type doesn't really matter here as long as it's not unspec. */
8410 fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
8411 memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
8412 fp->aux->stack_depth = tests[which].stack_depth;
8414 /* We cannot error here as we don't need type compatibility
8417 fp = bpf_prog_select_runtime(fp, err);
8419 pr_cont("FAIL to select_runtime err=%d\n", *err);
8429 static void release_filter(struct bpf_prog *fp, int which)
8431 __u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8433 switch (test_type) {
8435 bpf_prog_destroy(fp);
8443 static int __run_one(const struct bpf_prog *fp, const void *data,
8444 int runs, u64 *duration)
8450 start = ktime_get_ns();
8452 for (i = 0; i < runs; i++)
8453 ret = BPF_PROG_RUN(fp, data);
8455 finish = ktime_get_ns();
8458 *duration = finish - start;
8459 do_div(*duration, runs);
8464 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
8466 int err_cnt = 0, i, runs = MAX_TESTRUNS;
8468 for (i = 0; i < MAX_SUBTESTS; i++) {
8474 * NOTE: Several sub-tests may be present, in which case
8475 * a zero {data_size, result} tuple indicates the end of
8476 * the sub-test array. The first test is always run,
8477 * even if both data_size and result happen to be zero.
8480 test->test[i].data_size == 0 &&
8481 test->test[i].result == 0)
8484 data = generate_test_data(test, i);
8485 if (!data && !(test->aux & FLAG_NO_DATA)) {
8486 pr_cont("data generation failed ");
8490 ret = __run_one(fp, data, runs, &duration);
8491 release_test_data(test, data);
8493 if (ret == test->test[i].result) {
8494 pr_cont("%lld ", duration);
8496 pr_cont("ret %d != %d ", ret,
8497 test->test[i].result);
8505 static char test_name[64];
8506 module_param_string(test_name, test_name, sizeof(test_name), 0);
8508 static int test_id = -1;
8509 module_param(test_id, int, 0);
8511 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
8512 module_param_array(test_range, int, NULL, 0);
8514 static __init int find_test_index(const char *test_name)
8518 for (i = 0; i < ARRAY_SIZE(tests); i++) {
8519 if (!strcmp(tests[i].descr, test_name))
8525 static __init int prepare_bpf_tests(void)
8531 * if a test_id was specified, use test_range to
8532 * cover only that test.
8534 if (test_id >= ARRAY_SIZE(tests)) {
8535 pr_err("test_bpf: invalid test_id specified.\n");
8539 test_range[0] = test_id;
8540 test_range[1] = test_id;
8541 } else if (*test_name) {
8543 * if a test_name was specified, find it and setup
8544 * test_range to cover only that test.
8546 int idx = find_test_index(test_name);
8549 pr_err("test_bpf: no test named '%s' found.\n",
8553 test_range[0] = idx;
8554 test_range[1] = idx;
8557 * check that the supplied test_range is valid.
8559 if (test_range[0] >= ARRAY_SIZE(tests) ||
8560 test_range[1] >= ARRAY_SIZE(tests) ||
8561 test_range[0] < 0 || test_range[1] < 0) {
8562 pr_err("test_bpf: test_range is out of bound.\n");
8566 if (test_range[1] < test_range[0]) {
8567 pr_err("test_bpf: test_range is ending before it starts.\n");
8572 for (i = 0; i < ARRAY_SIZE(tests); i++) {
8573 if (tests[i].fill_helper &&
8574 tests[i].fill_helper(&tests[i]) < 0)
8581 static __init void destroy_bpf_tests(void)
8585 for (i = 0; i < ARRAY_SIZE(tests); i++) {
8586 if (tests[i].fill_helper)
8587 kfree(tests[i].u.ptr.insns);
8591 static bool exclude_test(int test_id)
8593 return test_id < test_range[0] || test_id > test_range[1];
8596 static __init struct sk_buff *build_test_skb(void)
8598 u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
8599 struct sk_buff *skb[2];
8600 struct page *page[2];
8601 int i, data_size = 8;
8603 for (i = 0; i < 2; i++) {
8604 page[i] = alloc_page(GFP_KERNEL);
8612 /* this will set skb[i]->head_frag */
8613 skb[i] = dev_alloc_skb(headroom + data_size);
8621 skb_reserve(skb[i], headroom);
8622 skb_put(skb[i], data_size);
8623 skb[i]->protocol = htons(ETH_P_IP);
8624 skb_reset_network_header(skb[i]);
8625 skb_set_mac_header(skb[i], -ETH_HLEN);
8627 skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
8628 // skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
8632 skb_shinfo(skb[0])->gso_size = 1448;
8633 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
8634 skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
8635 skb_shinfo(skb[0])->gso_segs = 0;
8636 skb_shinfo(skb[0])->frag_list = skb[1];
8638 /* adjust skb[0]'s len */
8639 skb[0]->len += skb[1]->len;
8640 skb[0]->data_len += skb[1]->data_len;
8641 skb[0]->truesize += skb[1]->truesize;
8646 __free_page(page[1]);
8650 __free_page(page[0]);
8655 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
8657 unsigned int alloc_size = 2000;
8658 unsigned int headroom = 102, doffset = 72, data_size = 1308;
8659 struct sk_buff *skb[2];
8662 /* skbs linked in a frag_list, both with linear data, with head_frag=0
8663 * (data allocated by kmalloc), both have tcp data of 1308 bytes
8664 * (total payload is 2616 bytes).
8665 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
8667 for (i = 0; i < 2; i++) {
8668 skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
8676 skb[i]->protocol = htons(ETH_P_IPV6);
8677 skb_reserve(skb[i], headroom);
8678 skb_put(skb[i], doffset + data_size);
8679 skb_reset_network_header(skb[i]);
8681 skb_reset_mac_header(skb[i]);
8683 skb_set_mac_header(skb[i], -ETH_HLEN);
8684 __skb_pull(skb[i], doffset);
8688 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
8691 skb_shinfo(skb[0])->gso_size = 1288;
8692 skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
8693 skb_shinfo(skb[0])->gso_segs = 0;
8694 skb_shinfo(skb[0])->frag_list = skb[1];
8696 /* adjust skb[0]'s len */
8697 skb[0]->len += skb[1]->len;
8698 skb[0]->data_len += skb[1]->len;
8699 skb[0]->truesize += skb[1]->truesize;
8709 struct skb_segment_test {
8711 struct sk_buff *(*build_skb)(void);
8712 netdev_features_t features;
8715 static struct skb_segment_test skb_segment_tests[] __initconst = {
8717 .descr = "gso_with_rx_frags",
8718 .build_skb = build_test_skb,
8719 .features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
8720 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
8723 .descr = "gso_linear_no_head_frag",
8724 .build_skb = build_test_skb_linear_no_head_frag,
8725 .features = NETIF_F_SG | NETIF_F_FRAGLIST |
8726 NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
8727 NETIF_F_LLTX_BIT | NETIF_F_GRO |
8728 NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
8729 NETIF_F_HW_VLAN_STAG_TX_BIT
8733 static __init int test_skb_segment_single(const struct skb_segment_test *test)
8735 struct sk_buff *skb, *segs;
8738 skb = test->build_skb();
8740 pr_info("%s: failed to build_test_skb", __func__);
8744 segs = skb_segment(skb, test->features);
8745 if (!IS_ERR(segs)) {
8746 kfree_skb_list(segs);
8754 static __init int test_skb_segment(void)
8756 int i, err_cnt = 0, pass_cnt = 0;
8758 for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
8759 const struct skb_segment_test *test = &skb_segment_tests[i];
8761 pr_info("#%d %s ", i, test->descr);
8763 if (test_skb_segment_single(test)) {
8772 pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
8774 return err_cnt ? -EINVAL : 0;
8777 static __init int test_bpf(void)
8779 int i, err_cnt = 0, pass_cnt = 0;
8780 int jit_cnt = 0, run_cnt = 0;
8782 for (i = 0; i < ARRAY_SIZE(tests); i++) {
8783 struct bpf_prog *fp;
8787 if (exclude_test(i))
8790 pr_info("#%d %s ", i, tests[i].descr);
8792 fp = generate_filter(i, &err);
8802 pr_cont("jited:%u ", fp->jited);
8808 err = run_one(fp, &tests[i]);
8809 release_filter(fp, i);
8812 pr_cont("FAIL (%d times)\n", err);
8820 pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
8821 pass_cnt, err_cnt, jit_cnt, run_cnt);
8823 return err_cnt ? -EINVAL : 0;
8826 static int __init test_bpf_init(void)
8830 ret = prepare_bpf_tests();
8835 destroy_bpf_tests();
8839 return test_skb_segment();
8842 static void __exit test_bpf_exit(void)
8846 module_init(test_bpf_init);
8847 module_exit(test_bpf_exit);
8849 MODULE_LICENSE("GPL");