• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Testsuite for BPF interpreter and BPF JIT compiler
4  *
5  * Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
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>
20 
21 /* General test specific settings */
22 #define MAX_SUBTESTS	3
23 #define MAX_TESTRUNS	1000
24 #define MAX_DATA	128
25 #define MAX_INSNS	512
26 #define MAX_K		0xffffFFFF
27 
28 /* Few constants used to init test 'skb' */
29 #define SKB_TYPE	3
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
37 
38 /* Redefine REGs to make tests less verbose */
39 #define R0		BPF_REG_0
40 #define R1		BPF_REG_1
41 #define R2		BPF_REG_2
42 #define R3		BPF_REG_3
43 #define R4		BPF_REG_4
44 #define R5		BPF_REG_5
45 #define R6		BPF_REG_6
46 #define R7		BPF_REG_7
47 #define R8		BPF_REG_8
48 #define R9		BPF_REG_9
49 #define R10		BPF_REG_10
50 
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)
55 
56 enum {
57 	CLASSIC  = BIT(6),	/* Old BPF instructions only. */
58 	INTERNAL = BIT(7),	/* Extended instruction set.  */
59 };
60 
61 #define TEST_TYPE_MASK		(CLASSIC | INTERNAL)
62 
63 struct bpf_test {
64 	const char *descr;
65 	union {
66 		struct sock_filter insns[MAX_INSNS];
67 		struct bpf_insn insns_int[MAX_INSNS];
68 		struct {
69 			void *insns;
70 			unsigned int len;
71 		} ptr;
72 	} u;
73 	__u8 aux;
74 	__u8 data[MAX_DATA];
75 	struct {
76 		int data_size;
77 		__u32 result;
78 	} test[MAX_SUBTESTS];
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 */
83 };
84 
85 /* Large test cases need separate allocation and fill handler. */
86 
bpf_fill_maxinsns1(struct bpf_test * self)87 static int bpf_fill_maxinsns1(struct bpf_test *self)
88 {
89 	unsigned int len = BPF_MAXINSNS;
90 	struct sock_filter *insn;
91 	__u32 k = ~0;
92 	int i;
93 
94 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
95 	if (!insn)
96 		return -ENOMEM;
97 
98 	for (i = 0; i < len; i++, k--)
99 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, k);
100 
101 	self->u.ptr.insns = insn;
102 	self->u.ptr.len = len;
103 
104 	return 0;
105 }
106 
bpf_fill_maxinsns2(struct bpf_test * self)107 static int bpf_fill_maxinsns2(struct bpf_test *self)
108 {
109 	unsigned int len = BPF_MAXINSNS;
110 	struct sock_filter *insn;
111 	int i;
112 
113 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
114 	if (!insn)
115 		return -ENOMEM;
116 
117 	for (i = 0; i < len; i++)
118 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
119 
120 	self->u.ptr.insns = insn;
121 	self->u.ptr.len = len;
122 
123 	return 0;
124 }
125 
bpf_fill_maxinsns3(struct bpf_test * self)126 static int bpf_fill_maxinsns3(struct bpf_test *self)
127 {
128 	unsigned int len = BPF_MAXINSNS;
129 	struct sock_filter *insn;
130 	struct rnd_state rnd;
131 	int i;
132 
133 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
134 	if (!insn)
135 		return -ENOMEM;
136 
137 	prandom_seed_state(&rnd, 3141592653589793238ULL);
138 
139 	for (i = 0; i < len - 1; i++) {
140 		__u32 k = prandom_u32_state(&rnd);
141 
142 		insn[i] = __BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, k);
143 	}
144 
145 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
146 
147 	self->u.ptr.insns = insn;
148 	self->u.ptr.len = len;
149 
150 	return 0;
151 }
152 
bpf_fill_maxinsns4(struct bpf_test * self)153 static int bpf_fill_maxinsns4(struct bpf_test *self)
154 {
155 	unsigned int len = BPF_MAXINSNS + 1;
156 	struct sock_filter *insn;
157 	int i;
158 
159 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
160 	if (!insn)
161 		return -ENOMEM;
162 
163 	for (i = 0; i < len; i++)
164 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
165 
166 	self->u.ptr.insns = insn;
167 	self->u.ptr.len = len;
168 
169 	return 0;
170 }
171 
bpf_fill_maxinsns5(struct bpf_test * self)172 static int bpf_fill_maxinsns5(struct bpf_test *self)
173 {
174 	unsigned int len = BPF_MAXINSNS;
175 	struct sock_filter *insn;
176 	int i;
177 
178 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
179 	if (!insn)
180 		return -ENOMEM;
181 
182 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
183 
184 	for (i = 1; i < len - 1; i++)
185 		insn[i] = __BPF_STMT(BPF_RET | BPF_K, 0xfefefefe);
186 
187 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
188 
189 	self->u.ptr.insns = insn;
190 	self->u.ptr.len = len;
191 
192 	return 0;
193 }
194 
bpf_fill_maxinsns6(struct bpf_test * self)195 static int bpf_fill_maxinsns6(struct bpf_test *self)
196 {
197 	unsigned int len = BPF_MAXINSNS;
198 	struct sock_filter *insn;
199 	int i;
200 
201 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
202 	if (!insn)
203 		return -ENOMEM;
204 
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);
208 
209 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
210 
211 	self->u.ptr.insns = insn;
212 	self->u.ptr.len = len;
213 
214 	return 0;
215 }
216 
bpf_fill_maxinsns7(struct bpf_test * self)217 static int bpf_fill_maxinsns7(struct bpf_test *self)
218 {
219 	unsigned int len = BPF_MAXINSNS;
220 	struct sock_filter *insn;
221 	int i;
222 
223 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
224 	if (!insn)
225 		return -ENOMEM;
226 
227 	for (i = 0; i < len - 4; i++)
228 		insn[i] = __BPF_STMT(BPF_LD | BPF_W | BPF_ABS, SKF_AD_OFF +
229 				     SKF_AD_CPU);
230 
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 +
233 				   SKF_AD_CPU);
234 	insn[len - 2] = __BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0);
235 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
236 
237 	self->u.ptr.insns = insn;
238 	self->u.ptr.len = len;
239 
240 	return 0;
241 }
242 
bpf_fill_maxinsns8(struct bpf_test * self)243 static int bpf_fill_maxinsns8(struct bpf_test *self)
244 {
245 	unsigned int len = BPF_MAXINSNS;
246 	struct sock_filter *insn;
247 	int i, jmp_off = len - 3;
248 
249 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
250 	if (!insn)
251 		return -ENOMEM;
252 
253 	insn[0] = __BPF_STMT(BPF_LD | BPF_IMM, 0xffffffff);
254 
255 	for (i = 1; i < len - 1; i++)
256 		insn[i] = __BPF_JUMP(BPF_JMP | BPF_JGT, 0xffffffff, jmp_off--, 0);
257 
258 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_A, 0);
259 
260 	self->u.ptr.insns = insn;
261 	self->u.ptr.len = len;
262 
263 	return 0;
264 }
265 
bpf_fill_maxinsns9(struct bpf_test * self)266 static int bpf_fill_maxinsns9(struct bpf_test *self)
267 {
268 	unsigned int len = BPF_MAXINSNS;
269 	struct bpf_insn *insn;
270 	int i;
271 
272 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
273 	if (!insn)
274 		return -ENOMEM;
275 
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();
279 
280 	for (i = 3; i < len - 2; i++)
281 		insn[i] = BPF_ALU32_IMM(BPF_MOV, R0, 0xfefefefe);
282 
283 	insn[len - 2] = BPF_EXIT_INSN();
284 	insn[len - 1] = BPF_JMP_IMM(BPF_JA, 0, 0, -(len - 1));
285 
286 	self->u.ptr.insns = insn;
287 	self->u.ptr.len = len;
288 
289 	return 0;
290 }
291 
bpf_fill_maxinsns10(struct bpf_test * self)292 static int bpf_fill_maxinsns10(struct bpf_test *self)
293 {
294 	unsigned int len = BPF_MAXINSNS, hlen = len - 2;
295 	struct bpf_insn *insn;
296 	int i;
297 
298 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
299 	if (!insn)
300 		return -ENOMEM;
301 
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);
306 
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();
310 
311 	self->u.ptr.insns = insn;
312 	self->u.ptr.len = len;
313 
314 	return 0;
315 }
316 
__bpf_fill_ja(struct bpf_test * self,unsigned int len,unsigned int plen)317 static int __bpf_fill_ja(struct bpf_test *self, unsigned int len,
318 			 unsigned int plen)
319 {
320 	struct sock_filter *insn;
321 	unsigned int rlen;
322 	int i, j;
323 
324 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
325 	if (!insn)
326 		return -ENOMEM;
327 
328 	rlen = (len % plen) - 1;
329 
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,
333 						 plen - 1 - j, 0, 0);
334 	for (j = 0; j < rlen; j++)
335 		insn[i + j] = __BPF_JUMP(BPF_JMP | BPF_JA, rlen - 1 - j,
336 					 0, 0);
337 
338 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xababcbac);
339 
340 	self->u.ptr.insns = insn;
341 	self->u.ptr.len = len;
342 
343 	return 0;
344 }
345 
bpf_fill_maxinsns11(struct bpf_test * self)346 static int bpf_fill_maxinsns11(struct bpf_test *self)
347 {
348 	/* Hits 70 passes on x86_64 and triggers NOPs padding. */
349 	return __bpf_fill_ja(self, BPF_MAXINSNS, 68);
350 }
351 
bpf_fill_maxinsns12(struct bpf_test * self)352 static int bpf_fill_maxinsns12(struct bpf_test *self)
353 {
354 	unsigned int len = BPF_MAXINSNS;
355 	struct sock_filter *insn;
356 	int i = 0;
357 
358 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
359 	if (!insn)
360 		return -ENOMEM;
361 
362 	insn[0] = __BPF_JUMP(BPF_JMP | BPF_JA, len - 2, 0, 0);
363 
364 	for (i = 1; i < len - 1; i++)
365 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
366 
367 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xabababab);
368 
369 	self->u.ptr.insns = insn;
370 	self->u.ptr.len = len;
371 
372 	return 0;
373 }
374 
bpf_fill_maxinsns13(struct bpf_test * self)375 static int bpf_fill_maxinsns13(struct bpf_test *self)
376 {
377 	unsigned int len = BPF_MAXINSNS;
378 	struct sock_filter *insn;
379 	int i = 0;
380 
381 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
382 	if (!insn)
383 		return -ENOMEM;
384 
385 	for (i = 0; i < len - 3; i++)
386 		insn[i] = __BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0);
387 
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);
391 
392 	self->u.ptr.insns = insn;
393 	self->u.ptr.len = len;
394 
395 	return 0;
396 }
397 
bpf_fill_ja(struct bpf_test * self)398 static int bpf_fill_ja(struct bpf_test *self)
399 {
400 	/* Hits exactly 11 passes on x86_64 JIT. */
401 	return __bpf_fill_ja(self, 12, 9);
402 }
403 
bpf_fill_ld_abs_get_processor_id(struct bpf_test * self)404 static int bpf_fill_ld_abs_get_processor_id(struct bpf_test *self)
405 {
406 	unsigned int len = BPF_MAXINSNS;
407 	struct sock_filter *insn;
408 	int i;
409 
410 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
411 	if (!insn)
412 		return -ENOMEM;
413 
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);
418 	}
419 
420 	insn[len - 1] = __BPF_STMT(BPF_RET | BPF_K, 0xbee);
421 
422 	self->u.ptr.insns = insn;
423 	self->u.ptr.len = len;
424 
425 	return 0;
426 }
427 
__bpf_fill_stxdw(struct bpf_test * self,int size)428 static int __bpf_fill_stxdw(struct bpf_test *self, int size)
429 {
430 	unsigned int len = BPF_MAXINSNS;
431 	struct bpf_insn *insn;
432 	int i;
433 
434 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
435 	if (!insn)
436 		return -ENOMEM;
437 
438 	insn[0] = BPF_ALU32_IMM(BPF_MOV, R0, 1);
439 	insn[1] = BPF_ST_MEM(size, R10, -40, 42);
440 
441 	for (i = 2; i < len - 2; i++)
442 		insn[i] = BPF_STX_XADD(size, R10, R0, -40);
443 
444 	insn[len - 2] = BPF_LDX_MEM(size, R0, R10, -40);
445 	insn[len - 1] = BPF_EXIT_INSN();
446 
447 	self->u.ptr.insns = insn;
448 	self->u.ptr.len = len;
449 	self->stack_depth = 40;
450 
451 	return 0;
452 }
453 
bpf_fill_stxw(struct bpf_test * self)454 static int bpf_fill_stxw(struct bpf_test *self)
455 {
456 	return __bpf_fill_stxdw(self, BPF_W);
457 }
458 
bpf_fill_stxdw(struct bpf_test * self)459 static int bpf_fill_stxdw(struct bpf_test *self)
460 {
461 	return __bpf_fill_stxdw(self, BPF_DW);
462 }
463 
bpf_fill_long_jmp(struct bpf_test * self)464 static int bpf_fill_long_jmp(struct bpf_test *self)
465 {
466 	unsigned int len = BPF_MAXINSNS;
467 	struct bpf_insn *insn;
468 	int i;
469 
470 	insn = kmalloc_array(len, sizeof(*insn), GFP_KERNEL);
471 	if (!insn)
472 		return -ENOMEM;
473 
474 	insn[0] = BPF_ALU64_IMM(BPF_MOV, R0, 1);
475 	insn[1] = BPF_JMP_IMM(BPF_JEQ, R0, 1, len - 2 - 1);
476 
477 	/*
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.
482 	 *
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
486 	 * branch conversion.
487 	 */
488 	for (i = 2; i < len - 1; i++)
489 		insn[i] = BPF_ALU64_IMM(BPF_MUL, R0, (i << 16) + i);
490 
491 	insn[len - 1] = BPF_EXIT_INSN();
492 
493 	self->u.ptr.insns = insn;
494 	self->u.ptr.len = len;
495 
496 	return 0;
497 }
498 
499 static struct bpf_test tests[] = {
500 	{
501 		"TAX",
502 		.u.insns = {
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)
514 		},
515 		CLASSIC,
516 		{ 10, 20, 30, 40, 50 },
517 		{ { 2, 10 }, { 3, 20 }, { 4, 30 } },
518 	},
519 	{
520 		"TXA",
521 		.u.insns = {
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 */
526 		},
527 		CLASSIC,
528 		{ 10, 20, 30, 40, 50 },
529 		{ { 1, 2 }, { 3, 6 }, { 4, 8 } },
530 	},
531 	{
532 		"ADD_SUB_MUL_K",
533 		.u.insns = {
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)
541 		},
542 		CLASSIC | FLAG_NO_DATA,
543 		{ },
544 		{ { 0, 0xfffffffd } }
545 	},
546 	{
547 		"DIV_MOD_KX",
548 		.u.insns = {
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)
565 		},
566 		CLASSIC | FLAG_NO_DATA,
567 		{ },
568 		{ { 0, 0x20000000 } }
569 	},
570 	{
571 		"AND_OR_LSH_K",
572 		.u.insns = {
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)
581 		},
582 		CLASSIC | FLAG_NO_DATA,
583 		{ },
584 		{ { 0, 0x800000ff }, { 1, 0x800000ff } },
585 	},
586 	{
587 		"LD_IMM_0",
588 		.u.insns = {
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),
593 		},
594 		CLASSIC,
595 		{ },
596 		{ { 1, 1 } },
597 	},
598 	{
599 		"LD_IND",
600 		.u.insns = {
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)
604 		},
605 		CLASSIC,
606 		{ },
607 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
608 	},
609 	{
610 		"LD_ABS",
611 		.u.insns = {
612 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS, 1000),
613 			BPF_STMT(BPF_RET | BPF_K, 1)
614 		},
615 		CLASSIC,
616 		{ },
617 		{ { 1, 0 }, { 10, 0 }, { 60, 0 } },
618 	},
619 	{
620 		"LD_ABS_LL",
621 		.u.insns = {
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)
627 		},
628 		CLASSIC,
629 		{ 1, 2, 3 },
630 		{ { 1, 0 }, { 2, 3 } },
631 	},
632 	{
633 		"LD_IND_LL",
634 		.u.insns = {
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)
641 		},
642 		CLASSIC,
643 		{ 1, 2, 3, 0xff },
644 		{ { 1, 1 }, { 3, 3 }, { 4, 0xff } },
645 	},
646 	{
647 		"LD_ABS_NET",
648 		.u.insns = {
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)
654 		},
655 		CLASSIC,
656 		{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 },
657 		{ { 15, 0 }, { 16, 3 } },
658 	},
659 	{
660 		"LD_IND_NET",
661 		.u.insns = {
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)
668 		},
669 		CLASSIC,
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 } },
672 	},
673 	{
674 		"LD_PKTTYPE",
675 		.u.insns = {
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)
689 		},
690 		CLASSIC,
691 		{ },
692 		{ { 1, 3 }, { 10, 3 } },
693 	},
694 	{
695 		"LD_MARK",
696 		.u.insns = {
697 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
698 				 SKF_AD_OFF + SKF_AD_MARK),
699 			BPF_STMT(BPF_RET | BPF_A, 0)
700 		},
701 		CLASSIC,
702 		{ },
703 		{ { 1, SKB_MARK}, { 10, SKB_MARK} },
704 	},
705 	{
706 		"LD_RXHASH",
707 		.u.insns = {
708 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
709 				 SKF_AD_OFF + SKF_AD_RXHASH),
710 			BPF_STMT(BPF_RET | BPF_A, 0)
711 		},
712 		CLASSIC,
713 		{ },
714 		{ { 1, SKB_HASH}, { 10, SKB_HASH} },
715 	},
716 	{
717 		"LD_QUEUE",
718 		.u.insns = {
719 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
720 				 SKF_AD_OFF + SKF_AD_QUEUE),
721 			BPF_STMT(BPF_RET | BPF_A, 0)
722 		},
723 		CLASSIC,
724 		{ },
725 		{ { 1, SKB_QUEUE_MAP }, { 10, SKB_QUEUE_MAP } },
726 	},
727 	{
728 		"LD_PROTOCOL",
729 		.u.insns = {
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)
741 		},
742 		CLASSIC,
743 		{ 10, 20, 30 },
744 		{ { 10, ETH_P_IP }, { 100, ETH_P_IP } },
745 	},
746 	{
747 		"LD_VLAN_TAG",
748 		.u.insns = {
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)
752 		},
753 		CLASSIC,
754 		{ },
755 		{
756 			{ 1, SKB_VLAN_TCI },
757 			{ 10, SKB_VLAN_TCI }
758 		},
759 	},
760 	{
761 		"LD_VLAN_TAG_PRESENT",
762 		.u.insns = {
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)
766 		},
767 		CLASSIC,
768 		{ },
769 		{
770 			{ 1, SKB_VLAN_PRESENT },
771 			{ 10, SKB_VLAN_PRESENT }
772 		},
773 	},
774 	{
775 		"LD_IFINDEX",
776 		.u.insns = {
777 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
778 				 SKF_AD_OFF + SKF_AD_IFINDEX),
779 			BPF_STMT(BPF_RET | BPF_A, 0)
780 		},
781 		CLASSIC,
782 		{ },
783 		{ { 1, SKB_DEV_IFINDEX }, { 10, SKB_DEV_IFINDEX } },
784 	},
785 	{
786 		"LD_HATYPE",
787 		.u.insns = {
788 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
789 				 SKF_AD_OFF + SKF_AD_HATYPE),
790 			BPF_STMT(BPF_RET | BPF_A, 0)
791 		},
792 		CLASSIC,
793 		{ },
794 		{ { 1, SKB_DEV_TYPE }, { 10, SKB_DEV_TYPE } },
795 	},
796 	{
797 		"LD_CPU",
798 		.u.insns = {
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)
806 		},
807 		CLASSIC,
808 		{ },
809 		{ { 1, 0 }, { 10, 0 } },
810 	},
811 	{
812 		"LD_NLATTR",
813 		.u.insns = {
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)
820 		},
821 		CLASSIC,
822 #ifdef __BIG_ENDIAN
823 		{ 0xff, 0xff, 0, 4, 0, 2, 0, 4, 0, 3 },
824 #else
825 		{ 0xff, 0xff, 4, 0, 2, 0, 4, 0, 3, 0 },
826 #endif
827 		{ { 4, 0 }, { 20, 6 } },
828 	},
829 	{
830 		"LD_NLATTR_NEST",
831 		.u.insns = {
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)
858 		},
859 		CLASSIC,
860 #ifdef __BIG_ENDIAN
861 		{ 0xff, 0xff, 0, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3 },
862 #else
863 		{ 0xff, 0xff, 12, 0, 1, 0, 4, 0, 2, 0, 4, 0, 3, 0 },
864 #endif
865 		{ { 4, 0 }, { 20, 10 } },
866 	},
867 	{
868 		"LD_PAYLOAD_OFF",
869 		.u.insns = {
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)
881 		},
882 		CLASSIC,
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
886 		 */
887 		{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
888 		  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
889 		  0x08, 0x00,
890 		  0x45, 0x00, 0x00, 0x54, 0xac, 0x8b, 0x40, 0x00, 0x40,
891 		  0x01, 0x90, 0x1b, 0x7f, 0x00, 0x00, 0x01 },
892 		{ { 30, 0 }, { 100, 42 } },
893 	},
894 	{
895 		"LD_ANC_XOR",
896 		.u.insns = {
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)
902 		},
903 		CLASSIC,
904 		{ },
905 		{ { 4, 0xA ^ 300 }, { 20, 0xA ^ 300 } },
906 	},
907 	{
908 		"SPILL_FILL",
909 		.u.insns = {
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)
924 		},
925 		CLASSIC,
926 		{ },
927 		{ { 1, 0x80000001 }, { 2, 0x80000002 }, { 60, 0x80000000 ^ 60 } }
928 	},
929 	{
930 		"JEQ",
931 		.u.insns = {
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)
937 		},
938 		CLASSIC,
939 		{ 3, 3, 3, 3, 3 },
940 		{ { 1, 0 }, { 3, 1 }, { 4, MAX_K } },
941 	},
942 	{
943 		"JGT",
944 		.u.insns = {
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)
950 		},
951 		CLASSIC,
952 		{ 4, 4, 4, 3, 3 },
953 		{ { 2, 0 }, { 3, 1 }, { 4, MAX_K } },
954 	},
955 	{
956 		"JGE (jt 0), test 1",
957 		.u.insns = {
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)
963 		},
964 		CLASSIC,
965 		{ 4, 4, 4, 3, 3 },
966 		{ { 2, 0 }, { 3, 1 }, { 4, 1 } },
967 	},
968 	{
969 		"JGE (jt 0), test 2",
970 		.u.insns = {
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)
976 		},
977 		CLASSIC,
978 		{ 4, 4, 5, 3, 3 },
979 		{ { 4, 1 }, { 5, 1 }, { 6, MAX_K } },
980 	},
981 	{
982 		"JGE",
983 		.u.insns = {
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)
995 		},
996 		CLASSIC,
997 		{ 1, 2, 3, 4, 5 },
998 		{ { 1, 20 }, { 3, 40 }, { 5, MAX_K } },
999 	},
1000 	{
1001 		"JSET",
1002 		.u.insns = {
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)
1027 		},
1028 		CLASSIC,
1029 		{ 0, 0xAA, 0x55, 1 },
1030 		{ { 4, 10 }, { 5, 20 }, { 6, MAX_K } },
1031 	},
1032 	{
1033 		"tcpdump port 22",
1034 		.u.insns = {
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),
1059 		},
1060 		CLASSIC,
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
1065 		 */
1066 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1067 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1068 		  0x08, 0x00,
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 */
1073 		  0xc2, 0x24,
1074 		  0x00, 0x16 /* dst port */ },
1075 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1076 	},
1077 	{
1078 		"tcpdump complex",
1079 		.u.insns = {
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
1083 			 */
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),
1117 		},
1118 		CLASSIC,
1119 		{ 0x10, 0xbf, 0x48, 0xd6, 0x43, 0xd6,
1120 		  0x3c, 0x07, 0x54, 0x43, 0xe5, 0x76,
1121 		  0x08, 0x00,
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 */
1126 		  0xc2, 0x24,
1127 		  0x00, 0x16 /* dst port */ },
1128 		{ { 10, 0 }, { 30, 0 }, { 100, 65535 } },
1129 	},
1130 	{
1131 		"RET_A",
1132 		.u.insns = {
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)
1136 		},
1137 		CLASSIC,
1138 		{ },
1139 		{ {1, 0}, {2, 0} },
1140 	},
1141 	{
1142 		"INT: ADD trivial",
1143 		.u.insns_int = {
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),
1151 			BPF_EXIT_INSN(),
1152 		},
1153 		INTERNAL,
1154 		{ },
1155 		{ { 0, 0xfffffffd } }
1156 	},
1157 	{
1158 		"INT: MUL_X",
1159 		.u.insns_int = {
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),
1165 			BPF_EXIT_INSN(),
1166 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
1167 			BPF_EXIT_INSN(),
1168 		},
1169 		INTERNAL,
1170 		{ },
1171 		{ { 0, 1 } }
1172 	},
1173 	{
1174 		"INT: MUL_X2",
1175 		.u.insns_int = {
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),
1182 			BPF_EXIT_INSN(),
1183 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
1184 			BPF_EXIT_INSN(),
1185 		},
1186 		INTERNAL,
1187 		{ },
1188 		{ { 0, 1 } }
1189 	},
1190 	{
1191 		"INT: MUL32_X",
1192 		.u.insns_int = {
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),
1199 			BPF_EXIT_INSN(),
1200 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
1201 			BPF_EXIT_INSN(),
1202 		},
1203 		INTERNAL,
1204 		{ },
1205 		{ { 0, 1 } }
1206 	},
1207 	{
1208 		/* Have to test all register combinations, since
1209 		 * JITing of different registers will produce
1210 		 * different asm code.
1211 		 */
1212 		"INT: ADD 64-bit",
1213 		.u.insns_int = {
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),
1255 			BPF_EXIT_INSN(),
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),
1267 			BPF_EXIT_INSN(),
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),
1279 			BPF_EXIT_INSN(),
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),
1291 			BPF_EXIT_INSN(),
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),
1303 			BPF_EXIT_INSN(),
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),
1315 			BPF_EXIT_INSN(),
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),
1327 			BPF_EXIT_INSN(),
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),
1339 			BPF_EXIT_INSN(),
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),
1351 			BPF_EXIT_INSN(),
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),
1363 			BPF_EXIT_INSN(),
1364 		},
1365 		INTERNAL,
1366 		{ },
1367 		{ { 0, 2957380 } }
1368 	},
1369 	{
1370 		"INT: ADD 32-bit",
1371 		.u.insns_int = {
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),
1401 			BPF_EXIT_INSN(),
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),
1413 			BPF_EXIT_INSN(),
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),
1425 			BPF_EXIT_INSN(),
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),
1437 			BPF_EXIT_INSN(),
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),
1449 			BPF_EXIT_INSN(),
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),
1461 			BPF_EXIT_INSN(),
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),
1473 			BPF_EXIT_INSN(),
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),
1485 			BPF_EXIT_INSN(),
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),
1497 			BPF_EXIT_INSN(),
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),
1509 			BPF_EXIT_INSN(),
1510 		},
1511 		INTERNAL,
1512 		{ },
1513 		{ { 0, 2957380 } }
1514 	},
1515 	{	/* Mainly checking JIT here. */
1516 		"INT: SUB",
1517 		.u.insns_int = {
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),
1540 			BPF_EXIT_INSN(),
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),
1642 			BPF_EXIT_INSN(),
1643 		},
1644 		INTERNAL,
1645 		{ },
1646 		{ { 0, 11 } }
1647 	},
1648 	{	/* Mainly checking JIT here. */
1649 		"INT: XOR",
1650 		.u.insns_int = {
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),
1654 			BPF_EXIT_INSN(),
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),
1660 			BPF_EXIT_INSN(),
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),
1666 			BPF_EXIT_INSN(),
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),
1672 			BPF_EXIT_INSN(),
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),
1678 			BPF_EXIT_INSN(),
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),
1685 			BPF_EXIT_INSN(),
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),
1689 			BPF_EXIT_INSN(),
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),
1693 			BPF_EXIT_INSN(),
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),
1697 			BPF_EXIT_INSN(),
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),
1701 			BPF_EXIT_INSN(),
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),
1706 			BPF_EXIT_INSN(),
1707 			BPF_ALU64_IMM(BPF_MOV, R0, 1),
1708 			BPF_EXIT_INSN(),
1709 		},
1710 		INTERNAL,
1711 		{ },
1712 		{ { 0, 1 } }
1713 	},
1714 	{	/* Mainly checking JIT here. */
1715 		"INT: MUL",
1716 		.u.insns_int = {
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),
1739 			BPF_EXIT_INSN(),
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),
1753 			BPF_EXIT_INSN(),
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),
1757 			BPF_EXIT_INSN(),
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),
1770 			BPF_EXIT_INSN(),
1771 		},
1772 		INTERNAL,
1773 		{ },
1774 		{ { 0, 0x35d97ef2 } }
1775 	},
1776 	{	/* Mainly checking JIT here. */
1777 		"MOV REG64",
1778 		.u.insns_int = {
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),
1810 			BPF_EXIT_INSN(),
1811 		},
1812 		INTERNAL,
1813 		{ },
1814 		{ { 0, 0xfefe } }
1815 	},
1816 	{	/* Mainly checking JIT here. */
1817 		"MOV REG32",
1818 		.u.insns_int = {
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),
1850 			BPF_EXIT_INSN(),
1851 		},
1852 		INTERNAL,
1853 		{ },
1854 		{ { 0, 0xfefe } }
1855 	},
1856 	{	/* Mainly checking JIT here. */
1857 		"LD IMM64",
1858 		.u.insns_int = {
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),
1890 			BPF_EXIT_INSN(),
1891 		},
1892 		INTERNAL,
1893 		{ },
1894 		{ { 0, 0xfefe } }
1895 	},
1896 	{
1897 		"INT: ALU MIX",
1898 		.u.insns_int = {
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),
1905 			BPF_EXIT_INSN(),
1906 			BPF_ALU64_IMM(BPF_MOD, R0, 3),
1907 			BPF_JMP_IMM(BPF_JEQ, R0, 1, 1),
1908 			BPF_EXIT_INSN(),
1909 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
1910 			BPF_EXIT_INSN(),
1911 		},
1912 		INTERNAL,
1913 		{ },
1914 		{ { 0, -1 } }
1915 	},
1916 	{
1917 		"INT: shifts by register",
1918 		.u.insns_int = {
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),
1923 			BPF_EXIT_INSN(),
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),
1928 			BPF_EXIT_INSN(),
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),
1934 			BPF_EXIT_INSN(),
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),
1938 			BPF_EXIT_INSN(),
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),
1942 			BPF_EXIT_INSN(),
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),
1946 			BPF_EXIT_INSN(),
1947 			BPF_MOV64_IMM(R0, -1),
1948 			BPF_EXIT_INSN(),
1949 		},
1950 		INTERNAL,
1951 		{ },
1952 		{ { 0, -1 } }
1953 	},
1954 	{
1955 		/*
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.
1962 		 */
1963 		"INT: Register clobbering, R1 updated",
1964 		.u.insns_int = {
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),
1987 			BPF_EXIT_INSN(),
1988 		},
1989 		INTERNAL,
1990 		{ },
1991 		{ { 0, 1 } }
1992 	},
1993 	{
1994 		"INT: Register clobbering, R2 updated",
1995 		.u.insns_int = {
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),
2018 			BPF_EXIT_INSN(),
2019 		},
2020 		INTERNAL,
2021 		{ },
2022 		{ { 0, 1 } }
2023 	},
2024 	{
2025 		/*
2026 		 * Test 32-bit JITs that implement complex ALU64 operations as
2027 		 * function calls R0 = f(R1, R2), and must re-arrange operands.
2028 		 */
2029 #define NUMER 0xfedcba9876543210ULL
2030 #define DENOM 0x0123456789abcdefULL
2031 		"ALU64_DIV X: Operand register permutations",
2032 		.u.insns_int = {
2033 			/* R0 / R2 */
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),
2038 			BPF_EXIT_INSN(),
2039 			/* R1 / R0 */
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),
2044 			BPF_EXIT_INSN(),
2045 			/* R0 / R1 */
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),
2050 			BPF_EXIT_INSN(),
2051 			/* R2 / R0 */
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),
2056 			BPF_EXIT_INSN(),
2057 			/* R2 / R1 */
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),
2062 			BPF_EXIT_INSN(),
2063 			/* R1 / R2 */
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),
2068 			BPF_EXIT_INSN(),
2069 			/* R1 / R1 */
2070 			BPF_LD_IMM64(R1, NUMER),
2071 			BPF_ALU64_REG(BPF_DIV, R1, R1),
2072 			BPF_JMP_IMM(BPF_JEQ, R1, 1, 1),
2073 			BPF_EXIT_INSN(),
2074 			/* R2 / R2 */
2075 			BPF_LD_IMM64(R2, DENOM),
2076 			BPF_ALU64_REG(BPF_DIV, R2, R2),
2077 			BPF_JMP_IMM(BPF_JEQ, R2, 1, 1),
2078 			BPF_EXIT_INSN(),
2079 			/* R3 / R4 */
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),
2084 			BPF_EXIT_INSN(),
2085 			/* Successful return */
2086 			BPF_LD_IMM64(R0, 1),
2087 			BPF_EXIT_INSN(),
2088 		},
2089 		INTERNAL,
2090 		{ },
2091 		{ { 0, 1 } },
2092 #undef NUMER
2093 #undef DENOM
2094 	},
2095 #ifdef CONFIG_32BIT
2096 	{
2097 		"INT: 32-bit context pointer word order and zero-extension",
2098 		.u.insns_int = {
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),
2104 			BPF_EXIT_INSN(),
2105 		},
2106 		INTERNAL,
2107 		{ },
2108 		{ { 0, 1 } }
2109 	},
2110 #endif
2111 	{
2112 		"check: missing ret",
2113 		.u.insns = {
2114 			BPF_STMT(BPF_LD | BPF_IMM, 1),
2115 		},
2116 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2117 		{ },
2118 		{ },
2119 		.fill_helper = NULL,
2120 		.expected_errcode = -EINVAL,
2121 	},
2122 	{
2123 		"check: div_k_0",
2124 		.u.insns = {
2125 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0),
2126 			BPF_STMT(BPF_RET | BPF_K, 0)
2127 		},
2128 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2129 		{ },
2130 		{ },
2131 		.fill_helper = NULL,
2132 		.expected_errcode = -EINVAL,
2133 	},
2134 	{
2135 		"check: unknown insn",
2136 		.u.insns = {
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)
2140 		},
2141 		CLASSIC | FLAG_EXPECTED_FAIL,
2142 		{ },
2143 		{ },
2144 		.fill_helper = NULL,
2145 		.expected_errcode = -EINVAL,
2146 	},
2147 	{
2148 		"check: out of range spill/fill",
2149 		.u.insns = {
2150 			BPF_STMT(BPF_STX, 16),
2151 			BPF_STMT(BPF_RET | BPF_K, 0)
2152 		},
2153 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2154 		{ },
2155 		{ },
2156 		.fill_helper = NULL,
2157 		.expected_errcode = -EINVAL,
2158 	},
2159 	{
2160 		"JUMPS + HOLES",
2161 		.u.insns = {
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),
2219 		},
2220 		CLASSIC,
2221 		{ 0x00, 0x1b, 0x21, 0x3c, 0x9d, 0xf8,
2222 		  0x90, 0xe2, 0xba, 0x0a, 0x56, 0xb4,
2223 		  0x08, 0x00,
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,
2228 		  0xbb, 0xb6,
2229 		  0xa9, 0xfa,
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 },
2239 		{ { 88, 0x001b } }
2240 	},
2241 	{
2242 		"check: RET X",
2243 		.u.insns = {
2244 			BPF_STMT(BPF_RET | BPF_X, 0),
2245 		},
2246 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2247 		{ },
2248 		{ },
2249 		.fill_helper = NULL,
2250 		.expected_errcode = -EINVAL,
2251 	},
2252 	{
2253 		"check: LDX + RET X",
2254 		.u.insns = {
2255 			BPF_STMT(BPF_LDX | BPF_IMM, 42),
2256 			BPF_STMT(BPF_RET | BPF_X, 0),
2257 		},
2258 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2259 		{ },
2260 		{ },
2261 		.fill_helper = NULL,
2262 		.expected_errcode = -EINVAL,
2263 	},
2264 	{	/* Mainly checking JIT here. */
2265 		"M[]: alt STX + LDX",
2266 		.u.insns = {
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),
2349 		},
2350 		CLASSIC | FLAG_NO_DATA,
2351 		{ },
2352 		{ { 0, 116 } },
2353 	},
2354 	{	/* Mainly checking JIT here. */
2355 		"M[]: full STX + full LDX",
2356 		.u.insns = {
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),
2422 		},
2423 		CLASSIC | FLAG_NO_DATA,
2424 		{ },
2425 		{ { 0, 0x2a5a5e5 } },
2426 	},
2427 	{
2428 		"check: SKF_AD_MAX",
2429 		.u.insns = {
2430 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2431 				 SKF_AD_OFF + SKF_AD_MAX),
2432 			BPF_STMT(BPF_RET | BPF_A, 0),
2433 		},
2434 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
2435 		{ },
2436 		{ },
2437 		.fill_helper = NULL,
2438 		.expected_errcode = -EINVAL,
2439 	},
2440 	{	/* Passes checker but fails during runtime. */
2441 		"LD [SKF_AD_OFF-1]",
2442 		.u.insns = {
2443 			BPF_STMT(BPF_LD | BPF_W | BPF_ABS,
2444 				 SKF_AD_OFF - 1),
2445 			BPF_STMT(BPF_RET | BPF_K, 1),
2446 		},
2447 		CLASSIC,
2448 		{ },
2449 		{ { 1, 0 } },
2450 	},
2451 	{
2452 		"load 64-bit immediate",
2453 		.u.insns_int = {
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),
2462 			BPF_EXIT_INSN(),
2463 			BPF_JMP_IMM(BPF_JEQ, R3, 0x1234, 1),
2464 			BPF_EXIT_INSN(),
2465 			BPF_LD_IMM64(R0, 0x1ffffffffLL),
2466 			BPF_ALU64_IMM(BPF_RSH, R0, 32), /* R0 = 1 */
2467 			BPF_EXIT_INSN(),
2468 		},
2469 		INTERNAL,
2470 		{ },
2471 		{ { 0, 1 } }
2472 	},
2473 	/* BPF_ALU | BPF_MOV | BPF_X */
2474 	{
2475 		"ALU_MOV_X: dst = 2",
2476 		.u.insns_int = {
2477 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
2478 			BPF_ALU32_REG(BPF_MOV, R0, R1),
2479 			BPF_EXIT_INSN(),
2480 		},
2481 		INTERNAL,
2482 		{ },
2483 		{ { 0, 2 } },
2484 	},
2485 	{
2486 		"ALU_MOV_X: dst = 4294967295",
2487 		.u.insns_int = {
2488 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2489 			BPF_ALU32_REG(BPF_MOV, R0, R1),
2490 			BPF_EXIT_INSN(),
2491 		},
2492 		INTERNAL,
2493 		{ },
2494 		{ { 0, 4294967295U } },
2495 	},
2496 	{
2497 		"ALU64_MOV_X: dst = 2",
2498 		.u.insns_int = {
2499 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
2500 			BPF_ALU64_REG(BPF_MOV, R0, R1),
2501 			BPF_EXIT_INSN(),
2502 		},
2503 		INTERNAL,
2504 		{ },
2505 		{ { 0, 2 } },
2506 	},
2507 	{
2508 		"ALU64_MOV_X: dst = 4294967295",
2509 		.u.insns_int = {
2510 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
2511 			BPF_ALU64_REG(BPF_MOV, R0, R1),
2512 			BPF_EXIT_INSN(),
2513 		},
2514 		INTERNAL,
2515 		{ },
2516 		{ { 0, 4294967295U } },
2517 	},
2518 	/* BPF_ALU | BPF_MOV | BPF_K */
2519 	{
2520 		"ALU_MOV_K: dst = 2",
2521 		.u.insns_int = {
2522 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
2523 			BPF_EXIT_INSN(),
2524 		},
2525 		INTERNAL,
2526 		{ },
2527 		{ { 0, 2 } },
2528 	},
2529 	{
2530 		"ALU_MOV_K: dst = 4294967295",
2531 		.u.insns_int = {
2532 			BPF_ALU32_IMM(BPF_MOV, R0, 4294967295U),
2533 			BPF_EXIT_INSN(),
2534 		},
2535 		INTERNAL,
2536 		{ },
2537 		{ { 0, 4294967295U } },
2538 	},
2539 	{
2540 		"ALU_MOV_K: 0x0000ffffffff0000 = 0x00000000ffffffff",
2541 		.u.insns_int = {
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),
2547 			BPF_EXIT_INSN(),
2548 			BPF_MOV32_IMM(R0, 1),
2549 			BPF_EXIT_INSN(),
2550 		},
2551 		INTERNAL,
2552 		{ },
2553 		{ { 0, 0x1 } },
2554 	},
2555 	{
2556 		"ALU_MOV_K: small negative",
2557 		.u.insns_int = {
2558 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
2559 			BPF_EXIT_INSN(),
2560 		},
2561 		INTERNAL,
2562 		{ },
2563 		{ { 0, -123 } }
2564 	},
2565 	{
2566 		"ALU_MOV_K: small negative zero extension",
2567 		.u.insns_int = {
2568 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
2569 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
2570 			BPF_EXIT_INSN(),
2571 		},
2572 		INTERNAL,
2573 		{ },
2574 		{ { 0, 0 } }
2575 	},
2576 	{
2577 		"ALU_MOV_K: large negative",
2578 		.u.insns_int = {
2579 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2580 			BPF_EXIT_INSN(),
2581 		},
2582 		INTERNAL,
2583 		{ },
2584 		{ { 0, -123456789 } }
2585 	},
2586 	{
2587 		"ALU_MOV_K: large negative zero extension",
2588 		.u.insns_int = {
2589 			BPF_ALU32_IMM(BPF_MOV, R0, -123456789),
2590 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
2591 			BPF_EXIT_INSN(),
2592 		},
2593 		INTERNAL,
2594 		{ },
2595 		{ { 0, 0 } }
2596 	},
2597 	{
2598 		"ALU64_MOV_K: dst = 2",
2599 		.u.insns_int = {
2600 			BPF_ALU64_IMM(BPF_MOV, R0, 2),
2601 			BPF_EXIT_INSN(),
2602 		},
2603 		INTERNAL,
2604 		{ },
2605 		{ { 0, 2 } },
2606 	},
2607 	{
2608 		"ALU64_MOV_K: dst = 2147483647",
2609 		.u.insns_int = {
2610 			BPF_ALU64_IMM(BPF_MOV, R0, 2147483647),
2611 			BPF_EXIT_INSN(),
2612 		},
2613 		INTERNAL,
2614 		{ },
2615 		{ { 0, 2147483647 } },
2616 	},
2617 	{
2618 		"ALU64_OR_K: dst = 0x0",
2619 		.u.insns_int = {
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),
2625 			BPF_EXIT_INSN(),
2626 			BPF_MOV32_IMM(R0, 1),
2627 			BPF_EXIT_INSN(),
2628 		},
2629 		INTERNAL,
2630 		{ },
2631 		{ { 0, 0x1 } },
2632 	},
2633 	{
2634 		"ALU64_MOV_K: dst = -1",
2635 		.u.insns_int = {
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),
2641 			BPF_EXIT_INSN(),
2642 			BPF_MOV32_IMM(R0, 1),
2643 			BPF_EXIT_INSN(),
2644 		},
2645 		INTERNAL,
2646 		{ },
2647 		{ { 0, 0x1 } },
2648 	},
2649 	{
2650 		"ALU64_MOV_K: small negative",
2651 		.u.insns_int = {
2652 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
2653 			BPF_EXIT_INSN(),
2654 		},
2655 		INTERNAL,
2656 		{ },
2657 		{ { 0, -123 } }
2658 	},
2659 	{
2660 		"ALU64_MOV_K: small negative sign extension",
2661 		.u.insns_int = {
2662 			BPF_ALU64_IMM(BPF_MOV, R0, -123),
2663 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
2664 			BPF_EXIT_INSN(),
2665 		},
2666 		INTERNAL,
2667 		{ },
2668 		{ { 0, 0xffffffff } }
2669 	},
2670 	{
2671 		"ALU64_MOV_K: large negative",
2672 		.u.insns_int = {
2673 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2674 			BPF_EXIT_INSN(),
2675 		},
2676 		INTERNAL,
2677 		{ },
2678 		{ { 0, -123456789 } }
2679 	},
2680 	{
2681 		"ALU64_MOV_K: large negative sign extension",
2682 		.u.insns_int = {
2683 			BPF_ALU64_IMM(BPF_MOV, R0, -123456789),
2684 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
2685 			BPF_EXIT_INSN(),
2686 		},
2687 		INTERNAL,
2688 		{ },
2689 		{ { 0, 0xffffffff } }
2690 	},
2691 	/* BPF_ALU | BPF_ADD | BPF_X */
2692 	{
2693 		"ALU_ADD_X: 1 + 2 = 3",
2694 		.u.insns_int = {
2695 			BPF_LD_IMM64(R0, 1),
2696 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
2697 			BPF_ALU32_REG(BPF_ADD, R0, R1),
2698 			BPF_EXIT_INSN(),
2699 		},
2700 		INTERNAL,
2701 		{ },
2702 		{ { 0, 3 } },
2703 	},
2704 	{
2705 		"ALU_ADD_X: 1 + 4294967294 = 4294967295",
2706 		.u.insns_int = {
2707 			BPF_LD_IMM64(R0, 1),
2708 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2709 			BPF_ALU32_REG(BPF_ADD, R0, R1),
2710 			BPF_EXIT_INSN(),
2711 		},
2712 		INTERNAL,
2713 		{ },
2714 		{ { 0, 4294967295U } },
2715 	},
2716 	{
2717 		"ALU_ADD_X: 2 + 4294967294 = 0",
2718 		.u.insns_int = {
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),
2724 			BPF_EXIT_INSN(),
2725 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
2726 			BPF_EXIT_INSN(),
2727 		},
2728 		INTERNAL,
2729 		{ },
2730 		{ { 0, 1 } },
2731 	},
2732 	{
2733 		"ALU64_ADD_X: 1 + 2 = 3",
2734 		.u.insns_int = {
2735 			BPF_LD_IMM64(R0, 1),
2736 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
2737 			BPF_ALU64_REG(BPF_ADD, R0, R1),
2738 			BPF_EXIT_INSN(),
2739 		},
2740 		INTERNAL,
2741 		{ },
2742 		{ { 0, 3 } },
2743 	},
2744 	{
2745 		"ALU64_ADD_X: 1 + 4294967294 = 4294967295",
2746 		.u.insns_int = {
2747 			BPF_LD_IMM64(R0, 1),
2748 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
2749 			BPF_ALU64_REG(BPF_ADD, R0, R1),
2750 			BPF_EXIT_INSN(),
2751 		},
2752 		INTERNAL,
2753 		{ },
2754 		{ { 0, 4294967295U } },
2755 	},
2756 	{
2757 		"ALU64_ADD_X: 2 + 4294967294 = 4294967296",
2758 		.u.insns_int = {
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),
2765 			BPF_EXIT_INSN(),
2766 			BPF_MOV32_IMM(R0, 1),
2767 			BPF_EXIT_INSN(),
2768 		},
2769 		INTERNAL,
2770 		{ },
2771 		{ { 0, 1 } },
2772 	},
2773 	/* BPF_ALU | BPF_ADD | BPF_K */
2774 	{
2775 		"ALU_ADD_K: 1 + 2 = 3",
2776 		.u.insns_int = {
2777 			BPF_LD_IMM64(R0, 1),
2778 			BPF_ALU32_IMM(BPF_ADD, R0, 2),
2779 			BPF_EXIT_INSN(),
2780 		},
2781 		INTERNAL,
2782 		{ },
2783 		{ { 0, 3 } },
2784 	},
2785 	{
2786 		"ALU_ADD_K: 3 + 0 = 3",
2787 		.u.insns_int = {
2788 			BPF_LD_IMM64(R0, 3),
2789 			BPF_ALU32_IMM(BPF_ADD, R0, 0),
2790 			BPF_EXIT_INSN(),
2791 		},
2792 		INTERNAL,
2793 		{ },
2794 		{ { 0, 3 } },
2795 	},
2796 	{
2797 		"ALU_ADD_K: 1 + 4294967294 = 4294967295",
2798 		.u.insns_int = {
2799 			BPF_LD_IMM64(R0, 1),
2800 			BPF_ALU32_IMM(BPF_ADD, R0, 4294967294U),
2801 			BPF_EXIT_INSN(),
2802 		},
2803 		INTERNAL,
2804 		{ },
2805 		{ { 0, 4294967295U } },
2806 	},
2807 	{
2808 		"ALU_ADD_K: 4294967294 + 2 = 0",
2809 		.u.insns_int = {
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),
2814 			BPF_EXIT_INSN(),
2815 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
2816 			BPF_EXIT_INSN(),
2817 		},
2818 		INTERNAL,
2819 		{ },
2820 		{ { 0, 1 } },
2821 	},
2822 	{
2823 		"ALU_ADD_K: 0 + (-1) = 0x00000000ffffffff",
2824 		.u.insns_int = {
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),
2830 			BPF_EXIT_INSN(),
2831 			BPF_MOV32_IMM(R0, 1),
2832 			BPF_EXIT_INSN(),
2833 		},
2834 		INTERNAL,
2835 		{ },
2836 		{ { 0, 0x1 } },
2837 	},
2838 	{
2839 		"ALU_ADD_K: 0 + 0xffff = 0xffff",
2840 		.u.insns_int = {
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),
2846 			BPF_EXIT_INSN(),
2847 			BPF_MOV32_IMM(R0, 1),
2848 			BPF_EXIT_INSN(),
2849 		},
2850 		INTERNAL,
2851 		{ },
2852 		{ { 0, 0x1 } },
2853 	},
2854 	{
2855 		"ALU_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
2856 		.u.insns_int = {
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),
2862 			BPF_EXIT_INSN(),
2863 			BPF_MOV32_IMM(R0, 1),
2864 			BPF_EXIT_INSN(),
2865 		},
2866 		INTERNAL,
2867 		{ },
2868 		{ { 0, 0x1 } },
2869 	},
2870 	{
2871 		"ALU_ADD_K: 0 + 0x80000000 = 0x80000000",
2872 		.u.insns_int = {
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),
2878 			BPF_EXIT_INSN(),
2879 			BPF_MOV32_IMM(R0, 1),
2880 			BPF_EXIT_INSN(),
2881 		},
2882 		INTERNAL,
2883 		{ },
2884 		{ { 0, 0x1 } },
2885 	},
2886 	{
2887 		"ALU_ADD_K: 0 + 0x80008000 = 0x80008000",
2888 		.u.insns_int = {
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),
2894 			BPF_EXIT_INSN(),
2895 			BPF_MOV32_IMM(R0, 1),
2896 			BPF_EXIT_INSN(),
2897 		},
2898 		INTERNAL,
2899 		{ },
2900 		{ { 0, 0x1 } },
2901 	},
2902 	{
2903 		"ALU64_ADD_K: 1 + 2 = 3",
2904 		.u.insns_int = {
2905 			BPF_LD_IMM64(R0, 1),
2906 			BPF_ALU64_IMM(BPF_ADD, R0, 2),
2907 			BPF_EXIT_INSN(),
2908 		},
2909 		INTERNAL,
2910 		{ },
2911 		{ { 0, 3 } },
2912 	},
2913 	{
2914 		"ALU64_ADD_K: 3 + 0 = 3",
2915 		.u.insns_int = {
2916 			BPF_LD_IMM64(R0, 3),
2917 			BPF_ALU64_IMM(BPF_ADD, R0, 0),
2918 			BPF_EXIT_INSN(),
2919 		},
2920 		INTERNAL,
2921 		{ },
2922 		{ { 0, 3 } },
2923 	},
2924 	{
2925 		"ALU64_ADD_K: 1 + 2147483646 = 2147483647",
2926 		.u.insns_int = {
2927 			BPF_LD_IMM64(R0, 1),
2928 			BPF_ALU64_IMM(BPF_ADD, R0, 2147483646),
2929 			BPF_EXIT_INSN(),
2930 		},
2931 		INTERNAL,
2932 		{ },
2933 		{ { 0, 2147483647 } },
2934 	},
2935 	{
2936 		"ALU64_ADD_K: 4294967294 + 2 = 4294967296",
2937 		.u.insns_int = {
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),
2943 			BPF_EXIT_INSN(),
2944 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
2945 			BPF_EXIT_INSN(),
2946 		},
2947 		INTERNAL,
2948 		{ },
2949 		{ { 0, 1 } },
2950 	},
2951 	{
2952 		"ALU64_ADD_K: 2147483646 + -2147483647 = -1",
2953 		.u.insns_int = {
2954 			BPF_LD_IMM64(R0, 2147483646),
2955 			BPF_ALU64_IMM(BPF_ADD, R0, -2147483647),
2956 			BPF_EXIT_INSN(),
2957 		},
2958 		INTERNAL,
2959 		{ },
2960 		{ { 0, -1 } },
2961 	},
2962 	{
2963 		"ALU64_ADD_K: 1 + 0 = 1",
2964 		.u.insns_int = {
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),
2970 			BPF_EXIT_INSN(),
2971 			BPF_MOV32_IMM(R0, 1),
2972 			BPF_EXIT_INSN(),
2973 		},
2974 		INTERNAL,
2975 		{ },
2976 		{ { 0, 0x1 } },
2977 	},
2978 	{
2979 		"ALU64_ADD_K: 0 + (-1) = 0xffffffffffffffff",
2980 		.u.insns_int = {
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),
2986 			BPF_EXIT_INSN(),
2987 			BPF_MOV32_IMM(R0, 1),
2988 			BPF_EXIT_INSN(),
2989 		},
2990 		INTERNAL,
2991 		{ },
2992 		{ { 0, 0x1 } },
2993 	},
2994 	{
2995 		"ALU64_ADD_K: 0 + 0xffff = 0xffff",
2996 		.u.insns_int = {
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),
3002 			BPF_EXIT_INSN(),
3003 			BPF_MOV32_IMM(R0, 1),
3004 			BPF_EXIT_INSN(),
3005 		},
3006 		INTERNAL,
3007 		{ },
3008 		{ { 0, 0x1 } },
3009 	},
3010 	{
3011 		"ALU64_ADD_K: 0 + 0x7fffffff = 0x7fffffff",
3012 		.u.insns_int = {
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),
3018 			BPF_EXIT_INSN(),
3019 			BPF_MOV32_IMM(R0, 1),
3020 			BPF_EXIT_INSN(),
3021 		},
3022 		INTERNAL,
3023 		{ },
3024 		{ { 0, 0x1 } },
3025 	},
3026 	{
3027 		"ALU64_ADD_K: 0 + 0x80000000 = 0xffffffff80000000",
3028 		.u.insns_int = {
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),
3034 			BPF_EXIT_INSN(),
3035 			BPF_MOV32_IMM(R0, 1),
3036 			BPF_EXIT_INSN(),
3037 		},
3038 		INTERNAL,
3039 		{ },
3040 		{ { 0, 0x1 } },
3041 	},
3042 	{
3043 		"ALU_ADD_K: 0 + 0x80008000 = 0xffffffff80008000",
3044 		.u.insns_int = {
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),
3050 			BPF_EXIT_INSN(),
3051 			BPF_MOV32_IMM(R0, 1),
3052 			BPF_EXIT_INSN(),
3053 		},
3054 		INTERNAL,
3055 		{ },
3056 		{ { 0, 0x1 } },
3057 	},
3058 	/* BPF_ALU | BPF_SUB | BPF_X */
3059 	{
3060 		"ALU_SUB_X: 3 - 1 = 2",
3061 		.u.insns_int = {
3062 			BPF_LD_IMM64(R0, 3),
3063 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
3064 			BPF_ALU32_REG(BPF_SUB, R0, R1),
3065 			BPF_EXIT_INSN(),
3066 		},
3067 		INTERNAL,
3068 		{ },
3069 		{ { 0, 2 } },
3070 	},
3071 	{
3072 		"ALU_SUB_X: 4294967295 - 4294967294 = 1",
3073 		.u.insns_int = {
3074 			BPF_LD_IMM64(R0, 4294967295U),
3075 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
3076 			BPF_ALU32_REG(BPF_SUB, R0, R1),
3077 			BPF_EXIT_INSN(),
3078 		},
3079 		INTERNAL,
3080 		{ },
3081 		{ { 0, 1 } },
3082 	},
3083 	{
3084 		"ALU64_SUB_X: 3 - 1 = 2",
3085 		.u.insns_int = {
3086 			BPF_LD_IMM64(R0, 3),
3087 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
3088 			BPF_ALU64_REG(BPF_SUB, R0, R1),
3089 			BPF_EXIT_INSN(),
3090 		},
3091 		INTERNAL,
3092 		{ },
3093 		{ { 0, 2 } },
3094 	},
3095 	{
3096 		"ALU64_SUB_X: 4294967295 - 4294967294 = 1",
3097 		.u.insns_int = {
3098 			BPF_LD_IMM64(R0, 4294967295U),
3099 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967294U),
3100 			BPF_ALU64_REG(BPF_SUB, R0, R1),
3101 			BPF_EXIT_INSN(),
3102 		},
3103 		INTERNAL,
3104 		{ },
3105 		{ { 0, 1 } },
3106 	},
3107 	/* BPF_ALU | BPF_SUB | BPF_K */
3108 	{
3109 		"ALU_SUB_K: 3 - 1 = 2",
3110 		.u.insns_int = {
3111 			BPF_LD_IMM64(R0, 3),
3112 			BPF_ALU32_IMM(BPF_SUB, R0, 1),
3113 			BPF_EXIT_INSN(),
3114 		},
3115 		INTERNAL,
3116 		{ },
3117 		{ { 0, 2 } },
3118 	},
3119 	{
3120 		"ALU_SUB_K: 3 - 0 = 3",
3121 		.u.insns_int = {
3122 			BPF_LD_IMM64(R0, 3),
3123 			BPF_ALU32_IMM(BPF_SUB, R0, 0),
3124 			BPF_EXIT_INSN(),
3125 		},
3126 		INTERNAL,
3127 		{ },
3128 		{ { 0, 3 } },
3129 	},
3130 	{
3131 		"ALU_SUB_K: 4294967295 - 4294967294 = 1",
3132 		.u.insns_int = {
3133 			BPF_LD_IMM64(R0, 4294967295U),
3134 			BPF_ALU32_IMM(BPF_SUB, R0, 4294967294U),
3135 			BPF_EXIT_INSN(),
3136 		},
3137 		INTERNAL,
3138 		{ },
3139 		{ { 0, 1 } },
3140 	},
3141 	{
3142 		"ALU64_SUB_K: 3 - 1 = 2",
3143 		.u.insns_int = {
3144 			BPF_LD_IMM64(R0, 3),
3145 			BPF_ALU64_IMM(BPF_SUB, R0, 1),
3146 			BPF_EXIT_INSN(),
3147 		},
3148 		INTERNAL,
3149 		{ },
3150 		{ { 0, 2 } },
3151 	},
3152 	{
3153 		"ALU64_SUB_K: 3 - 0 = 3",
3154 		.u.insns_int = {
3155 			BPF_LD_IMM64(R0, 3),
3156 			BPF_ALU64_IMM(BPF_SUB, R0, 0),
3157 			BPF_EXIT_INSN(),
3158 		},
3159 		INTERNAL,
3160 		{ },
3161 		{ { 0, 3 } },
3162 	},
3163 	{
3164 		"ALU64_SUB_K: 4294967294 - 4294967295 = -1",
3165 		.u.insns_int = {
3166 			BPF_LD_IMM64(R0, 4294967294U),
3167 			BPF_ALU64_IMM(BPF_SUB, R0, 4294967295U),
3168 			BPF_EXIT_INSN(),
3169 		},
3170 		INTERNAL,
3171 		{ },
3172 		{ { 0, -1 } },
3173 	},
3174 	{
3175 		"ALU64_ADD_K: 2147483646 - 2147483647 = -1",
3176 		.u.insns_int = {
3177 			BPF_LD_IMM64(R0, 2147483646),
3178 			BPF_ALU64_IMM(BPF_SUB, R0, 2147483647),
3179 			BPF_EXIT_INSN(),
3180 		},
3181 		INTERNAL,
3182 		{ },
3183 		{ { 0, -1 } },
3184 	},
3185 	/* BPF_ALU | BPF_MUL | BPF_X */
3186 	{
3187 		"ALU_MUL_X: 2 * 3 = 6",
3188 		.u.insns_int = {
3189 			BPF_LD_IMM64(R0, 2),
3190 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
3191 			BPF_ALU32_REG(BPF_MUL, R0, R1),
3192 			BPF_EXIT_INSN(),
3193 		},
3194 		INTERNAL,
3195 		{ },
3196 		{ { 0, 6 } },
3197 	},
3198 	{
3199 		"ALU_MUL_X: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3200 		.u.insns_int = {
3201 			BPF_LD_IMM64(R0, 2),
3202 			BPF_ALU32_IMM(BPF_MOV, R1, 0x7FFFFFF8),
3203 			BPF_ALU32_REG(BPF_MUL, R0, R1),
3204 			BPF_EXIT_INSN(),
3205 		},
3206 		INTERNAL,
3207 		{ },
3208 		{ { 0, 0xFFFFFFF0 } },
3209 	},
3210 	{
3211 		"ALU_MUL_X: -1 * -1 = 1",
3212 		.u.insns_int = {
3213 			BPF_LD_IMM64(R0, -1),
3214 			BPF_ALU32_IMM(BPF_MOV, R1, -1),
3215 			BPF_ALU32_REG(BPF_MUL, R0, R1),
3216 			BPF_EXIT_INSN(),
3217 		},
3218 		INTERNAL,
3219 		{ },
3220 		{ { 0, 1 } },
3221 	},
3222 	{
3223 		"ALU64_MUL_X: 2 * 3 = 6",
3224 		.u.insns_int = {
3225 			BPF_LD_IMM64(R0, 2),
3226 			BPF_ALU32_IMM(BPF_MOV, R1, 3),
3227 			BPF_ALU64_REG(BPF_MUL, R0, R1),
3228 			BPF_EXIT_INSN(),
3229 		},
3230 		INTERNAL,
3231 		{ },
3232 		{ { 0, 6 } },
3233 	},
3234 	{
3235 		"ALU64_MUL_X: 1 * 2147483647 = 2147483647",
3236 		.u.insns_int = {
3237 			BPF_LD_IMM64(R0, 1),
3238 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3239 			BPF_ALU64_REG(BPF_MUL, R0, R1),
3240 			BPF_EXIT_INSN(),
3241 		},
3242 		INTERNAL,
3243 		{ },
3244 		{ { 0, 2147483647 } },
3245 	},
3246 	{
3247 		"ALU64_MUL_X: 64x64 multiply, low word",
3248 		.u.insns_int = {
3249 			BPF_LD_IMM64(R0, 0x0fedcba987654321LL),
3250 			BPF_LD_IMM64(R1, 0x123456789abcdef0LL),
3251 			BPF_ALU64_REG(BPF_MUL, R0, R1),
3252 			BPF_EXIT_INSN(),
3253 		},
3254 		INTERNAL,
3255 		{ },
3256 		{ { 0, 0xe5618cf0 } }
3257 	},
3258 	{
3259 		"ALU64_MUL_X: 64x64 multiply, high word",
3260 		.u.insns_int = {
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),
3265 			BPF_EXIT_INSN(),
3266 		},
3267 		INTERNAL,
3268 		{ },
3269 		{ { 0, 0x2236d88f } }
3270 	},
3271 	/* BPF_ALU | BPF_MUL | BPF_K */
3272 	{
3273 		"ALU_MUL_K: 2 * 3 = 6",
3274 		.u.insns_int = {
3275 			BPF_LD_IMM64(R0, 2),
3276 			BPF_ALU32_IMM(BPF_MUL, R0, 3),
3277 			BPF_EXIT_INSN(),
3278 		},
3279 		INTERNAL,
3280 		{ },
3281 		{ { 0, 6 } },
3282 	},
3283 	{
3284 		"ALU_MUL_K: 3 * 1 = 3",
3285 		.u.insns_int = {
3286 			BPF_LD_IMM64(R0, 3),
3287 			BPF_ALU32_IMM(BPF_MUL, R0, 1),
3288 			BPF_EXIT_INSN(),
3289 		},
3290 		INTERNAL,
3291 		{ },
3292 		{ { 0, 3 } },
3293 	},
3294 	{
3295 		"ALU_MUL_K: 2 * 0x7FFFFFF8 = 0xFFFFFFF0",
3296 		.u.insns_int = {
3297 			BPF_LD_IMM64(R0, 2),
3298 			BPF_ALU32_IMM(BPF_MUL, R0, 0x7FFFFFF8),
3299 			BPF_EXIT_INSN(),
3300 		},
3301 		INTERNAL,
3302 		{ },
3303 		{ { 0, 0xFFFFFFF0 } },
3304 	},
3305 	{
3306 		"ALU_MUL_K: 1 * (-1) = 0x00000000ffffffff",
3307 		.u.insns_int = {
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),
3313 			BPF_EXIT_INSN(),
3314 			BPF_MOV32_IMM(R0, 1),
3315 			BPF_EXIT_INSN(),
3316 		},
3317 		INTERNAL,
3318 		{ },
3319 		{ { 0, 0x1 } },
3320 	},
3321 	{
3322 		"ALU64_MUL_K: 2 * 3 = 6",
3323 		.u.insns_int = {
3324 			BPF_LD_IMM64(R0, 2),
3325 			BPF_ALU64_IMM(BPF_MUL, R0, 3),
3326 			BPF_EXIT_INSN(),
3327 		},
3328 		INTERNAL,
3329 		{ },
3330 		{ { 0, 6 } },
3331 	},
3332 	{
3333 		"ALU64_MUL_K: 3 * 1 = 3",
3334 		.u.insns_int = {
3335 			BPF_LD_IMM64(R0, 3),
3336 			BPF_ALU64_IMM(BPF_MUL, R0, 1),
3337 			BPF_EXIT_INSN(),
3338 		},
3339 		INTERNAL,
3340 		{ },
3341 		{ { 0, 3 } },
3342 	},
3343 	{
3344 		"ALU64_MUL_K: 1 * 2147483647 = 2147483647",
3345 		.u.insns_int = {
3346 			BPF_LD_IMM64(R0, 1),
3347 			BPF_ALU64_IMM(BPF_MUL, R0, 2147483647),
3348 			BPF_EXIT_INSN(),
3349 		},
3350 		INTERNAL,
3351 		{ },
3352 		{ { 0, 2147483647 } },
3353 	},
3354 	{
3355 		"ALU64_MUL_K: 1 * -2147483647 = -2147483647",
3356 		.u.insns_int = {
3357 			BPF_LD_IMM64(R0, 1),
3358 			BPF_ALU64_IMM(BPF_MUL, R0, -2147483647),
3359 			BPF_EXIT_INSN(),
3360 		},
3361 		INTERNAL,
3362 		{ },
3363 		{ { 0, -2147483647 } },
3364 	},
3365 	{
3366 		"ALU64_MUL_K: 1 * (-1) = 0xffffffffffffffff",
3367 		.u.insns_int = {
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),
3373 			BPF_EXIT_INSN(),
3374 			BPF_MOV32_IMM(R0, 1),
3375 			BPF_EXIT_INSN(),
3376 		},
3377 		INTERNAL,
3378 		{ },
3379 		{ { 0, 0x1 } },
3380 	},
3381 	{
3382 		"ALU64_MUL_K: 64x32 multiply, low word",
3383 		.u.insns_int = {
3384 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3385 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
3386 			BPF_EXIT_INSN(),
3387 		},
3388 		INTERNAL,
3389 		{ },
3390 		{ { 0, 0xe242d208 } }
3391 	},
3392 	{
3393 		"ALU64_MUL_K: 64x32 multiply, high word",
3394 		.u.insns_int = {
3395 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
3396 			BPF_ALU64_IMM(BPF_MUL, R0, 0x12345678),
3397 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
3398 			BPF_EXIT_INSN(),
3399 		},
3400 		INTERNAL,
3401 		{ },
3402 		{ { 0, 0xc28f5c28 } }
3403 	},
3404 	/* BPF_ALU | BPF_DIV | BPF_X */
3405 	{
3406 		"ALU_DIV_X: 6 / 2 = 3",
3407 		.u.insns_int = {
3408 			BPF_LD_IMM64(R0, 6),
3409 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3410 			BPF_ALU32_REG(BPF_DIV, R0, R1),
3411 			BPF_EXIT_INSN(),
3412 		},
3413 		INTERNAL,
3414 		{ },
3415 		{ { 0, 3 } },
3416 	},
3417 	{
3418 		"ALU_DIV_X: 4294967295 / 4294967295 = 1",
3419 		.u.insns_int = {
3420 			BPF_LD_IMM64(R0, 4294967295U),
3421 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967295U),
3422 			BPF_ALU32_REG(BPF_DIV, R0, R1),
3423 			BPF_EXIT_INSN(),
3424 		},
3425 		INTERNAL,
3426 		{ },
3427 		{ { 0, 1 } },
3428 	},
3429 	{
3430 		"ALU64_DIV_X: 6 / 2 = 3",
3431 		.u.insns_int = {
3432 			BPF_LD_IMM64(R0, 6),
3433 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3434 			BPF_ALU64_REG(BPF_DIV, R0, R1),
3435 			BPF_EXIT_INSN(),
3436 		},
3437 		INTERNAL,
3438 		{ },
3439 		{ { 0, 3 } },
3440 	},
3441 	{
3442 		"ALU64_DIV_X: 2147483647 / 2147483647 = 1",
3443 		.u.insns_int = {
3444 			BPF_LD_IMM64(R0, 2147483647),
3445 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483647),
3446 			BPF_ALU64_REG(BPF_DIV, R0, R1),
3447 			BPF_EXIT_INSN(),
3448 		},
3449 		INTERNAL,
3450 		{ },
3451 		{ { 0, 1 } },
3452 	},
3453 	{
3454 		"ALU64_DIV_X: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3455 		.u.insns_int = {
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),
3462 			BPF_EXIT_INSN(),
3463 			BPF_MOV32_IMM(R0, 1),
3464 			BPF_EXIT_INSN(),
3465 		},
3466 		INTERNAL,
3467 		{ },
3468 		{ { 0, 0x1 } },
3469 	},
3470 	/* BPF_ALU | BPF_DIV | BPF_K */
3471 	{
3472 		"ALU_DIV_K: 6 / 2 = 3",
3473 		.u.insns_int = {
3474 			BPF_LD_IMM64(R0, 6),
3475 			BPF_ALU32_IMM(BPF_DIV, R0, 2),
3476 			BPF_EXIT_INSN(),
3477 		},
3478 		INTERNAL,
3479 		{ },
3480 		{ { 0, 3 } },
3481 	},
3482 	{
3483 		"ALU_DIV_K: 3 / 1 = 3",
3484 		.u.insns_int = {
3485 			BPF_LD_IMM64(R0, 3),
3486 			BPF_ALU32_IMM(BPF_DIV, R0, 1),
3487 			BPF_EXIT_INSN(),
3488 		},
3489 		INTERNAL,
3490 		{ },
3491 		{ { 0, 3 } },
3492 	},
3493 	{
3494 		"ALU_DIV_K: 4294967295 / 4294967295 = 1",
3495 		.u.insns_int = {
3496 			BPF_LD_IMM64(R0, 4294967295U),
3497 			BPF_ALU32_IMM(BPF_DIV, R0, 4294967295U),
3498 			BPF_EXIT_INSN(),
3499 		},
3500 		INTERNAL,
3501 		{ },
3502 		{ { 0, 1 } },
3503 	},
3504 	{
3505 		"ALU_DIV_K: 0xffffffffffffffff / (-1) = 0x1",
3506 		.u.insns_int = {
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),
3512 			BPF_EXIT_INSN(),
3513 			BPF_MOV32_IMM(R0, 1),
3514 			BPF_EXIT_INSN(),
3515 		},
3516 		INTERNAL,
3517 		{ },
3518 		{ { 0, 0x1 } },
3519 	},
3520 	{
3521 		"ALU64_DIV_K: 6 / 2 = 3",
3522 		.u.insns_int = {
3523 			BPF_LD_IMM64(R0, 6),
3524 			BPF_ALU64_IMM(BPF_DIV, R0, 2),
3525 			BPF_EXIT_INSN(),
3526 		},
3527 		INTERNAL,
3528 		{ },
3529 		{ { 0, 3 } },
3530 	},
3531 	{
3532 		"ALU64_DIV_K: 3 / 1 = 3",
3533 		.u.insns_int = {
3534 			BPF_LD_IMM64(R0, 3),
3535 			BPF_ALU64_IMM(BPF_DIV, R0, 1),
3536 			BPF_EXIT_INSN(),
3537 		},
3538 		INTERNAL,
3539 		{ },
3540 		{ { 0, 3 } },
3541 	},
3542 	{
3543 		"ALU64_DIV_K: 2147483647 / 2147483647 = 1",
3544 		.u.insns_int = {
3545 			BPF_LD_IMM64(R0, 2147483647),
3546 			BPF_ALU64_IMM(BPF_DIV, R0, 2147483647),
3547 			BPF_EXIT_INSN(),
3548 		},
3549 		INTERNAL,
3550 		{ },
3551 		{ { 0, 1 } },
3552 	},
3553 	{
3554 		"ALU64_DIV_K: 0xffffffffffffffff / (-1) = 0x0000000000000001",
3555 		.u.insns_int = {
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),
3561 			BPF_EXIT_INSN(),
3562 			BPF_MOV32_IMM(R0, 1),
3563 			BPF_EXIT_INSN(),
3564 		},
3565 		INTERNAL,
3566 		{ },
3567 		{ { 0, 0x1 } },
3568 	},
3569 	/* BPF_ALU | BPF_MOD | BPF_X */
3570 	{
3571 		"ALU_MOD_X: 3 % 2 = 1",
3572 		.u.insns_int = {
3573 			BPF_LD_IMM64(R0, 3),
3574 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3575 			BPF_ALU32_REG(BPF_MOD, R0, R1),
3576 			BPF_EXIT_INSN(),
3577 		},
3578 		INTERNAL,
3579 		{ },
3580 		{ { 0, 1 } },
3581 	},
3582 	{
3583 		"ALU_MOD_X: 4294967295 % 4294967293 = 2",
3584 		.u.insns_int = {
3585 			BPF_LD_IMM64(R0, 4294967295U),
3586 			BPF_ALU32_IMM(BPF_MOV, R1, 4294967293U),
3587 			BPF_ALU32_REG(BPF_MOD, R0, R1),
3588 			BPF_EXIT_INSN(),
3589 		},
3590 		INTERNAL,
3591 		{ },
3592 		{ { 0, 2 } },
3593 	},
3594 	{
3595 		"ALU64_MOD_X: 3 % 2 = 1",
3596 		.u.insns_int = {
3597 			BPF_LD_IMM64(R0, 3),
3598 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3599 			BPF_ALU64_REG(BPF_MOD, R0, R1),
3600 			BPF_EXIT_INSN(),
3601 		},
3602 		INTERNAL,
3603 		{ },
3604 		{ { 0, 1 } },
3605 	},
3606 	{
3607 		"ALU64_MOD_X: 2147483647 % 2147483645 = 2",
3608 		.u.insns_int = {
3609 			BPF_LD_IMM64(R0, 2147483647),
3610 			BPF_ALU32_IMM(BPF_MOV, R1, 2147483645),
3611 			BPF_ALU64_REG(BPF_MOD, R0, R1),
3612 			BPF_EXIT_INSN(),
3613 		},
3614 		INTERNAL,
3615 		{ },
3616 		{ { 0, 2 } },
3617 	},
3618 	/* BPF_ALU | BPF_MOD | BPF_K */
3619 	{
3620 		"ALU_MOD_K: 3 % 2 = 1",
3621 		.u.insns_int = {
3622 			BPF_LD_IMM64(R0, 3),
3623 			BPF_ALU32_IMM(BPF_MOD, R0, 2),
3624 			BPF_EXIT_INSN(),
3625 		},
3626 		INTERNAL,
3627 		{ },
3628 		{ { 0, 1 } },
3629 	},
3630 	{
3631 		"ALU_MOD_K: 3 % 1 = 0",
3632 		.u.insns_int = {
3633 			BPF_LD_IMM64(R0, 3),
3634 			BPF_ALU32_IMM(BPF_MOD, R0, 1),
3635 			BPF_EXIT_INSN(),
3636 		},
3637 		INTERNAL,
3638 		{ },
3639 		{ { 0, 0 } },
3640 	},
3641 	{
3642 		"ALU_MOD_K: 4294967295 % 4294967293 = 2",
3643 		.u.insns_int = {
3644 			BPF_LD_IMM64(R0, 4294967295U),
3645 			BPF_ALU32_IMM(BPF_MOD, R0, 4294967293U),
3646 			BPF_EXIT_INSN(),
3647 		},
3648 		INTERNAL,
3649 		{ },
3650 		{ { 0, 2 } },
3651 	},
3652 	{
3653 		"ALU64_MOD_K: 3 % 2 = 1",
3654 		.u.insns_int = {
3655 			BPF_LD_IMM64(R0, 3),
3656 			BPF_ALU64_IMM(BPF_MOD, R0, 2),
3657 			BPF_EXIT_INSN(),
3658 		},
3659 		INTERNAL,
3660 		{ },
3661 		{ { 0, 1 } },
3662 	},
3663 	{
3664 		"ALU64_MOD_K: 3 % 1 = 0",
3665 		.u.insns_int = {
3666 			BPF_LD_IMM64(R0, 3),
3667 			BPF_ALU64_IMM(BPF_MOD, R0, 1),
3668 			BPF_EXIT_INSN(),
3669 		},
3670 		INTERNAL,
3671 		{ },
3672 		{ { 0, 0 } },
3673 	},
3674 	{
3675 		"ALU64_MOD_K: 2147483647 % 2147483645 = 2",
3676 		.u.insns_int = {
3677 			BPF_LD_IMM64(R0, 2147483647),
3678 			BPF_ALU64_IMM(BPF_MOD, R0, 2147483645),
3679 			BPF_EXIT_INSN(),
3680 		},
3681 		INTERNAL,
3682 		{ },
3683 		{ { 0, 2 } },
3684 	},
3685 	/* BPF_ALU | BPF_AND | BPF_X */
3686 	{
3687 		"ALU_AND_X: 3 & 2 = 2",
3688 		.u.insns_int = {
3689 			BPF_LD_IMM64(R0, 3),
3690 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3691 			BPF_ALU32_REG(BPF_AND, R0, R1),
3692 			BPF_EXIT_INSN(),
3693 		},
3694 		INTERNAL,
3695 		{ },
3696 		{ { 0, 2 } },
3697 	},
3698 	{
3699 		"ALU_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3700 		.u.insns_int = {
3701 			BPF_LD_IMM64(R0, 0xffffffff),
3702 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3703 			BPF_ALU32_REG(BPF_AND, R0, R1),
3704 			BPF_EXIT_INSN(),
3705 		},
3706 		INTERNAL,
3707 		{ },
3708 		{ { 0, 0xffffffff } },
3709 	},
3710 	{
3711 		"ALU64_AND_X: 3 & 2 = 2",
3712 		.u.insns_int = {
3713 			BPF_LD_IMM64(R0, 3),
3714 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3715 			BPF_ALU64_REG(BPF_AND, R0, R1),
3716 			BPF_EXIT_INSN(),
3717 		},
3718 		INTERNAL,
3719 		{ },
3720 		{ { 0, 2 } },
3721 	},
3722 	{
3723 		"ALU64_AND_X: 0xffffffff & 0xffffffff = 0xffffffff",
3724 		.u.insns_int = {
3725 			BPF_LD_IMM64(R0, 0xffffffff),
3726 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3727 			BPF_ALU64_REG(BPF_AND, R0, R1),
3728 			BPF_EXIT_INSN(),
3729 		},
3730 		INTERNAL,
3731 		{ },
3732 		{ { 0, 0xffffffff } },
3733 	},
3734 	/* BPF_ALU | BPF_AND | BPF_K */
3735 	{
3736 		"ALU_AND_K: 3 & 2 = 2",
3737 		.u.insns_int = {
3738 			BPF_LD_IMM64(R0, 3),
3739 			BPF_ALU32_IMM(BPF_AND, R0, 2),
3740 			BPF_EXIT_INSN(),
3741 		},
3742 		INTERNAL,
3743 		{ },
3744 		{ { 0, 2 } },
3745 	},
3746 	{
3747 		"ALU_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3748 		.u.insns_int = {
3749 			BPF_LD_IMM64(R0, 0xffffffff),
3750 			BPF_ALU32_IMM(BPF_AND, R0, 0xffffffff),
3751 			BPF_EXIT_INSN(),
3752 		},
3753 		INTERNAL,
3754 		{ },
3755 		{ { 0, 0xffffffff } },
3756 	},
3757 	{
3758 		"ALU_AND_K: Small immediate",
3759 		.u.insns_int = {
3760 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3761 			BPF_ALU32_IMM(BPF_AND, R0, 15),
3762 			BPF_EXIT_INSN(),
3763 		},
3764 		INTERNAL,
3765 		{ },
3766 		{ { 0, 4 } }
3767 	},
3768 	{
3769 		"ALU_AND_K: Large immediate",
3770 		.u.insns_int = {
3771 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
3772 			BPF_ALU32_IMM(BPF_AND, R0, 0xafbfcfdf),
3773 			BPF_EXIT_INSN(),
3774 		},
3775 		INTERNAL,
3776 		{ },
3777 		{ { 0, 0xa1b2c3d4 } }
3778 	},
3779 	{
3780 		"ALU_AND_K: Zero extension",
3781 		.u.insns_int = {
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),
3787 			BPF_EXIT_INSN(),
3788 			BPF_MOV32_IMM(R0, 1),
3789 			BPF_EXIT_INSN(),
3790 		},
3791 		INTERNAL,
3792 		{ },
3793 		{ { 0, 1 } }
3794 	},
3795 	{
3796 		"ALU64_AND_K: 3 & 2 = 2",
3797 		.u.insns_int = {
3798 			BPF_LD_IMM64(R0, 3),
3799 			BPF_ALU64_IMM(BPF_AND, R0, 2),
3800 			BPF_EXIT_INSN(),
3801 		},
3802 		INTERNAL,
3803 		{ },
3804 		{ { 0, 2 } },
3805 	},
3806 	{
3807 		"ALU64_AND_K: 0xffffffff & 0xffffffff = 0xffffffff",
3808 		.u.insns_int = {
3809 			BPF_LD_IMM64(R0, 0xffffffff),
3810 			BPF_ALU64_IMM(BPF_AND, R0, 0xffffffff),
3811 			BPF_EXIT_INSN(),
3812 		},
3813 		INTERNAL,
3814 		{ },
3815 		{ { 0, 0xffffffff } },
3816 	},
3817 	{
3818 		"ALU64_AND_K: 0x0000ffffffff0000 & 0x0 = 0x0000000000000000",
3819 		.u.insns_int = {
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),
3825 			BPF_EXIT_INSN(),
3826 			BPF_MOV32_IMM(R0, 1),
3827 			BPF_EXIT_INSN(),
3828 		},
3829 		INTERNAL,
3830 		{ },
3831 		{ { 0, 0x1 } },
3832 	},
3833 	{
3834 		"ALU64_AND_K: 0x0000ffffffff0000 & -1 = 0x0000ffffffff0000",
3835 		.u.insns_int = {
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),
3841 			BPF_EXIT_INSN(),
3842 			BPF_MOV32_IMM(R0, 1),
3843 			BPF_EXIT_INSN(),
3844 		},
3845 		INTERNAL,
3846 		{ },
3847 		{ { 0, 0x1 } },
3848 	},
3849 	{
3850 		"ALU64_AND_K: 0xffffffffffffffff & -1 = 0xffffffffffffffff",
3851 		.u.insns_int = {
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),
3857 			BPF_EXIT_INSN(),
3858 			BPF_MOV32_IMM(R0, 1),
3859 			BPF_EXIT_INSN(),
3860 		},
3861 		INTERNAL,
3862 		{ },
3863 		{ { 0, 0x1 } },
3864 	},
3865 	{
3866 		"ALU64_AND_K: Sign extension 1",
3867 		.u.insns_int = {
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),
3873 			BPF_EXIT_INSN(),
3874 			BPF_MOV32_IMM(R0, 1),
3875 			BPF_EXIT_INSN(),
3876 		},
3877 		INTERNAL,
3878 		{ },
3879 		{ { 0, 1 } }
3880 	},
3881 	{
3882 		"ALU64_AND_K: Sign extension 2",
3883 		.u.insns_int = {
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),
3889 			BPF_EXIT_INSN(),
3890 			BPF_MOV32_IMM(R0, 1),
3891 			BPF_EXIT_INSN(),
3892 		},
3893 		INTERNAL,
3894 		{ },
3895 		{ { 0, 1 } }
3896 	},
3897 	/* BPF_ALU | BPF_OR | BPF_X */
3898 	{
3899 		"ALU_OR_X: 1 | 2 = 3",
3900 		.u.insns_int = {
3901 			BPF_LD_IMM64(R0, 1),
3902 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3903 			BPF_ALU32_REG(BPF_OR, R0, R1),
3904 			BPF_EXIT_INSN(),
3905 		},
3906 		INTERNAL,
3907 		{ },
3908 		{ { 0, 3 } },
3909 	},
3910 	{
3911 		"ALU_OR_X: 0x0 | 0xffffffff = 0xffffffff",
3912 		.u.insns_int = {
3913 			BPF_LD_IMM64(R0, 0),
3914 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3915 			BPF_ALU32_REG(BPF_OR, R0, R1),
3916 			BPF_EXIT_INSN(),
3917 		},
3918 		INTERNAL,
3919 		{ },
3920 		{ { 0, 0xffffffff } },
3921 	},
3922 	{
3923 		"ALU64_OR_X: 1 | 2 = 3",
3924 		.u.insns_int = {
3925 			BPF_LD_IMM64(R0, 1),
3926 			BPF_ALU32_IMM(BPF_MOV, R1, 2),
3927 			BPF_ALU64_REG(BPF_OR, R0, R1),
3928 			BPF_EXIT_INSN(),
3929 		},
3930 		INTERNAL,
3931 		{ },
3932 		{ { 0, 3 } },
3933 	},
3934 	{
3935 		"ALU64_OR_X: 0 | 0xffffffff = 0xffffffff",
3936 		.u.insns_int = {
3937 			BPF_LD_IMM64(R0, 0),
3938 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
3939 			BPF_ALU64_REG(BPF_OR, R0, R1),
3940 			BPF_EXIT_INSN(),
3941 		},
3942 		INTERNAL,
3943 		{ },
3944 		{ { 0, 0xffffffff } },
3945 	},
3946 	/* BPF_ALU | BPF_OR | BPF_K */
3947 	{
3948 		"ALU_OR_K: 1 | 2 = 3",
3949 		.u.insns_int = {
3950 			BPF_LD_IMM64(R0, 1),
3951 			BPF_ALU32_IMM(BPF_OR, R0, 2),
3952 			BPF_EXIT_INSN(),
3953 		},
3954 		INTERNAL,
3955 		{ },
3956 		{ { 0, 3 } },
3957 	},
3958 	{
3959 		"ALU_OR_K: 0 & 0xffffffff = 0xffffffff",
3960 		.u.insns_int = {
3961 			BPF_LD_IMM64(R0, 0),
3962 			BPF_ALU32_IMM(BPF_OR, R0, 0xffffffff),
3963 			BPF_EXIT_INSN(),
3964 		},
3965 		INTERNAL,
3966 		{ },
3967 		{ { 0, 0xffffffff } },
3968 	},
3969 	{
3970 		"ALU_OR_K: Small immediate",
3971 		.u.insns_int = {
3972 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3973 			BPF_ALU32_IMM(BPF_OR, R0, 1),
3974 			BPF_EXIT_INSN(),
3975 		},
3976 		INTERNAL,
3977 		{ },
3978 		{ { 0, 0x01020305 } }
3979 	},
3980 	{
3981 		"ALU_OR_K: Large immediate",
3982 		.u.insns_int = {
3983 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
3984 			BPF_ALU32_IMM(BPF_OR, R0, 0xa0b0c0d0),
3985 			BPF_EXIT_INSN(),
3986 		},
3987 		INTERNAL,
3988 		{ },
3989 		{ { 0, 0xa1b2c3d4 } }
3990 	},
3991 	{
3992 		"ALU_OR_K: Zero extension",
3993 		.u.insns_int = {
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),
3999 			BPF_EXIT_INSN(),
4000 			BPF_MOV32_IMM(R0, 1),
4001 			BPF_EXIT_INSN(),
4002 		},
4003 		INTERNAL,
4004 		{ },
4005 		{ { 0, 1 } }
4006 	},
4007 	{
4008 		"ALU64_OR_K: 1 | 2 = 3",
4009 		.u.insns_int = {
4010 			BPF_LD_IMM64(R0, 1),
4011 			BPF_ALU64_IMM(BPF_OR, R0, 2),
4012 			BPF_EXIT_INSN(),
4013 		},
4014 		INTERNAL,
4015 		{ },
4016 		{ { 0, 3 } },
4017 	},
4018 	{
4019 		"ALU64_OR_K: 0 & 0xffffffff = 0xffffffff",
4020 		.u.insns_int = {
4021 			BPF_LD_IMM64(R0, 0),
4022 			BPF_ALU64_IMM(BPF_OR, R0, 0xffffffff),
4023 			BPF_EXIT_INSN(),
4024 		},
4025 		INTERNAL,
4026 		{ },
4027 		{ { 0, 0xffffffff } },
4028 	},
4029 	{
4030 		"ALU64_OR_K: 0x0000ffffffff0000 | 0x0 = 0x0000ffffffff0000",
4031 		.u.insns_int = {
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),
4037 			BPF_EXIT_INSN(),
4038 			BPF_MOV32_IMM(R0, 1),
4039 			BPF_EXIT_INSN(),
4040 		},
4041 		INTERNAL,
4042 		{ },
4043 		{ { 0, 0x1 } },
4044 	},
4045 	{
4046 		"ALU64_OR_K: 0x0000ffffffff0000 | -1 = 0xffffffffffffffff",
4047 		.u.insns_int = {
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),
4053 			BPF_EXIT_INSN(),
4054 			BPF_MOV32_IMM(R0, 1),
4055 			BPF_EXIT_INSN(),
4056 		},
4057 		INTERNAL,
4058 		{ },
4059 		{ { 0, 0x1 } },
4060 	},
4061 	{
4062 		"ALU64_OR_K: 0x000000000000000 | -1 = 0xffffffffffffffff",
4063 		.u.insns_int = {
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),
4069 			BPF_EXIT_INSN(),
4070 			BPF_MOV32_IMM(R0, 1),
4071 			BPF_EXIT_INSN(),
4072 		},
4073 		INTERNAL,
4074 		{ },
4075 		{ { 0, 0x1 } },
4076 	},
4077 	{
4078 		"ALU64_OR_K: Sign extension 1",
4079 		.u.insns_int = {
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),
4085 			BPF_EXIT_INSN(),
4086 			BPF_MOV32_IMM(R0, 1),
4087 			BPF_EXIT_INSN(),
4088 		},
4089 		INTERNAL,
4090 		{ },
4091 		{ { 0, 1 } }
4092 	},
4093 	{
4094 		"ALU64_OR_K: Sign extension 2",
4095 		.u.insns_int = {
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),
4101 			BPF_EXIT_INSN(),
4102 			BPF_MOV32_IMM(R0, 1),
4103 			BPF_EXIT_INSN(),
4104 		},
4105 		INTERNAL,
4106 		{ },
4107 		{ { 0, 1 } }
4108 	},
4109 	/* BPF_ALU | BPF_XOR | BPF_X */
4110 	{
4111 		"ALU_XOR_X: 5 ^ 6 = 3",
4112 		.u.insns_int = {
4113 			BPF_LD_IMM64(R0, 5),
4114 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
4115 			BPF_ALU32_REG(BPF_XOR, R0, R1),
4116 			BPF_EXIT_INSN(),
4117 		},
4118 		INTERNAL,
4119 		{ },
4120 		{ { 0, 3 } },
4121 	},
4122 	{
4123 		"ALU_XOR_X: 0x1 ^ 0xffffffff = 0xfffffffe",
4124 		.u.insns_int = {
4125 			BPF_LD_IMM64(R0, 1),
4126 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
4127 			BPF_ALU32_REG(BPF_XOR, R0, R1),
4128 			BPF_EXIT_INSN(),
4129 		},
4130 		INTERNAL,
4131 		{ },
4132 		{ { 0, 0xfffffffe } },
4133 	},
4134 	{
4135 		"ALU64_XOR_X: 5 ^ 6 = 3",
4136 		.u.insns_int = {
4137 			BPF_LD_IMM64(R0, 5),
4138 			BPF_ALU32_IMM(BPF_MOV, R1, 6),
4139 			BPF_ALU64_REG(BPF_XOR, R0, R1),
4140 			BPF_EXIT_INSN(),
4141 		},
4142 		INTERNAL,
4143 		{ },
4144 		{ { 0, 3 } },
4145 	},
4146 	{
4147 		"ALU64_XOR_X: 1 ^ 0xffffffff = 0xfffffffe",
4148 		.u.insns_int = {
4149 			BPF_LD_IMM64(R0, 1),
4150 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
4151 			BPF_ALU64_REG(BPF_XOR, R0, R1),
4152 			BPF_EXIT_INSN(),
4153 		},
4154 		INTERNAL,
4155 		{ },
4156 		{ { 0, 0xfffffffe } },
4157 	},
4158 	/* BPF_ALU | BPF_XOR | BPF_K */
4159 	{
4160 		"ALU_XOR_K: 5 ^ 6 = 3",
4161 		.u.insns_int = {
4162 			BPF_LD_IMM64(R0, 5),
4163 			BPF_ALU32_IMM(BPF_XOR, R0, 6),
4164 			BPF_EXIT_INSN(),
4165 		},
4166 		INTERNAL,
4167 		{ },
4168 		{ { 0, 3 } },
4169 	},
4170 	{
4171 		"ALU_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
4172 		.u.insns_int = {
4173 			BPF_LD_IMM64(R0, 1),
4174 			BPF_ALU32_IMM(BPF_XOR, R0, 0xffffffff),
4175 			BPF_EXIT_INSN(),
4176 		},
4177 		INTERNAL,
4178 		{ },
4179 		{ { 0, 0xfffffffe } },
4180 	},
4181 	{
4182 		"ALU_XOR_K: Small immediate",
4183 		.u.insns_int = {
4184 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01020304),
4185 			BPF_ALU32_IMM(BPF_XOR, R0, 15),
4186 			BPF_EXIT_INSN(),
4187 		},
4188 		INTERNAL,
4189 		{ },
4190 		{ { 0, 0x0102030b } }
4191 	},
4192 	{
4193 		"ALU_XOR_K: Large immediate",
4194 		.u.insns_int = {
4195 			BPF_ALU32_IMM(BPF_MOV, R0, 0xf1f2f3f4),
4196 			BPF_ALU32_IMM(BPF_XOR, R0, 0xafbfcfdf),
4197 			BPF_EXIT_INSN(),
4198 		},
4199 		INTERNAL,
4200 		{ },
4201 		{ { 0, 0x5e4d3c2b } }
4202 	},
4203 	{
4204 		"ALU_XOR_K: Zero extension",
4205 		.u.insns_int = {
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),
4211 			BPF_EXIT_INSN(),
4212 			BPF_MOV32_IMM(R0, 1),
4213 			BPF_EXIT_INSN(),
4214 		},
4215 		INTERNAL,
4216 		{ },
4217 		{ { 0, 1 } }
4218 	},
4219 	{
4220 		"ALU64_XOR_K: 5 ^ 6 = 3",
4221 		.u.insns_int = {
4222 			BPF_LD_IMM64(R0, 5),
4223 			BPF_ALU64_IMM(BPF_XOR, R0, 6),
4224 			BPF_EXIT_INSN(),
4225 		},
4226 		INTERNAL,
4227 		{ },
4228 		{ { 0, 3 } },
4229 	},
4230 	{
4231 		"ALU64_XOR_K: 1 ^ 0xffffffff = 0xfffffffe",
4232 		.u.insns_int = {
4233 			BPF_LD_IMM64(R0, 1),
4234 			BPF_ALU64_IMM(BPF_XOR, R0, 0xffffffff),
4235 			BPF_EXIT_INSN(),
4236 		},
4237 		INTERNAL,
4238 		{ },
4239 		{ { 0, 0xfffffffe } },
4240 	},
4241 	{
4242 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ 0x0 = 0x0000ffffffff0000",
4243 		.u.insns_int = {
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),
4249 			BPF_EXIT_INSN(),
4250 			BPF_MOV32_IMM(R0, 1),
4251 			BPF_EXIT_INSN(),
4252 		},
4253 		INTERNAL,
4254 		{ },
4255 		{ { 0, 0x1 } },
4256 	},
4257 	{
4258 		"ALU64_XOR_K: 0x0000ffffffff0000 ^ -1 = 0xffff00000000ffff",
4259 		.u.insns_int = {
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),
4265 			BPF_EXIT_INSN(),
4266 			BPF_MOV32_IMM(R0, 1),
4267 			BPF_EXIT_INSN(),
4268 		},
4269 		INTERNAL,
4270 		{ },
4271 		{ { 0, 0x1 } },
4272 	},
4273 	{
4274 		"ALU64_XOR_K: 0x000000000000000 ^ -1 = 0xffffffffffffffff",
4275 		.u.insns_int = {
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),
4281 			BPF_EXIT_INSN(),
4282 			BPF_MOV32_IMM(R0, 1),
4283 			BPF_EXIT_INSN(),
4284 		},
4285 		INTERNAL,
4286 		{ },
4287 		{ { 0, 0x1 } },
4288 	},
4289 	{
4290 		"ALU64_XOR_K: Sign extension 1",
4291 		.u.insns_int = {
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),
4297 			BPF_EXIT_INSN(),
4298 			BPF_MOV32_IMM(R0, 1),
4299 			BPF_EXIT_INSN(),
4300 		},
4301 		INTERNAL,
4302 		{ },
4303 		{ { 0, 1 } }
4304 	},
4305 	{
4306 		"ALU64_XOR_K: Sign extension 2",
4307 		.u.insns_int = {
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),
4313 			BPF_EXIT_INSN(),
4314 			BPF_MOV32_IMM(R0, 1),
4315 			BPF_EXIT_INSN(),
4316 		},
4317 		INTERNAL,
4318 		{ },
4319 		{ { 0, 1 } }
4320 	},
4321 	/* BPF_ALU | BPF_LSH | BPF_X */
4322 	{
4323 		"ALU_LSH_X: 1 << 1 = 2",
4324 		.u.insns_int = {
4325 			BPF_LD_IMM64(R0, 1),
4326 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
4327 			BPF_ALU32_REG(BPF_LSH, R0, R1),
4328 			BPF_EXIT_INSN(),
4329 		},
4330 		INTERNAL,
4331 		{ },
4332 		{ { 0, 2 } },
4333 	},
4334 	{
4335 		"ALU_LSH_X: 1 << 31 = 0x80000000",
4336 		.u.insns_int = {
4337 			BPF_LD_IMM64(R0, 1),
4338 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
4339 			BPF_ALU32_REG(BPF_LSH, R0, R1),
4340 			BPF_EXIT_INSN(),
4341 		},
4342 		INTERNAL,
4343 		{ },
4344 		{ { 0, 0x80000000 } },
4345 	},
4346 	{
4347 		"ALU_LSH_X: 0x12345678 << 12 = 0x45678000",
4348 		.u.insns_int = {
4349 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4350 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
4351 			BPF_ALU32_REG(BPF_LSH, R0, R1),
4352 			BPF_EXIT_INSN(),
4353 		},
4354 		INTERNAL,
4355 		{ },
4356 		{ { 0, 0x45678000 } }
4357 	},
4358 	{
4359 		"ALU64_LSH_X: 1 << 1 = 2",
4360 		.u.insns_int = {
4361 			BPF_LD_IMM64(R0, 1),
4362 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
4363 			BPF_ALU64_REG(BPF_LSH, R0, R1),
4364 			BPF_EXIT_INSN(),
4365 		},
4366 		INTERNAL,
4367 		{ },
4368 		{ { 0, 2 } },
4369 	},
4370 	{
4371 		"ALU64_LSH_X: 1 << 31 = 0x80000000",
4372 		.u.insns_int = {
4373 			BPF_LD_IMM64(R0, 1),
4374 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
4375 			BPF_ALU64_REG(BPF_LSH, R0, R1),
4376 			BPF_EXIT_INSN(),
4377 		},
4378 		INTERNAL,
4379 		{ },
4380 		{ { 0, 0x80000000 } },
4381 	},
4382 	{
4383 		"ALU64_LSH_X: Shift < 32, low word",
4384 		.u.insns_int = {
4385 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4386 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
4387 			BPF_ALU64_REG(BPF_LSH, R0, R1),
4388 			BPF_EXIT_INSN(),
4389 		},
4390 		INTERNAL,
4391 		{ },
4392 		{ { 0, 0xbcdef000 } }
4393 	},
4394 	{
4395 		"ALU64_LSH_X: Shift < 32, high word",
4396 		.u.insns_int = {
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),
4401 			BPF_EXIT_INSN(),
4402 		},
4403 		INTERNAL,
4404 		{ },
4405 		{ { 0, 0x3456789a } }
4406 	},
4407 	{
4408 		"ALU64_LSH_X: Shift > 32, low word",
4409 		.u.insns_int = {
4410 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4411 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
4412 			BPF_ALU64_REG(BPF_LSH, R0, R1),
4413 			BPF_EXIT_INSN(),
4414 		},
4415 		INTERNAL,
4416 		{ },
4417 		{ { 0, 0 } }
4418 	},
4419 	{
4420 		"ALU64_LSH_X: Shift > 32, high word",
4421 		.u.insns_int = {
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),
4426 			BPF_EXIT_INSN(),
4427 		},
4428 		INTERNAL,
4429 		{ },
4430 		{ { 0, 0x9abcdef0 } }
4431 	},
4432 	{
4433 		"ALU64_LSH_X: Shift == 32, low word",
4434 		.u.insns_int = {
4435 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4436 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
4437 			BPF_ALU64_REG(BPF_LSH, R0, R1),
4438 			BPF_EXIT_INSN(),
4439 		},
4440 		INTERNAL,
4441 		{ },
4442 		{ { 0, 0 } }
4443 	},
4444 	{
4445 		"ALU64_LSH_X: Shift == 32, high word",
4446 		.u.insns_int = {
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),
4451 			BPF_EXIT_INSN(),
4452 		},
4453 		INTERNAL,
4454 		{ },
4455 		{ { 0, 0x89abcdef } }
4456 	},
4457 	{
4458 		"ALU64_LSH_X: Zero shift, low word",
4459 		.u.insns_int = {
4460 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4461 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
4462 			BPF_ALU64_REG(BPF_LSH, R0, R1),
4463 			BPF_EXIT_INSN(),
4464 		},
4465 		INTERNAL,
4466 		{ },
4467 		{ { 0, 0x89abcdef } }
4468 	},
4469 	{
4470 		"ALU64_LSH_X: Zero shift, high word",
4471 		.u.insns_int = {
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),
4476 			BPF_EXIT_INSN(),
4477 		},
4478 		INTERNAL,
4479 		{ },
4480 		{ { 0, 0x01234567 } }
4481 	},
4482 	/* BPF_ALU | BPF_LSH | BPF_K */
4483 	{
4484 		"ALU_LSH_K: 1 << 1 = 2",
4485 		.u.insns_int = {
4486 			BPF_LD_IMM64(R0, 1),
4487 			BPF_ALU32_IMM(BPF_LSH, R0, 1),
4488 			BPF_EXIT_INSN(),
4489 		},
4490 		INTERNAL,
4491 		{ },
4492 		{ { 0, 2 } },
4493 	},
4494 	{
4495 		"ALU_LSH_K: 1 << 31 = 0x80000000",
4496 		.u.insns_int = {
4497 			BPF_LD_IMM64(R0, 1),
4498 			BPF_ALU32_IMM(BPF_LSH, R0, 31),
4499 			BPF_EXIT_INSN(),
4500 		},
4501 		INTERNAL,
4502 		{ },
4503 		{ { 0, 0x80000000 } },
4504 	},
4505 	{
4506 		"ALU_LSH_K: 0x12345678 << 12 = 0x45678000",
4507 		.u.insns_int = {
4508 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4509 			BPF_ALU32_IMM(BPF_LSH, R0, 12),
4510 			BPF_EXIT_INSN(),
4511 		},
4512 		INTERNAL,
4513 		{ },
4514 		{ { 0, 0x45678000 } }
4515 	},
4516 	{
4517 		"ALU_LSH_K: 0x12345678 << 0 = 0x12345678",
4518 		.u.insns_int = {
4519 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4520 			BPF_ALU32_IMM(BPF_LSH, R0, 0),
4521 			BPF_EXIT_INSN(),
4522 		},
4523 		INTERNAL,
4524 		{ },
4525 		{ { 0, 0x12345678 } }
4526 	},
4527 	{
4528 		"ALU64_LSH_K: 1 << 1 = 2",
4529 		.u.insns_int = {
4530 			BPF_LD_IMM64(R0, 1),
4531 			BPF_ALU64_IMM(BPF_LSH, R0, 1),
4532 			BPF_EXIT_INSN(),
4533 		},
4534 		INTERNAL,
4535 		{ },
4536 		{ { 0, 2 } },
4537 	},
4538 	{
4539 		"ALU64_LSH_K: 1 << 31 = 0x80000000",
4540 		.u.insns_int = {
4541 			BPF_LD_IMM64(R0, 1),
4542 			BPF_ALU64_IMM(BPF_LSH, R0, 31),
4543 			BPF_EXIT_INSN(),
4544 		},
4545 		INTERNAL,
4546 		{ },
4547 		{ { 0, 0x80000000 } },
4548 	},
4549 	{
4550 		"ALU64_LSH_K: Shift < 32, low word",
4551 		.u.insns_int = {
4552 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4553 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
4554 			BPF_EXIT_INSN(),
4555 		},
4556 		INTERNAL,
4557 		{ },
4558 		{ { 0, 0xbcdef000 } }
4559 	},
4560 	{
4561 		"ALU64_LSH_K: Shift < 32, high word",
4562 		.u.insns_int = {
4563 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4564 			BPF_ALU64_IMM(BPF_LSH, R0, 12),
4565 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4566 			BPF_EXIT_INSN(),
4567 		},
4568 		INTERNAL,
4569 		{ },
4570 		{ { 0, 0x3456789a } }
4571 	},
4572 	{
4573 		"ALU64_LSH_K: Shift > 32, low word",
4574 		.u.insns_int = {
4575 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4576 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
4577 			BPF_EXIT_INSN(),
4578 		},
4579 		INTERNAL,
4580 		{ },
4581 		{ { 0, 0 } }
4582 	},
4583 	{
4584 		"ALU64_LSH_K: Shift > 32, high word",
4585 		.u.insns_int = {
4586 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4587 			BPF_ALU64_IMM(BPF_LSH, R0, 36),
4588 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4589 			BPF_EXIT_INSN(),
4590 		},
4591 		INTERNAL,
4592 		{ },
4593 		{ { 0, 0x9abcdef0 } }
4594 	},
4595 	{
4596 		"ALU64_LSH_K: Shift == 32, low word",
4597 		.u.insns_int = {
4598 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4599 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
4600 			BPF_EXIT_INSN(),
4601 		},
4602 		INTERNAL,
4603 		{ },
4604 		{ { 0, 0 } }
4605 	},
4606 	{
4607 		"ALU64_LSH_K: Shift == 32, high word",
4608 		.u.insns_int = {
4609 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4610 			BPF_ALU64_IMM(BPF_LSH, R0, 32),
4611 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4612 			BPF_EXIT_INSN(),
4613 		},
4614 		INTERNAL,
4615 		{ },
4616 		{ { 0, 0x89abcdef } }
4617 	},
4618 	{
4619 		"ALU64_LSH_K: Zero shift",
4620 		.u.insns_int = {
4621 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4622 			BPF_ALU64_IMM(BPF_LSH, R0, 0),
4623 			BPF_EXIT_INSN(),
4624 		},
4625 		INTERNAL,
4626 		{ },
4627 		{ { 0, 0x89abcdef } }
4628 	},
4629 	/* BPF_ALU | BPF_RSH | BPF_X */
4630 	{
4631 		"ALU_RSH_X: 2 >> 1 = 1",
4632 		.u.insns_int = {
4633 			BPF_LD_IMM64(R0, 2),
4634 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
4635 			BPF_ALU32_REG(BPF_RSH, R0, R1),
4636 			BPF_EXIT_INSN(),
4637 		},
4638 		INTERNAL,
4639 		{ },
4640 		{ { 0, 1 } },
4641 	},
4642 	{
4643 		"ALU_RSH_X: 0x80000000 >> 31 = 1",
4644 		.u.insns_int = {
4645 			BPF_LD_IMM64(R0, 0x80000000),
4646 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
4647 			BPF_ALU32_REG(BPF_RSH, R0, R1),
4648 			BPF_EXIT_INSN(),
4649 		},
4650 		INTERNAL,
4651 		{ },
4652 		{ { 0, 1 } },
4653 	},
4654 	{
4655 		"ALU_RSH_X: 0x12345678 >> 20 = 0x123",
4656 		.u.insns_int = {
4657 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4658 			BPF_ALU32_IMM(BPF_MOV, R1, 20),
4659 			BPF_ALU32_REG(BPF_RSH, R0, R1),
4660 			BPF_EXIT_INSN(),
4661 		},
4662 		INTERNAL,
4663 		{ },
4664 		{ { 0, 0x123 } }
4665 	},
4666 	{
4667 		"ALU64_RSH_X: 2 >> 1 = 1",
4668 		.u.insns_int = {
4669 			BPF_LD_IMM64(R0, 2),
4670 			BPF_ALU32_IMM(BPF_MOV, R1, 1),
4671 			BPF_ALU64_REG(BPF_RSH, R0, R1),
4672 			BPF_EXIT_INSN(),
4673 		},
4674 		INTERNAL,
4675 		{ },
4676 		{ { 0, 1 } },
4677 	},
4678 	{
4679 		"ALU64_RSH_X: 0x80000000 >> 31 = 1",
4680 		.u.insns_int = {
4681 			BPF_LD_IMM64(R0, 0x80000000),
4682 			BPF_ALU32_IMM(BPF_MOV, R1, 31),
4683 			BPF_ALU64_REG(BPF_RSH, R0, R1),
4684 			BPF_EXIT_INSN(),
4685 		},
4686 		INTERNAL,
4687 		{ },
4688 		{ { 0, 1 } },
4689 	},
4690 	{
4691 		"ALU64_RSH_X: Shift < 32, low word",
4692 		.u.insns_int = {
4693 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4694 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
4695 			BPF_ALU64_REG(BPF_RSH, R0, R1),
4696 			BPF_EXIT_INSN(),
4697 		},
4698 		INTERNAL,
4699 		{ },
4700 		{ { 0, 0x56789abc } }
4701 	},
4702 	{
4703 		"ALU64_RSH_X: Shift < 32, high word",
4704 		.u.insns_int = {
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),
4709 			BPF_EXIT_INSN(),
4710 		},
4711 		INTERNAL,
4712 		{ },
4713 		{ { 0, 0x00081234 } }
4714 	},
4715 	{
4716 		"ALU64_RSH_X: Shift > 32, low word",
4717 		.u.insns_int = {
4718 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4719 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
4720 			BPF_ALU64_REG(BPF_RSH, R0, R1),
4721 			BPF_EXIT_INSN(),
4722 		},
4723 		INTERNAL,
4724 		{ },
4725 		{ { 0, 0x08123456 } }
4726 	},
4727 	{
4728 		"ALU64_RSH_X: Shift > 32, high word",
4729 		.u.insns_int = {
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),
4734 			BPF_EXIT_INSN(),
4735 		},
4736 		INTERNAL,
4737 		{ },
4738 		{ { 0, 0 } }
4739 	},
4740 	{
4741 		"ALU64_RSH_X: Shift == 32, low word",
4742 		.u.insns_int = {
4743 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4744 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
4745 			BPF_ALU64_REG(BPF_RSH, R0, R1),
4746 			BPF_EXIT_INSN(),
4747 		},
4748 		INTERNAL,
4749 		{ },
4750 		{ { 0, 0x81234567 } }
4751 	},
4752 	{
4753 		"ALU64_RSH_X: Shift == 32, high word",
4754 		.u.insns_int = {
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),
4759 			BPF_EXIT_INSN(),
4760 		},
4761 		INTERNAL,
4762 		{ },
4763 		{ { 0, 0 } }
4764 	},
4765 	{
4766 		"ALU64_RSH_X: Zero shift, low word",
4767 		.u.insns_int = {
4768 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4769 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
4770 			BPF_ALU64_REG(BPF_RSH, R0, R1),
4771 			BPF_EXIT_INSN(),
4772 		},
4773 		INTERNAL,
4774 		{ },
4775 		{ { 0, 0x89abcdef } }
4776 	},
4777 	{
4778 		"ALU64_RSH_X: Zero shift, high word",
4779 		.u.insns_int = {
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),
4784 			BPF_EXIT_INSN(),
4785 		},
4786 		INTERNAL,
4787 		{ },
4788 		{ { 0, 0x81234567 } }
4789 	},
4790 	/* BPF_ALU | BPF_RSH | BPF_K */
4791 	{
4792 		"ALU_RSH_K: 2 >> 1 = 1",
4793 		.u.insns_int = {
4794 			BPF_LD_IMM64(R0, 2),
4795 			BPF_ALU32_IMM(BPF_RSH, R0, 1),
4796 			BPF_EXIT_INSN(),
4797 		},
4798 		INTERNAL,
4799 		{ },
4800 		{ { 0, 1 } },
4801 	},
4802 	{
4803 		"ALU_RSH_K: 0x80000000 >> 31 = 1",
4804 		.u.insns_int = {
4805 			BPF_LD_IMM64(R0, 0x80000000),
4806 			BPF_ALU32_IMM(BPF_RSH, R0, 31),
4807 			BPF_EXIT_INSN(),
4808 		},
4809 		INTERNAL,
4810 		{ },
4811 		{ { 0, 1 } },
4812 	},
4813 	{
4814 		"ALU_RSH_K: 0x12345678 >> 20 = 0x123",
4815 		.u.insns_int = {
4816 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4817 			BPF_ALU32_IMM(BPF_RSH, R0, 20),
4818 			BPF_EXIT_INSN(),
4819 		},
4820 		INTERNAL,
4821 		{ },
4822 		{ { 0, 0x123 } }
4823 	},
4824 	{
4825 		"ALU_RSH_K: 0x12345678 >> 0 = 0x12345678",
4826 		.u.insns_int = {
4827 			BPF_ALU32_IMM(BPF_MOV, R0, 0x12345678),
4828 			BPF_ALU32_IMM(BPF_RSH, R0, 0),
4829 			BPF_EXIT_INSN(),
4830 		},
4831 		INTERNAL,
4832 		{ },
4833 		{ { 0, 0x12345678 } }
4834 	},
4835 	{
4836 		"ALU64_RSH_K: 2 >> 1 = 1",
4837 		.u.insns_int = {
4838 			BPF_LD_IMM64(R0, 2),
4839 			BPF_ALU64_IMM(BPF_RSH, R0, 1),
4840 			BPF_EXIT_INSN(),
4841 		},
4842 		INTERNAL,
4843 		{ },
4844 		{ { 0, 1 } },
4845 	},
4846 	{
4847 		"ALU64_RSH_K: 0x80000000 >> 31 = 1",
4848 		.u.insns_int = {
4849 			BPF_LD_IMM64(R0, 0x80000000),
4850 			BPF_ALU64_IMM(BPF_RSH, R0, 31),
4851 			BPF_EXIT_INSN(),
4852 		},
4853 		INTERNAL,
4854 		{ },
4855 		{ { 0, 1 } },
4856 	},
4857 	{
4858 		"ALU64_RSH_K: Shift < 32, low word",
4859 		.u.insns_int = {
4860 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4861 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
4862 			BPF_EXIT_INSN(),
4863 		},
4864 		INTERNAL,
4865 		{ },
4866 		{ { 0, 0x56789abc } }
4867 	},
4868 	{
4869 		"ALU64_RSH_K: Shift < 32, high word",
4870 		.u.insns_int = {
4871 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4872 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
4873 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4874 			BPF_EXIT_INSN(),
4875 		},
4876 		INTERNAL,
4877 		{ },
4878 		{ { 0, 0x00081234 } }
4879 	},
4880 	{
4881 		"ALU64_RSH_K: Shift > 32, low word",
4882 		.u.insns_int = {
4883 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4884 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
4885 			BPF_EXIT_INSN(),
4886 		},
4887 		INTERNAL,
4888 		{ },
4889 		{ { 0, 0x08123456 } }
4890 	},
4891 	{
4892 		"ALU64_RSH_K: Shift > 32, high word",
4893 		.u.insns_int = {
4894 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4895 			BPF_ALU64_IMM(BPF_RSH, R0, 36),
4896 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4897 			BPF_EXIT_INSN(),
4898 		},
4899 		INTERNAL,
4900 		{ },
4901 		{ { 0, 0 } }
4902 	},
4903 	{
4904 		"ALU64_RSH_K: Shift == 32, low word",
4905 		.u.insns_int = {
4906 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4907 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4908 			BPF_EXIT_INSN(),
4909 		},
4910 		INTERNAL,
4911 		{ },
4912 		{ { 0, 0x81234567 } }
4913 	},
4914 	{
4915 		"ALU64_RSH_K: Shift == 32, high word",
4916 		.u.insns_int = {
4917 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4918 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4919 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
4920 			BPF_EXIT_INSN(),
4921 		},
4922 		INTERNAL,
4923 		{ },
4924 		{ { 0, 0 } }
4925 	},
4926 	{
4927 		"ALU64_RSH_K: Zero shift",
4928 		.u.insns_int = {
4929 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
4930 			BPF_ALU64_IMM(BPF_RSH, R0, 0),
4931 			BPF_EXIT_INSN(),
4932 		},
4933 		INTERNAL,
4934 		{ },
4935 		{ { 0, 0x89abcdef } }
4936 	},
4937 	/* BPF_ALU | BPF_ARSH | BPF_X */
4938 	{
4939 		"ALU32_ARSH_X: -1234 >> 7 = -10",
4940 		.u.insns_int = {
4941 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
4942 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
4943 			BPF_ALU32_REG(BPF_ARSH, R0, R1),
4944 			BPF_EXIT_INSN(),
4945 		},
4946 		INTERNAL,
4947 		{ },
4948 		{ { 0, -10 } }
4949 	},
4950 	{
4951 		"ALU64_ARSH_X: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
4952 		.u.insns_int = {
4953 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
4954 			BPF_ALU32_IMM(BPF_MOV, R1, 40),
4955 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
4956 			BPF_EXIT_INSN(),
4957 		},
4958 		INTERNAL,
4959 		{ },
4960 		{ { 0, 0xffff00ff } },
4961 	},
4962 	{
4963 		"ALU64_ARSH_X: Shift < 32, low word",
4964 		.u.insns_int = {
4965 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4966 			BPF_ALU32_IMM(BPF_MOV, R1, 12),
4967 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
4968 			BPF_EXIT_INSN(),
4969 		},
4970 		INTERNAL,
4971 		{ },
4972 		{ { 0, 0x56789abc } }
4973 	},
4974 	{
4975 		"ALU64_ARSH_X: Shift < 32, high word",
4976 		.u.insns_int = {
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),
4981 			BPF_EXIT_INSN(),
4982 		},
4983 		INTERNAL,
4984 		{ },
4985 		{ { 0, 0xfff81234 } }
4986 	},
4987 	{
4988 		"ALU64_ARSH_X: Shift > 32, low word",
4989 		.u.insns_int = {
4990 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
4991 			BPF_ALU32_IMM(BPF_MOV, R1, 36),
4992 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
4993 			BPF_EXIT_INSN(),
4994 		},
4995 		INTERNAL,
4996 		{ },
4997 		{ { 0, 0xf8123456 } }
4998 	},
4999 	{
5000 		"ALU64_ARSH_X: Shift > 32, high word",
5001 		.u.insns_int = {
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),
5006 			BPF_EXIT_INSN(),
5007 		},
5008 		INTERNAL,
5009 		{ },
5010 		{ { 0, -1 } }
5011 	},
5012 	{
5013 		"ALU64_ARSH_X: Shift == 32, low word",
5014 		.u.insns_int = {
5015 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5016 			BPF_ALU32_IMM(BPF_MOV, R1, 32),
5017 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
5018 			BPF_EXIT_INSN(),
5019 		},
5020 		INTERNAL,
5021 		{ },
5022 		{ { 0, 0x81234567 } }
5023 	},
5024 	{
5025 		"ALU64_ARSH_X: Shift == 32, high word",
5026 		.u.insns_int = {
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),
5031 			BPF_EXIT_INSN(),
5032 		},
5033 		INTERNAL,
5034 		{ },
5035 		{ { 0, -1 } }
5036 	},
5037 	{
5038 		"ALU64_ARSH_X: Zero shift, low word",
5039 		.u.insns_int = {
5040 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5041 			BPF_ALU32_IMM(BPF_MOV, R1, 0),
5042 			BPF_ALU64_REG(BPF_ARSH, R0, R1),
5043 			BPF_EXIT_INSN(),
5044 		},
5045 		INTERNAL,
5046 		{ },
5047 		{ { 0, 0x89abcdef } }
5048 	},
5049 	{
5050 		"ALU64_ARSH_X: Zero shift, high word",
5051 		.u.insns_int = {
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),
5056 			BPF_EXIT_INSN(),
5057 		},
5058 		INTERNAL,
5059 		{ },
5060 		{ { 0, 0x81234567 } }
5061 	},
5062 	/* BPF_ALU | BPF_ARSH | BPF_K */
5063 	{
5064 		"ALU32_ARSH_K: -1234 >> 7 = -10",
5065 		.u.insns_int = {
5066 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
5067 			BPF_ALU32_IMM(BPF_ARSH, R0, 7),
5068 			BPF_EXIT_INSN(),
5069 		},
5070 		INTERNAL,
5071 		{ },
5072 		{ { 0, -10 } }
5073 	},
5074 	{
5075 		"ALU32_ARSH_K: -1234 >> 0 = -1234",
5076 		.u.insns_int = {
5077 			BPF_ALU32_IMM(BPF_MOV, R0, -1234),
5078 			BPF_ALU32_IMM(BPF_ARSH, R0, 0),
5079 			BPF_EXIT_INSN(),
5080 		},
5081 		INTERNAL,
5082 		{ },
5083 		{ { 0, -1234 } }
5084 	},
5085 	{
5086 		"ALU64_ARSH_K: 0xff00ff0000000000 >> 40 = 0xffffffffffff00ff",
5087 		.u.insns_int = {
5088 			BPF_LD_IMM64(R0, 0xff00ff0000000000LL),
5089 			BPF_ALU64_IMM(BPF_ARSH, R0, 40),
5090 			BPF_EXIT_INSN(),
5091 		},
5092 		INTERNAL,
5093 		{ },
5094 		{ { 0, 0xffff00ff } },
5095 	},
5096 	{
5097 		"ALU64_ARSH_K: Shift < 32, low word",
5098 		.u.insns_int = {
5099 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5100 			BPF_ALU64_IMM(BPF_RSH, R0, 12),
5101 			BPF_EXIT_INSN(),
5102 		},
5103 		INTERNAL,
5104 		{ },
5105 		{ { 0, 0x56789abc } }
5106 	},
5107 	{
5108 		"ALU64_ARSH_K: Shift < 32, high word",
5109 		.u.insns_int = {
5110 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5111 			BPF_ALU64_IMM(BPF_ARSH, R0, 12),
5112 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5113 			BPF_EXIT_INSN(),
5114 		},
5115 		INTERNAL,
5116 		{ },
5117 		{ { 0, 0xfff81234 } }
5118 	},
5119 	{
5120 		"ALU64_ARSH_K: Shift > 32, low word",
5121 		.u.insns_int = {
5122 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5123 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
5124 			BPF_EXIT_INSN(),
5125 		},
5126 		INTERNAL,
5127 		{ },
5128 		{ { 0, 0xf8123456 } }
5129 	},
5130 	{
5131 		"ALU64_ARSH_K: Shift > 32, high word",
5132 		.u.insns_int = {
5133 			BPF_LD_IMM64(R0, 0xf123456789abcdefLL),
5134 			BPF_ALU64_IMM(BPF_ARSH, R0, 36),
5135 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5136 			BPF_EXIT_INSN(),
5137 		},
5138 		INTERNAL,
5139 		{ },
5140 		{ { 0, -1 } }
5141 	},
5142 	{
5143 		"ALU64_ARSH_K: Shift == 32, low word",
5144 		.u.insns_int = {
5145 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5146 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
5147 			BPF_EXIT_INSN(),
5148 		},
5149 		INTERNAL,
5150 		{ },
5151 		{ { 0, 0x81234567 } }
5152 	},
5153 	{
5154 		"ALU64_ARSH_K: Shift == 32, high word",
5155 		.u.insns_int = {
5156 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5157 			BPF_ALU64_IMM(BPF_ARSH, R0, 32),
5158 			BPF_ALU64_IMM(BPF_RSH, R0, 32),
5159 			BPF_EXIT_INSN(),
5160 		},
5161 		INTERNAL,
5162 		{ },
5163 		{ { 0, -1 } }
5164 	},
5165 	{
5166 		"ALU64_ARSH_K: Zero shift",
5167 		.u.insns_int = {
5168 			BPF_LD_IMM64(R0, 0x8123456789abcdefLL),
5169 			BPF_ALU64_IMM(BPF_ARSH, R0, 0),
5170 			BPF_EXIT_INSN(),
5171 		},
5172 		INTERNAL,
5173 		{ },
5174 		{ { 0, 0x89abcdef } }
5175 	},
5176 	/* BPF_ALU | BPF_NEG */
5177 	{
5178 		"ALU_NEG: -(3) = -3",
5179 		.u.insns_int = {
5180 			BPF_ALU32_IMM(BPF_MOV, R0, 3),
5181 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
5182 			BPF_EXIT_INSN(),
5183 		},
5184 		INTERNAL,
5185 		{ },
5186 		{ { 0, -3 } },
5187 	},
5188 	{
5189 		"ALU_NEG: -(-3) = 3",
5190 		.u.insns_int = {
5191 			BPF_ALU32_IMM(BPF_MOV, R0, -3),
5192 			BPF_ALU32_IMM(BPF_NEG, R0, 0),
5193 			BPF_EXIT_INSN(),
5194 		},
5195 		INTERNAL,
5196 		{ },
5197 		{ { 0, 3 } },
5198 	},
5199 	{
5200 		"ALU64_NEG: -(3) = -3",
5201 		.u.insns_int = {
5202 			BPF_LD_IMM64(R0, 3),
5203 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
5204 			BPF_EXIT_INSN(),
5205 		},
5206 		INTERNAL,
5207 		{ },
5208 		{ { 0, -3 } },
5209 	},
5210 	{
5211 		"ALU64_NEG: -(-3) = 3",
5212 		.u.insns_int = {
5213 			BPF_LD_IMM64(R0, -3),
5214 			BPF_ALU64_IMM(BPF_NEG, R0, 0),
5215 			BPF_EXIT_INSN(),
5216 		},
5217 		INTERNAL,
5218 		{ },
5219 		{ { 0, 3 } },
5220 	},
5221 	/* BPF_ALU | BPF_END | BPF_FROM_BE */
5222 	{
5223 		"ALU_END_FROM_BE 16: 0x0123456789abcdef -> 0xcdef",
5224 		.u.insns_int = {
5225 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5226 			BPF_ENDIAN(BPF_FROM_BE, R0, 16),
5227 			BPF_EXIT_INSN(),
5228 		},
5229 		INTERNAL,
5230 		{ },
5231 		{ { 0,  cpu_to_be16(0xcdef) } },
5232 	},
5233 	{
5234 		"ALU_END_FROM_BE 32: 0x0123456789abcdef -> 0x89abcdef",
5235 		.u.insns_int = {
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 */
5241 			BPF_EXIT_INSN(),
5242 		},
5243 		INTERNAL,
5244 		{ },
5245 		{ { 0, cpu_to_be32(0x89abcdef) } },
5246 	},
5247 	{
5248 		"ALU_END_FROM_BE 64: 0x0123456789abcdef -> 0x89abcdef",
5249 		.u.insns_int = {
5250 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5251 			BPF_ENDIAN(BPF_FROM_BE, R0, 64),
5252 			BPF_EXIT_INSN(),
5253 		},
5254 		INTERNAL,
5255 		{ },
5256 		{ { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
5257 	},
5258 	/* BPF_ALU | BPF_END | BPF_FROM_LE */
5259 	{
5260 		"ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
5261 		.u.insns_int = {
5262 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5263 			BPF_ENDIAN(BPF_FROM_LE, R0, 16),
5264 			BPF_EXIT_INSN(),
5265 		},
5266 		INTERNAL,
5267 		{ },
5268 		{ { 0, cpu_to_le16(0xcdef) } },
5269 	},
5270 	{
5271 		"ALU_END_FROM_LE 32: 0x0123456789abcdef -> 0xefcdab89",
5272 		.u.insns_int = {
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 */
5278 			BPF_EXIT_INSN(),
5279 		},
5280 		INTERNAL,
5281 		{ },
5282 		{ { 0, cpu_to_le32(0x89abcdef) } },
5283 	},
5284 	{
5285 		"ALU_END_FROM_LE 64: 0x0123456789abcdef -> 0x67452301",
5286 		.u.insns_int = {
5287 			BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
5288 			BPF_ENDIAN(BPF_FROM_LE, R0, 64),
5289 			BPF_EXIT_INSN(),
5290 		},
5291 		INTERNAL,
5292 		{ },
5293 		{ { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
5294 	},
5295 	/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
5296 	{
5297 		"ST_MEM_B: Store/Load byte: max negative",
5298 		.u.insns_int = {
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),
5302 			BPF_EXIT_INSN(),
5303 		},
5304 		INTERNAL,
5305 		{ },
5306 		{ { 0, 0xff } },
5307 		.stack_depth = 40,
5308 	},
5309 	{
5310 		"ST_MEM_B: Store/Load byte: max positive",
5311 		.u.insns_int = {
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),
5315 			BPF_EXIT_INSN(),
5316 		},
5317 		INTERNAL,
5318 		{ },
5319 		{ { 0, 0x7f } },
5320 		.stack_depth = 40,
5321 	},
5322 	{
5323 		"STX_MEM_B: Store/Load byte: max negative",
5324 		.u.insns_int = {
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),
5329 			BPF_EXIT_INSN(),
5330 		},
5331 		INTERNAL,
5332 		{ },
5333 		{ { 0, 0xff } },
5334 		.stack_depth = 40,
5335 	},
5336 	{
5337 		"ST_MEM_H: Store/Load half word: max negative",
5338 		.u.insns_int = {
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),
5342 			BPF_EXIT_INSN(),
5343 		},
5344 		INTERNAL,
5345 		{ },
5346 		{ { 0, 0xffff } },
5347 		.stack_depth = 40,
5348 	},
5349 	{
5350 		"ST_MEM_H: Store/Load half word: max positive",
5351 		.u.insns_int = {
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),
5355 			BPF_EXIT_INSN(),
5356 		},
5357 		INTERNAL,
5358 		{ },
5359 		{ { 0, 0x7fff } },
5360 		.stack_depth = 40,
5361 	},
5362 	{
5363 		"STX_MEM_H: Store/Load half word: max negative",
5364 		.u.insns_int = {
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),
5369 			BPF_EXIT_INSN(),
5370 		},
5371 		INTERNAL,
5372 		{ },
5373 		{ { 0, 0xffff } },
5374 		.stack_depth = 40,
5375 	},
5376 	{
5377 		"ST_MEM_W: Store/Load word: max negative",
5378 		.u.insns_int = {
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),
5382 			BPF_EXIT_INSN(),
5383 		},
5384 		INTERNAL,
5385 		{ },
5386 		{ { 0, 0xffffffff } },
5387 		.stack_depth = 40,
5388 	},
5389 	{
5390 		"ST_MEM_W: Store/Load word: max positive",
5391 		.u.insns_int = {
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),
5395 			BPF_EXIT_INSN(),
5396 		},
5397 		INTERNAL,
5398 		{ },
5399 		{ { 0, 0x7fffffff } },
5400 		.stack_depth = 40,
5401 	},
5402 	{
5403 		"STX_MEM_W: Store/Load word: max negative",
5404 		.u.insns_int = {
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),
5409 			BPF_EXIT_INSN(),
5410 		},
5411 		INTERNAL,
5412 		{ },
5413 		{ { 0, 0xffffffff } },
5414 		.stack_depth = 40,
5415 	},
5416 	{
5417 		"ST_MEM_DW: Store/Load double word: max negative",
5418 		.u.insns_int = {
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),
5422 			BPF_EXIT_INSN(),
5423 		},
5424 		INTERNAL,
5425 		{ },
5426 		{ { 0, 0xffffffff } },
5427 		.stack_depth = 40,
5428 	},
5429 	{
5430 		"ST_MEM_DW: Store/Load double word: max negative 2",
5431 		.u.insns_int = {
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),
5438 			BPF_EXIT_INSN(),
5439 			BPF_MOV32_IMM(R0, 1),
5440 			BPF_EXIT_INSN(),
5441 		},
5442 		INTERNAL,
5443 		{ },
5444 		{ { 0, 0x1 } },
5445 		.stack_depth = 40,
5446 	},
5447 	{
5448 		"ST_MEM_DW: Store/Load double word: max positive",
5449 		.u.insns_int = {
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),
5453 			BPF_EXIT_INSN(),
5454 		},
5455 		INTERNAL,
5456 		{ },
5457 		{ { 0, 0x7fffffff } },
5458 		.stack_depth = 40,
5459 	},
5460 	{
5461 		"STX_MEM_DW: Store/Load double word: max negative",
5462 		.u.insns_int = {
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),
5467 			BPF_EXIT_INSN(),
5468 		},
5469 		INTERNAL,
5470 		{ },
5471 		{ { 0, 0xffffffff } },
5472 		.stack_depth = 40,
5473 	},
5474 	{
5475 		"STX_MEM_DW: Store double word: first word in memory",
5476 		.u.insns_int = {
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),
5481 			BPF_EXIT_INSN(),
5482 		},
5483 		INTERNAL,
5484 		{ },
5485 #ifdef __BIG_ENDIAN
5486 		{ { 0, 0x01234567 } },
5487 #else
5488 		{ { 0, 0x89abcdef } },
5489 #endif
5490 		.stack_depth = 40,
5491 	},
5492 	{
5493 		"STX_MEM_DW: Store double word: second word in memory",
5494 		.u.insns_int = {
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),
5499 			BPF_EXIT_INSN(),
5500 		},
5501 		INTERNAL,
5502 		{ },
5503 #ifdef __BIG_ENDIAN
5504 		{ { 0, 0x89abcdef } },
5505 #else
5506 		{ { 0, 0x01234567 } },
5507 #endif
5508 		.stack_depth = 40,
5509 	},
5510 	/* BPF_STX | BPF_ATOMIC | BPF_W/DW */
5511 	{
5512 		"STX_XADD_W: X + 1 + 1 + 1 + ...",
5513 		{ },
5514 		INTERNAL,
5515 		{ },
5516 		{ { 0, 4134 } },
5517 		.fill_helper = bpf_fill_stxw,
5518 	},
5519 	{
5520 		"STX_XADD_DW: X + 1 + 1 + 1 + ...",
5521 		{ },
5522 		INTERNAL,
5523 		{ },
5524 		{ { 0, 4134 } },
5525 		.fill_helper = bpf_fill_stxdw,
5526 	},
5527 	/*
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.
5531 	 */
5532 #define BPF_ATOMIC_OP_TEST1(width, op, logic, old, update, result)	\
5533 {									\
5534 	"BPF_ATOMIC | " #width ", " #op ": Test: "			\
5535 		#old " " #logic " " #update " = " #result,		\
5536 	.u.insns_int = {						\
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),			\
5541 		BPF_EXIT_INSN(),					\
5542 	},								\
5543 	INTERNAL,							\
5544 	{ },								\
5545 	{ { 0, result } },						\
5546 	.stack_depth = 40,						\
5547 }
5548 #define BPF_ATOMIC_OP_TEST2(width, op, logic, old, update, result)	\
5549 {									\
5550 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r10: "	\
5551 		#old " " #logic " " #update " = " #result,		\
5552 	.u.insns_int = {						\
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),				\
5559 		BPF_EXIT_INSN(),					\
5560 	},								\
5561 	INTERNAL,							\
5562 	{ },								\
5563 	{ { 0, 0 } },							\
5564 	.stack_depth = 40,						\
5565 }
5566 #define BPF_ATOMIC_OP_TEST3(width, op, logic, old, update, result)	\
5567 {									\
5568 	"BPF_ATOMIC | " #width ", " #op ": Test side effects, r0: "	\
5569 		#old " " #logic " " #update " = " #result,		\
5570 	.u.insns_int = {						\
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),			\
5576 		BPF_EXIT_INSN(),					\
5577 	},								\
5578 	INTERNAL,                                                       \
5579 	{ },                                                            \
5580 	{ { 0, 0 } },                                                   \
5581 	.stack_depth = 40,                                              \
5582 }
5583 #define BPF_ATOMIC_OP_TEST4(width, op, logic, old, update, result)	\
5584 {									\
5585 	"BPF_ATOMIC | " #width ", " #op ": Test fetch: "		\
5586 		#old " " #logic " " #update " = " #result,		\
5587 	.u.insns_int = {						\
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),                         \
5592 		BPF_EXIT_INSN(),					\
5593 	},								\
5594 	INTERNAL,                                                       \
5595 	{ },                                                            \
5596 	{ { 0, (op) & BPF_FETCH ? old : update } },			\
5597 	.stack_depth = 40,                                              \
5598 }
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_ATOMIC | BPF_W, BPF_CMPXCHG */
5694 	{
5695 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
5696 		.u.insns_int = {
5697 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5698 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
5699 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5700 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5701 			BPF_EXIT_INSN(),
5702 		},
5703 		INTERNAL,
5704 		{ },
5705 		{ { 0, 0x01234567 } },
5706 		.stack_depth = 40,
5707 	},
5708 	{
5709 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
5710 		.u.insns_int = {
5711 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5712 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
5713 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5714 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5715 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
5716 			BPF_EXIT_INSN(),
5717 		},
5718 		INTERNAL,
5719 		{ },
5720 		{ { 0, 0x89abcdef } },
5721 		.stack_depth = 40,
5722 	},
5723 	{
5724 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
5725 		.u.insns_int = {
5726 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5727 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
5728 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5729 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5730 			BPF_EXIT_INSN(),
5731 		},
5732 		INTERNAL,
5733 		{ },
5734 		{ { 0, 0x01234567 } },
5735 		.stack_depth = 40,
5736 	},
5737 	{
5738 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
5739 		.u.insns_int = {
5740 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5741 			BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
5742 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5743 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5744 			BPF_LDX_MEM(BPF_W, R0, R10, -40),
5745 			BPF_EXIT_INSN(),
5746 		},
5747 		INTERNAL,
5748 		{ },
5749 		{ { 0, 0x01234567 } },
5750 		.stack_depth = 40,
5751 	},
5752 	{
5753 		"BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
5754 		.u.insns_int = {
5755 			BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
5756 			BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
5757 			BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
5758 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5759 			BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
5760 			BPF_ALU32_REG(BPF_MOV, R0, R3),
5761 			BPF_EXIT_INSN(),
5762 		},
5763 		INTERNAL,
5764 		{ },
5765 		{ { 0, 0x89abcdef } },
5766 		.stack_depth = 40,
5767 	},
5768 	/* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
5769 	{
5770 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
5771 		.u.insns_int = {
5772 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5773 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5774 			BPF_ALU64_REG(BPF_MOV, R0, R1),
5775 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
5776 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5777 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
5778 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5779 			BPF_EXIT_INSN(),
5780 		},
5781 		INTERNAL,
5782 		{ },
5783 		{ { 0, 0 } },
5784 		.stack_depth = 40,
5785 	},
5786 	{
5787 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
5788 		.u.insns_int = {
5789 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5790 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5791 			BPF_ALU64_REG(BPF_MOV, R0, R1),
5792 			BPF_STX_MEM(BPF_DW, R10, R0, -40),
5793 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5794 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5795 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
5796 			BPF_ALU64_REG(BPF_SUB, R0, R2),
5797 			BPF_EXIT_INSN(),
5798 		},
5799 		INTERNAL,
5800 		{ },
5801 		{ { 0, 0 } },
5802 		.stack_depth = 40,
5803 	},
5804 	{
5805 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
5806 		.u.insns_int = {
5807 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5808 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5809 			BPF_ALU64_REG(BPF_MOV, R0, R1),
5810 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
5811 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
5812 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5813 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
5814 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5815 			BPF_EXIT_INSN(),
5816 		},
5817 		INTERNAL,
5818 		{ },
5819 		{ { 0, 0 } },
5820 		.stack_depth = 40,
5821 	},
5822 	{
5823 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
5824 		.u.insns_int = {
5825 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5826 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5827 			BPF_ALU64_REG(BPF_MOV, R0, R1),
5828 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
5829 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
5830 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5831 			BPF_LDX_MEM(BPF_DW, R0, R10, -40),
5832 			BPF_JMP_REG(BPF_JNE, R0, R1, 1),
5833 			BPF_ALU64_REG(BPF_SUB, R0, R1),
5834 			BPF_EXIT_INSN(),
5835 		},
5836 		INTERNAL,
5837 		{ },
5838 		{ { 0, 0 } },
5839 		.stack_depth = 40,
5840 	},
5841 	{
5842 		"BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
5843 		.u.insns_int = {
5844 			BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
5845 			BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
5846 			BPF_ALU64_REG(BPF_MOV, R0, R1),
5847 			BPF_STX_MEM(BPF_DW, R10, R1, -40),
5848 			BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
5849 			BPF_LD_IMM64(R0, 0xfecdba9876543210ULL),
5850 			BPF_JMP_REG(BPF_JNE, R0, R2, 1),
5851 			BPF_ALU64_REG(BPF_SUB, R0, R2),
5852 			BPF_EXIT_INSN(),
5853 		},
5854 		INTERNAL,
5855 		{ },
5856 		{ { 0, 0 } },
5857 		.stack_depth = 40,
5858 	},
5859 	/* BPF_JMP32 | BPF_JEQ | BPF_K */
5860 	{
5861 		"JMP32_JEQ_K: Small immediate",
5862 		.u.insns_int = {
5863 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
5864 			BPF_JMP32_IMM(BPF_JEQ, R0, 321, 1),
5865 			BPF_JMP32_IMM(BPF_JEQ, R0, 123, 1),
5866 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5867 			BPF_EXIT_INSN(),
5868 		},
5869 		INTERNAL,
5870 		{ },
5871 		{ { 0, 123 } }
5872 	},
5873 	{
5874 		"JMP32_JEQ_K: Large immediate",
5875 		.u.insns_int = {
5876 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5877 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678 & 0xffff, 1),
5878 			BPF_JMP32_IMM(BPF_JEQ, R0, 12345678, 1),
5879 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5880 			BPF_EXIT_INSN(),
5881 		},
5882 		INTERNAL,
5883 		{ },
5884 		{ { 0, 12345678 } }
5885 	},
5886 	{
5887 		"JMP32_JEQ_K: negative immediate",
5888 		.u.insns_int = {
5889 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
5890 			BPF_JMP32_IMM(BPF_JEQ, R0,  123, 1),
5891 			BPF_JMP32_IMM(BPF_JEQ, R0, -123, 1),
5892 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5893 			BPF_EXIT_INSN(),
5894 		},
5895 		INTERNAL,
5896 		{ },
5897 		{ { 0, -123 } }
5898 	},
5899 	/* BPF_JMP32 | BPF_JEQ | BPF_X */
5900 	{
5901 		"JMP32_JEQ_X",
5902 		.u.insns_int = {
5903 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5904 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5905 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 2),
5906 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5907 			BPF_JMP32_REG(BPF_JEQ, R0, R1, 1),
5908 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5909 			BPF_EXIT_INSN(),
5910 		},
5911 		INTERNAL,
5912 		{ },
5913 		{ { 0, 1234 } }
5914 	},
5915 	/* BPF_JMP32 | BPF_JNE | BPF_K */
5916 	{
5917 		"JMP32_JNE_K: Small immediate",
5918 		.u.insns_int = {
5919 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
5920 			BPF_JMP32_IMM(BPF_JNE, R0, 123, 1),
5921 			BPF_JMP32_IMM(BPF_JNE, R0, 321, 1),
5922 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5923 			BPF_EXIT_INSN(),
5924 		},
5925 		INTERNAL,
5926 		{ },
5927 		{ { 0, 123 } }
5928 	},
5929 	{
5930 		"JMP32_JNE_K: Large immediate",
5931 		.u.insns_int = {
5932 			BPF_ALU32_IMM(BPF_MOV, R0, 12345678),
5933 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678, 1),
5934 			BPF_JMP32_IMM(BPF_JNE, R0, 12345678 & 0xffff, 1),
5935 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5936 			BPF_EXIT_INSN(),
5937 		},
5938 		INTERNAL,
5939 		{ },
5940 		{ { 0, 12345678 } }
5941 	},
5942 	{
5943 		"JMP32_JNE_K: negative immediate",
5944 		.u.insns_int = {
5945 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
5946 			BPF_JMP32_IMM(BPF_JNE, R0, -123, 1),
5947 			BPF_JMP32_IMM(BPF_JNE, R0,  123, 1),
5948 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5949 			BPF_EXIT_INSN(),
5950 		},
5951 		INTERNAL,
5952 		{ },
5953 		{ { 0, -123 } }
5954 	},
5955 	/* BPF_JMP32 | BPF_JNE | BPF_X */
5956 	{
5957 		"JMP32_JNE_X",
5958 		.u.insns_int = {
5959 			BPF_ALU32_IMM(BPF_MOV, R0, 1234),
5960 			BPF_ALU32_IMM(BPF_MOV, R1, 1234),
5961 			BPF_JMP32_REG(BPF_JNE, R0, R1, 2),
5962 			BPF_ALU32_IMM(BPF_MOV, R1, 4321),
5963 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
5964 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5965 			BPF_EXIT_INSN(),
5966 		},
5967 		INTERNAL,
5968 		{ },
5969 		{ { 0, 1234 } }
5970 	},
5971 	/* BPF_JMP32 | BPF_JSET | BPF_K */
5972 	{
5973 		"JMP32_JSET_K: Small immediate",
5974 		.u.insns_int = {
5975 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
5976 			BPF_JMP32_IMM(BPF_JSET, R0, 2, 1),
5977 			BPF_JMP32_IMM(BPF_JSET, R0, 3, 1),
5978 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5979 			BPF_EXIT_INSN(),
5980 		},
5981 		INTERNAL,
5982 		{ },
5983 		{ { 0, 1 } }
5984 	},
5985 	{
5986 		"JMP32_JSET_K: Large immediate",
5987 		.u.insns_int = {
5988 			BPF_ALU32_IMM(BPF_MOV, R0, 0x40000000),
5989 			BPF_JMP32_IMM(BPF_JSET, R0, 0x3fffffff, 1),
5990 			BPF_JMP32_IMM(BPF_JSET, R0, 0x60000000, 1),
5991 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
5992 			BPF_EXIT_INSN(),
5993 		},
5994 		INTERNAL,
5995 		{ },
5996 		{ { 0, 0x40000000 } }
5997 	},
5998 	{
5999 		"JMP32_JSET_K: negative immediate",
6000 		.u.insns_int = {
6001 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
6002 			BPF_JMP32_IMM(BPF_JSET, R0, -1, 1),
6003 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6004 			BPF_EXIT_INSN(),
6005 		},
6006 		INTERNAL,
6007 		{ },
6008 		{ { 0, -123 } }
6009 	},
6010 	/* BPF_JMP32 | BPF_JSET | BPF_X */
6011 	{
6012 		"JMP32_JSET_X",
6013 		.u.insns_int = {
6014 			BPF_ALU32_IMM(BPF_MOV, R0, 8),
6015 			BPF_ALU32_IMM(BPF_MOV, R1, 7),
6016 			BPF_JMP32_REG(BPF_JSET, R0, R1, 2),
6017 			BPF_ALU32_IMM(BPF_MOV, R1, 8 | 2),
6018 			BPF_JMP32_REG(BPF_JNE, R0, R1, 1),
6019 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6020 			BPF_EXIT_INSN(),
6021 		},
6022 		INTERNAL,
6023 		{ },
6024 		{ { 0, 8 } }
6025 	},
6026 	/* BPF_JMP32 | BPF_JGT | BPF_K */
6027 	{
6028 		"JMP32_JGT_K: Small immediate",
6029 		.u.insns_int = {
6030 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
6031 			BPF_JMP32_IMM(BPF_JGT, R0, 123, 1),
6032 			BPF_JMP32_IMM(BPF_JGT, R0, 122, 1),
6033 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6034 			BPF_EXIT_INSN(),
6035 		},
6036 		INTERNAL,
6037 		{ },
6038 		{ { 0, 123 } }
6039 	},
6040 	{
6041 		"JMP32_JGT_K: Large immediate",
6042 		.u.insns_int = {
6043 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6044 			BPF_JMP32_IMM(BPF_JGT, R0, 0xffffffff, 1),
6045 			BPF_JMP32_IMM(BPF_JGT, R0, 0xfffffffd, 1),
6046 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6047 			BPF_EXIT_INSN(),
6048 		},
6049 		INTERNAL,
6050 		{ },
6051 		{ { 0, 0xfffffffe } }
6052 	},
6053 	/* BPF_JMP32 | BPF_JGT | BPF_X */
6054 	{
6055 		"JMP32_JGT_X",
6056 		.u.insns_int = {
6057 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6058 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6059 			BPF_JMP32_REG(BPF_JGT, R0, R1, 2),
6060 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
6061 			BPF_JMP32_REG(BPF_JGT, R0, R1, 1),
6062 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6063 			BPF_EXIT_INSN(),
6064 		},
6065 		INTERNAL,
6066 		{ },
6067 		{ { 0, 0xfffffffe } }
6068 	},
6069 	/* BPF_JMP32 | BPF_JGE | BPF_K */
6070 	{
6071 		"JMP32_JGE_K: Small immediate",
6072 		.u.insns_int = {
6073 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
6074 			BPF_JMP32_IMM(BPF_JGE, R0, 124, 1),
6075 			BPF_JMP32_IMM(BPF_JGE, R0, 123, 1),
6076 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6077 			BPF_EXIT_INSN(),
6078 		},
6079 		INTERNAL,
6080 		{ },
6081 		{ { 0, 123 } }
6082 	},
6083 	{
6084 		"JMP32_JGE_K: Large immediate",
6085 		.u.insns_int = {
6086 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6087 			BPF_JMP32_IMM(BPF_JGE, R0, 0xffffffff, 1),
6088 			BPF_JMP32_IMM(BPF_JGE, R0, 0xfffffffe, 1),
6089 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6090 			BPF_EXIT_INSN(),
6091 		},
6092 		INTERNAL,
6093 		{ },
6094 		{ { 0, 0xfffffffe } }
6095 	},
6096 	/* BPF_JMP32 | BPF_JGE | BPF_X */
6097 	{
6098 		"JMP32_JGE_X",
6099 		.u.insns_int = {
6100 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6101 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6102 			BPF_JMP32_REG(BPF_JGE, R0, R1, 2),
6103 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
6104 			BPF_JMP32_REG(BPF_JGE, R0, R1, 1),
6105 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6106 			BPF_EXIT_INSN(),
6107 		},
6108 		INTERNAL,
6109 		{ },
6110 		{ { 0, 0xfffffffe } }
6111 	},
6112 	/* BPF_JMP32 | BPF_JLT | BPF_K */
6113 	{
6114 		"JMP32_JLT_K: Small immediate",
6115 		.u.insns_int = {
6116 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
6117 			BPF_JMP32_IMM(BPF_JLT, R0, 123, 1),
6118 			BPF_JMP32_IMM(BPF_JLT, R0, 124, 1),
6119 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6120 			BPF_EXIT_INSN(),
6121 		},
6122 		INTERNAL,
6123 		{ },
6124 		{ { 0, 123 } }
6125 	},
6126 	{
6127 		"JMP32_JLT_K: Large immediate",
6128 		.u.insns_int = {
6129 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6130 			BPF_JMP32_IMM(BPF_JLT, R0, 0xfffffffd, 1),
6131 			BPF_JMP32_IMM(BPF_JLT, R0, 0xffffffff, 1),
6132 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6133 			BPF_EXIT_INSN(),
6134 		},
6135 		INTERNAL,
6136 		{ },
6137 		{ { 0, 0xfffffffe } }
6138 	},
6139 	/* BPF_JMP32 | BPF_JLT | BPF_X */
6140 	{
6141 		"JMP32_JLT_X",
6142 		.u.insns_int = {
6143 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6144 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
6145 			BPF_JMP32_REG(BPF_JLT, R0, R1, 2),
6146 			BPF_ALU32_IMM(BPF_MOV, R1, 0xffffffff),
6147 			BPF_JMP32_REG(BPF_JLT, R0, R1, 1),
6148 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6149 			BPF_EXIT_INSN(),
6150 		},
6151 		INTERNAL,
6152 		{ },
6153 		{ { 0, 0xfffffffe } }
6154 	},
6155 	/* BPF_JMP32 | BPF_JLE | BPF_K */
6156 	{
6157 		"JMP32_JLE_K: Small immediate",
6158 		.u.insns_int = {
6159 			BPF_ALU32_IMM(BPF_MOV, R0, 123),
6160 			BPF_JMP32_IMM(BPF_JLE, R0, 122, 1),
6161 			BPF_JMP32_IMM(BPF_JLE, R0, 123, 1),
6162 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6163 			BPF_EXIT_INSN(),
6164 		},
6165 		INTERNAL,
6166 		{ },
6167 		{ { 0, 123 } }
6168 	},
6169 	{
6170 		"JMP32_JLE_K: Large immediate",
6171 		.u.insns_int = {
6172 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6173 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffd, 1),
6174 			BPF_JMP32_IMM(BPF_JLE, R0, 0xfffffffe, 1),
6175 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6176 			BPF_EXIT_INSN(),
6177 		},
6178 		INTERNAL,
6179 		{ },
6180 		{ { 0, 0xfffffffe } }
6181 	},
6182 	/* BPF_JMP32 | BPF_JLE | BPF_X */
6183 	{
6184 		"JMP32_JLE_X",
6185 		.u.insns_int = {
6186 			BPF_ALU32_IMM(BPF_MOV, R0, 0xfffffffe),
6187 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffd),
6188 			BPF_JMP32_REG(BPF_JLE, R0, R1, 2),
6189 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfffffffe),
6190 			BPF_JMP32_REG(BPF_JLE, R0, R1, 1),
6191 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6192 			BPF_EXIT_INSN(),
6193 		},
6194 		INTERNAL,
6195 		{ },
6196 		{ { 0, 0xfffffffe } }
6197 	},
6198 	/* BPF_JMP32 | BPF_JSGT | BPF_K */
6199 	{
6200 		"JMP32_JSGT_K: Small immediate",
6201 		.u.insns_int = {
6202 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
6203 			BPF_JMP32_IMM(BPF_JSGT, R0, -123, 1),
6204 			BPF_JMP32_IMM(BPF_JSGT, R0, -124, 1),
6205 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6206 			BPF_EXIT_INSN(),
6207 		},
6208 		INTERNAL,
6209 		{ },
6210 		{ { 0, -123 } }
6211 	},
6212 	{
6213 		"JMP32_JSGT_K: Large immediate",
6214 		.u.insns_int = {
6215 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6216 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345678, 1),
6217 			BPF_JMP32_IMM(BPF_JSGT, R0, -12345679, 1),
6218 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6219 			BPF_EXIT_INSN(),
6220 		},
6221 		INTERNAL,
6222 		{ },
6223 		{ { 0, -12345678 } }
6224 	},
6225 	/* BPF_JMP32 | BPF_JSGT | BPF_X */
6226 	{
6227 		"JMP32_JSGT_X",
6228 		.u.insns_int = {
6229 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6230 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6231 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 2),
6232 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
6233 			BPF_JMP32_REG(BPF_JSGT, R0, R1, 1),
6234 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6235 			BPF_EXIT_INSN(),
6236 		},
6237 		INTERNAL,
6238 		{ },
6239 		{ { 0, -12345678 } }
6240 	},
6241 	/* BPF_JMP32 | BPF_JSGE | BPF_K */
6242 	{
6243 		"JMP32_JSGE_K: Small immediate",
6244 		.u.insns_int = {
6245 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
6246 			BPF_JMP32_IMM(BPF_JSGE, R0, -122, 1),
6247 			BPF_JMP32_IMM(BPF_JSGE, R0, -123, 1),
6248 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6249 			BPF_EXIT_INSN(),
6250 		},
6251 		INTERNAL,
6252 		{ },
6253 		{ { 0, -123 } }
6254 	},
6255 	{
6256 		"JMP32_JSGE_K: Large immediate",
6257 		.u.insns_int = {
6258 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6259 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345677, 1),
6260 			BPF_JMP32_IMM(BPF_JSGE, R0, -12345678, 1),
6261 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6262 			BPF_EXIT_INSN(),
6263 		},
6264 		INTERNAL,
6265 		{ },
6266 		{ { 0, -12345678 } }
6267 	},
6268 	/* BPF_JMP32 | BPF_JSGE | BPF_X */
6269 	{
6270 		"JMP32_JSGE_X",
6271 		.u.insns_int = {
6272 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6273 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
6274 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 2),
6275 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6276 			BPF_JMP32_REG(BPF_JSGE, R0, R1, 1),
6277 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6278 			BPF_EXIT_INSN(),
6279 		},
6280 		INTERNAL,
6281 		{ },
6282 		{ { 0, -12345678 } }
6283 	},
6284 	/* BPF_JMP32 | BPF_JSLT | BPF_K */
6285 	{
6286 		"JMP32_JSLT_K: Small immediate",
6287 		.u.insns_int = {
6288 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
6289 			BPF_JMP32_IMM(BPF_JSLT, R0, -123, 1),
6290 			BPF_JMP32_IMM(BPF_JSLT, R0, -122, 1),
6291 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6292 			BPF_EXIT_INSN(),
6293 		},
6294 		INTERNAL,
6295 		{ },
6296 		{ { 0, -123 } }
6297 	},
6298 	{
6299 		"JMP32_JSLT_K: Large immediate",
6300 		.u.insns_int = {
6301 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6302 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345678, 1),
6303 			BPF_JMP32_IMM(BPF_JSLT, R0, -12345677, 1),
6304 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6305 			BPF_EXIT_INSN(),
6306 		},
6307 		INTERNAL,
6308 		{ },
6309 		{ { 0, -12345678 } }
6310 	},
6311 	/* BPF_JMP32 | BPF_JSLT | BPF_X */
6312 	{
6313 		"JMP32_JSLT_X",
6314 		.u.insns_int = {
6315 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6316 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6317 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 2),
6318 			BPF_ALU32_IMM(BPF_MOV, R1, -12345677),
6319 			BPF_JMP32_REG(BPF_JSLT, R0, R1, 1),
6320 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6321 			BPF_EXIT_INSN(),
6322 		},
6323 		INTERNAL,
6324 		{ },
6325 		{ { 0, -12345678 } }
6326 	},
6327 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
6328 	{
6329 		"JMP32_JSLE_K: Small immediate",
6330 		.u.insns_int = {
6331 			BPF_ALU32_IMM(BPF_MOV, R0, -123),
6332 			BPF_JMP32_IMM(BPF_JSLE, R0, -124, 1),
6333 			BPF_JMP32_IMM(BPF_JSLE, R0, -123, 1),
6334 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6335 			BPF_EXIT_INSN(),
6336 		},
6337 		INTERNAL,
6338 		{ },
6339 		{ { 0, -123 } }
6340 	},
6341 	{
6342 		"JMP32_JSLE_K: Large immediate",
6343 		.u.insns_int = {
6344 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6345 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345679, 1),
6346 			BPF_JMP32_IMM(BPF_JSLE, R0, -12345678, 1),
6347 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6348 			BPF_EXIT_INSN(),
6349 		},
6350 		INTERNAL,
6351 		{ },
6352 		{ { 0, -12345678 } }
6353 	},
6354 	/* BPF_JMP32 | BPF_JSLE | BPF_K */
6355 	{
6356 		"JMP32_JSLE_X",
6357 		.u.insns_int = {
6358 			BPF_ALU32_IMM(BPF_MOV, R0, -12345678),
6359 			BPF_ALU32_IMM(BPF_MOV, R1, -12345679),
6360 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 2),
6361 			BPF_ALU32_IMM(BPF_MOV, R1, -12345678),
6362 			BPF_JMP32_REG(BPF_JSLE, R0, R1, 1),
6363 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6364 			BPF_EXIT_INSN(),
6365 		},
6366 		INTERNAL,
6367 		{ },
6368 		{ { 0, -12345678 } }
6369 	},
6370 	/* BPF_JMP | BPF_EXIT */
6371 	{
6372 		"JMP_EXIT",
6373 		.u.insns_int = {
6374 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4711),
6375 			BPF_EXIT_INSN(),
6376 			BPF_ALU32_IMM(BPF_MOV, R0, 0x4712),
6377 		},
6378 		INTERNAL,
6379 		{ },
6380 		{ { 0, 0x4711 } },
6381 	},
6382 	/* BPF_JMP | BPF_JA */
6383 	{
6384 		"JMP_JA: Unconditional jump: if (true) return 1",
6385 		.u.insns_int = {
6386 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6387 			BPF_JMP_IMM(BPF_JA, 0, 0, 1),
6388 			BPF_EXIT_INSN(),
6389 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6390 			BPF_EXIT_INSN(),
6391 		},
6392 		INTERNAL,
6393 		{ },
6394 		{ { 0, 1 } },
6395 	},
6396 	/* BPF_JMP | BPF_JSLT | BPF_K */
6397 	{
6398 		"JMP_JSLT_K: Signed jump: if (-2 < -1) return 1",
6399 		.u.insns_int = {
6400 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6401 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
6402 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
6403 			BPF_EXIT_INSN(),
6404 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6405 			BPF_EXIT_INSN(),
6406 		},
6407 		INTERNAL,
6408 		{ },
6409 		{ { 0, 1 } },
6410 	},
6411 	{
6412 		"JMP_JSLT_K: Signed jump: if (-1 < -1) return 0",
6413 		.u.insns_int = {
6414 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6415 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6416 			BPF_JMP_IMM(BPF_JSLT, R1, -1, 1),
6417 			BPF_EXIT_INSN(),
6418 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6419 			BPF_EXIT_INSN(),
6420 		},
6421 		INTERNAL,
6422 		{ },
6423 		{ { 0, 1 } },
6424 	},
6425 	/* BPF_JMP | BPF_JSGT | BPF_K */
6426 	{
6427 		"JMP_JSGT_K: Signed jump: if (-1 > -2) return 1",
6428 		.u.insns_int = {
6429 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6430 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6431 			BPF_JMP_IMM(BPF_JSGT, R1, -2, 1),
6432 			BPF_EXIT_INSN(),
6433 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6434 			BPF_EXIT_INSN(),
6435 		},
6436 		INTERNAL,
6437 		{ },
6438 		{ { 0, 1 } },
6439 	},
6440 	{
6441 		"JMP_JSGT_K: Signed jump: if (-1 > -1) return 0",
6442 		.u.insns_int = {
6443 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6444 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6445 			BPF_JMP_IMM(BPF_JSGT, R1, -1, 1),
6446 			BPF_EXIT_INSN(),
6447 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6448 			BPF_EXIT_INSN(),
6449 		},
6450 		INTERNAL,
6451 		{ },
6452 		{ { 0, 1 } },
6453 	},
6454 	/* BPF_JMP | BPF_JSLE | BPF_K */
6455 	{
6456 		"JMP_JSLE_K: Signed jump: if (-2 <= -1) return 1",
6457 		.u.insns_int = {
6458 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6459 			BPF_LD_IMM64(R1, 0xfffffffffffffffeLL),
6460 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
6461 			BPF_EXIT_INSN(),
6462 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6463 			BPF_EXIT_INSN(),
6464 		},
6465 		INTERNAL,
6466 		{ },
6467 		{ { 0, 1 } },
6468 	},
6469 	{
6470 		"JMP_JSLE_K: Signed jump: if (-1 <= -1) return 1",
6471 		.u.insns_int = {
6472 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6473 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6474 			BPF_JMP_IMM(BPF_JSLE, R1, -1, 1),
6475 			BPF_EXIT_INSN(),
6476 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6477 			BPF_EXIT_INSN(),
6478 		},
6479 		INTERNAL,
6480 		{ },
6481 		{ { 0, 1 } },
6482 	},
6483 	{
6484 		"JMP_JSLE_K: Signed jump: value walk 1",
6485 		.u.insns_int = {
6486 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6487 			BPF_LD_IMM64(R1, 3),
6488 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 6),
6489 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
6490 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
6491 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
6492 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
6493 			BPF_ALU64_IMM(BPF_SUB, R1, 1),
6494 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
6495 			BPF_EXIT_INSN(),		/* bad exit */
6496 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
6497 			BPF_EXIT_INSN(),
6498 		},
6499 		INTERNAL,
6500 		{ },
6501 		{ { 0, 1 } },
6502 	},
6503 	{
6504 		"JMP_JSLE_K: Signed jump: value walk 2",
6505 		.u.insns_int = {
6506 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6507 			BPF_LD_IMM64(R1, 3),
6508 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 4),
6509 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
6510 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 2),
6511 			BPF_ALU64_IMM(BPF_SUB, R1, 2),
6512 			BPF_JMP_IMM(BPF_JSLE, R1, 0, 1),
6513 			BPF_EXIT_INSN(),		/* bad exit */
6514 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
6515 			BPF_EXIT_INSN(),
6516 		},
6517 		INTERNAL,
6518 		{ },
6519 		{ { 0, 1 } },
6520 	},
6521 	/* BPF_JMP | BPF_JSGE | BPF_K */
6522 	{
6523 		"JMP_JSGE_K: Signed jump: if (-1 >= -2) return 1",
6524 		.u.insns_int = {
6525 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6526 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6527 			BPF_JMP_IMM(BPF_JSGE, R1, -2, 1),
6528 			BPF_EXIT_INSN(),
6529 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6530 			BPF_EXIT_INSN(),
6531 		},
6532 		INTERNAL,
6533 		{ },
6534 		{ { 0, 1 } },
6535 	},
6536 	{
6537 		"JMP_JSGE_K: Signed jump: if (-1 >= -1) return 1",
6538 		.u.insns_int = {
6539 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6540 			BPF_LD_IMM64(R1, 0xffffffffffffffffLL),
6541 			BPF_JMP_IMM(BPF_JSGE, R1, -1, 1),
6542 			BPF_EXIT_INSN(),
6543 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6544 			BPF_EXIT_INSN(),
6545 		},
6546 		INTERNAL,
6547 		{ },
6548 		{ { 0, 1 } },
6549 	},
6550 	{
6551 		"JMP_JSGE_K: Signed jump: value walk 1",
6552 		.u.insns_int = {
6553 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6554 			BPF_LD_IMM64(R1, -3),
6555 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 6),
6556 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
6557 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6558 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
6559 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6560 			BPF_ALU64_IMM(BPF_ADD, R1, 1),
6561 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6562 			BPF_EXIT_INSN(),		/* bad exit */
6563 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
6564 			BPF_EXIT_INSN(),
6565 		},
6566 		INTERNAL,
6567 		{ },
6568 		{ { 0, 1 } },
6569 	},
6570 	{
6571 		"JMP_JSGE_K: Signed jump: value walk 2",
6572 		.u.insns_int = {
6573 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6574 			BPF_LD_IMM64(R1, -3),
6575 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 4),
6576 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
6577 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 2),
6578 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
6579 			BPF_JMP_IMM(BPF_JSGE, R1, 0, 1),
6580 			BPF_EXIT_INSN(),		/* bad exit */
6581 			BPF_ALU32_IMM(BPF_MOV, R0, 1),	/* good exit */
6582 			BPF_EXIT_INSN(),
6583 		},
6584 		INTERNAL,
6585 		{ },
6586 		{ { 0, 1 } },
6587 	},
6588 	/* BPF_JMP | BPF_JGT | BPF_K */
6589 	{
6590 		"JMP_JGT_K: if (3 > 2) return 1",
6591 		.u.insns_int = {
6592 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6593 			BPF_LD_IMM64(R1, 3),
6594 			BPF_JMP_IMM(BPF_JGT, R1, 2, 1),
6595 			BPF_EXIT_INSN(),
6596 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6597 			BPF_EXIT_INSN(),
6598 		},
6599 		INTERNAL,
6600 		{ },
6601 		{ { 0, 1 } },
6602 	},
6603 	{
6604 		"JMP_JGT_K: Unsigned jump: if (-1 > 1) return 1",
6605 		.u.insns_int = {
6606 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6607 			BPF_LD_IMM64(R1, -1),
6608 			BPF_JMP_IMM(BPF_JGT, R1, 1, 1),
6609 			BPF_EXIT_INSN(),
6610 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6611 			BPF_EXIT_INSN(),
6612 		},
6613 		INTERNAL,
6614 		{ },
6615 		{ { 0, 1 } },
6616 	},
6617 	/* BPF_JMP | BPF_JLT | BPF_K */
6618 	{
6619 		"JMP_JLT_K: if (2 < 3) return 1",
6620 		.u.insns_int = {
6621 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6622 			BPF_LD_IMM64(R1, 2),
6623 			BPF_JMP_IMM(BPF_JLT, R1, 3, 1),
6624 			BPF_EXIT_INSN(),
6625 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6626 			BPF_EXIT_INSN(),
6627 		},
6628 		INTERNAL,
6629 		{ },
6630 		{ { 0, 1 } },
6631 	},
6632 	{
6633 		"JMP_JGT_K: Unsigned jump: if (1 < -1) return 1",
6634 		.u.insns_int = {
6635 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6636 			BPF_LD_IMM64(R1, 1),
6637 			BPF_JMP_IMM(BPF_JLT, R1, -1, 1),
6638 			BPF_EXIT_INSN(),
6639 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6640 			BPF_EXIT_INSN(),
6641 		},
6642 		INTERNAL,
6643 		{ },
6644 		{ { 0, 1 } },
6645 	},
6646 	/* BPF_JMP | BPF_JGE | BPF_K */
6647 	{
6648 		"JMP_JGE_K: if (3 >= 2) return 1",
6649 		.u.insns_int = {
6650 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6651 			BPF_LD_IMM64(R1, 3),
6652 			BPF_JMP_IMM(BPF_JGE, R1, 2, 1),
6653 			BPF_EXIT_INSN(),
6654 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6655 			BPF_EXIT_INSN(),
6656 		},
6657 		INTERNAL,
6658 		{ },
6659 		{ { 0, 1 } },
6660 	},
6661 	/* BPF_JMP | BPF_JLE | BPF_K */
6662 	{
6663 		"JMP_JLE_K: if (2 <= 3) return 1",
6664 		.u.insns_int = {
6665 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6666 			BPF_LD_IMM64(R1, 2),
6667 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6668 			BPF_EXIT_INSN(),
6669 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6670 			BPF_EXIT_INSN(),
6671 		},
6672 		INTERNAL,
6673 		{ },
6674 		{ { 0, 1 } },
6675 	},
6676 	/* BPF_JMP | BPF_JGT | BPF_K jump backwards */
6677 	{
6678 		"JMP_JGT_K: if (3 > 2) return 1 (jump backwards)",
6679 		.u.insns_int = {
6680 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6681 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6682 			BPF_EXIT_INSN(),
6683 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6684 			BPF_LD_IMM64(R1, 3), /* note: this takes 2 insns */
6685 			BPF_JMP_IMM(BPF_JGT, R1, 2, -6), /* goto out */
6686 			BPF_EXIT_INSN(),
6687 		},
6688 		INTERNAL,
6689 		{ },
6690 		{ { 0, 1 } },
6691 	},
6692 	{
6693 		"JMP_JGE_K: if (3 >= 3) return 1",
6694 		.u.insns_int = {
6695 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6696 			BPF_LD_IMM64(R1, 3),
6697 			BPF_JMP_IMM(BPF_JGE, R1, 3, 1),
6698 			BPF_EXIT_INSN(),
6699 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6700 			BPF_EXIT_INSN(),
6701 		},
6702 		INTERNAL,
6703 		{ },
6704 		{ { 0, 1 } },
6705 	},
6706 	/* BPF_JMP | BPF_JLT | BPF_K jump backwards */
6707 	{
6708 		"JMP_JGT_K: if (2 < 3) return 1 (jump backwards)",
6709 		.u.insns_int = {
6710 			BPF_JMP_IMM(BPF_JA, 0, 0, 2), /* goto start */
6711 			BPF_ALU32_IMM(BPF_MOV, R0, 1), /* out: */
6712 			BPF_EXIT_INSN(),
6713 			BPF_ALU32_IMM(BPF_MOV, R0, 0), /* start: */
6714 			BPF_LD_IMM64(R1, 2), /* note: this takes 2 insns */
6715 			BPF_JMP_IMM(BPF_JLT, R1, 3, -6), /* goto out */
6716 			BPF_EXIT_INSN(),
6717 		},
6718 		INTERNAL,
6719 		{ },
6720 		{ { 0, 1 } },
6721 	},
6722 	{
6723 		"JMP_JLE_K: if (3 <= 3) return 1",
6724 		.u.insns_int = {
6725 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6726 			BPF_LD_IMM64(R1, 3),
6727 			BPF_JMP_IMM(BPF_JLE, R1, 3, 1),
6728 			BPF_EXIT_INSN(),
6729 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6730 			BPF_EXIT_INSN(),
6731 		},
6732 		INTERNAL,
6733 		{ },
6734 		{ { 0, 1 } },
6735 	},
6736 	/* BPF_JMP | BPF_JNE | BPF_K */
6737 	{
6738 		"JMP_JNE_K: if (3 != 2) return 1",
6739 		.u.insns_int = {
6740 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6741 			BPF_LD_IMM64(R1, 3),
6742 			BPF_JMP_IMM(BPF_JNE, R1, 2, 1),
6743 			BPF_EXIT_INSN(),
6744 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6745 			BPF_EXIT_INSN(),
6746 		},
6747 		INTERNAL,
6748 		{ },
6749 		{ { 0, 1 } },
6750 	},
6751 	/* BPF_JMP | BPF_JEQ | BPF_K */
6752 	{
6753 		"JMP_JEQ_K: if (3 == 3) return 1",
6754 		.u.insns_int = {
6755 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6756 			BPF_LD_IMM64(R1, 3),
6757 			BPF_JMP_IMM(BPF_JEQ, R1, 3, 1),
6758 			BPF_EXIT_INSN(),
6759 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6760 			BPF_EXIT_INSN(),
6761 		},
6762 		INTERNAL,
6763 		{ },
6764 		{ { 0, 1 } },
6765 	},
6766 	/* BPF_JMP | BPF_JSET | BPF_K */
6767 	{
6768 		"JMP_JSET_K: if (0x3 & 0x2) return 1",
6769 		.u.insns_int = {
6770 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6771 			BPF_LD_IMM64(R1, 3),
6772 			BPF_JMP_IMM(BPF_JSET, R1, 2, 1),
6773 			BPF_EXIT_INSN(),
6774 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6775 			BPF_EXIT_INSN(),
6776 		},
6777 		INTERNAL,
6778 		{ },
6779 		{ { 0, 1 } },
6780 	},
6781 	{
6782 		"JMP_JSET_K: if (0x3 & 0xffffffff) return 1",
6783 		.u.insns_int = {
6784 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6785 			BPF_LD_IMM64(R1, 3),
6786 			BPF_JMP_IMM(BPF_JSET, R1, 0xffffffff, 1),
6787 			BPF_EXIT_INSN(),
6788 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6789 			BPF_EXIT_INSN(),
6790 		},
6791 		INTERNAL,
6792 		{ },
6793 		{ { 0, 1 } },
6794 	},
6795 	/* BPF_JMP | BPF_JSGT | BPF_X */
6796 	{
6797 		"JMP_JSGT_X: Signed jump: if (-1 > -2) return 1",
6798 		.u.insns_int = {
6799 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6800 			BPF_LD_IMM64(R1, -1),
6801 			BPF_LD_IMM64(R2, -2),
6802 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6803 			BPF_EXIT_INSN(),
6804 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6805 			BPF_EXIT_INSN(),
6806 		},
6807 		INTERNAL,
6808 		{ },
6809 		{ { 0, 1 } },
6810 	},
6811 	{
6812 		"JMP_JSGT_X: Signed jump: if (-1 > -1) return 0",
6813 		.u.insns_int = {
6814 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6815 			BPF_LD_IMM64(R1, -1),
6816 			BPF_LD_IMM64(R2, -1),
6817 			BPF_JMP_REG(BPF_JSGT, R1, R2, 1),
6818 			BPF_EXIT_INSN(),
6819 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6820 			BPF_EXIT_INSN(),
6821 		},
6822 		INTERNAL,
6823 		{ },
6824 		{ { 0, 1 } },
6825 	},
6826 	/* BPF_JMP | BPF_JSLT | BPF_X */
6827 	{
6828 		"JMP_JSLT_X: Signed jump: if (-2 < -1) return 1",
6829 		.u.insns_int = {
6830 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6831 			BPF_LD_IMM64(R1, -1),
6832 			BPF_LD_IMM64(R2, -2),
6833 			BPF_JMP_REG(BPF_JSLT, R2, R1, 1),
6834 			BPF_EXIT_INSN(),
6835 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6836 			BPF_EXIT_INSN(),
6837 		},
6838 		INTERNAL,
6839 		{ },
6840 		{ { 0, 1 } },
6841 	},
6842 	{
6843 		"JMP_JSLT_X: Signed jump: if (-1 < -1) return 0",
6844 		.u.insns_int = {
6845 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6846 			BPF_LD_IMM64(R1, -1),
6847 			BPF_LD_IMM64(R2, -1),
6848 			BPF_JMP_REG(BPF_JSLT, R1, R2, 1),
6849 			BPF_EXIT_INSN(),
6850 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6851 			BPF_EXIT_INSN(),
6852 		},
6853 		INTERNAL,
6854 		{ },
6855 		{ { 0, 1 } },
6856 	},
6857 	/* BPF_JMP | BPF_JSGE | BPF_X */
6858 	{
6859 		"JMP_JSGE_X: Signed jump: if (-1 >= -2) return 1",
6860 		.u.insns_int = {
6861 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6862 			BPF_LD_IMM64(R1, -1),
6863 			BPF_LD_IMM64(R2, -2),
6864 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6865 			BPF_EXIT_INSN(),
6866 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6867 			BPF_EXIT_INSN(),
6868 		},
6869 		INTERNAL,
6870 		{ },
6871 		{ { 0, 1 } },
6872 	},
6873 	{
6874 		"JMP_JSGE_X: Signed jump: if (-1 >= -1) return 1",
6875 		.u.insns_int = {
6876 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6877 			BPF_LD_IMM64(R1, -1),
6878 			BPF_LD_IMM64(R2, -1),
6879 			BPF_JMP_REG(BPF_JSGE, R1, R2, 1),
6880 			BPF_EXIT_INSN(),
6881 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6882 			BPF_EXIT_INSN(),
6883 		},
6884 		INTERNAL,
6885 		{ },
6886 		{ { 0, 1 } },
6887 	},
6888 	/* BPF_JMP | BPF_JSLE | BPF_X */
6889 	{
6890 		"JMP_JSLE_X: Signed jump: if (-2 <= -1) return 1",
6891 		.u.insns_int = {
6892 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6893 			BPF_LD_IMM64(R1, -1),
6894 			BPF_LD_IMM64(R2, -2),
6895 			BPF_JMP_REG(BPF_JSLE, R2, R1, 1),
6896 			BPF_EXIT_INSN(),
6897 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6898 			BPF_EXIT_INSN(),
6899 		},
6900 		INTERNAL,
6901 		{ },
6902 		{ { 0, 1 } },
6903 	},
6904 	{
6905 		"JMP_JSLE_X: Signed jump: if (-1 <= -1) return 1",
6906 		.u.insns_int = {
6907 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6908 			BPF_LD_IMM64(R1, -1),
6909 			BPF_LD_IMM64(R2, -1),
6910 			BPF_JMP_REG(BPF_JSLE, R1, R2, 1),
6911 			BPF_EXIT_INSN(),
6912 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6913 			BPF_EXIT_INSN(),
6914 		},
6915 		INTERNAL,
6916 		{ },
6917 		{ { 0, 1 } },
6918 	},
6919 	/* BPF_JMP | BPF_JGT | BPF_X */
6920 	{
6921 		"JMP_JGT_X: if (3 > 2) return 1",
6922 		.u.insns_int = {
6923 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6924 			BPF_LD_IMM64(R1, 3),
6925 			BPF_LD_IMM64(R2, 2),
6926 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6927 			BPF_EXIT_INSN(),
6928 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6929 			BPF_EXIT_INSN(),
6930 		},
6931 		INTERNAL,
6932 		{ },
6933 		{ { 0, 1 } },
6934 	},
6935 	{
6936 		"JMP_JGT_X: Unsigned jump: if (-1 > 1) return 1",
6937 		.u.insns_int = {
6938 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6939 			BPF_LD_IMM64(R1, -1),
6940 			BPF_LD_IMM64(R2, 1),
6941 			BPF_JMP_REG(BPF_JGT, R1, R2, 1),
6942 			BPF_EXIT_INSN(),
6943 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6944 			BPF_EXIT_INSN(),
6945 		},
6946 		INTERNAL,
6947 		{ },
6948 		{ { 0, 1 } },
6949 	},
6950 	/* BPF_JMP | BPF_JLT | BPF_X */
6951 	{
6952 		"JMP_JLT_X: if (2 < 3) return 1",
6953 		.u.insns_int = {
6954 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6955 			BPF_LD_IMM64(R1, 3),
6956 			BPF_LD_IMM64(R2, 2),
6957 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6958 			BPF_EXIT_INSN(),
6959 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6960 			BPF_EXIT_INSN(),
6961 		},
6962 		INTERNAL,
6963 		{ },
6964 		{ { 0, 1 } },
6965 	},
6966 	{
6967 		"JMP_JLT_X: Unsigned jump: if (1 < -1) return 1",
6968 		.u.insns_int = {
6969 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6970 			BPF_LD_IMM64(R1, -1),
6971 			BPF_LD_IMM64(R2, 1),
6972 			BPF_JMP_REG(BPF_JLT, R2, R1, 1),
6973 			BPF_EXIT_INSN(),
6974 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6975 			BPF_EXIT_INSN(),
6976 		},
6977 		INTERNAL,
6978 		{ },
6979 		{ { 0, 1 } },
6980 	},
6981 	/* BPF_JMP | BPF_JGE | BPF_X */
6982 	{
6983 		"JMP_JGE_X: if (3 >= 2) return 1",
6984 		.u.insns_int = {
6985 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
6986 			BPF_LD_IMM64(R1, 3),
6987 			BPF_LD_IMM64(R2, 2),
6988 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
6989 			BPF_EXIT_INSN(),
6990 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
6991 			BPF_EXIT_INSN(),
6992 		},
6993 		INTERNAL,
6994 		{ },
6995 		{ { 0, 1 } },
6996 	},
6997 	{
6998 		"JMP_JGE_X: if (3 >= 3) return 1",
6999 		.u.insns_int = {
7000 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7001 			BPF_LD_IMM64(R1, 3),
7002 			BPF_LD_IMM64(R2, 3),
7003 			BPF_JMP_REG(BPF_JGE, R1, R2, 1),
7004 			BPF_EXIT_INSN(),
7005 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7006 			BPF_EXIT_INSN(),
7007 		},
7008 		INTERNAL,
7009 		{ },
7010 		{ { 0, 1 } },
7011 	},
7012 	/* BPF_JMP | BPF_JLE | BPF_X */
7013 	{
7014 		"JMP_JLE_X: if (2 <= 3) return 1",
7015 		.u.insns_int = {
7016 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7017 			BPF_LD_IMM64(R1, 3),
7018 			BPF_LD_IMM64(R2, 2),
7019 			BPF_JMP_REG(BPF_JLE, R2, R1, 1),
7020 			BPF_EXIT_INSN(),
7021 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7022 			BPF_EXIT_INSN(),
7023 		},
7024 		INTERNAL,
7025 		{ },
7026 		{ { 0, 1 } },
7027 	},
7028 	{
7029 		"JMP_JLE_X: if (3 <= 3) return 1",
7030 		.u.insns_int = {
7031 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7032 			BPF_LD_IMM64(R1, 3),
7033 			BPF_LD_IMM64(R2, 3),
7034 			BPF_JMP_REG(BPF_JLE, R1, R2, 1),
7035 			BPF_EXIT_INSN(),
7036 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7037 			BPF_EXIT_INSN(),
7038 		},
7039 		INTERNAL,
7040 		{ },
7041 		{ { 0, 1 } },
7042 	},
7043 	{
7044 		/* Mainly testing JIT + imm64 here. */
7045 		"JMP_JGE_X: ldimm64 test 1",
7046 		.u.insns_int = {
7047 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7048 			BPF_LD_IMM64(R1, 3),
7049 			BPF_LD_IMM64(R2, 2),
7050 			BPF_JMP_REG(BPF_JGE, R1, R2, 2),
7051 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7052 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7053 			BPF_EXIT_INSN(),
7054 		},
7055 		INTERNAL,
7056 		{ },
7057 		{ { 0, 0xeeeeeeeeU } },
7058 	},
7059 	{
7060 		"JMP_JGE_X: ldimm64 test 2",
7061 		.u.insns_int = {
7062 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7063 			BPF_LD_IMM64(R1, 3),
7064 			BPF_LD_IMM64(R2, 2),
7065 			BPF_JMP_REG(BPF_JGE, R1, R2, 0),
7066 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7067 			BPF_EXIT_INSN(),
7068 		},
7069 		INTERNAL,
7070 		{ },
7071 		{ { 0, 0xffffffffU } },
7072 	},
7073 	{
7074 		"JMP_JGE_X: ldimm64 test 3",
7075 		.u.insns_int = {
7076 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7077 			BPF_LD_IMM64(R1, 3),
7078 			BPF_LD_IMM64(R2, 2),
7079 			BPF_JMP_REG(BPF_JGE, R1, R2, 4),
7080 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7081 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7082 			BPF_EXIT_INSN(),
7083 		},
7084 		INTERNAL,
7085 		{ },
7086 		{ { 0, 1 } },
7087 	},
7088 	{
7089 		"JMP_JLE_X: ldimm64 test 1",
7090 		.u.insns_int = {
7091 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7092 			BPF_LD_IMM64(R1, 3),
7093 			BPF_LD_IMM64(R2, 2),
7094 			BPF_JMP_REG(BPF_JLE, R2, R1, 2),
7095 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7096 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7097 			BPF_EXIT_INSN(),
7098 		},
7099 		INTERNAL,
7100 		{ },
7101 		{ { 0, 0xeeeeeeeeU } },
7102 	},
7103 	{
7104 		"JMP_JLE_X: ldimm64 test 2",
7105 		.u.insns_int = {
7106 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7107 			BPF_LD_IMM64(R1, 3),
7108 			BPF_LD_IMM64(R2, 2),
7109 			BPF_JMP_REG(BPF_JLE, R2, R1, 0),
7110 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7111 			BPF_EXIT_INSN(),
7112 		},
7113 		INTERNAL,
7114 		{ },
7115 		{ { 0, 0xffffffffU } },
7116 	},
7117 	{
7118 		"JMP_JLE_X: ldimm64 test 3",
7119 		.u.insns_int = {
7120 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7121 			BPF_LD_IMM64(R1, 3),
7122 			BPF_LD_IMM64(R2, 2),
7123 			BPF_JMP_REG(BPF_JLE, R2, R1, 4),
7124 			BPF_LD_IMM64(R0, 0xffffffffffffffffULL),
7125 			BPF_LD_IMM64(R0, 0xeeeeeeeeeeeeeeeeULL),
7126 			BPF_EXIT_INSN(),
7127 		},
7128 		INTERNAL,
7129 		{ },
7130 		{ { 0, 1 } },
7131 	},
7132 	/* BPF_JMP | BPF_JNE | BPF_X */
7133 	{
7134 		"JMP_JNE_X: if (3 != 2) return 1",
7135 		.u.insns_int = {
7136 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7137 			BPF_LD_IMM64(R1, 3),
7138 			BPF_LD_IMM64(R2, 2),
7139 			BPF_JMP_REG(BPF_JNE, R1, R2, 1),
7140 			BPF_EXIT_INSN(),
7141 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7142 			BPF_EXIT_INSN(),
7143 		},
7144 		INTERNAL,
7145 		{ },
7146 		{ { 0, 1 } },
7147 	},
7148 	/* BPF_JMP | BPF_JEQ | BPF_X */
7149 	{
7150 		"JMP_JEQ_X: if (3 == 3) return 1",
7151 		.u.insns_int = {
7152 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7153 			BPF_LD_IMM64(R1, 3),
7154 			BPF_LD_IMM64(R2, 3),
7155 			BPF_JMP_REG(BPF_JEQ, R1, R2, 1),
7156 			BPF_EXIT_INSN(),
7157 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7158 			BPF_EXIT_INSN(),
7159 		},
7160 		INTERNAL,
7161 		{ },
7162 		{ { 0, 1 } },
7163 	},
7164 	/* BPF_JMP | BPF_JSET | BPF_X */
7165 	{
7166 		"JMP_JSET_X: if (0x3 & 0x2) return 1",
7167 		.u.insns_int = {
7168 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7169 			BPF_LD_IMM64(R1, 3),
7170 			BPF_LD_IMM64(R2, 2),
7171 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
7172 			BPF_EXIT_INSN(),
7173 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7174 			BPF_EXIT_INSN(),
7175 		},
7176 		INTERNAL,
7177 		{ },
7178 		{ { 0, 1 } },
7179 	},
7180 	{
7181 		"JMP_JSET_X: if (0x3 & 0xffffffff) return 1",
7182 		.u.insns_int = {
7183 			BPF_ALU32_IMM(BPF_MOV, R0, 0),
7184 			BPF_LD_IMM64(R1, 3),
7185 			BPF_LD_IMM64(R2, 0xffffffff),
7186 			BPF_JMP_REG(BPF_JSET, R1, R2, 1),
7187 			BPF_EXIT_INSN(),
7188 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
7189 			BPF_EXIT_INSN(),
7190 		},
7191 		INTERNAL,
7192 		{ },
7193 		{ { 0, 1 } },
7194 	},
7195 	{	/* Mainly checking JIT here. */
7196 		"BPF_MAXINSNS: Very long conditional jump",
7197 		{ },
7198 		INTERNAL | FLAG_NO_DATA,
7199 		{ },
7200 		{ { 0, 1 } },
7201 		.fill_helper = bpf_fill_long_jmp,
7202 	},
7203 	{
7204 		"JMP_JA: Jump, gap, jump, ...",
7205 		{ },
7206 		CLASSIC | FLAG_NO_DATA,
7207 		{ },
7208 		{ { 0, 0xababcbac } },
7209 		.fill_helper = bpf_fill_ja,
7210 	},
7211 	{	/* Mainly checking JIT here. */
7212 		"BPF_MAXINSNS: Maximum possible literals",
7213 		{ },
7214 		CLASSIC | FLAG_NO_DATA,
7215 		{ },
7216 		{ { 0, 0xffffffff } },
7217 		.fill_helper = bpf_fill_maxinsns1,
7218 	},
7219 	{	/* Mainly checking JIT here. */
7220 		"BPF_MAXINSNS: Single literal",
7221 		{ },
7222 		CLASSIC | FLAG_NO_DATA,
7223 		{ },
7224 		{ { 0, 0xfefefefe } },
7225 		.fill_helper = bpf_fill_maxinsns2,
7226 	},
7227 	{	/* Mainly checking JIT here. */
7228 		"BPF_MAXINSNS: Run/add until end",
7229 		{ },
7230 		CLASSIC | FLAG_NO_DATA,
7231 		{ },
7232 		{ { 0, 0x947bf368 } },
7233 		.fill_helper = bpf_fill_maxinsns3,
7234 	},
7235 	{
7236 		"BPF_MAXINSNS: Too many instructions",
7237 		{ },
7238 		CLASSIC | FLAG_NO_DATA | FLAG_EXPECTED_FAIL,
7239 		{ },
7240 		{ },
7241 		.fill_helper = bpf_fill_maxinsns4,
7242 		.expected_errcode = -EINVAL,
7243 	},
7244 	{	/* Mainly checking JIT here. */
7245 		"BPF_MAXINSNS: Very long jump",
7246 		{ },
7247 		CLASSIC | FLAG_NO_DATA,
7248 		{ },
7249 		{ { 0, 0xabababab } },
7250 		.fill_helper = bpf_fill_maxinsns5,
7251 	},
7252 	{	/* Mainly checking JIT here. */
7253 		"BPF_MAXINSNS: Ctx heavy transformations",
7254 		{ },
7255 		CLASSIC,
7256 		{ },
7257 		{
7258 			{  1, SKB_VLAN_PRESENT },
7259 			{ 10, SKB_VLAN_PRESENT }
7260 		},
7261 		.fill_helper = bpf_fill_maxinsns6,
7262 	},
7263 	{	/* Mainly checking JIT here. */
7264 		"BPF_MAXINSNS: Call heavy transformations",
7265 		{ },
7266 		CLASSIC | FLAG_NO_DATA,
7267 		{ },
7268 		{ { 1, 0 }, { 10, 0 } },
7269 		.fill_helper = bpf_fill_maxinsns7,
7270 	},
7271 	{	/* Mainly checking JIT here. */
7272 		"BPF_MAXINSNS: Jump heavy test",
7273 		{ },
7274 		CLASSIC | FLAG_NO_DATA,
7275 		{ },
7276 		{ { 0, 0xffffffff } },
7277 		.fill_helper = bpf_fill_maxinsns8,
7278 	},
7279 	{	/* Mainly checking JIT here. */
7280 		"BPF_MAXINSNS: Very long jump backwards",
7281 		{ },
7282 		INTERNAL | FLAG_NO_DATA,
7283 		{ },
7284 		{ { 0, 0xcbababab } },
7285 		.fill_helper = bpf_fill_maxinsns9,
7286 	},
7287 	{	/* Mainly checking JIT here. */
7288 		"BPF_MAXINSNS: Edge hopping nuthouse",
7289 		{ },
7290 		INTERNAL | FLAG_NO_DATA,
7291 		{ },
7292 		{ { 0, 0xabababac } },
7293 		.fill_helper = bpf_fill_maxinsns10,
7294 	},
7295 	{
7296 		"BPF_MAXINSNS: Jump, gap, jump, ...",
7297 		{ },
7298 		CLASSIC | FLAG_NO_DATA,
7299 		{ },
7300 		{ { 0, 0xababcbac } },
7301 		.fill_helper = bpf_fill_maxinsns11,
7302 	},
7303 	{
7304 		"BPF_MAXINSNS: jump over MSH",
7305 		{ },
7306 		CLASSIC | FLAG_EXPECTED_FAIL,
7307 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
7308 		{ { 4, 0xabababab } },
7309 		.fill_helper = bpf_fill_maxinsns12,
7310 		.expected_errcode = -EINVAL,
7311 	},
7312 	{
7313 		"BPF_MAXINSNS: exec all MSH",
7314 		{ },
7315 		CLASSIC,
7316 		{ 0xfa, 0xfb, 0xfc, 0xfd, },
7317 		{ { 4, 0xababab83 } },
7318 		.fill_helper = bpf_fill_maxinsns13,
7319 	},
7320 	{
7321 		"BPF_MAXINSNS: ld_abs+get_processor_id",
7322 		{ },
7323 		CLASSIC,
7324 		{ },
7325 		{ { 1, 0xbee } },
7326 		.fill_helper = bpf_fill_ld_abs_get_processor_id,
7327 	},
7328 	/*
7329 	 * LD_IND / LD_ABS on fragmented SKBs
7330 	 */
7331 	{
7332 		"LD_IND byte frag",
7333 		.u.insns = {
7334 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7335 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x0),
7336 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7337 		},
7338 		CLASSIC | FLAG_SKB_FRAG,
7339 		{ },
7340 		{ {0x40, 0x42} },
7341 		.frag_data = {
7342 			0x42, 0x00, 0x00, 0x00,
7343 			0x43, 0x44, 0x00, 0x00,
7344 			0x21, 0x07, 0x19, 0x83,
7345 		},
7346 	},
7347 	{
7348 		"LD_IND halfword frag",
7349 		.u.insns = {
7350 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7351 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x4),
7352 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7353 		},
7354 		CLASSIC | FLAG_SKB_FRAG,
7355 		{ },
7356 		{ {0x40, 0x4344} },
7357 		.frag_data = {
7358 			0x42, 0x00, 0x00, 0x00,
7359 			0x43, 0x44, 0x00, 0x00,
7360 			0x21, 0x07, 0x19, 0x83,
7361 		},
7362 	},
7363 	{
7364 		"LD_IND word frag",
7365 		.u.insns = {
7366 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7367 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x8),
7368 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7369 		},
7370 		CLASSIC | FLAG_SKB_FRAG,
7371 		{ },
7372 		{ {0x40, 0x21071983} },
7373 		.frag_data = {
7374 			0x42, 0x00, 0x00, 0x00,
7375 			0x43, 0x44, 0x00, 0x00,
7376 			0x21, 0x07, 0x19, 0x83,
7377 		},
7378 	},
7379 	{
7380 		"LD_IND halfword mixed head/frag",
7381 		.u.insns = {
7382 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7383 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
7384 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7385 		},
7386 		CLASSIC | FLAG_SKB_FRAG,
7387 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
7388 		{ {0x40, 0x0519} },
7389 		.frag_data = { 0x19, 0x82 },
7390 	},
7391 	{
7392 		"LD_IND word mixed head/frag",
7393 		.u.insns = {
7394 			BPF_STMT(BPF_LDX | BPF_IMM, 0x40),
7395 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
7396 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7397 		},
7398 		CLASSIC | FLAG_SKB_FRAG,
7399 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
7400 		{ {0x40, 0x25051982} },
7401 		.frag_data = { 0x19, 0x82 },
7402 	},
7403 	{
7404 		"LD_ABS byte frag",
7405 		.u.insns = {
7406 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x40),
7407 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7408 		},
7409 		CLASSIC | FLAG_SKB_FRAG,
7410 		{ },
7411 		{ {0x40, 0x42} },
7412 		.frag_data = {
7413 			0x42, 0x00, 0x00, 0x00,
7414 			0x43, 0x44, 0x00, 0x00,
7415 			0x21, 0x07, 0x19, 0x83,
7416 		},
7417 	},
7418 	{
7419 		"LD_ABS halfword frag",
7420 		.u.insns = {
7421 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x44),
7422 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7423 		},
7424 		CLASSIC | FLAG_SKB_FRAG,
7425 		{ },
7426 		{ {0x40, 0x4344} },
7427 		.frag_data = {
7428 			0x42, 0x00, 0x00, 0x00,
7429 			0x43, 0x44, 0x00, 0x00,
7430 			0x21, 0x07, 0x19, 0x83,
7431 		},
7432 	},
7433 	{
7434 		"LD_ABS word frag",
7435 		.u.insns = {
7436 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x48),
7437 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7438 		},
7439 		CLASSIC | FLAG_SKB_FRAG,
7440 		{ },
7441 		{ {0x40, 0x21071983} },
7442 		.frag_data = {
7443 			0x42, 0x00, 0x00, 0x00,
7444 			0x43, 0x44, 0x00, 0x00,
7445 			0x21, 0x07, 0x19, 0x83,
7446 		},
7447 	},
7448 	{
7449 		"LD_ABS halfword mixed head/frag",
7450 		.u.insns = {
7451 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
7452 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7453 		},
7454 		CLASSIC | FLAG_SKB_FRAG,
7455 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
7456 		{ {0x40, 0x0519} },
7457 		.frag_data = { 0x19, 0x82 },
7458 	},
7459 	{
7460 		"LD_ABS word mixed head/frag",
7461 		.u.insns = {
7462 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3e),
7463 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7464 		},
7465 		CLASSIC | FLAG_SKB_FRAG,
7466 		{ [0x3e] = 0x25, [0x3f] = 0x05, },
7467 		{ {0x40, 0x25051982} },
7468 		.frag_data = { 0x19, 0x82 },
7469 	},
7470 	/*
7471 	 * LD_IND / LD_ABS on non fragmented SKBs
7472 	 */
7473 	{
7474 		/*
7475 		 * this tests that the JIT/interpreter correctly resets X
7476 		 * before using it in an LD_IND instruction.
7477 		 */
7478 		"LD_IND byte default X",
7479 		.u.insns = {
7480 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7481 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7482 		},
7483 		CLASSIC,
7484 		{ [0x1] = 0x42 },
7485 		{ {0x40, 0x42 } },
7486 	},
7487 	{
7488 		"LD_IND byte positive offset",
7489 		.u.insns = {
7490 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7491 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7492 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7493 		},
7494 		CLASSIC,
7495 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7496 		{ {0x40, 0x82 } },
7497 	},
7498 	{
7499 		"LD_IND byte negative offset",
7500 		.u.insns = {
7501 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7502 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x1),
7503 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7504 		},
7505 		CLASSIC,
7506 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7507 		{ {0x40, 0x05 } },
7508 	},
7509 	{
7510 		"LD_IND byte positive offset, all ff",
7511 		.u.insns = {
7512 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7513 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7514 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7515 		},
7516 		CLASSIC,
7517 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7518 		{ {0x40, 0xff } },
7519 	},
7520 	{
7521 		"LD_IND byte positive offset, out of bounds",
7522 		.u.insns = {
7523 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7524 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, 0x1),
7525 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7526 		},
7527 		CLASSIC,
7528 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7529 		{ {0x3f, 0 }, },
7530 	},
7531 	{
7532 		"LD_IND byte negative offset, out of bounds",
7533 		.u.insns = {
7534 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7535 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, -0x3f),
7536 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7537 		},
7538 		CLASSIC,
7539 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7540 		{ {0x3f, 0 } },
7541 	},
7542 	{
7543 		"LD_IND byte negative offset, multiple calls",
7544 		.u.insns = {
7545 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7546 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 1),
7547 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 2),
7548 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 3),
7549 			BPF_STMT(BPF_LD | BPF_IND | BPF_B, SKF_LL_OFF + 4),
7550 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7551 		},
7552 		CLASSIC,
7553 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7554 		{ {0x40, 0x82 }, },
7555 	},
7556 	{
7557 		"LD_IND halfword positive offset",
7558 		.u.insns = {
7559 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7560 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x2),
7561 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7562 		},
7563 		CLASSIC,
7564 		{
7565 			[0x1c] = 0xaa, [0x1d] = 0x55,
7566 			[0x1e] = 0xbb, [0x1f] = 0x66,
7567 			[0x20] = 0xcc, [0x21] = 0x77,
7568 			[0x22] = 0xdd, [0x23] = 0x88,
7569 		},
7570 		{ {0x40, 0xdd88 } },
7571 	},
7572 	{
7573 		"LD_IND halfword negative offset",
7574 		.u.insns = {
7575 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7576 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x2),
7577 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7578 		},
7579 		CLASSIC,
7580 		{
7581 			[0x1c] = 0xaa, [0x1d] = 0x55,
7582 			[0x1e] = 0xbb, [0x1f] = 0x66,
7583 			[0x20] = 0xcc, [0x21] = 0x77,
7584 			[0x22] = 0xdd, [0x23] = 0x88,
7585 		},
7586 		{ {0x40, 0xbb66 } },
7587 	},
7588 	{
7589 		"LD_IND halfword unaligned",
7590 		.u.insns = {
7591 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7592 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x1),
7593 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7594 		},
7595 		CLASSIC,
7596 		{
7597 			[0x1c] = 0xaa, [0x1d] = 0x55,
7598 			[0x1e] = 0xbb, [0x1f] = 0x66,
7599 			[0x20] = 0xcc, [0x21] = 0x77,
7600 			[0x22] = 0xdd, [0x23] = 0x88,
7601 		},
7602 		{ {0x40, 0x66cc } },
7603 	},
7604 	{
7605 		"LD_IND halfword positive offset, all ff",
7606 		.u.insns = {
7607 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3d),
7608 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7609 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7610 		},
7611 		CLASSIC,
7612 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7613 		{ {0x40, 0xffff } },
7614 	},
7615 	{
7616 		"LD_IND halfword positive offset, out of bounds",
7617 		.u.insns = {
7618 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7619 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, 0x1),
7620 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7621 		},
7622 		CLASSIC,
7623 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7624 		{ {0x3f, 0 }, },
7625 	},
7626 	{
7627 		"LD_IND halfword negative offset, out of bounds",
7628 		.u.insns = {
7629 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7630 			BPF_STMT(BPF_LD | BPF_IND | BPF_H, -0x3f),
7631 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7632 		},
7633 		CLASSIC,
7634 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7635 		{ {0x3f, 0 } },
7636 	},
7637 	{
7638 		"LD_IND word positive offset",
7639 		.u.insns = {
7640 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7641 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x4),
7642 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7643 		},
7644 		CLASSIC,
7645 		{
7646 			[0x1c] = 0xaa, [0x1d] = 0x55,
7647 			[0x1e] = 0xbb, [0x1f] = 0x66,
7648 			[0x20] = 0xcc, [0x21] = 0x77,
7649 			[0x22] = 0xdd, [0x23] = 0x88,
7650 			[0x24] = 0xee, [0x25] = 0x99,
7651 			[0x26] = 0xff, [0x27] = 0xaa,
7652 		},
7653 		{ {0x40, 0xee99ffaa } },
7654 	},
7655 	{
7656 		"LD_IND word negative offset",
7657 		.u.insns = {
7658 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7659 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x4),
7660 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7661 		},
7662 		CLASSIC,
7663 		{
7664 			[0x1c] = 0xaa, [0x1d] = 0x55,
7665 			[0x1e] = 0xbb, [0x1f] = 0x66,
7666 			[0x20] = 0xcc, [0x21] = 0x77,
7667 			[0x22] = 0xdd, [0x23] = 0x88,
7668 			[0x24] = 0xee, [0x25] = 0x99,
7669 			[0x26] = 0xff, [0x27] = 0xaa,
7670 		},
7671 		{ {0x40, 0xaa55bb66 } },
7672 	},
7673 	{
7674 		"LD_IND word unaligned (addr & 3 == 2)",
7675 		.u.insns = {
7676 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7677 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x2),
7678 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7679 		},
7680 		CLASSIC,
7681 		{
7682 			[0x1c] = 0xaa, [0x1d] = 0x55,
7683 			[0x1e] = 0xbb, [0x1f] = 0x66,
7684 			[0x20] = 0xcc, [0x21] = 0x77,
7685 			[0x22] = 0xdd, [0x23] = 0x88,
7686 			[0x24] = 0xee, [0x25] = 0x99,
7687 			[0x26] = 0xff, [0x27] = 0xaa,
7688 		},
7689 		{ {0x40, 0xbb66cc77 } },
7690 	},
7691 	{
7692 		"LD_IND word unaligned (addr & 3 == 1)",
7693 		.u.insns = {
7694 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7695 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3),
7696 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7697 		},
7698 		CLASSIC,
7699 		{
7700 			[0x1c] = 0xaa, [0x1d] = 0x55,
7701 			[0x1e] = 0xbb, [0x1f] = 0x66,
7702 			[0x20] = 0xcc, [0x21] = 0x77,
7703 			[0x22] = 0xdd, [0x23] = 0x88,
7704 			[0x24] = 0xee, [0x25] = 0x99,
7705 			[0x26] = 0xff, [0x27] = 0xaa,
7706 		},
7707 		{ {0x40, 0x55bb66cc } },
7708 	},
7709 	{
7710 		"LD_IND word unaligned (addr & 3 == 3)",
7711 		.u.insns = {
7712 			BPF_STMT(BPF_LDX | BPF_IMM, 0x20),
7713 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x1),
7714 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7715 		},
7716 		CLASSIC,
7717 		{
7718 			[0x1c] = 0xaa, [0x1d] = 0x55,
7719 			[0x1e] = 0xbb, [0x1f] = 0x66,
7720 			[0x20] = 0xcc, [0x21] = 0x77,
7721 			[0x22] = 0xdd, [0x23] = 0x88,
7722 			[0x24] = 0xee, [0x25] = 0x99,
7723 			[0x26] = 0xff, [0x27] = 0xaa,
7724 		},
7725 		{ {0x40, 0x66cc77dd } },
7726 	},
7727 	{
7728 		"LD_IND word positive offset, all ff",
7729 		.u.insns = {
7730 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3b),
7731 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
7732 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7733 		},
7734 		CLASSIC,
7735 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7736 		{ {0x40, 0xffffffff } },
7737 	},
7738 	{
7739 		"LD_IND word positive offset, out of bounds",
7740 		.u.insns = {
7741 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7742 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, 0x1),
7743 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7744 		},
7745 		CLASSIC,
7746 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7747 		{ {0x3f, 0 }, },
7748 	},
7749 	{
7750 		"LD_IND word negative offset, out of bounds",
7751 		.u.insns = {
7752 			BPF_STMT(BPF_LDX | BPF_IMM, 0x3e),
7753 			BPF_STMT(BPF_LD | BPF_IND | BPF_W, -0x3f),
7754 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7755 		},
7756 		CLASSIC,
7757 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7758 		{ {0x3f, 0 } },
7759 	},
7760 	{
7761 		"LD_ABS byte",
7762 		.u.insns = {
7763 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x20),
7764 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7765 		},
7766 		CLASSIC,
7767 		{
7768 			[0x1c] = 0xaa, [0x1d] = 0x55,
7769 			[0x1e] = 0xbb, [0x1f] = 0x66,
7770 			[0x20] = 0xcc, [0x21] = 0x77,
7771 			[0x22] = 0xdd, [0x23] = 0x88,
7772 			[0x24] = 0xee, [0x25] = 0x99,
7773 			[0x26] = 0xff, [0x27] = 0xaa,
7774 		},
7775 		{ {0x40, 0xcc } },
7776 	},
7777 	{
7778 		"LD_ABS byte positive offset, all ff",
7779 		.u.insns = {
7780 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7781 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7782 		},
7783 		CLASSIC,
7784 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7785 		{ {0x40, 0xff } },
7786 	},
7787 	{
7788 		"LD_ABS byte positive offset, out of bounds",
7789 		.u.insns = {
7790 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, 0x3f),
7791 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7792 		},
7793 		CLASSIC,
7794 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7795 		{ {0x3f, 0 }, },
7796 	},
7797 	{
7798 		"LD_ABS byte negative offset, out of bounds load",
7799 		.u.insns = {
7800 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, -1),
7801 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7802 		},
7803 		CLASSIC | FLAG_EXPECTED_FAIL,
7804 		.expected_errcode = -EINVAL,
7805 	},
7806 	{
7807 		"LD_ABS byte negative offset, in bounds",
7808 		.u.insns = {
7809 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7810 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7811 		},
7812 		CLASSIC,
7813 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7814 		{ {0x40, 0x82 }, },
7815 	},
7816 	{
7817 		"LD_ABS byte negative offset, out of bounds",
7818 		.u.insns = {
7819 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7820 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7821 		},
7822 		CLASSIC,
7823 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7824 		{ {0x3f, 0 }, },
7825 	},
7826 	{
7827 		"LD_ABS byte negative offset, multiple calls",
7828 		.u.insns = {
7829 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3c),
7830 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3d),
7831 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3e),
7832 			BPF_STMT(BPF_LD | BPF_ABS | BPF_B, SKF_LL_OFF + 0x3f),
7833 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7834 		},
7835 		CLASSIC,
7836 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7837 		{ {0x40, 0x82 }, },
7838 	},
7839 	{
7840 		"LD_ABS halfword",
7841 		.u.insns = {
7842 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x22),
7843 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7844 		},
7845 		CLASSIC,
7846 		{
7847 			[0x1c] = 0xaa, [0x1d] = 0x55,
7848 			[0x1e] = 0xbb, [0x1f] = 0x66,
7849 			[0x20] = 0xcc, [0x21] = 0x77,
7850 			[0x22] = 0xdd, [0x23] = 0x88,
7851 			[0x24] = 0xee, [0x25] = 0x99,
7852 			[0x26] = 0xff, [0x27] = 0xaa,
7853 		},
7854 		{ {0x40, 0xdd88 } },
7855 	},
7856 	{
7857 		"LD_ABS halfword unaligned",
7858 		.u.insns = {
7859 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x25),
7860 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7861 		},
7862 		CLASSIC,
7863 		{
7864 			[0x1c] = 0xaa, [0x1d] = 0x55,
7865 			[0x1e] = 0xbb, [0x1f] = 0x66,
7866 			[0x20] = 0xcc, [0x21] = 0x77,
7867 			[0x22] = 0xdd, [0x23] = 0x88,
7868 			[0x24] = 0xee, [0x25] = 0x99,
7869 			[0x26] = 0xff, [0x27] = 0xaa,
7870 		},
7871 		{ {0x40, 0x99ff } },
7872 	},
7873 	{
7874 		"LD_ABS halfword positive offset, all ff",
7875 		.u.insns = {
7876 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3e),
7877 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7878 		},
7879 		CLASSIC,
7880 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7881 		{ {0x40, 0xffff } },
7882 	},
7883 	{
7884 		"LD_ABS halfword positive offset, out of bounds",
7885 		.u.insns = {
7886 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, 0x3f),
7887 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7888 		},
7889 		CLASSIC,
7890 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7891 		{ {0x3f, 0 }, },
7892 	},
7893 	{
7894 		"LD_ABS halfword negative offset, out of bounds load",
7895 		.u.insns = {
7896 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, -1),
7897 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7898 		},
7899 		CLASSIC | FLAG_EXPECTED_FAIL,
7900 		.expected_errcode = -EINVAL,
7901 	},
7902 	{
7903 		"LD_ABS halfword negative offset, in bounds",
7904 		.u.insns = {
7905 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7906 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7907 		},
7908 		CLASSIC,
7909 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7910 		{ {0x40, 0x1982 }, },
7911 	},
7912 	{
7913 		"LD_ABS halfword negative offset, out of bounds",
7914 		.u.insns = {
7915 			BPF_STMT(BPF_LD | BPF_ABS | BPF_H, SKF_LL_OFF + 0x3e),
7916 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7917 		},
7918 		CLASSIC,
7919 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
7920 		{ {0x3f, 0 }, },
7921 	},
7922 	{
7923 		"LD_ABS word",
7924 		.u.insns = {
7925 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x1c),
7926 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7927 		},
7928 		CLASSIC,
7929 		{
7930 			[0x1c] = 0xaa, [0x1d] = 0x55,
7931 			[0x1e] = 0xbb, [0x1f] = 0x66,
7932 			[0x20] = 0xcc, [0x21] = 0x77,
7933 			[0x22] = 0xdd, [0x23] = 0x88,
7934 			[0x24] = 0xee, [0x25] = 0x99,
7935 			[0x26] = 0xff, [0x27] = 0xaa,
7936 		},
7937 		{ {0x40, 0xaa55bb66 } },
7938 	},
7939 	{
7940 		"LD_ABS word unaligned (addr & 3 == 2)",
7941 		.u.insns = {
7942 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x22),
7943 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7944 		},
7945 		CLASSIC,
7946 		{
7947 			[0x1c] = 0xaa, [0x1d] = 0x55,
7948 			[0x1e] = 0xbb, [0x1f] = 0x66,
7949 			[0x20] = 0xcc, [0x21] = 0x77,
7950 			[0x22] = 0xdd, [0x23] = 0x88,
7951 			[0x24] = 0xee, [0x25] = 0x99,
7952 			[0x26] = 0xff, [0x27] = 0xaa,
7953 		},
7954 		{ {0x40, 0xdd88ee99 } },
7955 	},
7956 	{
7957 		"LD_ABS word unaligned (addr & 3 == 1)",
7958 		.u.insns = {
7959 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x21),
7960 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7961 		},
7962 		CLASSIC,
7963 		{
7964 			[0x1c] = 0xaa, [0x1d] = 0x55,
7965 			[0x1e] = 0xbb, [0x1f] = 0x66,
7966 			[0x20] = 0xcc, [0x21] = 0x77,
7967 			[0x22] = 0xdd, [0x23] = 0x88,
7968 			[0x24] = 0xee, [0x25] = 0x99,
7969 			[0x26] = 0xff, [0x27] = 0xaa,
7970 		},
7971 		{ {0x40, 0x77dd88ee } },
7972 	},
7973 	{
7974 		"LD_ABS word unaligned (addr & 3 == 3)",
7975 		.u.insns = {
7976 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x23),
7977 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7978 		},
7979 		CLASSIC,
7980 		{
7981 			[0x1c] = 0xaa, [0x1d] = 0x55,
7982 			[0x1e] = 0xbb, [0x1f] = 0x66,
7983 			[0x20] = 0xcc, [0x21] = 0x77,
7984 			[0x22] = 0xdd, [0x23] = 0x88,
7985 			[0x24] = 0xee, [0x25] = 0x99,
7986 			[0x26] = 0xff, [0x27] = 0xaa,
7987 		},
7988 		{ {0x40, 0x88ee99ff } },
7989 	},
7990 	{
7991 		"LD_ABS word positive offset, all ff",
7992 		.u.insns = {
7993 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3c),
7994 			BPF_STMT(BPF_RET | BPF_A, 0x0),
7995 		},
7996 		CLASSIC,
7997 		{ [0x3c] = 0xff, [0x3d] = 0xff,  [0x3e] = 0xff, [0x3f] = 0xff },
7998 		{ {0x40, 0xffffffff } },
7999 	},
8000 	{
8001 		"LD_ABS word positive offset, out of bounds",
8002 		.u.insns = {
8003 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, 0x3f),
8004 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8005 		},
8006 		CLASSIC,
8007 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8008 		{ {0x3f, 0 }, },
8009 	},
8010 	{
8011 		"LD_ABS word negative offset, out of bounds load",
8012 		.u.insns = {
8013 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, -1),
8014 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8015 		},
8016 		CLASSIC | FLAG_EXPECTED_FAIL,
8017 		.expected_errcode = -EINVAL,
8018 	},
8019 	{
8020 		"LD_ABS word negative offset, in bounds",
8021 		.u.insns = {
8022 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
8023 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8024 		},
8025 		CLASSIC,
8026 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8027 		{ {0x40, 0x25051982 }, },
8028 	},
8029 	{
8030 		"LD_ABS word negative offset, out of bounds",
8031 		.u.insns = {
8032 			BPF_STMT(BPF_LD | BPF_ABS | BPF_W, SKF_LL_OFF + 0x3c),
8033 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8034 		},
8035 		CLASSIC,
8036 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8037 		{ {0x3f, 0 }, },
8038 	},
8039 	{
8040 		"LDX_MSH standalone, preserved A",
8041 		.u.insns = {
8042 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8043 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
8044 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8045 		},
8046 		CLASSIC,
8047 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8048 		{ {0x40, 0xffeebbaa }, },
8049 	},
8050 	{
8051 		"LDX_MSH standalone, preserved A 2",
8052 		.u.insns = {
8053 			BPF_STMT(BPF_LD | BPF_IMM, 0x175e9d63),
8054 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
8055 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3d),
8056 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
8057 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3f),
8058 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8059 		},
8060 		CLASSIC,
8061 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8062 		{ {0x40, 0x175e9d63 }, },
8063 	},
8064 	{
8065 		"LDX_MSH standalone, test result 1",
8066 		.u.insns = {
8067 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8068 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3c),
8069 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
8070 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8071 		},
8072 		CLASSIC,
8073 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8074 		{ {0x40, 0x14 }, },
8075 	},
8076 	{
8077 		"LDX_MSH standalone, test result 2",
8078 		.u.insns = {
8079 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8080 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x3e),
8081 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
8082 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8083 		},
8084 		CLASSIC,
8085 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8086 		{ {0x40, 0x24 }, },
8087 	},
8088 	{
8089 		"LDX_MSH standalone, negative offset",
8090 		.u.insns = {
8091 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8092 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, -1),
8093 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
8094 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8095 		},
8096 		CLASSIC,
8097 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8098 		{ {0x40, 0 }, },
8099 	},
8100 	{
8101 		"LDX_MSH standalone, negative offset 2",
8102 		.u.insns = {
8103 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8104 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, SKF_LL_OFF + 0x3e),
8105 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
8106 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8107 		},
8108 		CLASSIC,
8109 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8110 		{ {0x40, 0x24 }, },
8111 	},
8112 	{
8113 		"LDX_MSH standalone, out of bounds",
8114 		.u.insns = {
8115 			BPF_STMT(BPF_LD | BPF_IMM, 0xffeebbaa),
8116 			BPF_STMT(BPF_LDX | BPF_B | BPF_MSH, 0x40),
8117 			BPF_STMT(BPF_MISC | BPF_TXA, 0),
8118 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8119 		},
8120 		CLASSIC,
8121 		{ [0x3c] = 0x25, [0x3d] = 0x05,  [0x3e] = 0x19, [0x3f] = 0x82 },
8122 		{ {0x40, 0 }, },
8123 	},
8124 	/*
8125 	 * verify that the interpreter or JIT correctly sets A and X
8126 	 * to 0.
8127 	 */
8128 	{
8129 		"ADD default X",
8130 		.u.insns = {
8131 			/*
8132 			 * A = 0x42
8133 			 * A = A + X
8134 			 * ret A
8135 			 */
8136 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8137 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_X, 0),
8138 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8139 		},
8140 		CLASSIC | FLAG_NO_DATA,
8141 		{},
8142 		{ {0x1, 0x42 } },
8143 	},
8144 	{
8145 		"ADD default A",
8146 		.u.insns = {
8147 			/*
8148 			 * A = A + 0x42
8149 			 * ret A
8150 			 */
8151 			BPF_STMT(BPF_ALU | BPF_ADD | BPF_K, 0x42),
8152 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8153 		},
8154 		CLASSIC | FLAG_NO_DATA,
8155 		{},
8156 		{ {0x1, 0x42 } },
8157 	},
8158 	{
8159 		"SUB default X",
8160 		.u.insns = {
8161 			/*
8162 			 * A = 0x66
8163 			 * A = A - X
8164 			 * ret A
8165 			 */
8166 			BPF_STMT(BPF_LD | BPF_IMM, 0x66),
8167 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_X, 0),
8168 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8169 		},
8170 		CLASSIC | FLAG_NO_DATA,
8171 		{},
8172 		{ {0x1, 0x66 } },
8173 	},
8174 	{
8175 		"SUB default A",
8176 		.u.insns = {
8177 			/*
8178 			 * A = A - -0x66
8179 			 * ret A
8180 			 */
8181 			BPF_STMT(BPF_ALU | BPF_SUB | BPF_K, -0x66),
8182 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8183 		},
8184 		CLASSIC | FLAG_NO_DATA,
8185 		{},
8186 		{ {0x1, 0x66 } },
8187 	},
8188 	{
8189 		"MUL default X",
8190 		.u.insns = {
8191 			/*
8192 			 * A = 0x42
8193 			 * A = A * X
8194 			 * ret A
8195 			 */
8196 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8197 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_X, 0),
8198 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8199 		},
8200 		CLASSIC | FLAG_NO_DATA,
8201 		{},
8202 		{ {0x1, 0x0 } },
8203 	},
8204 	{
8205 		"MUL default A",
8206 		.u.insns = {
8207 			/*
8208 			 * A = A * 0x66
8209 			 * ret A
8210 			 */
8211 			BPF_STMT(BPF_ALU | BPF_MUL | BPF_K, 0x66),
8212 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8213 		},
8214 		CLASSIC | FLAG_NO_DATA,
8215 		{},
8216 		{ {0x1, 0x0 } },
8217 	},
8218 	{
8219 		"DIV default X",
8220 		.u.insns = {
8221 			/*
8222 			 * A = 0x42
8223 			 * A = A / X ; this halt the filter execution if X is 0
8224 			 * ret 0x42
8225 			 */
8226 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8227 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_X, 0),
8228 			BPF_STMT(BPF_RET | BPF_K, 0x42),
8229 		},
8230 		CLASSIC | FLAG_NO_DATA,
8231 		{},
8232 		{ {0x1, 0x0 } },
8233 	},
8234 	{
8235 		"DIV default A",
8236 		.u.insns = {
8237 			/*
8238 			 * A = A / 1
8239 			 * ret A
8240 			 */
8241 			BPF_STMT(BPF_ALU | BPF_DIV | BPF_K, 0x1),
8242 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8243 		},
8244 		CLASSIC | FLAG_NO_DATA,
8245 		{},
8246 		{ {0x1, 0x0 } },
8247 	},
8248 	{
8249 		"MOD default X",
8250 		.u.insns = {
8251 			/*
8252 			 * A = 0x42
8253 			 * A = A mod X ; this halt the filter execution if X is 0
8254 			 * ret 0x42
8255 			 */
8256 			BPF_STMT(BPF_LD | BPF_IMM, 0x42),
8257 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_X, 0),
8258 			BPF_STMT(BPF_RET | BPF_K, 0x42),
8259 		},
8260 		CLASSIC | FLAG_NO_DATA,
8261 		{},
8262 		{ {0x1, 0x0 } },
8263 	},
8264 	{
8265 		"MOD default A",
8266 		.u.insns = {
8267 			/*
8268 			 * A = A mod 1
8269 			 * ret A
8270 			 */
8271 			BPF_STMT(BPF_ALU | BPF_MOD | BPF_K, 0x1),
8272 			BPF_STMT(BPF_RET | BPF_A, 0x0),
8273 		},
8274 		CLASSIC | FLAG_NO_DATA,
8275 		{},
8276 		{ {0x1, 0x0 } },
8277 	},
8278 	{
8279 		"JMP EQ default A",
8280 		.u.insns = {
8281 			/*
8282 			 * cmp A, 0x0, 0, 1
8283 			 * ret 0x42
8284 			 * ret 0x66
8285 			 */
8286 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0x0, 0, 1),
8287 			BPF_STMT(BPF_RET | BPF_K, 0x42),
8288 			BPF_STMT(BPF_RET | BPF_K, 0x66),
8289 		},
8290 		CLASSIC | FLAG_NO_DATA,
8291 		{},
8292 		{ {0x1, 0x42 } },
8293 	},
8294 	{
8295 		"JMP EQ default X",
8296 		.u.insns = {
8297 			/*
8298 			 * A = 0x0
8299 			 * cmp A, X, 0, 1
8300 			 * ret 0x42
8301 			 * ret 0x66
8302 			 */
8303 			BPF_STMT(BPF_LD | BPF_IMM, 0x0),
8304 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_X, 0x0, 0, 1),
8305 			BPF_STMT(BPF_RET | BPF_K, 0x42),
8306 			BPF_STMT(BPF_RET | BPF_K, 0x66),
8307 		},
8308 		CLASSIC | FLAG_NO_DATA,
8309 		{},
8310 		{ {0x1, 0x42 } },
8311 	},
8312 	/* Checking interpreter vs JIT wrt signed extended imms. */
8313 	{
8314 		"JNE signed compare, test 1",
8315 		.u.insns_int = {
8316 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8317 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8318 			BPF_MOV64_REG(R2, R1),
8319 			BPF_ALU64_REG(BPF_AND, R2, R3),
8320 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8321 			BPF_JMP_IMM(BPF_JNE, R2, -17104896, 1),
8322 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
8323 			BPF_EXIT_INSN(),
8324 		},
8325 		INTERNAL,
8326 		{ },
8327 		{ { 0, 1 } },
8328 	},
8329 	{
8330 		"JNE signed compare, test 2",
8331 		.u.insns_int = {
8332 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8333 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8334 			BPF_MOV64_REG(R2, R1),
8335 			BPF_ALU64_REG(BPF_AND, R2, R3),
8336 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8337 			BPF_JMP_IMM(BPF_JNE, R2, 0xfefb0000, 1),
8338 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
8339 			BPF_EXIT_INSN(),
8340 		},
8341 		INTERNAL,
8342 		{ },
8343 		{ { 0, 1 } },
8344 	},
8345 	{
8346 		"JNE signed compare, test 3",
8347 		.u.insns_int = {
8348 			BPF_ALU32_IMM(BPF_MOV, R1, 0xfefbbc12),
8349 			BPF_ALU32_IMM(BPF_MOV, R3, 0xffff0000),
8350 			BPF_ALU32_IMM(BPF_MOV, R4, 0xfefb0000),
8351 			BPF_MOV64_REG(R2, R1),
8352 			BPF_ALU64_REG(BPF_AND, R2, R3),
8353 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8354 			BPF_JMP_REG(BPF_JNE, R2, R4, 1),
8355 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
8356 			BPF_EXIT_INSN(),
8357 		},
8358 		INTERNAL,
8359 		{ },
8360 		{ { 0, 2 } },
8361 	},
8362 	{
8363 		"JNE signed compare, test 4",
8364 		.u.insns_int = {
8365 			BPF_LD_IMM64(R1, -17104896),
8366 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8367 			BPF_JMP_IMM(BPF_JNE, R1, -17104896, 1),
8368 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
8369 			BPF_EXIT_INSN(),
8370 		},
8371 		INTERNAL,
8372 		{ },
8373 		{ { 0, 2 } },
8374 	},
8375 	{
8376 		"JNE signed compare, test 5",
8377 		.u.insns_int = {
8378 			BPF_LD_IMM64(R1, 0xfefb0000),
8379 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8380 			BPF_JMP_IMM(BPF_JNE, R1, 0xfefb0000, 1),
8381 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
8382 			BPF_EXIT_INSN(),
8383 		},
8384 		INTERNAL,
8385 		{ },
8386 		{ { 0, 1 } },
8387 	},
8388 	{
8389 		"JNE signed compare, test 6",
8390 		.u.insns_int = {
8391 			BPF_LD_IMM64(R1, 0x7efb0000),
8392 			BPF_ALU32_IMM(BPF_MOV, R0, 1),
8393 			BPF_JMP_IMM(BPF_JNE, R1, 0x7efb0000, 1),
8394 			BPF_ALU32_IMM(BPF_MOV, R0, 2),
8395 			BPF_EXIT_INSN(),
8396 		},
8397 		INTERNAL,
8398 		{ },
8399 		{ { 0, 2 } },
8400 	},
8401 	{
8402 		"JNE signed compare, test 7",
8403 		.u.insns = {
8404 			BPF_STMT(BPF_LD | BPF_IMM, 0xffff0000),
8405 			BPF_STMT(BPF_MISC | BPF_TAX, 0),
8406 			BPF_STMT(BPF_LD | BPF_IMM, 0xfefbbc12),
8407 			BPF_STMT(BPF_ALU | BPF_AND | BPF_X, 0),
8408 			BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, 0xfefb0000, 1, 0),
8409 			BPF_STMT(BPF_RET | BPF_K, 1),
8410 			BPF_STMT(BPF_RET | BPF_K, 2),
8411 		},
8412 		CLASSIC | FLAG_NO_DATA,
8413 		{},
8414 		{ { 0, 2 } },
8415 	},
8416 };
8417 
8418 static struct net_device dev;
8419 
populate_skb(char * buf,int size)8420 static struct sk_buff *populate_skb(char *buf, int size)
8421 {
8422 	struct sk_buff *skb;
8423 
8424 	if (size >= MAX_DATA)
8425 		return NULL;
8426 
8427 	skb = alloc_skb(MAX_DATA, GFP_KERNEL);
8428 	if (!skb)
8429 		return NULL;
8430 
8431 	__skb_put_data(skb, buf, size);
8432 
8433 	/* Initialize a fake skb with test pattern. */
8434 	skb_reset_mac_header(skb);
8435 	skb->protocol = htons(ETH_P_IP);
8436 	skb->pkt_type = SKB_TYPE;
8437 	skb->mark = SKB_MARK;
8438 	skb->hash = SKB_HASH;
8439 	skb->queue_mapping = SKB_QUEUE_MAP;
8440 	skb->vlan_tci = SKB_VLAN_TCI;
8441 	skb->vlan_present = SKB_VLAN_PRESENT;
8442 	skb->vlan_proto = htons(ETH_P_IP);
8443 	dev_net_set(&dev, &init_net);
8444 	skb->dev = &dev;
8445 	skb->dev->ifindex = SKB_DEV_IFINDEX;
8446 	skb->dev->type = SKB_DEV_TYPE;
8447 	skb_set_network_header(skb, min(size, ETH_HLEN));
8448 
8449 	return skb;
8450 }
8451 
generate_test_data(struct bpf_test * test,int sub)8452 static void *generate_test_data(struct bpf_test *test, int sub)
8453 {
8454 	struct sk_buff *skb;
8455 	struct page *page;
8456 
8457 	if (test->aux & FLAG_NO_DATA)
8458 		return NULL;
8459 
8460 	/* Test case expects an skb, so populate one. Various
8461 	 * subtests generate skbs of different sizes based on
8462 	 * the same data.
8463 	 */
8464 	skb = populate_skb(test->data, test->test[sub].data_size);
8465 	if (!skb)
8466 		return NULL;
8467 
8468 	if (test->aux & FLAG_SKB_FRAG) {
8469 		/*
8470 		 * when the test requires a fragmented skb, add a
8471 		 * single fragment to the skb, filled with
8472 		 * test->frag_data.
8473 		 */
8474 		void *ptr;
8475 
8476 		page = alloc_page(GFP_KERNEL);
8477 
8478 		if (!page)
8479 			goto err_kfree_skb;
8480 
8481 		ptr = kmap(page);
8482 		if (!ptr)
8483 			goto err_free_page;
8484 		memcpy(ptr, test->frag_data, MAX_DATA);
8485 		kunmap(page);
8486 		skb_add_rx_frag(skb, 0, page, 0, MAX_DATA, MAX_DATA);
8487 	}
8488 
8489 	return skb;
8490 
8491 err_free_page:
8492 	__free_page(page);
8493 err_kfree_skb:
8494 	kfree_skb(skb);
8495 	return NULL;
8496 }
8497 
release_test_data(const struct bpf_test * test,void * data)8498 static void release_test_data(const struct bpf_test *test, void *data)
8499 {
8500 	if (test->aux & FLAG_NO_DATA)
8501 		return;
8502 
8503 	kfree_skb(data);
8504 }
8505 
filter_length(int which)8506 static int filter_length(int which)
8507 {
8508 	struct sock_filter *fp;
8509 	int len;
8510 
8511 	if (tests[which].fill_helper)
8512 		return tests[which].u.ptr.len;
8513 
8514 	fp = tests[which].u.insns;
8515 	for (len = MAX_INSNS - 1; len > 0; --len)
8516 		if (fp[len].code != 0 || fp[len].k != 0)
8517 			break;
8518 
8519 	return len + 1;
8520 }
8521 
filter_pointer(int which)8522 static void *filter_pointer(int which)
8523 {
8524 	if (tests[which].fill_helper)
8525 		return tests[which].u.ptr.insns;
8526 	else
8527 		return tests[which].u.insns;
8528 }
8529 
generate_filter(int which,int * err)8530 static struct bpf_prog *generate_filter(int which, int *err)
8531 {
8532 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8533 	unsigned int flen = filter_length(which);
8534 	void *fptr = filter_pointer(which);
8535 	struct sock_fprog_kern fprog;
8536 	struct bpf_prog *fp;
8537 
8538 	switch (test_type) {
8539 	case CLASSIC:
8540 		fprog.filter = fptr;
8541 		fprog.len = flen;
8542 
8543 		*err = bpf_prog_create(&fp, &fprog);
8544 		if (tests[which].aux & FLAG_EXPECTED_FAIL) {
8545 			if (*err == tests[which].expected_errcode) {
8546 				pr_cont("PASS\n");
8547 				/* Verifier rejected filter as expected. */
8548 				*err = 0;
8549 				return NULL;
8550 			} else {
8551 				pr_cont("UNEXPECTED_PASS\n");
8552 				/* Verifier didn't reject the test that's
8553 				 * bad enough, just return!
8554 				 */
8555 				*err = -EINVAL;
8556 				return NULL;
8557 			}
8558 		}
8559 		if (*err) {
8560 			pr_cont("FAIL to prog_create err=%d len=%d\n",
8561 				*err, fprog.len);
8562 			return NULL;
8563 		}
8564 		break;
8565 
8566 	case INTERNAL:
8567 		fp = bpf_prog_alloc(bpf_prog_size(flen), 0);
8568 		if (fp == NULL) {
8569 			pr_cont("UNEXPECTED_FAIL no memory left\n");
8570 			*err = -ENOMEM;
8571 			return NULL;
8572 		}
8573 
8574 		fp->len = flen;
8575 		/* Type doesn't really matter here as long as it's not unspec. */
8576 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
8577 		memcpy(fp->insnsi, fptr, fp->len * sizeof(struct bpf_insn));
8578 		fp->aux->stack_depth = tests[which].stack_depth;
8579 
8580 		/* We cannot error here as we don't need type compatibility
8581 		 * checks.
8582 		 */
8583 		fp = bpf_prog_select_runtime(fp, err);
8584 		if (*err) {
8585 			pr_cont("FAIL to select_runtime err=%d\n", *err);
8586 			return NULL;
8587 		}
8588 		break;
8589 	}
8590 
8591 	*err = 0;
8592 	return fp;
8593 }
8594 
release_filter(struct bpf_prog * fp,int which)8595 static void release_filter(struct bpf_prog *fp, int which)
8596 {
8597 	__u8 test_type = tests[which].aux & TEST_TYPE_MASK;
8598 
8599 	switch (test_type) {
8600 	case CLASSIC:
8601 		bpf_prog_destroy(fp);
8602 		break;
8603 	case INTERNAL:
8604 		bpf_prog_free(fp);
8605 		break;
8606 	}
8607 }
8608 
__run_one(const struct bpf_prog * fp,const void * data,int runs,u64 * duration)8609 static int __run_one(const struct bpf_prog *fp, const void *data,
8610 		     int runs, u64 *duration)
8611 {
8612 	u64 start, finish;
8613 	int ret = 0, i;
8614 
8615 	migrate_disable();
8616 	start = ktime_get_ns();
8617 
8618 	for (i = 0; i < runs; i++)
8619 		ret = bpf_prog_run(fp, data);
8620 
8621 	finish = ktime_get_ns();
8622 	migrate_enable();
8623 
8624 	*duration = finish - start;
8625 	do_div(*duration, runs);
8626 
8627 	return ret;
8628 }
8629 
run_one(const struct bpf_prog * fp,struct bpf_test * test)8630 static int run_one(const struct bpf_prog *fp, struct bpf_test *test)
8631 {
8632 	int err_cnt = 0, i, runs = MAX_TESTRUNS;
8633 
8634 	for (i = 0; i < MAX_SUBTESTS; i++) {
8635 		void *data;
8636 		u64 duration;
8637 		u32 ret;
8638 
8639 		/*
8640 		 * NOTE: Several sub-tests may be present, in which case
8641 		 * a zero {data_size, result} tuple indicates the end of
8642 		 * the sub-test array. The first test is always run,
8643 		 * even if both data_size and result happen to be zero.
8644 		 */
8645 		if (i > 0 &&
8646 		    test->test[i].data_size == 0 &&
8647 		    test->test[i].result == 0)
8648 			break;
8649 
8650 		data = generate_test_data(test, i);
8651 		if (!data && !(test->aux & FLAG_NO_DATA)) {
8652 			pr_cont("data generation failed ");
8653 			err_cnt++;
8654 			break;
8655 		}
8656 		ret = __run_one(fp, data, runs, &duration);
8657 		release_test_data(test, data);
8658 
8659 		if (ret == test->test[i].result) {
8660 			pr_cont("%lld ", duration);
8661 		} else {
8662 			pr_cont("ret %d != %d ", ret,
8663 				test->test[i].result);
8664 			err_cnt++;
8665 		}
8666 	}
8667 
8668 	return err_cnt;
8669 }
8670 
8671 static char test_name[64];
8672 module_param_string(test_name, test_name, sizeof(test_name), 0);
8673 
8674 static int test_id = -1;
8675 module_param(test_id, int, 0);
8676 
8677 static int test_range[2] = { 0, ARRAY_SIZE(tests) - 1 };
8678 module_param_array(test_range, int, NULL, 0);
8679 
find_test_index(const char * test_name)8680 static __init int find_test_index(const char *test_name)
8681 {
8682 	int i;
8683 
8684 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
8685 		if (!strcmp(tests[i].descr, test_name))
8686 			return i;
8687 	}
8688 	return -1;
8689 }
8690 
prepare_bpf_tests(void)8691 static __init int prepare_bpf_tests(void)
8692 {
8693 	int i;
8694 
8695 	if (test_id >= 0) {
8696 		/*
8697 		 * if a test_id was specified, use test_range to
8698 		 * cover only that test.
8699 		 */
8700 		if (test_id >= ARRAY_SIZE(tests)) {
8701 			pr_err("test_bpf: invalid test_id specified.\n");
8702 			return -EINVAL;
8703 		}
8704 
8705 		test_range[0] = test_id;
8706 		test_range[1] = test_id;
8707 	} else if (*test_name) {
8708 		/*
8709 		 * if a test_name was specified, find it and setup
8710 		 * test_range to cover only that test.
8711 		 */
8712 		int idx = find_test_index(test_name);
8713 
8714 		if (idx < 0) {
8715 			pr_err("test_bpf: no test named '%s' found.\n",
8716 			       test_name);
8717 			return -EINVAL;
8718 		}
8719 		test_range[0] = idx;
8720 		test_range[1] = idx;
8721 	} else {
8722 		/*
8723 		 * check that the supplied test_range is valid.
8724 		 */
8725 		if (test_range[0] >= ARRAY_SIZE(tests) ||
8726 		    test_range[1] >= ARRAY_SIZE(tests) ||
8727 		    test_range[0] < 0 || test_range[1] < 0) {
8728 			pr_err("test_bpf: test_range is out of bound.\n");
8729 			return -EINVAL;
8730 		}
8731 
8732 		if (test_range[1] < test_range[0]) {
8733 			pr_err("test_bpf: test_range is ending before it starts.\n");
8734 			return -EINVAL;
8735 		}
8736 	}
8737 
8738 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
8739 		if (tests[i].fill_helper &&
8740 		    tests[i].fill_helper(&tests[i]) < 0)
8741 			return -ENOMEM;
8742 	}
8743 
8744 	return 0;
8745 }
8746 
destroy_bpf_tests(void)8747 static __init void destroy_bpf_tests(void)
8748 {
8749 	int i;
8750 
8751 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
8752 		if (tests[i].fill_helper)
8753 			kfree(tests[i].u.ptr.insns);
8754 	}
8755 }
8756 
exclude_test(int test_id)8757 static bool exclude_test(int test_id)
8758 {
8759 	return test_id < test_range[0] || test_id > test_range[1];
8760 }
8761 
build_test_skb(void)8762 static __init struct sk_buff *build_test_skb(void)
8763 {
8764 	u32 headroom = NET_SKB_PAD + NET_IP_ALIGN + ETH_HLEN;
8765 	struct sk_buff *skb[2];
8766 	struct page *page[2];
8767 	int i, data_size = 8;
8768 
8769 	for (i = 0; i < 2; i++) {
8770 		page[i] = alloc_page(GFP_KERNEL);
8771 		if (!page[i]) {
8772 			if (i == 0)
8773 				goto err_page0;
8774 			else
8775 				goto err_page1;
8776 		}
8777 
8778 		/* this will set skb[i]->head_frag */
8779 		skb[i] = dev_alloc_skb(headroom + data_size);
8780 		if (!skb[i]) {
8781 			if (i == 0)
8782 				goto err_skb0;
8783 			else
8784 				goto err_skb1;
8785 		}
8786 
8787 		skb_reserve(skb[i], headroom);
8788 		skb_put(skb[i], data_size);
8789 		skb[i]->protocol = htons(ETH_P_IP);
8790 		skb_reset_network_header(skb[i]);
8791 		skb_set_mac_header(skb[i], -ETH_HLEN);
8792 
8793 		skb_add_rx_frag(skb[i], 0, page[i], 0, 64, 64);
8794 		// skb_headlen(skb[i]): 8, skb[i]->head_frag = 1
8795 	}
8796 
8797 	/* setup shinfo */
8798 	skb_shinfo(skb[0])->gso_size = 1448;
8799 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV4;
8800 	skb_shinfo(skb[0])->gso_type |= SKB_GSO_DODGY;
8801 	skb_shinfo(skb[0])->gso_segs = 0;
8802 	skb_shinfo(skb[0])->frag_list = skb[1];
8803 
8804 	/* adjust skb[0]'s len */
8805 	skb[0]->len += skb[1]->len;
8806 	skb[0]->data_len += skb[1]->data_len;
8807 	skb[0]->truesize += skb[1]->truesize;
8808 
8809 	return skb[0];
8810 
8811 err_skb1:
8812 	__free_page(page[1]);
8813 err_page1:
8814 	kfree_skb(skb[0]);
8815 err_skb0:
8816 	__free_page(page[0]);
8817 err_page0:
8818 	return NULL;
8819 }
8820 
build_test_skb_linear_no_head_frag(void)8821 static __init struct sk_buff *build_test_skb_linear_no_head_frag(void)
8822 {
8823 	unsigned int alloc_size = 2000;
8824 	unsigned int headroom = 102, doffset = 72, data_size = 1308;
8825 	struct sk_buff *skb[2];
8826 	int i;
8827 
8828 	/* skbs linked in a frag_list, both with linear data, with head_frag=0
8829 	 * (data allocated by kmalloc), both have tcp data of 1308 bytes
8830 	 * (total payload is 2616 bytes).
8831 	 * Data offset is 72 bytes (40 ipv6 hdr, 32 tcp hdr). Some headroom.
8832 	 */
8833 	for (i = 0; i < 2; i++) {
8834 		skb[i] = alloc_skb(alloc_size, GFP_KERNEL);
8835 		if (!skb[i]) {
8836 			if (i == 0)
8837 				goto err_skb0;
8838 			else
8839 				goto err_skb1;
8840 		}
8841 
8842 		skb[i]->protocol = htons(ETH_P_IPV6);
8843 		skb_reserve(skb[i], headroom);
8844 		skb_put(skb[i], doffset + data_size);
8845 		skb_reset_network_header(skb[i]);
8846 		if (i == 0)
8847 			skb_reset_mac_header(skb[i]);
8848 		else
8849 			skb_set_mac_header(skb[i], -ETH_HLEN);
8850 		__skb_pull(skb[i], doffset);
8851 	}
8852 
8853 	/* setup shinfo.
8854 	 * mimic bpf_skb_proto_4_to_6, which resets gso_segs and assigns a
8855 	 * reduced gso_size.
8856 	 */
8857 	skb_shinfo(skb[0])->gso_size = 1288;
8858 	skb_shinfo(skb[0])->gso_type = SKB_GSO_TCPV6 | SKB_GSO_DODGY;
8859 	skb_shinfo(skb[0])->gso_segs = 0;
8860 	skb_shinfo(skb[0])->frag_list = skb[1];
8861 
8862 	/* adjust skb[0]'s len */
8863 	skb[0]->len += skb[1]->len;
8864 	skb[0]->data_len += skb[1]->len;
8865 	skb[0]->truesize += skb[1]->truesize;
8866 
8867 	return skb[0];
8868 
8869 err_skb1:
8870 	kfree_skb(skb[0]);
8871 err_skb0:
8872 	return NULL;
8873 }
8874 
8875 struct skb_segment_test {
8876 	const char *descr;
8877 	struct sk_buff *(*build_skb)(void);
8878 	netdev_features_t features;
8879 };
8880 
8881 static struct skb_segment_test skb_segment_tests[] __initconst = {
8882 	{
8883 		.descr = "gso_with_rx_frags",
8884 		.build_skb = build_test_skb,
8885 		.features = NETIF_F_SG | NETIF_F_GSO_PARTIAL | NETIF_F_IP_CSUM |
8886 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM
8887 	},
8888 	{
8889 		.descr = "gso_linear_no_head_frag",
8890 		.build_skb = build_test_skb_linear_no_head_frag,
8891 		.features = NETIF_F_SG | NETIF_F_FRAGLIST |
8892 			    NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_GSO |
8893 			    NETIF_F_LLTX | NETIF_F_GRO |
8894 			    NETIF_F_IPV6_CSUM | NETIF_F_RXCSUM |
8895 			    NETIF_F_HW_VLAN_STAG_TX
8896 	}
8897 };
8898 
test_skb_segment_single(const struct skb_segment_test * test)8899 static __init int test_skb_segment_single(const struct skb_segment_test *test)
8900 {
8901 	struct sk_buff *skb, *segs;
8902 	int ret = -1;
8903 
8904 	skb = test->build_skb();
8905 	if (!skb) {
8906 		pr_info("%s: failed to build_test_skb", __func__);
8907 		goto done;
8908 	}
8909 
8910 	segs = skb_segment(skb, test->features);
8911 	if (!IS_ERR(segs)) {
8912 		kfree_skb_list(segs);
8913 		ret = 0;
8914 	}
8915 	kfree_skb(skb);
8916 done:
8917 	return ret;
8918 }
8919 
test_skb_segment(void)8920 static __init int test_skb_segment(void)
8921 {
8922 	int i, err_cnt = 0, pass_cnt = 0;
8923 
8924 	for (i = 0; i < ARRAY_SIZE(skb_segment_tests); i++) {
8925 		const struct skb_segment_test *test = &skb_segment_tests[i];
8926 
8927 		pr_info("#%d %s ", i, test->descr);
8928 
8929 		if (test_skb_segment_single(test)) {
8930 			pr_cont("FAIL\n");
8931 			err_cnt++;
8932 		} else {
8933 			pr_cont("PASS\n");
8934 			pass_cnt++;
8935 		}
8936 	}
8937 
8938 	pr_info("%s: Summary: %d PASSED, %d FAILED\n", __func__,
8939 		pass_cnt, err_cnt);
8940 	return err_cnt ? -EINVAL : 0;
8941 }
8942 
test_bpf(void)8943 static __init int test_bpf(void)
8944 {
8945 	int i, err_cnt = 0, pass_cnt = 0;
8946 	int jit_cnt = 0, run_cnt = 0;
8947 
8948 	for (i = 0; i < ARRAY_SIZE(tests); i++) {
8949 		struct bpf_prog *fp;
8950 		int err;
8951 
8952 		cond_resched();
8953 		if (exclude_test(i))
8954 			continue;
8955 
8956 		pr_info("#%d %s ", i, tests[i].descr);
8957 
8958 		fp = generate_filter(i, &err);
8959 		if (fp == NULL) {
8960 			if (err == 0) {
8961 				pass_cnt++;
8962 				continue;
8963 			}
8964 			err_cnt++;
8965 			continue;
8966 		}
8967 
8968 		pr_cont("jited:%u ", fp->jited);
8969 
8970 		run_cnt++;
8971 		if (fp->jited)
8972 			jit_cnt++;
8973 
8974 		err = run_one(fp, &tests[i]);
8975 		release_filter(fp, i);
8976 
8977 		if (err) {
8978 			pr_cont("FAIL (%d times)\n", err);
8979 			err_cnt++;
8980 		} else {
8981 			pr_cont("PASS\n");
8982 			pass_cnt++;
8983 		}
8984 	}
8985 
8986 	pr_info("Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
8987 		pass_cnt, err_cnt, jit_cnt, run_cnt);
8988 
8989 	return err_cnt ? -EINVAL : 0;
8990 }
8991 
8992 struct tail_call_test {
8993 	const char *descr;
8994 	struct bpf_insn insns[MAX_INSNS];
8995 	int flags;
8996 	int result;
8997 	int stack_depth;
8998 };
8999 
9000 /* Flags that can be passed to tail call test cases */
9001 #define FLAG_NEED_STATE		BIT(0)
9002 #define FLAG_RESULT_IN_STATE	BIT(1)
9003 
9004 /*
9005  * Magic marker used in test snippets for tail calls below.
9006  * BPF_LD/MOV to R2 and R2 with this immediate value is replaced
9007  * with the proper values by the test runner.
9008  */
9009 #define TAIL_CALL_MARKER 0x7a11ca11
9010 
9011 /* Special offset to indicate a NULL call target */
9012 #define TAIL_CALL_NULL 0x7fff
9013 
9014 /* Special offset to indicate an out-of-range index */
9015 #define TAIL_CALL_INVALID 0x7ffe
9016 
9017 #define TAIL_CALL(offset)			       \
9018 	BPF_LD_IMM64(R2, TAIL_CALL_MARKER),	       \
9019 	BPF_RAW_INSN(BPF_ALU | BPF_MOV | BPF_K, R3, 0, \
9020 		     offset, TAIL_CALL_MARKER),	       \
9021 	BPF_JMP_IMM(BPF_TAIL_CALL, 0, 0, 0)
9022 
9023 /*
9024  * Tail call tests. Each test case may call any other test in the table,
9025  * including itself, specified as a relative index offset from the calling
9026  * test. The index TAIL_CALL_NULL can be used to specify a NULL target
9027  * function to test the JIT error path. Similarly, the index TAIL_CALL_INVALID
9028  * results in a target index that is out of range.
9029  */
9030 static struct tail_call_test tail_call_tests[] = {
9031 	{
9032 		"Tail call leaf",
9033 		.insns = {
9034 			BPF_ALU64_REG(BPF_MOV, R0, R1),
9035 			BPF_ALU64_IMM(BPF_ADD, R0, 1),
9036 			BPF_EXIT_INSN(),
9037 		},
9038 		.result = 1,
9039 	},
9040 	{
9041 		"Tail call 2",
9042 		.insns = {
9043 			BPF_ALU64_IMM(BPF_ADD, R1, 2),
9044 			TAIL_CALL(-1),
9045 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
9046 			BPF_EXIT_INSN(),
9047 		},
9048 		.result = 3,
9049 	},
9050 	{
9051 		"Tail call 3",
9052 		.insns = {
9053 			BPF_ALU64_IMM(BPF_ADD, R1, 3),
9054 			TAIL_CALL(-1),
9055 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
9056 			BPF_EXIT_INSN(),
9057 		},
9058 		.result = 6,
9059 	},
9060 	{
9061 		"Tail call 4",
9062 		.insns = {
9063 			BPF_ALU64_IMM(BPF_ADD, R1, 4),
9064 			TAIL_CALL(-1),
9065 			BPF_ALU64_IMM(BPF_MOV, R0, -1),
9066 			BPF_EXIT_INSN(),
9067 		},
9068 		.result = 10,
9069 	},
9070 	{
9071 		"Tail call error path, max count reached",
9072 		.insns = {
9073 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
9074 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
9075 			BPF_STX_MEM(BPF_W, R1, R2, 0),
9076 			TAIL_CALL(0),
9077 			BPF_EXIT_INSN(),
9078 		},
9079 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
9080 		.result = (MAX_TAIL_CALL_CNT + 1 + 1) * MAX_TESTRUNS,
9081 	},
9082 	{
9083 		"Tail call error path, NULL target",
9084 		.insns = {
9085 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
9086 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
9087 			BPF_STX_MEM(BPF_W, R1, R2, 0),
9088 			TAIL_CALL(TAIL_CALL_NULL),
9089 			BPF_EXIT_INSN(),
9090 		},
9091 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
9092 		.result = MAX_TESTRUNS,
9093 	},
9094 	{
9095 		"Tail call error path, index out of range",
9096 		.insns = {
9097 			BPF_LDX_MEM(BPF_W, R2, R1, 0),
9098 			BPF_ALU64_IMM(BPF_ADD, R2, 1),
9099 			BPF_STX_MEM(BPF_W, R1, R2, 0),
9100 			TAIL_CALL(TAIL_CALL_INVALID),
9101 			BPF_EXIT_INSN(),
9102 		},
9103 		.flags = FLAG_NEED_STATE | FLAG_RESULT_IN_STATE,
9104 		.result = MAX_TESTRUNS,
9105 	},
9106 };
9107 
destroy_tail_call_tests(struct bpf_array * progs)9108 static void __init destroy_tail_call_tests(struct bpf_array *progs)
9109 {
9110 	int i;
9111 
9112 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++)
9113 		if (progs->ptrs[i])
9114 			bpf_prog_free(progs->ptrs[i]);
9115 	kfree(progs);
9116 }
9117 
prepare_tail_call_tests(struct bpf_array ** pprogs)9118 static __init int prepare_tail_call_tests(struct bpf_array **pprogs)
9119 {
9120 	int ntests = ARRAY_SIZE(tail_call_tests);
9121 	struct bpf_array *progs;
9122 	int which, err;
9123 
9124 	/* Allocate the table of programs to be used for tall calls */
9125 	progs = kzalloc(sizeof(*progs) + (ntests + 1) * sizeof(progs->ptrs[0]),
9126 			GFP_KERNEL);
9127 	if (!progs)
9128 		goto out_nomem;
9129 
9130 	/* Create all eBPF programs and populate the table */
9131 	for (which = 0; which < ntests; which++) {
9132 		struct tail_call_test *test = &tail_call_tests[which];
9133 		struct bpf_prog *fp;
9134 		int len, i;
9135 
9136 		/* Compute the number of program instructions */
9137 		for (len = 0; len < MAX_INSNS; len++) {
9138 			struct bpf_insn *insn = &test->insns[len];
9139 
9140 			if (len < MAX_INSNS - 1 &&
9141 			    insn->code == (BPF_LD | BPF_DW | BPF_IMM))
9142 				len++;
9143 			if (insn->code == 0)
9144 				break;
9145 		}
9146 
9147 		/* Allocate and initialize the program */
9148 		fp = bpf_prog_alloc(bpf_prog_size(len), 0);
9149 		if (!fp)
9150 			goto out_nomem;
9151 
9152 		fp->len = len;
9153 		fp->type = BPF_PROG_TYPE_SOCKET_FILTER;
9154 		fp->aux->stack_depth = test->stack_depth;
9155 		memcpy(fp->insnsi, test->insns, len * sizeof(struct bpf_insn));
9156 
9157 		/* Relocate runtime tail call offsets and addresses */
9158 		for (i = 0; i < len; i++) {
9159 			struct bpf_insn *insn = &fp->insnsi[i];
9160 
9161 			if (insn->imm != TAIL_CALL_MARKER)
9162 				continue;
9163 
9164 			switch (insn->code) {
9165 			case BPF_LD | BPF_DW | BPF_IMM:
9166 				insn[0].imm = (u32)(long)progs;
9167 				insn[1].imm = ((u64)(long)progs) >> 32;
9168 				break;
9169 
9170 			case BPF_ALU | BPF_MOV | BPF_K:
9171 				if (insn->off == TAIL_CALL_NULL)
9172 					insn->imm = ntests;
9173 				else if (insn->off == TAIL_CALL_INVALID)
9174 					insn->imm = ntests + 1;
9175 				else
9176 					insn->imm = which + insn->off;
9177 				insn->off = 0;
9178 			}
9179 		}
9180 
9181 		fp = bpf_prog_select_runtime(fp, &err);
9182 		if (err)
9183 			goto out_err;
9184 
9185 		progs->ptrs[which] = fp;
9186 	}
9187 
9188 	/* The last entry contains a NULL program pointer */
9189 	progs->map.max_entries = ntests + 1;
9190 	*pprogs = progs;
9191 	return 0;
9192 
9193 out_nomem:
9194 	err = -ENOMEM;
9195 
9196 out_err:
9197 	if (progs)
9198 		destroy_tail_call_tests(progs);
9199 	return err;
9200 }
9201 
test_tail_calls(struct bpf_array * progs)9202 static __init int test_tail_calls(struct bpf_array *progs)
9203 {
9204 	int i, err_cnt = 0, pass_cnt = 0;
9205 	int jit_cnt = 0, run_cnt = 0;
9206 
9207 	for (i = 0; i < ARRAY_SIZE(tail_call_tests); i++) {
9208 		struct tail_call_test *test = &tail_call_tests[i];
9209 		struct bpf_prog *fp = progs->ptrs[i];
9210 		int *data = NULL;
9211 		int state = 0;
9212 		u64 duration;
9213 		int ret;
9214 
9215 		cond_resched();
9216 
9217 		pr_info("#%d %s ", i, test->descr);
9218 		if (!fp) {
9219 			err_cnt++;
9220 			continue;
9221 		}
9222 		pr_cont("jited:%u ", fp->jited);
9223 
9224 		run_cnt++;
9225 		if (fp->jited)
9226 			jit_cnt++;
9227 
9228 		if (test->flags & FLAG_NEED_STATE)
9229 			data = &state;
9230 		ret = __run_one(fp, data, MAX_TESTRUNS, &duration);
9231 		if (test->flags & FLAG_RESULT_IN_STATE)
9232 			ret = state;
9233 		if (ret == test->result) {
9234 			pr_cont("%lld PASS", duration);
9235 			pass_cnt++;
9236 		} else {
9237 			pr_cont("ret %d != %d FAIL", ret, test->result);
9238 			err_cnt++;
9239 		}
9240 	}
9241 
9242 	pr_info("%s: Summary: %d PASSED, %d FAILED, [%d/%d JIT'ed]\n",
9243 		__func__, pass_cnt, err_cnt, jit_cnt, run_cnt);
9244 
9245 	return err_cnt ? -EINVAL : 0;
9246 }
9247 
test_bpf_init(void)9248 static int __init test_bpf_init(void)
9249 {
9250 	struct bpf_array *progs = NULL;
9251 	int ret;
9252 
9253 	ret = prepare_bpf_tests();
9254 	if (ret < 0)
9255 		return ret;
9256 
9257 	ret = test_bpf();
9258 	destroy_bpf_tests();
9259 	if (ret)
9260 		return ret;
9261 
9262 	ret = prepare_tail_call_tests(&progs);
9263 	if (ret)
9264 		return ret;
9265 	ret = test_tail_calls(progs);
9266 	destroy_tail_call_tests(progs);
9267 	if (ret)
9268 		return ret;
9269 
9270 	return test_skb_segment();
9271 }
9272 
test_bpf_exit(void)9273 static void __exit test_bpf_exit(void)
9274 {
9275 }
9276 
9277 module_init(test_bpf_init);
9278 module_exit(test_bpf_exit);
9279 
9280 MODULE_LICENSE("GPL");
9281